]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
Staging: epl: remove PUBLIC definition
authorGreg Kroah-Hartman <gregkh@suse.de>
Mon, 23 Mar 2009 17:45:12 +0000 (10:45 -0700)
committerGreg Kroah-Hartman <gregkh@suse.de>
Fri, 3 Apr 2009 21:54:20 +0000 (14:54 -0700)
It doesn't make sense here, so delete it.

Cc: Daniel Krueger <daniel.krueger@systec-electronic.com>
Cc: Ronald Sieber <Ronald.Sieber@systec-electronic.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
64 files changed:
drivers/staging/epl/Edrv8139.c
drivers/staging/epl/Epl.h
drivers/staging/epl/EplAmi.h
drivers/staging/epl/EplApiGeneric.c
drivers/staging/epl/EplApiLinuxKernel.c
drivers/staging/epl/EplApiProcessImage.c
drivers/staging/epl/EplDllk.c
drivers/staging/epl/EplErrorHandlerk.c
drivers/staging/epl/EplEvent.h
drivers/staging/epl/EplEventk.c
drivers/staging/epl/EplEventu.c
drivers/staging/epl/EplIdentu.c
drivers/staging/epl/EplNmtCnu.c
drivers/staging/epl/EplNmtMnu.c
drivers/staging/epl/EplNmtk.c
drivers/staging/epl/EplNmtu.c
drivers/staging/epl/EplNmtuCal.c
drivers/staging/epl/EplObd.c
drivers/staging/epl/EplObd.h
drivers/staging/epl/EplObdu.c
drivers/staging/epl/EplObduCal.c
drivers/staging/epl/EplObjDef.h
drivers/staging/epl/EplPdou.c
drivers/staging/epl/EplSdo.h
drivers/staging/epl/EplSdoAsndu.c
drivers/staging/epl/EplSdoAsySequ.c
drivers/staging/epl/EplSdoComu.c
drivers/staging/epl/EplSdoUdpu.c
drivers/staging/epl/EplStatusu.c
drivers/staging/epl/EplTarget.h
drivers/staging/epl/EplTimer.h
drivers/staging/epl/EplTimeruLinuxKernel.c
drivers/staging/epl/TimerHighReskX86.c
drivers/staging/epl/VirtualEthernetLinux.c
drivers/staging/epl/amix86.c
drivers/staging/epl/demo_main.c
drivers/staging/epl/global.h
drivers/staging/epl/kernel/EplErrorHandlerk.h
drivers/staging/epl/kernel/EplEventk.h
drivers/staging/epl/kernel/EplNmtk.h
drivers/staging/epl/kernel/EplObdk.h
drivers/staging/epl/kernel/EplTimerHighResk.h
drivers/staging/epl/kernel/EplTimerk.h
drivers/staging/epl/kernel/VirtualEthernet.h
drivers/staging/epl/proc_fs.c
drivers/staging/epl/user/EplCfgMau.h
drivers/staging/epl/user/EplDllu.h
drivers/staging/epl/user/EplDlluCal.h
drivers/staging/epl/user/EplEventu.h
drivers/staging/epl/user/EplIdentu.h
drivers/staging/epl/user/EplLedu.h
drivers/staging/epl/user/EplNmtCnu.h
drivers/staging/epl/user/EplNmtMnu.h
drivers/staging/epl/user/EplNmtu.h
drivers/staging/epl/user/EplNmtuCal.h
drivers/staging/epl/user/EplObdu.h
drivers/staging/epl/user/EplObduCal.h
drivers/staging/epl/user/EplPdou.h
drivers/staging/epl/user/EplSdoAsndu.h
drivers/staging/epl/user/EplSdoAsySequ.h
drivers/staging/epl/user/EplSdoComu.h
drivers/staging/epl/user/EplSdoUdpu.h
drivers/staging/epl/user/EplStatusu.h
drivers/staging/epl/user/EplTimeru.h

index 296354aaa9c7f633769cd9d9a53bb6026e20d0fb..b00e17e70b5ab0cfc4f2f0af20857612b7fcab9d 100644 (file)
 
 // TracePoint support for realtime-debugging
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
-void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 #else
index be60f771b63a14371f335042aad5ae04d65678e7..6e5910d1915d7394c1678c2c7ffdc0173a769af7 100644 (file)
@@ -131,9 +131,9 @@ typedef union {
 
 } tEplApiEventArg;
 
-typedef tEplKernel(PUBLIC ROM * tEplApiCbEvent) (tEplApiEventType EventType_p, // IN: event type (enum)
-                                                tEplApiEventArg * pEventArg_p, // IN: event argument (union)
-                                                void GENERIC * pUserArg_p);
+typedef tEplKernel(ROM *tEplApiCbEvent) (tEplApiEventType EventType_p, // IN: event type (enum)
+                                        tEplApiEventArg *pEventArg_p,  // IN: event argument (union)
+                                        void GENERIC *pUserArg_p);
 
 typedef struct {
        unsigned int m_uiSizeOfStruct;
@@ -212,62 +212,61 @@ typedef struct {
 // function prototypes
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiInitialize(tEplApiInitParam * pInitParam_p);
+tEplKernel EplApiInitialize(tEplApiInitParam *pInitParam_p);
 
-tEplKernel PUBLIC EplApiShutdown(void);
+tEplKernel EplApiShutdown(void);
 
-tEplKernel PUBLIC EplApiReadObject(tEplSdoComConHdl * pSdoComConHdl_p,
-                                  unsigned int uiNodeId_p,
-                                  unsigned int uiIndex_p,
-                                  unsigned int uiSubindex_p,
-                                  void *pDstData_le_p,
-                                  unsigned int *puiSize_p,
-                                  tEplSdoType SdoType_p, void *pUserArg_p);
+tEplKernel EplApiReadObject(tEplSdoComConHdl *pSdoComConHdl_p,
+                           unsigned int uiNodeId_p,
+                           unsigned int uiIndex_p,
+                           unsigned int uiSubindex_p,
+                           void *pDstData_le_p,
+                           unsigned int *puiSize_p,
+                           tEplSdoType SdoType_p, void *pUserArg_p);
 
-tEplKernel PUBLIC EplApiWriteObject(tEplSdoComConHdl * pSdoComConHdl_p,
-                                   unsigned int uiNodeId_p,
-                                   unsigned int uiIndex_p,
-                                   unsigned int uiSubindex_p,
-                                   void *pSrcData_le_p,
-                                   unsigned int uiSize_p,
-                                   tEplSdoType SdoType_p, void *pUserArg_p);
+tEplKernel EplApiWriteObject(tEplSdoComConHdl *pSdoComConHdl_p,
+                            unsigned int uiNodeId_p,
+                            unsigned int uiIndex_p,
+                            unsigned int uiSubindex_p,
+                            void *pSrcData_le_p,
+                            unsigned int uiSize_p,
+                            tEplSdoType SdoType_p, void *pUserArg_p);
 
-tEplKernel PUBLIC EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p);
+tEplKernel EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p);
 
-tEplKernel PUBLIC EplApiReadLocalObject(unsigned int uiIndex_p,
-                                       unsigned int uiSubindex_p,
-                                       void *pDstData_p,
-                                       unsigned int *puiSize_p);
+tEplKernel EplApiReadLocalObject(unsigned int uiIndex_p,
+                                unsigned int uiSubindex_p,
+                                void *pDstData_p,
+                                unsigned int *puiSize_p);
 
-tEplKernel PUBLIC EplApiWriteLocalObject(unsigned int uiIndex_p,
-                                        unsigned int uiSubindex_p,
-                                        void *pSrcData_p,
-                                        unsigned int uiSize_p);
+tEplKernel EplApiWriteLocalObject(unsigned int uiIndex_p,
+                                 unsigned int uiSubindex_p,
+                                 void *pSrcData_p,
+                                 unsigned int uiSize_p);
 
-tEplKernel PUBLIC EplApiCbObdAccess(tEplObdCbParam MEM * pParam_p);
+tEplKernel EplApiCbObdAccess(tEplObdCbParam MEM *pParam_p);
 
-tEplKernel PUBLIC EplApiLinkObject(unsigned int uiObjIndex_p,
-                                  void *pVar_p,
-                                  unsigned int *puiVarEntries_p,
-                                  tEplObdSize * pEntrySize_p,
-                                  unsigned int uiFirstSubindex_p);
+tEplKernel EplApiLinkObject(unsigned int uiObjIndex_p,
+                           void *pVar_p,
+                           unsigned int *puiVarEntries_p,
+                           tEplObdSize *pEntrySize_p,
+                           unsigned int uiFirstSubindex_p);
 
-tEplKernel PUBLIC EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p);
+tEplKernel EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p);
 
-tEplKernel PUBLIC EplApiProcess(void);
+tEplKernel EplApiProcess(void);
 
 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
-tEplKernel PUBLIC EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
-                                            tEplNmtNodeCommand NodeCommand_p);
+tEplKernel EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
+                                     tEplNmtNodeCommand NodeCommand_p);
 #endif
 
-tEplKernel PUBLIC EplApiGetIdentResponse(unsigned int uiNodeId_p,
-                                        tEplIdentResponse **
-                                        ppIdentResponse_p);
+tEplKernel EplApiGetIdentResponse(unsigned int uiNodeId_p,
+                                 tEplIdentResponse **ppIdentResponse_p);
 
 // functions for process image will be implemented in separate file
-tEplKernel PUBLIC EplApiProcessImageSetup(void);
-tEplKernel PUBLIC EplApiProcessImageExchangeIn(tEplApiProcessImage * pPI_p);
-tEplKernel PUBLIC EplApiProcessImageExchangeOut(tEplApiProcessImage * pPI_p);
+tEplKernel EplApiProcessImageSetup(void);
+tEplKernel EplApiProcessImageExchangeIn(tEplApiProcessImage *pPI_p);
+tEplKernel EplApiProcessImageExchangeOut(tEplApiProcessImage *pPI_p);
 
 #endif // #ifndef _EPL_API_H_
index 6fa04a4f0a130978395d74680c7f590a5cc4c32a..04aeed68f4cbd981930a69305ea8823b47e1c6af 100644 (file)
@@ -131,16 +131,16 @@ extern "C" {
 //
 // To save code space the function AmiSetByte is replaced by
 // an macro.
-// void   PUBLIC  AmiSetByte  (void FAR* pAddr_p, BYTE bByteVal_p);
+// void  AmiSetByte  (void FAR* pAddr_p, BYTE bByteVal_p);
 
 #define AmiSetByteToBe(pAddr_p, bByteVal_p)  {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);}
 #define AmiSetByteToLe(pAddr_p, bByteVal_p)  {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);}
 
 #if !defined(INLINE_ENABLED)
-       void PUBLIC AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p);
-       void PUBLIC AmiSetDwordToBe(void FAR * pAddr_p, DWORD dwDwordVal_p);
-       void PUBLIC AmiSetWordToLe(void FAR * pAddr_p, WORD wWordVal_p);
-       void PUBLIC AmiSetDwordToLe(void FAR * pAddr_p, DWORD dwDwordVal_p);
+void AmiSetWordToBe(void FAR *pAddr_p, WORD wWordVal_p);
+void AmiSetDwordToBe(void FAR *pAddr_p, DWORD dwDwordVal_p);
+void AmiSetWordToLe(void FAR *pAddr_p, WORD wWordVal_p);
+void AmiSetDwordToLe(void FAR *pAddr_p, DWORD dwDwordVal_p);
 #endif
 
 //---------------------------------------------------------------------------
@@ -149,17 +149,17 @@ extern "C" {
 //
 // To save code space the function AmiGetByte is replaced by
 // an macro.
-// BYTE   PUBLIC  AmiGetByte  (void FAR* pAddr_p);
+// BYTE   AmiGetByte  (void FAR* pAddr_p);
 
 #define AmiGetByteFromBe(pAddr_p)  (*(BYTE FAR*)(pAddr_p))
 #define AmiGetByteFromLe(pAddr_p)  (*(BYTE FAR*)(pAddr_p))
 
 #if !defined(INLINE_ENABLED)
 
-       WORD PUBLIC AmiGetWordFromBe(void FAR * pAddr_p);
-       DWORD PUBLIC AmiGetDwordFromBe(void FAR * pAddr_p);
-       WORD PUBLIC AmiGetWordFromLe(void FAR * pAddr_p);
-       DWORD PUBLIC AmiGetDwordFromLe(void FAR * pAddr_p);
+WORD AmiGetWordFromBe(void FAR *pAddr_p);
+DWORD AmiGetDwordFromBe(void FAR *pAddr_p);
+WORD AmiGetWordFromLe(void FAR *pAddr_p);
+DWORD AmiGetDwordFromLe(void FAR *pAddr_p);
 
 //---------------------------------------------------------------------------
 //
@@ -174,8 +174,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       void PUBLIC AmiSetDword24ToBe(void FAR * pAddr_p, DWORD dwDwordVal_p);
-       void PUBLIC AmiSetDword24ToLe(void FAR * pAddr_p, DWORD dwDwordVal_p);
+void AmiSetDword24ToBe(void FAR *pAddr_p, DWORD dwDwordVal_p);
+void AmiSetDword24ToLe(void FAR *pAddr_p, DWORD dwDwordVal_p);
 
 //---------------------------------------------------------------------------
 //
@@ -189,8 +189,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       DWORD PUBLIC AmiGetDword24FromBe(void FAR * pAddr_p);
-       DWORD PUBLIC AmiGetDword24FromLe(void FAR * pAddr_p);
+DWORD AmiGetDword24FromBe(void FAR *pAddr_p);
+DWORD AmiGetDword24FromLe(void FAR *pAddr_p);
 
 //#ifdef USE_VAR64
 
@@ -207,8 +207,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       void PUBLIC AmiSetQword40ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p);
-       void PUBLIC AmiSetQword40ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p);
+void AmiSetQword40ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p);
+void AmiSetQword40ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p);
 
 //---------------------------------------------------------------------------
 //
@@ -222,8 +222,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       QWORD PUBLIC AmiGetQword40FromBe(void FAR * pAddr_p);
-       QWORD PUBLIC AmiGetQword40FromLe(void FAR * pAddr_p);
+QWORD AmiGetQword40FromBe(void FAR *pAddr_p);
+QWORD AmiGetQword40FromLe(void FAR *pAddr_p);
 
 //---------------------------------------------------------------------------
 //
@@ -238,8 +238,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       void PUBLIC AmiSetQword48ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p);
-       void PUBLIC AmiSetQword48ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p);
+void AmiSetQword48ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p);
+void AmiSetQword48ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p);
 
 //---------------------------------------------------------------------------
 //
@@ -253,8 +253,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       QWORD PUBLIC AmiGetQword48FromBe(void FAR * pAddr_p);
-       QWORD PUBLIC AmiGetQword48FromLe(void FAR * pAddr_p);
+QWORD AmiGetQword48FromBe(void FAR *pAddr_p);
+QWORD AmiGetQword48FromLe(void FAR *pAddr_p);
 
 //---------------------------------------------------------------------------
 //
@@ -269,8 +269,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       void PUBLIC AmiSetQword56ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p);
-       void PUBLIC AmiSetQword56ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p);
+void AmiSetQword56ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p);
+void AmiSetQword56ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p);
 
 //---------------------------------------------------------------------------
 //
@@ -284,8 +284,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       QWORD PUBLIC AmiGetQword56FromBe(void FAR * pAddr_p);
-       QWORD PUBLIC AmiGetQword56FromLe(void FAR * pAddr_p);
+QWORD AmiGetQword56FromBe(void FAR *pAddr_p);
+QWORD AmiGetQword56FromLe(void FAR *pAddr_p);
 
 //---------------------------------------------------------------------------
 //
@@ -300,8 +300,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p);
-       void PUBLIC AmiSetQword64ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p);
+void AmiSetQword64ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p);
+void AmiSetQword64ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p);
 
 //---------------------------------------------------------------------------
 //
@@ -315,8 +315,8 @@ extern "C" {
 //
 //---------------------------------------------------------------------------
 
-       QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p);
-       QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p);
+QWORD AmiGetQword64FromBe(void FAR *pAddr_p);
+QWORD AmiGetQword64FromLe(void FAR *pAddr_p);
 
 //---------------------------------------------------------------------------
 //
@@ -330,9 +330,7 @@ extern "C" {
 // Return:      void
 //
 //---------------------------------------------------------------------------
-
-       void PUBLIC AmiSetTimeOfDay(void FAR * pAddr_p,
-                                   tTimeOfDay FAR * pTimeOfDay_p);
+void AmiSetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p);
 
 //---------------------------------------------------------------------------
 //
@@ -346,9 +344,7 @@ extern "C" {
 // Return:      void
 //
 //---------------------------------------------------------------------------
-
-       void PUBLIC AmiGetTimeOfDay(void FAR * pAddr_p,
-                                   tTimeOfDay FAR * pTimeOfDay_p);
+void AmiGetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p);
 
 #endif
 
index ae19e34cd7b35e016326ba2eaec1e338655f21d4..e174562ddf89b570b01c4e91e99e7088a62b4a59 100644 (file)
@@ -162,44 +162,41 @@ static tEplApiInstance EplApiInstance_g;
 //---------------------------------------------------------------------------
 
 // NMT state change event callback function
-static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange
-                                               NmtStateChange_p);
+static tEplKernel EplApiCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p);
 
 // update DLL configuration from OD
-static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p);
+static tEplKernel EplApiUpdateDllConfig(BOOL fUpdateIdentity_p);
 
 // update OD from init param
-static tEplKernel PUBLIC EplApiUpdateObd(void);
+static tEplKernel EplApiUpdateObd(void);
 
 // process events from user event queue
-static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p);
+static tEplKernel EplApiProcessEvent(tEplEvent *pEplEvent_p);
 
 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
 // callback function of SDO module
-static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p);
+static tEplKernel EplApiCbSdoCon(tEplSdoComFinished *pSdoComFinished_p);
 #endif
 
 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
 // callback functions of NmtMnu module
-static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p,
-                                          tEplNmtNodeEvent NodeEvent_p,
-                                          tEplNmtState NmtState_p,
-                                          WORD wErrorCode_p,
-                                          BOOL fMandatory_p);
-
-static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
-                                          tEplNmtState NmtState_p,
-                                          WORD wErrorCode_p);
+static tEplKernel EplApiCbNodeEvent(unsigned int uiNodeId_p,
+                                   tEplNmtNodeEvent NodeEvent_p,
+                                   tEplNmtState NmtState_p,
+                                   WORD wErrorCode_p, BOOL fMandatory_p);
+
+static tEplKernel EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
+                                   tEplNmtState NmtState_p,
+                                   WORD wErrorCode_p);
 #endif
 
 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
 // callback function of Ledu module
-static tEplKernel PUBLIC EplApiCbLedStateChange(tEplLedType LedType_p,
-                                               BOOL fOn_p);
+static tEplKernel EplApiCbLedStateChange(tEplLedType LedType_p, BOOL fOn_p);
 #endif
 
 // OD initialization function (implemented in Objdict.c)
-tEplKernel PUBLIC EplObdInitRam(tEplObdInitParam MEM * pInitParam_p);
+tEplKernel EplObdInitRam(tEplObdInitParam MEM *pInitParam_p);
 
 //=========================================================================//
 //                                                                         //
@@ -226,7 +223,7 @@ tEplKernel PUBLIC EplObdInitRam(tEplObdInitParam MEM * pInitParam_p);
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiInitialize(tEplApiInitParam * pInitParam_p)
+tEplKernel EplApiInitialize(tEplApiInitParam *pInitParam_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplObdInitParam ObdInitParam;
@@ -415,7 +412,7 @@ tEplKernel PUBLIC EplApiInitialize(tEplApiInitParam * pInitParam_p)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiShutdown(void)
+tEplKernel EplApiShutdown(void)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -523,7 +520,7 @@ tEplKernel PUBLIC EplApiShutdown(void)
 // State:
 //----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p)
+tEplKernel EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -553,11 +550,11 @@ tEplKernel PUBLIC EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p)
 // State:
 //----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiLinkObject(unsigned int uiObjIndex_p,
-                                  void *pVar_p,
-                                  unsigned int *puiVarEntries_p,
-                                  tEplObdSize * pEntrySize_p,
-                                  unsigned int uiFirstSubindex_p)
+tEplKernel EplApiLinkObject(unsigned int uiObjIndex_p,
+                           void *pVar_p,
+                           unsigned int *puiVarEntries_p,
+                           tEplObdSize *pEntrySize_p,
+                           unsigned int uiFirstSubindex_p)
 {
        BYTE bVarEntries;
        BYTE bIndexEntries;
@@ -677,13 +674,13 @@ tEplKernel PUBLIC EplApiLinkObject(unsigned int uiObjIndex_p,
 //
 // ----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiReadObject(tEplSdoComConHdl * pSdoComConHdl_p,
-                                  unsigned int uiNodeId_p,
-                                  unsigned int uiIndex_p,
-                                  unsigned int uiSubindex_p,
-                                  void *pDstData_le_p,
-                                  unsigned int *puiSize_p,
-                                  tEplSdoType SdoType_p, void *pUserArg_p)
+tEplKernel EplApiReadObject(tEplSdoComConHdl *pSdoComConHdl_p,
+                           unsigned int uiNodeId_p,
+                           unsigned int uiIndex_p,
+                           unsigned int uiSubindex_p,
+                           void *pDstData_le_p,
+                           unsigned int *puiSize_p,
+                           tEplSdoType SdoType_p, void *pUserArg_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -765,13 +762,13 @@ tEplKernel PUBLIC EplApiReadObject(tEplSdoComConHdl * pSdoComConHdl_p,
 //
 // ----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiWriteObject(tEplSdoComConHdl * pSdoComConHdl_p,
-                                   unsigned int uiNodeId_p,
-                                   unsigned int uiIndex_p,
-                                   unsigned int uiSubindex_p,
-                                   void *pSrcData_le_p,
-                                   unsigned int uiSize_p,
-                                   tEplSdoType SdoType_p, void *pUserArg_p)
+tEplKernel EplApiWriteObject(tEplSdoComConHdl *pSdoComConHdl_p,
+                            unsigned int uiNodeId_p,
+                            unsigned int uiIndex_p,
+                            unsigned int uiSubindex_p,
+                            void *pSrcData_le_p,
+                            unsigned int uiSize_p,
+                            tEplSdoType SdoType_p, void *pUserArg_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -850,7 +847,7 @@ tEplKernel PUBLIC EplApiWriteObject(tEplSdoComConHdl * pSdoComConHdl_p,
 //
 // ----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p)
+tEplKernel EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -881,10 +878,9 @@ tEplKernel PUBLIC EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p)
 //
 // ----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiReadLocalObject(unsigned int uiIndex_p,
-                                       unsigned int uiSubindex_p,
-                                       void *pDstData_p,
-                                       unsigned int *puiSize_p)
+tEplKernel EplApiReadLocalObject(unsigned int uiIndex_p,
+                                unsigned int uiSubindex_p,
+                                void *pDstData_p, unsigned int *puiSize_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplObdSize ObdSize;
@@ -911,10 +907,10 @@ tEplKernel PUBLIC EplApiReadLocalObject(unsigned int uiIndex_p,
 //
 // ----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiWriteLocalObject(unsigned int uiIndex_p,
-                                        unsigned int uiSubindex_p,
-                                        void *pSrcData_p,
-                                        unsigned int uiSize_p)
+tEplKernel EplApiWriteLocalObject(unsigned int uiIndex_p,
+                                 unsigned int uiSubindex_p,
+                                 void *pSrcData_p,
+                                 unsigned int uiSize_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -939,8 +935,8 @@ tEplKernel PUBLIC EplApiWriteLocalObject(unsigned int uiIndex_p,
 //
 // ----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
-                                            tEplNmtNodeCommand NodeCommand_p)
+tEplKernel EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
+                                     tEplNmtNodeCommand NodeCommand_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -966,7 +962,7 @@ tEplKernel PUBLIC EplApiMnTriggerStateChange(unsigned int uiNodeId_p,
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiCbObdAccess(tEplObdCbParam MEM * pParam_p)
+tEplKernel EplApiCbObdAccess(tEplObdCbParam MEM *pParam_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -1115,7 +1111,7 @@ tEplKernel PUBLIC EplApiCbObdAccess(tEplObdCbParam MEM * pParam_p)
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p)
+static tEplKernel EplApiProcessEvent(tEplEvent *pEplEvent_p)
 {
        tEplKernel Ret;
        tEplEventError *pEventError;
@@ -1188,8 +1184,7 @@ static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p)
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange
-                                               NmtStateChange_p)
+static tEplKernel EplApiCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p)
 {
        tEplKernel Ret = kEplSuccessful;
        BYTE bNmtState;
@@ -1411,7 +1406,7 @@ static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p)
+static tEplKernel EplApiUpdateDllConfig(BOOL fUpdateIdentity_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplDllConfigParam DllConfigParam;
@@ -1634,7 +1629,7 @@ static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p)
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplApiUpdateObd(void)
+static tEplKernel EplApiUpdateObd(void)
 {
        tEplKernel Ret = kEplSuccessful;
        WORD wTemp;
@@ -1905,7 +1900,7 @@ static tEplKernel PUBLIC EplApiUpdateObd(void)
 //---------------------------------------------------------------------------
 
 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
-static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p)
+static tEplKernel EplApiCbSdoCon(tEplSdoComFinished *pSdoComFinished_p)
 {
        tEplKernel Ret;
        tEplApiEventArg EventArg;
@@ -1946,10 +1941,10 @@ static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p)
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p,
-                                          tEplNmtNodeEvent NodeEvent_p,
-                                          tEplNmtState NmtState_p,
-                                          WORD wErrorCode_p, BOOL fMandatory_p)
+static tEplKernel EplApiCbNodeEvent(unsigned int uiNodeId_p,
+                                   tEplNmtNodeEvent NodeEvent_p,
+                                   tEplNmtState NmtState_p,
+                                   WORD wErrorCode_p, BOOL fMandatory_p)
 {
        tEplKernel Ret;
        tEplApiEventArg EventArg;
@@ -1990,9 +1985,9 @@ static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p,
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
-                                          tEplNmtState NmtState_p,
-                                          WORD wErrorCode_p)
+static tEplKernel EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
+                                   tEplNmtState NmtState_p,
+                                   WORD wErrorCode_p)
 {
        tEplKernel Ret;
        tEplApiEventArg EventArg;
@@ -2033,8 +2028,7 @@ static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p,
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplApiCbLedStateChange(tEplLedType LedType_p,
-                                               BOOL fOn_p)
+static tEplKernel EplApiCbLedStateChange(tEplLedType LedType_p, BOOL fOn_p)
 {
        tEplKernel Ret;
        tEplApiEventArg EventArg;
index 05ca0628d6ae3e65c13f98ec84e2cfcff5cd17e7..8d4a218c3248133ddccddb61dae012007a2ab16b 100644 (file)
@@ -139,7 +139,7 @@ MODULE_DESCRIPTION("EPL API driver");
 
 // TracePoint support for realtime-debugging
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 #else
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)
@@ -204,11 +204,11 @@ typedef struct {
 //  Prototypes of internal functions
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplLinCbEvent(tEplApiEventType EventType_p,  // IN: event type (enum)
-                               tEplApiEventArg * pEventArg_p,  // IN: event argument (union)
-                               void GENERIC * pUserArg_p);
+tEplKernel EplLinCbEvent(tEplApiEventType EventType_p, // IN: event type (enum)
+                        tEplApiEventArg *pEventArg_p,  // IN: event argument (union)
+                        void GENERIC *pUserArg_p);
 
-tEplKernel PUBLIC EplLinCbSync(void);
+tEplKernel EplLinCbSync(void);
 
 static int __init EplLinInit(void);
 static void __exit EplLinExit(void);
@@ -1158,9 +1158,9 @@ static int EplLinIoctl(struct inode *pDeviceFile_p,       // information about the dev
 //                                                                         //
 //=========================================================================//
 
-tEplKernel PUBLIC EplLinCbEvent(tEplApiEventType EventType_p,  // IN: event type (enum)
-                               tEplApiEventArg * pEventArg_p,  // IN: event argument (union)
-                               void GENERIC * pUserArg_p)
+tEplKernel EplLinCbEvent(tEplApiEventType EventType_p, // IN: event type (enum)
+                        tEplApiEventArg *pEventArg_p,  // IN: event argument (union)
+                        void GENERIC *pUserArg_p)
 {
        tEplKernel EplRet = kEplSuccessful;
        int iErr;
@@ -1224,7 +1224,7 @@ tEplKernel PUBLIC EplLinCbEvent(tEplApiEventType EventType_p,     // IN: event type
        return EplRet;
 }
 
-tEplKernel PUBLIC EplLinCbSync(void)
+tEplKernel EplLinCbSync(void)
 {
        tEplKernel EplRet = kEplSuccessful;
        int iErr;
index 2b2fdf229a75118eb30a9b4b52b0794c6693517e..4fbb7289e0bfc799f1c3a7772bdafaffb01cf8af 100644 (file)
@@ -169,7 +169,7 @@ static tEplApiProcessImageInstance EplApiProcessImageInstance_g;
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiProcessImageSetup(void)
+tEplKernel EplApiProcessImageSetup(void)
 {
        tEplKernel Ret = kEplSuccessful;
 #if ((EPL_API_PROCESS_IMAGE_SIZE_IN > 0) || (EPL_API_PROCESS_IMAGE_SIZE_OUT > 0))
@@ -280,7 +280,7 @@ tEplKernel PUBLIC EplApiProcessImageSetup(void)
 // State:
 //----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiProcessImageExchangeIn(tEplApiProcessImage * pPI_p)
+tEplKernel EplApiProcessImageExchangeIn(tEplApiProcessImage *pPI_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -315,7 +315,7 @@ tEplKernel PUBLIC EplApiProcessImageExchangeIn(tEplApiProcessImage * pPI_p)
 // State:
 //----------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplApiProcessImageExchangeOut(tEplApiProcessImage * pPI_p)
+tEplKernel EplApiProcessImageExchangeOut(tEplApiProcessImage *pPI_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
index 9e22641055c61cd7066410603c73d74e99d198fa..8fafe7524428f6c97fba13804d578bd221d875a3 100644 (file)
 
 // TracePoint support for realtime-debugging
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
-void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 #else
@@ -257,7 +257,7 @@ static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p,
 
 // called by high resolution timer module to monitor EPL cycle as CN
 #if EPL_TIMER_USE_HIGHRES != FALSE
-static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg * pEventArg_p);
+static tEplKernel EplDllkCbCnTimer(tEplTimerEventArg *pEventArg_p);
 #endif
 
 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0)
@@ -278,10 +278,9 @@ static tEplKernel EplDllkAsyncFrameNotReceived(tEplDllReqServiceId
                                               ReqServiceId_p,
                                               unsigned int uiNodeId_p);
 
-static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg * pEventArg_p);
+static tEplKernel EplDllkCbMnTimerCycle(tEplTimerEventArg *pEventArg_p);
 
-static tEplKernel PUBLIC EplDllkCbMnTimerResponse(tEplTimerEventArg *
-                                                 pEventArg_p);
+static tEplKernel EplDllkCbMnTimerResponse(tEplTimerEventArg *pEventArg_p);
 
 #endif
 
@@ -3546,7 +3545,7 @@ static tEplKernel EplDllkCheckFrame(tEplFrame * pFrame_p,
 //---------------------------------------------------------------------------
 
 #if EPL_TIMER_USE_HIGHRES != FALSE
-static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg * pEventArg_p)
+static tEplKernel EplDllkCbCnTimer(tEplTimerEventArg *pEventArg_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplNmtState NmtState;
@@ -3617,7 +3616,7 @@ static tEplKernel PUBLIC EplDllkCbCnTimer(tEplTimerEventArg * pEventArg_p)
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg * pEventArg_p)
+static tEplKernel EplDllkCbMnTimerCycle(tEplTimerEventArg *pEventArg_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplNmtState NmtState;
@@ -3670,8 +3669,7 @@ static tEplKernel PUBLIC EplDllkCbMnTimerCycle(tEplTimerEventArg * pEventArg_p)
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplDllkCbMnTimerResponse(tEplTimerEventArg *
-                                                 pEventArg_p)
+static tEplKernel EplDllkCbMnTimerResponse(tEplTimerEventArg *pEventArg_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplNmtState NmtState;
index d12521fc99a4001b4b4f5cc16e54a6e49363e246..25a44d961c00150b52f3d0f02a79d2e5fd3ffaf9 100644 (file)
@@ -176,7 +176,7 @@ static tEplKernel EplErrorHandlerkLinkArray(DWORD * pdwValue_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplErrorHandlerkInit(void)
+tEplKernel EplErrorHandlerkInit(void)
 {
        tEplKernel Ret;
 
@@ -203,7 +203,7 @@ tEplKernel PUBLIC EplErrorHandlerkInit(void)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplErrorHandlerkAddInstance(void)
+tEplKernel EplErrorHandlerkAddInstance(void)
 {
        tEplKernel Ret;
 
@@ -306,7 +306,7 @@ tEplKernel PUBLIC EplErrorHandlerkAddInstance(void)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplErrorHandlerkDelInstance()
+tEplKernel EplErrorHandlerkDelInstance(void)
 {
        tEplKernel Ret;
 
@@ -333,7 +333,7 @@ tEplKernel PUBLIC EplErrorHandlerkDelInstance()
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplErrorHandlerkProcess(tEplEvent * pEvent_p)
+tEplKernel EplErrorHandlerkProcess(tEplEvent *pEvent_p)
 {
        tEplKernel Ret;
        unsigned long ulDllErrorEvents;
index b6dc1b9b2ab1cb73bb4ee3e7adae5b40146f4234..c3c317df96c59038829e0a674b160c68d7079ae0 100644 (file)
@@ -267,10 +267,10 @@ typedef struct {
 } tEplErrorHandlerkEvent;
 
 // callback function to get informed about sync event
-typedef tEplKernel(PUBLIC * tEplSyncCb) (void);
+typedef tEplKernel(*tEplSyncCb) (void);
 
 // callback function for generic events
-typedef tEplKernel(PUBLIC * tEplProcessEventCb) (tEplEvent * pEplEvent_p);
+typedef tEplKernel(*tEplProcessEventCb) (tEplEvent *pEplEvent_p);
 
 //---------------------------------------------------------------------------
 // function prototypes
index 8068a6c5a0d0b3d4fdf3f923838f91f5e717f68e..165d7e9ef4ab2fcaf58542958914e9e21ba819bd 100644 (file)
 
 // TracePoint support for realtime-debugging
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
-void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 #else
@@ -172,7 +172,7 @@ static void EplEventkRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplEventkInit(tEplSyncCb pfnCbSync_p)
+tEplKernel EplEventkInit(tEplSyncCb pfnCbSync_p)
 {
        tEplKernel Ret;
 
@@ -196,7 +196,7 @@ tEplKernel PUBLIC EplEventkInit(tEplSyncCb pfnCbSync_p)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplEventkAddInstance(tEplSyncCb pfnCbSync_p)
+tEplKernel EplEventkAddInstance(tEplSyncCb pfnCbSync_p)
 {
        tEplKernel Ret;
 #ifndef EPL_NO_FIFO
@@ -275,7 +275,7 @@ tEplKernel PUBLIC EplEventkAddInstance(tEplSyncCb pfnCbSync_p)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplEventkDelInstance()
+tEplKernel EplEventkDelInstance(void)
 {
        tEplKernel Ret;
 #ifndef EPL_NO_FIFO
@@ -339,7 +339,7 @@ tEplKernel PUBLIC EplEventkDelInstance()
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplEventkProcess(tEplEvent * pEvent_p)
+tEplKernel EplEventkProcess(tEplEvent *pEvent_p)
 {
        tEplKernel Ret;
        tEplEventSource EventSource;
@@ -562,7 +562,7 @@ tEplKernel PUBLIC EplEventkProcess(tEplEvent * pEvent_p)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplEventkPost(tEplEvent * pEvent_p)
+tEplKernel EplEventkPost(tEplEvent *pEvent_p)
 {
        tEplKernel Ret;
 #ifndef EPL_NO_FIFO
@@ -755,9 +755,9 @@ tEplKernel PUBLIC EplEventkPost(tEplEvent * pEvent_p)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplEventkPostError(tEplEventSource EventSource_p,
-                                    tEplKernel EplError_p,
-                                    unsigned int uiArgSize_p, void *pArg_p)
+tEplKernel EplEventkPostError(tEplEventSource EventSource_p,
+                             tEplKernel EplError_p,
+                             unsigned int uiArgSize_p, void *pArg_p)
 {
        tEplKernel Ret;
        BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE];
index 815f9a87abf8e6e4c11fbb5bc0ed52f33f048ec0..d26e95a923a7aee9c0ddfa3cf77b1dbd0fd98eb6 100644 (file)
@@ -96,8 +96,8 @@
 
 // TracePoint support for realtime-debugging
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
-void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 #else
@@ -172,7 +172,7 @@ static void EplEventuRxSignalHandlerCb(tShbInstance pShbRxInstance_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p)
+tEplKernel EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p)
 {
        tEplKernel Ret;
 
@@ -199,8 +199,7 @@ tEplKernel PUBLIC EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplEventuAddInstance(tEplProcessEventCb
-                                      pfnApiProcessEventCb_p)
+tEplKernel EplEventuAddInstance(tEplProcessEventCb pfnApiProcessEventCb_p)
 {
        tEplKernel Ret;
 #ifndef EPL_NO_FIFO
@@ -280,7 +279,7 @@ tEplKernel PUBLIC EplEventuAddInstance(tEplProcessEventCb
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplEventuDelInstance()
+tEplKernel EplEventuDelInstance(void)
 {
        tEplKernel Ret;
 #ifndef EPL_NO_FIFO
@@ -348,7 +347,7 @@ tEplKernel PUBLIC EplEventuDelInstance()
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplEventuProcess(tEplEvent * pEvent_p)
+tEplKernel EplEventuProcess(tEplEvent *pEvent_p)
 {
        tEplKernel Ret;
        tEplEventSource EventSource;
@@ -515,7 +514,7 @@ tEplKernel PUBLIC EplEventuProcess(tEplEvent * pEvent_p)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplEventuPost(tEplEvent * pEvent_p)
+tEplKernel EplEventuPost(tEplEvent *pEvent_p)
 {
        tEplKernel Ret;
 #ifndef EPL_NO_FIFO
@@ -689,9 +688,9 @@ tEplKernel PUBLIC EplEventuPost(tEplEvent * pEvent_p)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplEventuPostError(tEplEventSource EventSource_p,
-                                    tEplKernel EplError_p,
-                                    unsigned int uiArgSize_p, void *pArg_p)
+tEplKernel EplEventuPostError(tEplEventSource EventSource_p,
+                             tEplKernel EplError_p,
+                             unsigned int uiArgSize_p, void *pArg_p)
 {
        tEplKernel Ret;
        BYTE abBuffer[EPL_MAX_EVENT_ARG_SIZE];
index ce59ef09ccdf99932853cb04f4725fe69e5877f7..75f941d97cc6e814fd6351621f93ebb603241bd8 100644 (file)
@@ -138,7 +138,7 @@ static tEplIdentuInstance EplIdentuInstance_g;
 // local function prototypes
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p);
+static tEplKernel EplIdentuCbIdentResponse(tEplFrameInfo *pFrameInfo_p);
 
 //=========================================================================//
 //                                                                         //
@@ -164,7 +164,7 @@ static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p);
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplIdentuInit()
+EPLDLLEXPORT tEplKernel EplIdentuInit(void)
 {
        tEplKernel Ret;
 
@@ -191,7 +191,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplIdentuInit()
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplIdentuAddInstance()
+EPLDLLEXPORT tEplKernel EplIdentuAddInstance(void)
 {
        tEplKernel Ret;
 
@@ -228,7 +228,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplIdentuAddInstance()
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplIdentuDelInstance()
+EPLDLLEXPORT tEplKernel EplIdentuDelInstance(void)
 {
        tEplKernel Ret;
 
@@ -263,7 +263,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplIdentuDelInstance()
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplIdentuReset()
+EPLDLLEXPORT tEplKernel EplIdentuReset(void)
 {
        tEplKernel Ret;
        int iIndex;
@@ -300,9 +300,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplIdentuReset()
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
-                                           tEplIdentResponse **
-                                           ppIdentResponse_p)
+tEplKernel EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
+                                    tEplIdentResponse **ppIdentResponse_p)
 {
        tEplKernel Ret;
 
@@ -338,9 +337,8 @@ tEplKernel PUBLIC EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
-                                               tEplIdentuCbResponse
-                                               pfnCbResponse_p)
+tEplKernel EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
+                                        tEplIdentuCbResponse pfnCbResponse_p)
 {
        tEplKernel Ret;
 
@@ -388,7 +386,7 @@ tEplKernel PUBLIC EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT DWORD PUBLIC EplIdentuGetRunningRequests(void)
+EPLDLLEXPORT DWORD EplIdentuGetRunningRequests(void)
 {
        DWORD dwReqs = 0;
        unsigned int uiIndex;
@@ -426,7 +424,7 @@ EPLDLLEXPORT DWORD PUBLIC EplIdentuGetRunningRequests(void)
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplIdentuCbIdentResponse(tEplFrameInfo * pFrameInfo_p)
+static tEplKernel EplIdentuCbIdentResponse(tEplFrameInfo *pFrameInfo_p)
 {
        tEplKernel Ret = kEplSuccessful;
        unsigned int uiNodeId;
index f2f46da08c7d8d595ca3aae7e5430570c2d6982f..2c39116753964ccdabf1e25f2d6309ccb28548a8 100644 (file)
@@ -110,7 +110,7 @@ static tEplNmtCommand EplNmtCnuGetNmtCommand(tEplFrameInfo * pFrameInfo_p);
 
 static BOOL EplNmtCnuNodeIdList(BYTE * pbNmtCommandDate_p);
 
-static tEplKernel PUBLIC EplNmtCnuCommandCb(tEplFrameInfo * pFrameInfo_p);
+static tEplKernel EplNmtCnuCommandCb(tEplFrameInfo *pFrameInfo_p);
 
 //=========================================================================//
 //                                                                         //
@@ -135,7 +135,7 @@ static tEplKernel PUBLIC EplNmtCnuCommandCb(tEplFrameInfo * pFrameInfo_p);
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuInit(unsigned int uiNodeId_p)
+EPLDLLEXPORT tEplKernel EplNmtCnuInit(unsigned int uiNodeId_p)
 {
        tEplKernel Ret;
 
@@ -161,7 +161,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuInit(unsigned int uiNodeId_p)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuAddInstance(unsigned int uiNodeId_p)
+EPLDLLEXPORT tEplKernel EplNmtCnuAddInstance(unsigned int uiNodeId_p)
 {
        tEplKernel Ret;
 
@@ -201,7 +201,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuAddInstance(unsigned int uiNodeId_p)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuDelInstance()
+EPLDLLEXPORT tEplKernel EplNmtCnuDelInstance(void)
 {
        tEplKernel Ret;
 
@@ -234,9 +234,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuDelInstance()
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p,
-                                                      tEplNmtCommand
-                                                      NmtCommand_p)
+EPLDLLEXPORT tEplKernel EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p,
+                                               tEplNmtCommand NmtCommand_p)
 {
        tEplKernel Ret;
        tEplFrameInfo NmtRequestFrameInfo;
@@ -297,9 +296,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p,
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC
-EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback
-                             pfnEplNmtCheckEventCb_p)
+EPLDLLEXPORT tEplKernel EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback pfnEplNmtCheckEventCb_p)
 {
        tEplKernel Ret;
 
@@ -335,7 +332,7 @@ EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback
 // State:
 //
 //---------------------------------------------------------------------------
-static tEplKernel PUBLIC EplNmtCnuCommandCb(tEplFrameInfo * pFrameInfo_p)
+static tEplKernel EplNmtCnuCommandCb(tEplFrameInfo *pFrameInfo_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplNmtCommand NmtCommand;
index 4ed0b6ce487c8820e8064d5a9a9c360bb509625f..79ffdbf7fad26c347439bbad1d44e24f398a67d6 100644 (file)
@@ -94,8 +94,8 @@
 
 // TracePoint support for realtime-debugging
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
-void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 #else
@@ -241,15 +241,13 @@ static tEplNmtMnuInstance EplNmtMnuInstance_g;
 // local function prototypes
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplNmtMnuCbNmtRequest(tEplFrameInfo * pFrameInfo_p);
+static tEplKernel EplNmtMnuCbNmtRequest(tEplFrameInfo *pFrameInfo_p);
 
-static tEplKernel PUBLIC EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
-                                                 tEplIdentResponse *
-                                                 pIdentResponse_p);
+static tEplKernel EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
+                                          tEplIdentResponse *pIdentResponse_p);
 
-static tEplKernel PUBLIC EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
-                                                  tEplStatusResponse *
-                                                  pStatusResponse_p);
+static tEplKernel EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
+                                           tEplStatusResponse *pStatusResponse_p);
 
 static tEplKernel EplNmtMnuCheckNmtState(unsigned int uiNodeId_p,
                                         tEplNmtMnuNodeInfo * pNodeInfo_p,
@@ -645,8 +643,7 @@ tEplKernel EplNmtMnuTriggerStateChange(unsigned int uiNodeId_p,
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange
-                                           NmtStateChange_p)
+tEplKernel EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -928,7 +925,7 @@ tEplKernel PUBLIC EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p)
+tEplKernel EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -949,7 +946,7 @@ tEplKernel PUBLIC EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p)
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtMnuProcessEvent(tEplEvent * pEvent_p)
+EPLDLLEXPORT tEplKernel EplNmtMnuProcessEvent(tEplEvent *pEvent_p)
 {
        tEplKernel Ret;
 
@@ -1258,11 +1255,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtMnuProcessEvent(tEplEvent * pEvent_p)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplNmtMnuGetDiagnosticInfo(unsigned int
-                                            *puiMandatorySlaveCount_p,
-                                            unsigned int
-                                            *puiSignalSlaveCount_p,
-                                            WORD * pwFlags_p)
+tEplKernel EplNmtMnuGetDiagnosticInfo(unsigned int *puiMandatorySlaveCount_p,
+                                     unsigned int *puiSignalSlaveCount_p,
+                                     WORD *pwFlags_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -1347,7 +1342,7 @@ Exit:
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplNmtMnuCbNmtRequest(tEplFrameInfo * pFrameInfo_p)
+static tEplKernel EplNmtMnuCbNmtRequest(tEplFrameInfo *pFrameInfo_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -1371,9 +1366,8 @@ static tEplKernel PUBLIC EplNmtMnuCbNmtRequest(tEplFrameInfo * pFrameInfo_p)
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
-                                                 tEplIdentResponse *
-                                                 pIdentResponse_p)
+static tEplKernel EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
+                                          tEplIdentResponse *pIdentResponse_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -1431,9 +1425,8 @@ static tEplKernel PUBLIC EplNmtMnuCbIdentResponse(unsigned int uiNodeId_p,
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
-                                                  tEplStatusResponse *
-                                                  pStatusResponse_p)
+static tEplKernel EplNmtMnuCbStatusResponse(unsigned int uiNodeId_p,
+                                           tEplStatusResponse *pStatusResponse_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
index 4e2d0e15e9473be92070ab0deb01e166f1a1e7e2..ad85d8e8511e9102a91e4ec72a4c19bad78f8637 100644 (file)
@@ -88,8 +88,8 @@
 
 // TracePoint support for realtime-debugging
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
-void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 #else
@@ -163,7 +163,7 @@ EPL_MCO_DEFINE_INSTANCE_FCT()
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR)
+EPLDLLEXPORT tEplKernel EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR)
 {
        tEplKernel Ret;
 
@@ -189,7 +189,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
+EPLDLLEXPORT tEplKernel EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
 {
        EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret;
 //tEplEvent               Event;
@@ -258,7 +258,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
 //
 //---------------------------------------------------------------------------
 #if (EPL_USE_DELETEINST_FUNC != FALSE)
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
+EPLDLLEXPORT tEplKernel EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
 {
        tEplKernel Ret = kEplSuccessful;
        // check for all API function if instance is valid
@@ -296,8 +296,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_
-                                             tEplEvent * pEvent_p)
+EPLDLLEXPORT tEplKernel EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplEvent *pEvent_p)
 {
        tEplKernel Ret;
        tEplNmtState OldNmtState;
@@ -1804,8 +1803,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplNmtState PUBLIC
-EplNmtkGetNmtState(EPL_MCO_DECL_PTR_INSTANCE_PTR)
+EPLDLLEXPORT tEplNmtState EplNmtkGetNmtState(EPL_MCO_DECL_PTR_INSTANCE_PTR)
 {
        tEplNmtState NmtState;
 
index 3de16a1eff5e14a7fe6c58e49804c320db1a36f4..3c6452fb304844e5d588157e77b9a7e1212297d7 100644 (file)
@@ -132,7 +132,7 @@ static tEplNmtuInstance EplNmtuInstance_g;
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuInit()
+EPLDLLEXPORT tEplKernel EplNmtuInit(void)
 {
        tEplKernel Ret;
 
@@ -158,7 +158,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuInit()
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuAddInstance()
+EPLDLLEXPORT tEplKernel EplNmtuAddInstance(void)
 {
        tEplKernel Ret;
 
@@ -187,7 +187,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuAddInstance()
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuDelInstance()
+EPLDLLEXPORT tEplKernel EplNmtuDelInstance(void)
 {
        tEplKernel Ret;
 
@@ -219,7 +219,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuDelInstance()
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p)
+EPLDLLEXPORT tEplKernel EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p)
 {
        tEplKernel Ret;
        tEplEvent Event;
@@ -253,7 +253,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplNmtState PUBLIC EplNmtuGetNmtState()
+EPLDLLEXPORT tEplNmtState EplNmtuGetNmtState(void)
 {
        tEplNmtState NmtState;
 
@@ -284,7 +284,7 @@ EPLDLLEXPORT tEplNmtState PUBLIC EplNmtuGetNmtState()
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuProcessEvent(tEplEvent * pEplEvent_p)
+EPLDLLEXPORT tEplKernel EplNmtuProcessEvent(tEplEvent *pEplEvent_p)
 {
        tEplKernel Ret;
 
@@ -664,9 +664,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplNmtuProcessEvent(tEplEvent * pEplEvent_p)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC
-EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback
-                            pfnEplNmtStateChangeCb_p)
+EPLDLLEXPORT tEplKernel EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback pfnEplNmtStateChangeCb_p)
 {
        tEplKernel Ret;
 
index 4a29ef58bf9b20e76a2d1f3d5e880644e8a949af..db823b919a5d3620f23e3640cc2d4d4de2b7d195 100644 (file)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplNmtState PUBLIC EplNmtkCalGetNmtState()
+EPLDLLEXPORT tEplNmtState EplNmtkCalGetNmtState(void)
 {
        tEplNmtState NmtState;
        // for test direkt call for EplNmtkGetNmtState()
index efbb1967a5dccd9322fad30f49230971d0f40908..a07582cec505f98ed0051050162d14eb8f444889 100644 (file)
@@ -189,24 +189,22 @@ void *EplObdGetObjectDataPtrIntern(tEplObdSubEntryPtr pSubindexEntry_p);
 static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p,
                                          BOOL * pfEntryNumerical_p);
 
-static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_
-                                            unsigned int uiIndex_p,
-                                            unsigned int uiSubIndex_p,
-                                            void *pSrcData_p,
-                                            void **ppDstData_p,
-                                            tEplObdSize Size_p,
-                                            tEplObdEntryPtr * ppObdEntry_p,
-                                            tEplObdSubEntryPtr * ppSubEntry_p,
-                                            tEplObdCbParam MEM * pCbParam_p,
-                                            tEplObdSize * pObdSize_p);
-
-static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_
-                                             tEplObdEntryPtr pObdEntry_p,
-                                             tEplObdSubEntryPtr pSubEntry_p,
-                                             tEplObdCbParam MEM * pCbParam_p,
-                                             void *pSrcData_p,
-                                             void *pDstData_p,
-                                             tEplObdSize ObdSize_p);
+static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                     unsigned int uiSubIndex_p,
+                                     void *pSrcData_p,
+                                     void **ppDstData_p,
+                                     tEplObdSize Size_p,
+                                     tEplObdEntryPtr *ppObdEntry_p,
+                                     tEplObdSubEntryPtr *ppSubEntry_p,
+                                     tEplObdCbParam MEM *pCbParam_p,
+                                     tEplObdSize *pObdSize_p);
+
+static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p,
+                                      tEplObdSubEntryPtr pSubEntry_p,
+                                      tEplObdCbParam MEM *pCbParam_p,
+                                      void *pSrcData_p,
+                                      void *pDstData_p,
+                                      tEplObdSize ObdSize_p);
 
 //=========================================================================//
 //                                                                         //
@@ -228,8 +226,7 @@ static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_
-                                         tEplObdInitParam MEM * pInitParam_p)
+EPLDLLEXPORT tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p)
 {
 
        tEplKernel Ret;
@@ -261,9 +258,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_
-                                                tEplObdInitParam MEM *
-                                                pInitParam_p)
+EPLDLLEXPORT tEplKernel EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p)
 {
 
        EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret;
@@ -308,7 +303,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 #if (EPL_USE_DELETEINST_FUNC != FALSE)
-EPLDLLEXPORT tEplKernel PUBLIC EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR)
+EPLDLLEXPORT tEplKernel EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR)
 {
        // check for all API function if instance is valid
        EPL_MCO_CHECK_INSTANCE_STATE();
@@ -341,11 +336,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR)
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                               unsigned int uiIndex_p,
-                                               unsigned int uiSubIndex_p,
-                                               void *pSrcData_p,
-                                               tEplObdSize Size_p)
+EPLDLLEXPORT tEplKernel EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                        unsigned int uiSubIndex_p,
+                                        void *pSrcData_p,
+                                        tEplObdSize Size_p)
 {
 
        tEplKernel Ret;
@@ -402,11 +396,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                              unsigned int uiIndex_p,
-                                              unsigned int uiSubIndex_p,
-                                              void *pDstData_p,
-                                              tEplObdSize * pSize_p)
+EPLDLLEXPORT tEplKernel EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                       unsigned int uiSubIndex_p,
+                                       void *pDstData_p,
+                                       tEplObdSize *pSize_p)
 {
 
        tEplKernel Ret;
@@ -487,9 +480,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_
-                                                 tEplObdPart ObdPart_p,
-                                                 tEplObdDir Direction_p)
+EPLDLLEXPORT tEplKernel EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdPart ObdPart_p,
+                                          tEplObdDir Direction_p)
 {
 
        tEplKernel Ret = kEplSuccessful;
@@ -587,8 +579,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_
-                                              tEplVarParam MEM * pVarParam_p)
+EPLDLLEXPORT tEplKernel EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ tEplVarParam MEM *pVarParam_p)
 {
 
        tEplKernel Ret;
@@ -674,9 +665,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT void *PUBLIC EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_
-                                                unsigned int uiIndex_p,
-                                                unsigned int uiSubIndex_p)
+EPLDLLEXPORT void *EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                         unsigned int uiSubIndex_p)
 {
        tEplKernel Ret;
        void *pData;
@@ -719,8 +709,7 @@ EPLDLLEXPORT void *PUBLIC EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_
-                                                   tEplObdEntryPtr pUserOd_p)
+EPLDLLEXPORT tEplKernel EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pUserOd_p)
 {
 
        EPL_MCO_CHECK_INSTANCE_STATE();
@@ -749,10 +738,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT void PUBLIC EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                           tEplObdVarEntry MEM * pVarEntry_p,
-                                           tEplObdType Type_p,
-                                           tEplObdSize ObdSize_p)
+EPLDLLEXPORT void EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdVarEntry MEM *pVarEntry_p,
+                                    tEplObdType Type_p, tEplObdSize ObdSize_p)
 {
 /*
     #if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
@@ -803,9 +790,8 @@ EPLDLLEXPORT void PUBLIC EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplObdSize PUBLIC EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_
-                                                 unsigned int uiIndex_p,
-                                                 unsigned int uiSubIndex_p)
+EPLDLLEXPORT tEplObdSize EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                          unsigned int uiSubIndex_p)
 {
        tEplKernel Ret;
        tEplObdSize ObdSize;
@@ -845,7 +831,7 @@ EPLDLLEXPORT tEplObdSize PUBLIC EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT unsigned int PUBLIC EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR)
+EPLDLLEXPORT unsigned int EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR)
 {
        tEplKernel Ret;
        tEplObdSize ObdSize;
@@ -882,9 +868,8 @@ EPLDLLEXPORT unsigned int PUBLIC EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdSetNodeId(EPL_MCO_DECL_PTR_INSTANCE_PTR_
-                                              unsigned int uiNodeId_p,
-                                              tEplObdNodeIdType NodeIdType_p)
+EPLDLLEXPORT tEplKernel EplObdSetNodeId(EPL_MCO_DECL_PTR_INSTANCE_PTR_ unsigned int uiNodeId_p,
+                                       tEplObdNodeIdType NodeIdType_p)
 {
        tEplKernel Ret;
        tEplObdSize ObdSize;
@@ -966,10 +951,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdSetNodeId(EPL_MCO_DECL_PTR_INSTANCE_PTR_
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_
-                                                unsigned int uiIndex_p,
-                                                unsigned int uiSubIndex_p,
-                                                BOOL * pfEntryNumerical_p)
+EPLDLLEXPORT tEplKernel EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                         unsigned int uiSubIndex_p,
+                                         BOOL *pfEntryNumerical_p)
 {
        tEplKernel Ret;
        tEplObdEntryPtr pObdEntry;
@@ -1018,11 +1002,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_
-                                                  unsigned int uiIndex_p,
-                                                  unsigned int uiSubIndex_p,
-                                                  void *pDstData_p,
-                                                  tEplObdSize * pSize_p)
+EPLDLLEXPORT tEplKernel EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                           unsigned int uiSubIndex_p,
+                                           void *pDstData_p,
+                                           tEplObdSize *pSize_p)
 {
        tEplKernel Ret;
        tEplObdEntryPtr pObdEntry;
@@ -1199,11 +1182,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_
-                                                     unsigned int uiIndex_p,
-                                                     unsigned int uiSubIndex_p,
-                                                     void *pSrcData_p,
-                                                     tEplObdSize Size_p)
+EPLDLLEXPORT tEplKernel EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                              unsigned int uiSubIndex_p,
+                                              void *pSrcData_p,
+                                              tEplObdSize Size_p)
 {
        tEplKernel Ret;
        tEplObdEntryPtr pObdEntry;
@@ -1345,10 +1327,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_
-                                                  unsigned int uiIndex_p,
-                                                  unsigned int uiSubIndex_p,
-                                                  tEplObdAccess * pAccessTyp_p)
+EPLDLLEXPORT tEplKernel EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                           unsigned int uiSubIndex_p,
+                                           tEplObdAccess *pAccessTyp_p)
 {
        tEplKernel Ret;
        tEplObdEntryPtr pObdEntry;
@@ -1388,10 +1369,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                      unsigned int uiIndex_p,
-                                      unsigned int uiSubindex_p,
-                                      tEplObdVarEntry MEM ** ppVarEntry_p)
+tEplKernel EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                               unsigned int uiSubindex_p,
+                               tEplObdVarEntry MEM **ppVarEntry_p)
 {
 
        tEplKernel Ret;
@@ -1870,16 +1850,15 @@ static tEplKernel EplObdCheckObjectRange(tEplObdSubEntryPtr pSubindexEntry_p,
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_
-                                            unsigned int uiIndex_p,
-                                            unsigned int uiSubIndex_p,
-                                            void *pSrcData_p,
-                                            void **ppDstData_p,
-                                            tEplObdSize Size_p,
-                                            tEplObdEntryPtr * ppObdEntry_p,
-                                            tEplObdSubEntryPtr * ppSubEntry_p,
-                                            tEplObdCbParam MEM * pCbParam_p,
-                                            tEplObdSize * pObdSize_p)
+static tEplKernel EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                     unsigned int uiSubIndex_p,
+                                     void *pSrcData_p,
+                                     void **ppDstData_p,
+                                     tEplObdSize Size_p,
+                                     tEplObdEntryPtr *ppObdEntry_p,
+                                     tEplObdSubEntryPtr *ppSubEntry_p,
+                                     tEplObdCbParam MEM *pCbParam_p,
+                                     tEplObdSize *pObdSize_p)
 {
 
        tEplKernel Ret;
@@ -2064,13 +2043,12 @@ static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_
 //
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_
-                                             tEplObdEntryPtr pObdEntry_p,
-                                             tEplObdSubEntryPtr pSubEntry_p,
-                                             tEplObdCbParam MEM * pCbParam_p,
-                                             void *pSrcData_p,
-                                             void *pDstData_p,
-                                             tEplObdSize ObdSize_p)
+static tEplKernel EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pObdEntry_p,
+                                      tEplObdSubEntryPtr pSubEntry_p,
+                                      tEplObdCbParam MEM *pCbParam_p,
+                                      void *pSrcData_p,
+                                      void *pDstData_p,
+                                      tEplObdSize ObdSize_p)
 {
 
        tEplKernel Ret;
@@ -2762,9 +2740,7 @@ static tEplKernel EplObdGetSubindexIntern(tEplObdEntryPtr pObdEntry_p,
 //
 //---------------------------------------------------------------------------
 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
-EPLDLLEXPORT tEplKernel PUBLIC
-EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_
-                             tEplObdStoreLoadObjCallback fpCallback_p)
+EPLDLLEXPORT tEplKernel EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdStoreLoadObjCallback fpCallback_p)
 {
 
        EPL_MCO_CHECK_INSTANCE_STATE();
index 88cc11e34ccd11d1450b9ee76a0d94c28598b9cc..6e450d84be86dc2a70233f6aeeba7ac134a9d8b1 100644 (file)
@@ -283,8 +283,7 @@ typedef enum {
        kVarValidAll = 0x03     // currently only size and data are implemented and used
 } tEplVarParamValid;
 
-typedef tEplKernel(PUBLIC ROM * tEplVarCallback) (CCM_DECL_INSTANCE_HDL_
-                                                 void *pParam_p);
+typedef tEplKernel(ROM *tEplVarCallback) (CCM_DECL_INSTANCE_HDL_ void *pParam_p);
 
 typedef struct {
        tEplVarParamValid m_ValidFlag;
@@ -376,9 +375,7 @@ typedef struct {
 } tEplObdCbParam;
 
 // define type for callback function: pParam_p points to tEplObdCbParam
-typedef tEplKernel(PUBLIC ROM * tEplObdCallback) (CCM_DECL_INSTANCE_HDL_
-                                                 tEplObdCbParam MEM *
-                                                 pParam_p);
+typedef tEplKernel(ROM *tEplObdCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbParam MEM * pParam_p);
 
 // do not change the order for this struct!!!
 
@@ -422,14 +419,10 @@ typedef struct {
 
 } tEplObdCbStoreParam;
 
-typedef tEplKernel(PUBLIC ROM * tInitTabEntryCallback) (void MEM * pTabEntry_p,
-                                                       unsigned int
-                                                       uiObjIndex_p);
+typedef tEplKernel(ROM *tInitTabEntryCallback) (void MEM * pTabEntry_p,
+                                               unsigned int uiObjIndex_p);
 
-typedef tEplKernel(PUBLIC ROM *
-                  tEplObdStoreLoadObjCallback) (CCM_DECL_INSTANCE_HDL_
-                                                tEplObdCbStoreParam MEM *
-                                                pCbStoreParam_p);
+typedef tEplKernel(ROM * tEplObdStoreLoadObjCallback) (CCM_DECL_INSTANCE_HDL_ tEplObdCbStoreParam MEM *pCbStoreParam_p);
 
 // -------------------------------------------------------------------------
 // this stucture is used for parameters for function ObdInitModuleTab()
index 218d152897cf6c8daf58753c61c78ffb1977fa0b..60f590bfbea00298f5feec52fd532e755f7aa3bf 100644 (file)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntry(unsigned int uiIndex_p,
-                                                unsigned int uiSubIndex_p,
-                                                void *pSrcData_p,
-                                                tEplObdSize Size_p)
+EPLDLLEXPORT tEplKernel EplObduWriteEntry(unsigned int uiIndex_p,
+                                         unsigned int uiSubIndex_p,
+                                         void *pSrcData_p, tEplObdSize Size_p)
 {
        tEplKernel Ret;
 
@@ -153,10 +152,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntry(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntry(unsigned int uiIndex_p,
-                                               unsigned int uiSubIndex_p,
-                                               void *pDstData_p,
-                                               tEplObdSize * pSize_p)
+EPLDLLEXPORT tEplKernel EplObduReadEntry(unsigned int uiIndex_p,
+                                        unsigned int uiSubIndex_p,
+                                        void *pDstData_p,
+                                        tEplObdSize *pSize_p)
 {
        tEplKernel Ret;
 
@@ -179,8 +178,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntry(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduAccessOdPart(tEplObdPart ObdPart_p,
-                                                  tEplObdDir Direction_p)
+EPLDLLEXPORT tEplKernel EplObduAccessOdPart(tEplObdPart ObdPart_p,
+                                           tEplObdDir Direction_p)
 {
        tEplKernel Ret;
 
@@ -202,7 +201,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduAccessOdPart(tEplObdPart ObdPart_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduDefineVar(tEplVarParam MEM * pVarParam_p)
+EPLDLLEXPORT tEplKernel EplObduDefineVar(tEplVarParam MEM *pVarParam_p)
 {
        tEplKernel Ret;
 
@@ -226,8 +225,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduDefineVar(tEplVarParam MEM * pVarParam_p)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT void *PUBLIC EplObduGetObjectDataPtr(unsigned int uiIndex_p,
-                                                 unsigned int uiSubIndex_p)
+EPLDLLEXPORT void *EplObduGetObjectDataPtr(unsigned int uiIndex_p,
+                                          unsigned int uiSubIndex_p)
 {
        void *pData;
 
@@ -250,7 +249,7 @@ EPLDLLEXPORT void *PUBLIC EplObduGetObjectDataPtr(unsigned int uiIndex_p,
 //
 //---------------------------------------------------------------------------
 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
-EPLDLLEXPORT tEplKernel PUBLIC EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p)
+EPLDLLEXPORT tEplKernel EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p)
 {
        tEplKernel Ret;
 
@@ -275,9 +274,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT void PUBLIC EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p,
-                                            BYTE bType_p,
-                                            tEplObdSize ObdSize_p)
+EPLDLLEXPORT void EplObduInitVarEntry(tEplObdVarEntry MEM *pVarEntry_p,
+                                     BYTE bType_p, tEplObdSize ObdSize_p)
 {
        EplObduCalInitVarEntry(pVarEntry_p, bType_p, ObdSize_p);
 }
@@ -299,8 +297,8 @@ EPLDLLEXPORT void PUBLIC EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplObdSize PUBLIC EplObduGetDataSize(unsigned int uiIndex_p,
-                                                  unsigned int uiSubIndex_p)
+EPLDLLEXPORT tEplObdSize EplObduGetDataSize(unsigned int uiIndex_p,
+                                           unsigned int uiSubIndex_p)
 {
        tEplObdSize Size;
 
@@ -323,7 +321,7 @@ EPLDLLEXPORT tEplObdSize PUBLIC EplObduGetDataSize(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT unsigned int PUBLIC EplObduGetNodeId()
+EPLDLLEXPORT unsigned int EplObduGetNodeId(void)
 {
        unsigned int uiNodeId;
 
@@ -347,8 +345,8 @@ EPLDLLEXPORT unsigned int PUBLIC EplObduGetNodeId()
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduSetNodeId(unsigned int uiNodeId_p,
-                                               tEplObdNodeIdType NodeIdType_p)
+EPLDLLEXPORT tEplKernel EplObduSetNodeId(unsigned int uiNodeId_p,
+                                        tEplObdNodeIdType NodeIdType_p)
 {
        tEplKernel Ret;
 
@@ -373,10 +371,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduSetNodeId(unsigned int uiNodeId_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduGetAccessType(unsigned int uiIndex_p,
-                                                   unsigned int uiSubIndex_p,
-                                                   tEplObdAccess *
-                                                   pAccessTyp_p)
+EPLDLLEXPORT tEplKernel EplObduGetAccessType(unsigned int uiIndex_p,
+                                            unsigned int uiSubIndex_p,
+                                            tEplObdAccess *pAccessTyp_p)
 {
        tEplObdAccess AccessType;
 
@@ -410,10 +407,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduGetAccessType(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntryToLe(unsigned int uiIndex_p,
-                                                   unsigned int uiSubIndex_p,
-                                                   void *pDstData_p,
-                                                   tEplObdSize * pSize_p)
+EPLDLLEXPORT tEplKernel EplObduReadEntryToLe(unsigned int uiIndex_p,
+                                            unsigned int uiSubIndex_p,
+                                            void *pDstData_p,
+                                            tEplObdSize *pSize_p)
 {
        tEplKernel Ret;
 
@@ -445,11 +442,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntryToLe(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntryFromLe(unsigned int uiIndex_p,
-                                                      unsigned int
-                                                      uiSubIndex_p,
-                                                      void *pSrcData_p,
-                                                      tEplObdSize Size_p)
+EPLDLLEXPORT tEplKernel EplObduWriteEntryFromLe(unsigned int uiIndex_p,
+                                               unsigned int uiSubIndex_p,
+                                               void *pSrcData_p,
+                                               tEplObdSize Size_p)
 {
        tEplKernel Ret;
 
@@ -475,11 +471,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntryFromLe(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                                    unsigned int uiIndex_p,
-                                                    unsigned int uiSubindex_p,
-                                                    tEplObdVarEntry MEM **
-                                                    ppVarEntry_p)
+EPLDLLEXPORT tEplKernel EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                             unsigned int uiSubindex_p,
+                                             tEplObdVarEntry MEM **ppVarEntry_p)
 {
        tEplKernel Ret;
 
index 85b3df0886b12387b0569fef14e0ba0b166b4fd1..980d382d49a4dfc8490cecf4bf3a5d858898c70d 100644 (file)
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntry(unsigned int uiIndex_p,
-                                                   unsigned int uiSubIndex_p,
-                                                   void *pSrcData_p,
-                                                   tEplObdSize Size_p)
+EPLDLLEXPORT tEplKernel EplObduCalWriteEntry(unsigned int uiIndex_p,
+                                            unsigned int uiSubIndex_p,
+                                            void *pSrcData_p,
+                                            tEplObdSize Size_p)
 {
        tEplKernel Ret;
 
@@ -155,10 +155,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntry(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntry(unsigned int uiIndex_p,
-                                                  unsigned int uiSubIndex_p,
-                                                  void *pDstData_p,
-                                                  tEplObdSize * pSize_p)
+EPLDLLEXPORT tEplKernel EplObduCalReadEntry(unsigned int uiIndex_p,
+                                           unsigned int uiSubIndex_p,
+                                           void *pDstData_p,
+                                           tEplObdSize *pSize_p)
 {
        tEplKernel Ret;
 
@@ -185,8 +185,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntry(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
-                                                     tEplObdDir Direction_p)
+EPLDLLEXPORT tEplKernel EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
+                                              tEplObdDir Direction_p)
 {
        tEplKernel Ret;
 
@@ -212,8 +212,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalDefineVar(tEplVarParam MEM *
-                                                  pVarParam_p)
+EPLDLLEXPORT tEplKernel EplObduCalDefineVar(tEplVarParam MEM *pVarParam_p)
 {
        tEplKernel Ret;
 
@@ -240,8 +239,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalDefineVar(tEplVarParam MEM *
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT void *PUBLIC EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
-                                                    unsigned int uiSubIndex_p)
+EPLDLLEXPORT void *EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
+                                             unsigned int uiSubIndex_p)
 {
        void *pData;
 
@@ -268,8 +267,7 @@ EPLDLLEXPORT void *PUBLIC EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
 //
 //---------------------------------------------------------------------------
 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalRegisterUserOd(tEplObdEntryPtr
-                                                       pUserOd_p)
+EPLDLLEXPORT tEplKernel EplObduCalRegisterUserOd(tEplObdEntryPtr pUserOd_p)
 {
        tEplKernel Ret;
 
@@ -298,9 +296,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalRegisterUserOd(tEplObdEntryPtr
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT void PUBLIC EplObduCalInitVarEntry(tEplObdVarEntry MEM *
-                                               pVarEntry_p, BYTE bType_p,
-                                               tEplObdSize ObdSize_p)
+EPLDLLEXPORT void EplObduCalInitVarEntry(tEplObdVarEntry MEM *pVarEntry_p,
+                                        BYTE bType_p, tEplObdSize ObdSize_p)
 {
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
        EplObdInitVarEntry(pVarEntry_p, bType_p, ObdSize_p);
@@ -324,8 +321,8 @@ EPLDLLEXPORT void PUBLIC EplObduCalInitVarEntry(tEplObdVarEntry MEM *
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplObdSize PUBLIC EplObduCalGetDataSize(unsigned int uiIndex_p,
-                                                     unsigned int uiSubIndex_p)
+EPLDLLEXPORT tEplObdSize EplObduCalGetDataSize(unsigned int uiIndex_p,
+                                              unsigned int uiSubIndex_p)
 {
        tEplObdSize Size;
 
@@ -352,7 +349,7 @@ EPLDLLEXPORT tEplObdSize PUBLIC EplObduCalGetDataSize(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT unsigned int PUBLIC EplObduCalGetNodeId()
+EPLDLLEXPORT unsigned int EplObduCalGetNodeId(void)
 {
        unsigned int uiNodeId;
 
@@ -380,9 +377,8 @@ EPLDLLEXPORT unsigned int PUBLIC EplObduCalGetNodeId()
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalSetNodeId(unsigned int uiNodeId_p,
-                                                  tEplObdNodeIdType
-                                                  NodeIdType_p)
+EPLDLLEXPORT tEplKernel EplObduCalSetNodeId(unsigned int uiNodeId_p,
+                                           tEplObdNodeIdType NodeIdType_p)
 {
        tEplKernel Ret;
 
@@ -411,11 +407,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalSetNodeId(unsigned int uiNodeId_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalGetAccessType(unsigned int uiIndex_p,
-                                                      unsigned int
-                                                      uiSubIndex_p,
-                                                      tEplObdAccess *
-                                                      pAccessTyp_p)
+EPLDLLEXPORT tEplKernel EplObduCalGetAccessType(unsigned int uiIndex_p,
+                                               unsigned int uiSubIndex_p,
+                                               tEplObdAccess *pAccessTyp_p)
 {
        tEplObdAccess AccesType;
 
@@ -447,11 +441,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalGetAccessType(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntryToLe(unsigned int uiIndex_p,
-                                                      unsigned int
-                                                      uiSubIndex_p,
-                                                      void *pDstData_p,
-                                                      tEplObdSize * pSize_p)
+EPLDLLEXPORT tEplKernel EplObduCalReadEntryToLe(unsigned int uiIndex_p,
+                                               unsigned int uiSubIndex_p,
+                                               void *pDstData_p,
+                                               tEplObdSize *pSize_p)
 {
        tEplKernel Ret;
 
@@ -481,12 +474,10 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntryToLe(unsigned int uiIndex_p,
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntryFromLe(unsigned int
-                                                         uiIndex_p,
-                                                         unsigned int
-                                                         uiSubIndex_p,
-                                                         void *pSrcData_p,
-                                                         tEplObdSize Size_p)
+EPLDLLEXPORT tEplKernel EplObduCalWriteEntryFromLe(unsigned int uiIndex_p,
+                                                  unsigned int uiSubIndex_p,
+                                                  void *pSrcData_p,
+                                                  tEplObdSize Size_p)
 {
        tEplKernel Ret;
 
@@ -514,10 +505,9 @@ EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntryFromLe(unsigned int
 // State:
 //
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC
-EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
-                        unsigned int uiSubindex_p,
-                        tEplObdVarEntry MEM ** ppVarEntry_p)
+EPLDLLEXPORT tEplKernel EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                                unsigned int uiSubindex_p,
+                                                tEplObdVarEntry MEM **ppVarEntry_p)
 {
        tEplKernel Ret;
 
index 7713125a3e8d5297d6fb948bce4800030d21a270..4a6fac56ef6cd959f521061c1a5d8b163c1ec081 100644 (file)
 //
 // ----------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EPL_OBD_INIT_RAM_NAME(tEplObdInitParam MEM *
-                                                    pInitParam_p)
+EPLDLLEXPORT tEplKernel EPL_OBD_INIT_RAM_NAME(tEplObdInitParam MEM *pInitParam_p)
 {
 
        tEplObdInitParam MEM *pInitParam = pInitParam_p;
index e7b10653a0edc058d5a751047715c3edfe2b889f..dfaabb4b9496e2e95fdf92f1a07e0e916e8d754f 100644 (file)
@@ -226,7 +226,7 @@ tEplKernel EplPdouDelInstance(void)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplPdouCbObdAccess(tEplObdCbParam MEM * pParam_p)
+tEplKernel EplPdouCbObdAccess(tEplObdCbParam MEM *pParam_p)
 {
        tEplKernel Ret = kEplSuccessful;
        unsigned int uiPdoId;
index 1cb3f2de4a3c8d5fe7eb5c4bcb73a84fa3586657..a09d1eb053958e6eaea83beb1f9ba8eb5cf47b25 100644 (file)
@@ -116,20 +116,18 @@ typedef unsigned int tEplSdoConHdl;
 
 // callback function pointer for Protocol Abstraction Layer to call
 // asynchronuus SDO Sequence Layer
-typedef tEplKernel(PUBLIC * tEplSequLayerReceiveCb) (tEplSdoConHdl ConHdl_p,
-                                                    tEplAsySdoSeq *
-                                                    pSdoSeqData_p,
-                                                    unsigned int uiDataSize_p);
+typedef tEplKernel(*tEplSequLayerReceiveCb) (tEplSdoConHdl ConHdl_p,
+                                            tEplAsySdoSeq *pSdoSeqData_p,
+                                            unsigned int uiDataSize_p);
 
 // handle between asynchronuus SDO Sequence Layer and SDO Command layer
 typedef unsigned int tEplSdoSeqConHdl;
 
 // callback function pointer for asynchronuus SDO Sequence Layer to call
 // SDO Command layer for received data
-typedef tEplKernel(PUBLIC *
-                  tEplSdoComReceiveCb) (tEplSdoSeqConHdl SdoSeqConHdl_p,
-                                        tEplAsySdoCom * pAsySdoCom_p,
-                                        unsigned int uiDataSize_p);
+typedef tEplKernel(* tEplSdoComReceiveCb) (tEplSdoSeqConHdl SdoSeqConHdl_p,
+                                          tEplAsySdoCom *pAsySdoCom_p,
+                                          unsigned int uiDataSize_p);
 
 // status of connection
 typedef enum {
@@ -143,9 +141,8 @@ typedef enum {
 
 // callback function pointer for asynchronuus SDO Sequence Layer to call
 // SDO Command layer for connection status
-typedef tEplKernel(PUBLIC * tEplSdoComConCb) (tEplSdoSeqConHdl SdoSeqConHdl_p,
-                                             tEplAsySdoConState
-                                             AsySdoConState_p);
+typedef tEplKernel(* tEplSdoComConCb) (tEplSdoSeqConHdl SdoSeqConHdl_p,
+                                      tEplAsySdoConState AsySdoConState_p);
 
 // handle between  SDO Command layer and application
 typedef unsigned int tEplSdoComConHdl;
@@ -221,8 +218,7 @@ typedef struct {
 } tEplSdoComFinished;
 
 // callback function pointer to inform application about connection
-typedef tEplKernel(PUBLIC * tEplSdoFinishedCb) (tEplSdoComFinished *
-                                               pSdoComFinished_p);
+typedef tEplKernel(* tEplSdoFinishedCb) (tEplSdoComFinished *pSdoComFinished_p);
 
 // structure to init SDO transfer to Read or Write by Index
 typedef struct {
index 05a00c9a731eaf9c78286291a0c43f16a4caa92f..a6596a51f1eb0948d2b5b1a8256f9ea5ccdbaa66 100644 (file)
@@ -110,7 +110,7 @@ static tEplSdoAsndInstance SdoAsndInstance_g;
 // local function prototypes
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplSdoAsnduCb(tEplFrameInfo * pFrameInfo_p);
+tEplKernel EplSdoAsnduCb(tEplFrameInfo *pFrameInfo_p);
 
 /***************************************************************************/
 /*                                                                         */
@@ -149,7 +149,7 @@ tEplKernel PUBLIC EplSdoAsnduCb(tEplFrameInfo * pFrameInfo_p);
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p)
+tEplKernel EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p)
 {
        tEplKernel Ret;
 
@@ -176,7 +176,7 @@ tEplKernel PUBLIC EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
+tEplKernel EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
 {
        tEplKernel Ret;
 
@@ -218,7 +218,7 @@ tEplKernel PUBLIC EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsnduDelInstance()
+tEplKernel EplSdoAsnduDelInstance(void)
 {
        tEplKernel Ret;
 
@@ -251,8 +251,8 @@ tEplKernel PUBLIC EplSdoAsnduDelInstance()
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsnduInitCon(tEplSdoConHdl * pSdoConHandle_p,
-                                    unsigned int uiTargetNodeId_p)
+tEplKernel EplSdoAsnduInitCon(tEplSdoConHdl *pSdoConHandle_p,
+                             unsigned int uiTargetNodeId_p)
 {
        tEplKernel Ret;
        unsigned int uiCount;
@@ -319,9 +319,9 @@ tEplKernel PUBLIC EplSdoAsnduInitCon(tEplSdoConHdl * pSdoConHandle_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p,
-                                     tEplFrame * pSrcData_p,
-                                     DWORD dwDataSize_p)
+tEplKernel EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p,
+                              tEplFrame *pSrcData_p,
+                              DWORD dwDataSize_p)
 {
        tEplKernel Ret;
        unsigned int uiArray;
@@ -379,7 +379,7 @@ tEplKernel PUBLIC EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p)
+tEplKernel EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p)
 {
        tEplKernel Ret;
        unsigned int uiArray;
@@ -422,7 +422,7 @@ tEplKernel PUBLIC EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsnduCb(tEplFrameInfo * pFrameInfo_p)
+tEplKernel EplSdoAsnduCb(tEplFrameInfo *pFrameInfo_p)
 {
        tEplKernel Ret = kEplSuccessful;
        unsigned int uiCount;
index 6b6a9975d78b17f9119dd3d4bbcb9ce540c073af..9048905dcde8fe402f28452f091511a6ed0b7e6a 100644 (file)
@@ -203,9 +203,9 @@ static tEplKernel EplSdoAsySeqSendLowerLayer(tEplAsySdoSeqCon * pAsySdoSeqCon_p,
                                             unsigned int uiDataSize_p,
                                             tEplFrame * pEplFrame_p);
 
-tEplKernel PUBLIC EplSdoAsyReceiveCb(tEplSdoConHdl ConHdl_p,
-                                    tEplAsySdoSeq * pSdoSeqData_p,
-                                    unsigned int uiDataSize_p);
+tEplKernel EplSdoAsyReceiveCb(tEplSdoConHdl ConHdl_p,
+                             tEplAsySdoSeq *pSdoSeqData_p,
+                             unsigned int uiDataSize_p);
 
 static tEplKernel EplSdoAsyInitHistory(void);
 
@@ -267,8 +267,8 @@ static tEplKernel EplSdoAsySeqSetTimer(tEplAsySdoSeqCon * pAsySdoSeqCon_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p,
-                                  tEplSdoComConCb fpSdoComConCb_p)
+tEplKernel EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p,
+                           tEplSdoComConCb fpSdoComConCb_p)
 {
        tEplKernel Ret;
 
@@ -297,8 +297,8 @@ tEplKernel PUBLIC EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p,
-                                         tEplSdoComConCb fpSdoComConCb_p)
+tEplKernel EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p,
+                                  tEplSdoComConCb fpSdoComConCb_p)
 {
        tEplKernel Ret;
 
@@ -380,7 +380,7 @@ tEplKernel PUBLIC EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsySeqDelInstance()
+tEplKernel EplSdoAsySeqDelInstance(void)
 {
        tEplKernel Ret;
        unsigned int uiCount;
@@ -439,9 +439,9 @@ tEplKernel PUBLIC EplSdoAsySeqDelInstance()
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsySeqInitCon(tEplSdoSeqConHdl * pSdoSeqConHdl_p,
-                                     unsigned int uiNodeId_p,
-                                     tEplSdoType SdoType)
+tEplKernel EplSdoAsySeqInitCon(tEplSdoSeqConHdl *pSdoSeqConHdl_p,
+                              unsigned int uiNodeId_p,
+                              tEplSdoType SdoType)
 {
        tEplKernel Ret;
        unsigned int uiCount;
@@ -594,9 +594,9 @@ tEplKernel PUBLIC EplSdoAsySeqInitCon(tEplSdoSeqConHdl * pSdoSeqConHdl_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p,
-                                      unsigned int uiDataSize_p,
-                                      tEplFrame * pabData_p)
+tEplKernel EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p,
+                               unsigned int uiDataSize_p,
+                               tEplFrame *pabData_p)
 {
        tEplKernel Ret;
        unsigned int uiHandle;
@@ -640,7 +640,7 @@ tEplKernel PUBLIC EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsySeqProcessEvent(tEplEvent * pEvent_p)
+tEplKernel EplSdoAsySeqProcessEvent(tEplEvent *pEvent_p)
 {
        tEplKernel Ret;
        tEplTimerEventArg *pTimerEventArg;
@@ -714,7 +714,7 @@ tEplKernel PUBLIC EplSdoAsySeqProcessEvent(tEplEvent * pEvent_p)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsySeqDelCon(tEplSdoSeqConHdl SdoSeqConHdl_p)
+tEplKernel EplSdoAsySeqDelCon(tEplSdoSeqConHdl SdoSeqConHdl_p)
 {
        tEplKernel Ret = kEplSuccessful;
        unsigned int uiHandle;
@@ -2139,9 +2139,9 @@ static tEplKernel EplSdoAsySeqSendLowerLayer(tEplAsySdoSeqCon * pAsySdoSeqCon_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsyReceiveCb(tEplSdoConHdl ConHdl_p,
-                                    tEplAsySdoSeq * pSdoSeqData_p,
-                                    unsigned int uiDataSize_p)
+tEplKernel EplSdoAsyReceiveCb(tEplSdoConHdl ConHdl_p,
+                             tEplAsySdoSeq *pSdoSeqData_p,
+                             unsigned int uiDataSize_p)
 {
        tEplKernel Ret;
        unsigned int uiCount = 0;
index ce0eb33f4c41129c8d2fa35bc62e7c85cc9fbe7d..af3d1b14674594fee16470feb207c53212ea18e7 100644 (file)
@@ -205,12 +205,12 @@ static tEplSdoComInstance SdoComInstance_g;
 //---------------------------------------------------------------------------
 // local function prototypes
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
-                                    tEplAsySdoCom * pAsySdoCom_p,
-                                    unsigned int uiDataSize_p);
+tEplKernel EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
+                             tEplAsySdoCom *pAsySdoCom_p,
+                             unsigned int uiDataSize_p);
 
-tEplKernel PUBLIC EplSdoComConCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
-                                tEplAsySdoConState AsySdoConState_p);
+tEplKernel EplSdoComConCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
+                         tEplAsySdoConState AsySdoConState_p);
 
 static tEplKernel EplSdoComSearchConIntern(tEplSdoSeqConHdl SdoSeqConHdl_p,
                                           tEplSdoComConEvent SdoComConEvent_p,
@@ -285,7 +285,7 @@ static tEplKernel EplSdoComClientSendAbort(tEplSdoComCon * pSdoComCon_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoComInit(void)
+tEplKernel EplSdoComInit(void)
 {
        tEplKernel Ret;
 
@@ -312,7 +312,7 @@ tEplKernel PUBLIC EplSdoComInit(void)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoComAddInstance(void)
+tEplKernel EplSdoComAddInstance(void)
 {
        tEplKernel Ret;
 
@@ -354,7 +354,7 @@ tEplKernel PUBLIC EplSdoComAddInstance(void)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoComDelInstance(void)
+tEplKernel EplSdoComDelInstance(void)
 {
        tEplKernel Ret;
 
@@ -398,9 +398,9 @@ tEplKernel PUBLIC EplSdoComDelInstance(void)
 //
 //---------------------------------------------------------------------------
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
-tEplKernel PUBLIC EplSdoComDefineCon(tEplSdoComConHdl * pSdoComConHdl_p,
-                                    unsigned int uiTargetNodeId_p,
-                                    tEplSdoType ProtType_p)
+tEplKernel EplSdoComDefineCon(tEplSdoComConHdl *pSdoComConHdl_p,
+                             unsigned int uiTargetNodeId_p,
+                             tEplSdoType ProtType_p)
 {
        tEplKernel Ret;
        unsigned int uiCount;
@@ -511,8 +511,7 @@ tEplKernel PUBLIC EplSdoComDefineCon(tEplSdoComConHdl * pSdoComConHdl_p,
 //
 //---------------------------------------------------------------------------
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
-tEplKernel PUBLIC EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex *
-                                              pSdoComTransParam_p)
+tEplKernel EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex *pSdoComTransParam_p)
 {
        tEplKernel Ret;
        tEplSdoComCon *pSdoComCon;
@@ -603,7 +602,7 @@ tEplKernel PUBLIC EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex *
 //
 //---------------------------------------------------------------------------
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
-tEplKernel PUBLIC EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p)
+tEplKernel EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p)
 {
        tEplKernel Ret;
        tEplSdoComCon *pSdoComCon;
@@ -669,8 +668,8 @@ tEplKernel PUBLIC EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p)
 //
 //---------------------------------------------------------------------------
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
-tEplKernel PUBLIC EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p,
-                                   tEplSdoComFinished * pSdoComFinished_p)
+tEplKernel EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p,
+                            tEplSdoComFinished *pSdoComFinished_p)
 {
        tEplKernel Ret;
        tEplSdoComCon *pSdoComCon;
@@ -747,8 +746,8 @@ tEplKernel PUBLIC EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p,
 //
 //---------------------------------------------------------------------------
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
-tEplKernel PUBLIC EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p,
-                                   DWORD dwAbortCode_p)
+tEplKernel EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p,
+                            DWORD dwAbortCode_p)
 {
        tEplKernel Ret;
        tEplSdoComCon *pSdoComCon;
@@ -803,9 +802,9 @@ tEplKernel PUBLIC EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
-                                    tEplAsySdoCom * pAsySdoCom_p,
-                                    unsigned int uiDataSize_p)
+tEplKernel EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
+                             tEplAsySdoCom *pAsySdoCom_p,
+                             unsigned int uiDataSize_p)
 {
        tEplKernel Ret;
 
@@ -840,8 +839,8 @@ tEplKernel PUBLIC EplSdoComReceiveCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoComConCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
-                                tEplAsySdoConState AsySdoConState_p)
+tEplKernel EplSdoComConCb(tEplSdoSeqConHdl SdoSeqConHdl_p,
+                         tEplAsySdoConState AsySdoConState_p)
 {
        tEplKernel Ret;
        tEplSdoComConEvent SdoComConEvent = kEplSdoComConEventSendFirst;
index be52233b3ee83690dd66e8bbd6916e6219103557..74fe25968e296d7fd119a53dbecb272811f4513b 100644 (file)
@@ -134,7 +134,7 @@ static tEplSdoUdpInstance SdoUdpInstance_g;
 //---------------------------------------------------------------------------
 
 #if (TARGET_SYSTEM == _WIN32_)
-static DWORD PUBLIC EplSdoUdpThread(LPVOID lpParameter);
+static DWORD EplSdoUdpThread(LPVOID lpParameter);
 
 #elif (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
 static int EplSdoUdpThread(void *pArg_p);
@@ -177,7 +177,7 @@ static int EplSdoUdpThread(void *pArg_p);
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p)
+tEplKernel EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p)
 {
        tEplKernel Ret;
 
@@ -205,7 +205,7 @@ tEplKernel PUBLIC EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
+tEplKernel EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
 {
        tEplKernel Ret;
 
@@ -273,7 +273,7 @@ tEplKernel PUBLIC EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p)
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoUdpuDelInstance()
+tEplKernel EplSdoUdpuDelInstance(void)
 {
        tEplKernel Ret;
 
@@ -340,8 +340,7 @@ tEplKernel PUBLIC EplSdoUdpuDelInstance()
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoUdpuConfig(unsigned long ulIpAddr_p,
-                                  unsigned int uiPort_p)
+tEplKernel EplSdoUdpuConfig(unsigned long ulIpAddr_p, unsigned int uiPort_p)
 {
        tEplKernel Ret;
        struct sockaddr_in Addr;
@@ -459,8 +458,8 @@ tEplKernel PUBLIC EplSdoUdpuConfig(unsigned long ulIpAddr_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoUdpuInitCon(tEplSdoConHdl * pSdoConHandle_p,
-                                   unsigned int uiTargetNodeId_p)
+tEplKernel EplSdoUdpuInitCon(tEplSdoConHdl *pSdoConHandle_p,
+                            unsigned int uiTargetNodeId_p)
 {
        tEplKernel Ret;
        unsigned int uiCount;
@@ -526,8 +525,8 @@ tEplKernel PUBLIC EplSdoUdpuInitCon(tEplSdoConHdl * pSdoConHandle_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p,
-                                    tEplFrame * pSrcData_p, DWORD dwDataSize_p)
+tEplKernel EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p,
+                             tEplFrame *pSrcData_p, DWORD dwDataSize_p)
 {
        tEplKernel Ret;
        int iError;
@@ -603,7 +602,7 @@ tEplKernel PUBLIC EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p,
 // State:
 //
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p)
+tEplKernel EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p)
 {
        tEplKernel Ret;
        unsigned int uiArray;
@@ -649,7 +648,7 @@ tEplKernel PUBLIC EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p)
 //
 //---------------------------------------------------------------------------
 #if (TARGET_SYSTEM == _WIN32_)
-static DWORD PUBLIC EplSdoUdpThread(LPVOID lpParameter)
+static DWORD EplSdoUdpThread(LPVOID lpParameter)
 #elif (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
 static int EplSdoUdpThread(void *pArg_p)
 #endif
index 689f9124ae29a84d272a4d4a737e851848d59dae..5dcabdf619142a3c68d7e872863c3df7d1cc894c 100644 (file)
@@ -137,8 +137,7 @@ static tEplStatusuInstance EplStatusuInstance_g;
 // local function prototypes
 //---------------------------------------------------------------------------
 
-static tEplKernel PUBLIC EplStatusuCbStatusResponse(tEplFrameInfo *
-                                                   pFrameInfo_p);
+static tEplKernel EplStatusuCbStatusResponse(tEplFrameInfo *pFrameInfo_p);
 
 //=========================================================================//
 //                                                                         //
@@ -164,7 +163,7 @@ static tEplKernel PUBLIC EplStatusuCbStatusResponse(tEplFrameInfo *
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplStatusuInit()
+EPLDLLEXPORT tEplKernel EplStatusuInit(void)
 {
        tEplKernel Ret;
 
@@ -191,7 +190,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplStatusuInit()
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplStatusuAddInstance()
+EPLDLLEXPORT tEplKernel EplStatusuAddInstance(void)
 {
        tEplKernel Ret;
 
@@ -228,7 +227,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplStatusuAddInstance()
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplStatusuDelInstance()
+EPLDLLEXPORT tEplKernel EplStatusuDelInstance(void)
 {
        tEplKernel Ret;
 
@@ -258,7 +257,7 @@ EPLDLLEXPORT tEplKernel PUBLIC EplStatusuDelInstance()
 //
 //---------------------------------------------------------------------------
 
-EPLDLLEXPORT tEplKernel PUBLIC EplStatusuReset()
+EPLDLLEXPORT tEplKernel EplStatusuReset(void)
 {
        tEplKernel Ret;
 
@@ -287,9 +286,8 @@ EPLDLLEXPORT tEplKernel PUBLIC EplStatusuReset()
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplStatusuRequestStatusResponse(unsigned int uiNodeId_p,
-                                                 tEplStatusuCbResponse
-                                                 pfnCbResponse_p)
+tEplKernel EplStatusuRequestStatusResponse(unsigned int uiNodeId_p,
+                                          tEplStatusuCbResponse pfnCbResponse_p)
 {
        tEplKernel Ret;
 
@@ -342,8 +340,7 @@ tEplKernel PUBLIC EplStatusuRequestStatusResponse(unsigned int uiNodeId_p,
 // State:
 //
 //---------------------------------------------------------------------------
-static tEplKernel PUBLIC EplStatusuCbStatusResponse(tEplFrameInfo *
-                                                   pFrameInfo_p)
+static tEplKernel EplStatusuCbStatusResponse(tEplFrameInfo *pFrameInfo_p)
 {
        tEplKernel Ret = kEplSuccessful;
        unsigned int uiNodeId;
index b2b66f82c03543a5d7fd4c1710cb1d24417d6909..462c6d0c0a16a245ffa05eb36f151754b38af339 100644 (file)
@@ -217,17 +217,15 @@ void trace(const char *fmt, ...);
 
 // currently no Timer functions are needed by EPL stack
 // so they are not implemented yet
-//void  PUBLIC TgtTimerInit(void);
-//DWORD PUBLIC TgtGetTickCount(void);
-//void PUBLIC TgtGetNetTime(tEplNetTime * pNetTime_p);
+//void  TgtTimerInit(void);
+//DWORD TgtGetTickCount(void);
+//void TgtGetNetTime(tEplNetTime * pNetTime_p);
 
 // functions for ethernet driver
-tEplKernel PUBLIC TgtInitEthIsr(void);
-void PUBLIC TgtFreeEthIsr(void);
-void PUBLIC TgtEnableGlobalInterrupt(BYTE fEnable_p);
-void PUBLIC TgtEnableEthInterrupt0(BYTE fEnable_p,
-                                  unsigned int uiInterruptMask_p);
-void PUBLIC TgtEnableEthInterrupt1(BYTE fEnable_p,
-                                  unsigned int uiInterruptMask_p);
+tEplKernel TgtInitEthIsr(void);
+void TgtFreeEthIsr(void);
+void TgtEnableGlobalInterrupt(BYTE fEnable_p);
+void TgtEnableEthInterrupt0(BYTE fEnable_p, unsigned int uiInterruptMask_p);
+void TgtEnableEthInterrupt1(BYTE fEnable_p, unsigned int uiInterruptMask_p);
 
 #endif // #ifndef _EPLTARGET_H_
index facbfd8740e6c9a798007164f0ee82c340d77951..d1a73eaf65c1b8da242de2736e876cd8c454992f 100644 (file)
@@ -107,8 +107,7 @@ typedef struct {
 
 } tEplTimerEventArg;
 
-typedef tEplKernel(PUBLIC * tEplTimerkCallback) (tEplTimerEventArg *
-                                                pEventArg_p);
+typedef tEplKernel(* tEplTimerkCallback) (tEplTimerEventArg *pEventArg_p);
 
 //---------------------------------------------------------------------------
 // function prototypes
index 08820d184055219b89038fb1a278a6d533494b98..ff80fc80d021123f8078f7f8a1c7c53f4e14308a 100644 (file)
@@ -99,7 +99,7 @@ typedef struct {
 //---------------------------------------------------------------------------
 // local function prototypes
 //---------------------------------------------------------------------------
-static void PUBLIC EplTimeruCbMs(unsigned long ulParameter_p);
+static void EplTimeruCbMs(unsigned long ulParameter_p);
 
 /***************************************************************************/
 /*                                                                         */
@@ -134,7 +134,7 @@ static void PUBLIC EplTimeruCbMs(unsigned long ulParameter_p);
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimeruInit()
+tEplKernel EplTimeruInit(void)
 {
        tEplKernel Ret;
 
@@ -157,7 +157,7 @@ tEplKernel PUBLIC EplTimeruInit()
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimeruAddInstance()
+tEplKernel EplTimeruAddInstance(void)
 {
        tEplKernel Ret;
 
@@ -182,7 +182,7 @@ tEplKernel PUBLIC EplTimeruAddInstance()
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimeruDelInstance()
+tEplKernel EplTimeruDelInstance(void)
 {
        tEplKernel Ret;
 
@@ -207,9 +207,9 @@ tEplKernel PUBLIC EplTimeruDelInstance()
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimeruSetTimerMs(tEplTimerHdl * pTimerHdl_p,
-                                     unsigned long ulTime_p,
-                                     tEplTimerArg Argument_p)
+tEplKernel EplTimeruSetTimerMs(tEplTimerHdl *pTimerHdl_p,
+                              unsigned long ulTime_p,
+                              tEplTimerArg Argument_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplTimeruData *pData;
@@ -257,9 +257,9 @@ tEplKernel PUBLIC EplTimeruSetTimerMs(tEplTimerHdl * pTimerHdl_p,
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimeruModifyTimerMs(tEplTimerHdl * pTimerHdl_p,
-                                        unsigned long ulTime_p,
-                                        tEplTimerArg Argument_p)
+tEplKernel EplTimeruModifyTimerMs(tEplTimerHdl *pTimerHdl_p,
+                                 unsigned long ulTime_p,
+                                 tEplTimerArg Argument_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplTimeruData *pData;
@@ -315,7 +315,7 @@ tEplKernel PUBLIC EplTimeruModifyTimerMs(tEplTimerHdl * pTimerHdl_p,
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimeruDeleteTimer(tEplTimerHdl * pTimerHdl_p)
+tEplKernel EplTimeruDeleteTimer(tEplTimerHdl *pTimerHdl_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplTimeruData *pData;
@@ -370,7 +370,7 @@ tEplKernel PUBLIC EplTimeruDeleteTimer(tEplTimerHdl * pTimerHdl_p)
 //
 //---------------------------------------------------------------------------
 
-BOOL PUBLIC EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p)
+BOOL EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p)
 {
        BOOL fActive = FALSE;
        tEplTimeruData *pData;
@@ -417,7 +417,7 @@ BOOL PUBLIC EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p)
 // State:
 //
 //---------------------------------------------------------------------------
-static void PUBLIC EplTimeruCbMs(unsigned long ulParameter_p)
+static void EplTimeruCbMs(unsigned long ulParameter_p)
 {
        tEplKernel Ret = kEplSuccessful;
        tEplTimeruData *pData;
index 82eee4702aa67b7a80e412aada765cae2ddc2fb1..11ae8192323d00efbf0846426ebe8d3609a9939e 100644 (file)
 
 // TracePoint support for realtime-debugging
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
-void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 #define TGT_DBG_POST_TRACE_VALUE(v)     TgtDbgPostTraceValue(v)
 #else
@@ -172,7 +172,7 @@ enum hrtimer_restart EplTimerHighReskCallback(struct hrtimer *pTimer_p);
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimerHighReskInit(void)
+tEplKernel EplTimerHighReskInit(void)
 {
        tEplKernel Ret;
 
@@ -196,7 +196,7 @@ tEplKernel PUBLIC EplTimerHighReskInit(void)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimerHighReskAddInstance(void)
+tEplKernel EplTimerHighReskAddInstance(void)
 {
        tEplKernel Ret;
        unsigned int uiIndex;
@@ -244,7 +244,7 @@ tEplKernel PUBLIC EplTimerHighReskAddInstance(void)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimerHighReskDelInstance(void)
+tEplKernel EplTimerHighReskDelInstance(void)
 {
        tEplTimerHighReskTimerInfo *pTimerInfo;
        tEplKernel Ret;
@@ -298,12 +298,11 @@ tEplKernel PUBLIC EplTimerHighReskDelInstance(void)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimerHighReskModifyTimerNs(tEplTimerHdl * pTimerHdl_p,
-                                               unsigned long long ullTimeNs_p,
-                                               tEplTimerkCallback
-                                               pfnCallback_p,
-                                               unsigned long ulArgument_p,
-                                               BOOL fContinuously_p)
+tEplKernel EplTimerHighReskModifyTimerNs(tEplTimerHdl *pTimerHdl_p,
+                                        unsigned long long ullTimeNs_p,
+                                        tEplTimerkCallback pfnCallback_p,
+                                        unsigned long ulArgument_p,
+                                        BOOL fContinuously_p)
 {
        tEplKernel Ret;
        unsigned int uiIndex;
@@ -396,7 +395,7 @@ tEplKernel PUBLIC EplTimerHighReskModifyTimerNs(tEplTimerHdl * pTimerHdl_p,
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimerHighReskDeleteTimer(tEplTimerHdl * pTimerHdl_p)
+tEplKernel EplTimerHighReskDeleteTimer(tEplTimerHdl *pTimerHdl_p)
 {
        tEplKernel Ret = kEplSuccessful;
        unsigned int uiIndex;
index 5d838dbf73a782a234ea8e0ae6a6e7f806252977..445b9e620c273af625fc8539a54e76b6bfa41b56 100644 (file)
@@ -285,7 +285,7 @@ static tEplKernel VEthRecvFrame(tEplFrameInfo * pFrameInfo_p)
        return Ret;
 }
 
-tEplKernel PUBLIC VEthAddInstance(tEplDllkInitParam * pInitParam_p)
+tEplKernel VEthAddInstance(tEplDllkInitParam *pInitParam_p)
 {
        tEplKernel Ret = kEplSuccessful;
 
@@ -324,7 +324,7 @@ tEplKernel PUBLIC VEthAddInstance(tEplDllkInitParam * pInitParam_p)
        return Ret;
 }
 
-tEplKernel PUBLIC VEthDelInstance(void)
+tEplKernel VEthDelInstance(void)
 {
        tEplKernel Ret = kEplSuccessful;
 
index 9f742384dac07b3dce28456218bef0d340f8add5..a2e54b6755ad8be0d28e7707a74e03f359d44421 100644 (file)
@@ -119,7 +119,7 @@ typedef struct {
 
 //------------< write BYTE in big endian >--------------------------
 /*
-void  PUBLIC  AmiSetByteToBe (void FAR* pAddr_p, BYTE bByteVal_p)
+void AmiSetByteToBe (void FAR* pAddr_p, BYTE bByteVal_p)
 {
 
    *(BYTE FAR*)pAddr_p = bByteVal_p;
@@ -129,7 +129,7 @@ void  PUBLIC  AmiSetByteToBe (void FAR* pAddr_p, BYTE bByteVal_p)
 
 //------------< write WORD in big endian >--------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p)
+INLINE_FUNCTION void AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p)
 {
        twStruct FAR *pwStruct;
        twStruct wValue;
@@ -144,8 +144,7 @@ INLINE_FUNCTION void PUBLIC AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p)
 
 //------------< write DWORD in big endian >-------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetDwordToBe(void FAR * pAddr_p,
-                                           DWORD dwDwordVal_p)
+INLINE_FUNCTION void AmiSetDwordToBe(void FAR *pAddr_p, DWORD dwDwordVal_p)
 {
        tdwStruct FAR *pdwStruct;
        tdwStruct dwValue;
@@ -178,7 +177,7 @@ INLINE_FUNCTION void PUBLIC AmiSetDwordToBe(void FAR * pAddr_p,
 
 //------------< write BYTE in little endian >--------------------------
 /*
-void  PUBLIC  AmiSetByteToLe (void FAR* pAddr_p, BYTE bByteVal_p)
+void AmiSetByteToLe (void FAR* pAddr_p, BYTE bByteVal_p)
 {
 
    *(BYTE FAR*)pAddr_p = bByteVal_p;
@@ -188,7 +187,7 @@ void  PUBLIC  AmiSetByteToLe (void FAR* pAddr_p, BYTE bByteVal_p)
 
 //------------< write WORD in little endian >--------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetWordToLe(void FAR * pAddr_p, WORD wWordVal_p)
+INLINE_FUNCTION void AmiSetWordToLe(void FAR *pAddr_p, WORD wWordVal_p)
 {
        twStruct FAR *pwStruct;
 
@@ -199,8 +198,7 @@ INLINE_FUNCTION void PUBLIC AmiSetWordToLe(void FAR * pAddr_p, WORD wWordVal_p)
 
 //------------< write DWORD in little endian >-------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetDwordToLe(void FAR * pAddr_p,
-                                           DWORD dwDwordVal_p)
+INLINE_FUNCTION void AmiSetDwordToLe(void FAR *pAddr_p, DWORD dwDwordVal_p)
 {
        tdwStruct FAR *pdwStruct;
 
@@ -226,7 +224,7 @@ INLINE_FUNCTION void PUBLIC AmiSetDwordToLe(void FAR * pAddr_p,
 
 //------------< read BYTE in big endian >---------------------------
 /*
-BYTE  PUBLIC  AmiGetByteFromBe (void FAR* pAddr_p)
+BYTE AmiGetByteFromBe (void FAR* pAddr_p)
 {
 
    return ( *(BYTE FAR*)pAddr_p );
@@ -236,7 +234,7 @@ BYTE  PUBLIC  AmiGetByteFromBe (void FAR* pAddr_p)
 
 //------------< read WORD in big endian >---------------------------
 
-INLINE_FUNCTION WORD PUBLIC AmiGetWordFromBe(void FAR * pAddr_p)
+INLINE_FUNCTION WORD AmiGetWordFromBe(void FAR *pAddr_p)
 {
        twStruct FAR *pwStruct;
        twStruct wValue;
@@ -252,7 +250,7 @@ INLINE_FUNCTION WORD PUBLIC AmiGetWordFromBe(void FAR * pAddr_p)
 
 //------------< read DWORD in big endian >--------------------------
 
-INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromBe(void FAR * pAddr_p)
+INLINE_FUNCTION DWORD AmiGetDwordFromBe(void FAR *pAddr_p)
 {
        tdwStruct FAR *pdwStruct;
        tdwStruct dwValue;
@@ -285,7 +283,7 @@ INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromBe(void FAR * pAddr_p)
 
 //------------< read BYTE in little endian >---------------------------
 /*
-BYTE  PUBLIC  AmiGetByteFromLe (void FAR* pAddr_p)
+BYTE AmiGetByteFromLe (void FAR* pAddr_p)
 {
 
    return ( *(BYTE FAR*)pAddr_p );
@@ -295,24 +293,22 @@ BYTE  PUBLIC  AmiGetByteFromLe (void FAR* pAddr_p)
 
 //------------< read WORD in little endian >---------------------------
 
-INLINE_FUNCTION WORD PUBLIC AmiGetWordFromLe(void FAR * pAddr_p)
+INLINE_FUNCTION WORD AmiGetWordFromLe(void FAR *pAddr_p)
 {
        twStruct FAR *pwStruct;
 
        pwStruct = (twStruct FAR *) pAddr_p;
        return (pwStruct->m_wWord);
-
 }
 
 //------------< read DWORD in little endian >--------------------------
 
-INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromLe(void FAR * pAddr_p)
+INLINE_FUNCTION DWORD AmiGetDwordFromLe(void FAR *pAddr_p)
 {
        tdwStruct FAR *pdwStruct;
 
        pdwStruct = (tdwStruct FAR *) pAddr_p;
        return (pdwStruct->m_dwDword);
-
 }
 
 //---------------------------------------------------------------------------
@@ -330,14 +326,11 @@ INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromLe(void FAR * pAddr_p)
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetDword24ToBe(void FAR * pAddr_p,
-                                             DWORD dwDwordVal_p)
+INLINE_FUNCTION void AmiSetDword24ToBe(void FAR *pAddr_p, DWORD dwDwordVal_p)
 {
-
        ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & dwDwordVal_p)[2];
        ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & dwDwordVal_p)[1];
        ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & dwDwordVal_p)[0];
-
 }
 
 //---------------------------------------------------------------------------
@@ -355,14 +348,11 @@ INLINE_FUNCTION void PUBLIC AmiSetDword24ToBe(void FAR * pAddr_p,
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetDword24ToLe(void FAR * pAddr_p,
-                                             DWORD dwDwordVal_p)
+INLINE_FUNCTION void AmiSetDword24ToLe(void FAR *pAddr_p, DWORD dwDwordVal_p)
 {
-
        ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & dwDwordVal_p)[0];
        ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & dwDwordVal_p)[1];
        ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & dwDwordVal_p)[2];
-
 }
 
 //---------------------------------------------------------------------------
@@ -378,17 +368,14 @@ INLINE_FUNCTION void PUBLIC AmiSetDword24ToLe(void FAR * pAddr_p,
 // State:       not tested
 //
 //---------------------------------------------------------------------------
-
-INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromBe(void FAR * pAddr_p)
+INLINE_FUNCTION DWORD AmiGetDword24FromBe(void FAR *pAddr_p)
 {
-
        tdwStruct dwStruct;
 
        dwStruct.m_dwDword = AmiGetDwordFromBe(pAddr_p);
        dwStruct.m_dwDword >>= 8;
 
        return (dwStruct.m_dwDword);
-
 }
 
 //---------------------------------------------------------------------------
@@ -404,17 +391,14 @@ INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromBe(void FAR * pAddr_p)
 // State:       not tested
 //
 //---------------------------------------------------------------------------
-
-INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromLe(void FAR * pAddr_p)
+INLINE_FUNCTION DWORD AmiGetDword24FromLe(void FAR *pAddr_p)
 {
-
        tdwStruct dwStruct;
 
        dwStruct.m_dwDword = AmiGetDwordFromLe(pAddr_p);
        dwStruct.m_dwDword &= 0x00FFFFFF;
 
        return (dwStruct.m_dwDword);
-
 }
 
 //#ifdef USE_VAR64
@@ -433,11 +417,8 @@ INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromLe(void FAR * pAddr_p)
 // State:       not tested
 //
 //---------------------------------------------------------------------------
-
-INLINE_FUNCTION void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p,
-                                             QWORD qwQwordVal_p)
+INLINE_FUNCTION void AmiSetQword64ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p)
 {
-
        ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[7];
        ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & qwQwordVal_p)[6];
        ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & qwQwordVal_p)[5];
@@ -446,7 +427,6 @@ INLINE_FUNCTION void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p,
        ((BYTE FAR *) pAddr_p)[5] = ((BYTE FAR *) & qwQwordVal_p)[2];
        ((BYTE FAR *) pAddr_p)[6] = ((BYTE FAR *) & qwQwordVal_p)[1];
        ((BYTE FAR *) pAddr_p)[7] = ((BYTE FAR *) & qwQwordVal_p)[0];
-
 }
 
 //---------------------------------------------------------------------------
@@ -463,16 +443,12 @@ INLINE_FUNCTION void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p,
 // State:       not tested
 //
 //---------------------------------------------------------------------------
-
-INLINE_FUNCTION void PUBLIC AmiSetQword64ToLe(void FAR * pAddr_p,
-                                             QWORD qwQwordVal_p)
+INLINE_FUNCTION void AmiSetQword64ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p)
 {
-
        QWORD FAR *pqwDst;
 
        pqwDst = (QWORD FAR *) pAddr_p;
        *pqwDst = qwQwordVal_p;
-
 }
 
 //---------------------------------------------------------------------------
@@ -488,10 +464,8 @@ INLINE_FUNCTION void PUBLIC AmiSetQword64ToLe(void FAR * pAddr_p,
 // State:       not tested
 //
 //---------------------------------------------------------------------------
-
-INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p)
+INLINE_FUNCTION QWORD AmiGetQword64FromBe(void FAR *pAddr_p)
 {
-
        tqwStruct qwStruct;
 
        ((BYTE FAR *) & qwStruct.m_qwQword)[0] = ((BYTE FAR *) pAddr_p)[7];
@@ -504,7 +478,6 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p)
        ((BYTE FAR *) & qwStruct.m_qwQword)[7] = ((BYTE FAR *) pAddr_p)[0];
 
        return (qwStruct.m_qwQword);
-
 }
 
 //---------------------------------------------------------------------------
@@ -520,10 +493,8 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p)
 // State:       not tested
 //
 //---------------------------------------------------------------------------
-
-INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p)
+INLINE_FUNCTION QWORD AmiGetQword64FromLe(void FAR *pAddr_p)
 {
-
        tqwStruct FAR *pqwStruct;
        tqwStruct qwStruct;
 
@@ -531,7 +502,6 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p)
        qwStruct.m_qwQword = pqwStruct->m_qwQword;
 
        return (qwStruct.m_qwQword);
-
 }
 
 //---------------------------------------------------------------------------
@@ -549,8 +519,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p)
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetQword40ToBe(void FAR * pAddr_p,
-                                             QWORD qwQwordVal_p)
+INLINE_FUNCTION void AmiSetQword40ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p)
 {
 
        ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[4];
@@ -576,8 +545,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword40ToBe(void FAR * pAddr_p,
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetQword40ToLe(void FAR * pAddr_p,
-                                             QWORD qwQwordVal_p)
+INLINE_FUNCTION void AmiSetQword40ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p)
 {
 
        ((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0];
@@ -599,7 +567,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword40ToLe(void FAR * pAddr_p,
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromBe(void FAR * pAddr_p)
+INLINE_FUNCTION QWORD AmiGetQword40FromBe(void FAR *pAddr_p)
 {
 
        tqwStruct qwStruct;
@@ -625,7 +593,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromBe(void FAR * pAddr_p)
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromLe(void FAR * pAddr_p)
+INLINE_FUNCTION QWORD AmiGetQword40FromLe(void FAR *pAddr_p)
 {
 
        tqwStruct qwStruct;
@@ -652,8 +620,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromLe(void FAR * pAddr_p)
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetQword48ToBe(void FAR * pAddr_p,
-                                             QWORD qwQwordVal_p)
+INLINE_FUNCTION void AmiSetQword48ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p)
 {
 
        ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[5];
@@ -680,8 +647,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword48ToBe(void FAR * pAddr_p,
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetQword48ToLe(void FAR * pAddr_p,
-                                             QWORD qwQwordVal_p)
+INLINE_FUNCTION void AmiSetQword48ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p)
 {
 
        ((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0];
@@ -703,7 +669,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword48ToLe(void FAR * pAddr_p,
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromBe(void FAR * pAddr_p)
+INLINE_FUNCTION QWORD AmiGetQword48FromBe(void FAR *pAddr_p)
 {
 
        tqwStruct qwStruct;
@@ -729,7 +695,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromBe(void FAR * pAddr_p)
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromLe(void FAR * pAddr_p)
+INLINE_FUNCTION QWORD AmiGetQword48FromLe(void FAR *pAddr_p)
 {
 
        tqwStruct qwStruct;
@@ -756,8 +722,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromLe(void FAR * pAddr_p)
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetQword56ToBe(void FAR * pAddr_p,
-                                             QWORD qwQwordVal_p)
+INLINE_FUNCTION void AmiSetQword56ToBe(void FAR *pAddr_p, QWORD qwQwordVal_p)
 {
 
        ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[6];
@@ -785,8 +750,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword56ToBe(void FAR * pAddr_p,
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetQword56ToLe(void FAR * pAddr_p,
-                                             QWORD qwQwordVal_p)
+INLINE_FUNCTION void AmiSetQword56ToLe(void FAR *pAddr_p, QWORD qwQwordVal_p)
 {
 
        ((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0];
@@ -809,7 +773,7 @@ INLINE_FUNCTION void PUBLIC AmiSetQword56ToLe(void FAR * pAddr_p,
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromBe(void FAR * pAddr_p)
+INLINE_FUNCTION QWORD AmiGetQword56FromBe(void FAR *pAddr_p)
 {
 
        tqwStruct qwStruct;
@@ -835,7 +799,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromBe(void FAR * pAddr_p)
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromLe(void FAR * pAddr_p)
+INLINE_FUNCTION QWORD AmiGetQword56FromLe(void FAR *pAddr_p)
 {
 
        tqwStruct qwStruct;
@@ -862,8 +826,7 @@ INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromLe(void FAR * pAddr_p)
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiSetTimeOfDay(void FAR * pAddr_p,
-                                           tTimeOfDay FAR * pTimeOfDay_p)
+INLINE_FUNCTION void AmiSetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p)
 {
 
        AmiSetDwordToLe(((BYTE FAR *) pAddr_p),
@@ -887,8 +850,7 @@ INLINE_FUNCTION void PUBLIC AmiSetTimeOfDay(void FAR * pAddr_p,
 //
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void PUBLIC AmiGetTimeOfDay(void FAR * pAddr_p,
-                                           tTimeOfDay FAR * pTimeOfDay_p)
+INLINE_FUNCTION void AmiGetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p)
 {
 
        pTimeOfDay_p->m_dwMs =
index 263fa042291d218d6931aecb5c08c0f2ad536b86..6be30d6b4a280af9b36f3e59dbb35843b5a9003f 100644 (file)
@@ -118,7 +118,7 @@ MODULE_DESCRIPTION("EPL MN demo");
 
 // TracePoint support for realtime-debugging
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)   TgtDbgSignalTracePoint(p)
 #else
 #define TGT_DBG_SIGNAL_TRACE_POINT(p)
@@ -188,13 +188,13 @@ module_param_named(cyclelen, uiCycleLen_g, uint, 0);
 // this function prototype here. If you want to use more than one Epl
 // instances then the function name of each object dictionary has to differ.
 
-tEplKernel PUBLIC EplObdInitRam(tEplObdInitParam MEM * pInitParam_p);
+tEplKernel EplObdInitRam(tEplObdInitParam MEM * pInitParam_p);
 
-tEplKernel PUBLIC AppCbEvent(tEplApiEventType EventType_p,     // IN: event type (enum)
-                            tEplApiEventArg * pEventArg_p,     // IN: event argument (union)
-                            void GENERIC * pUserArg_p);
+tEplKernel AppCbEvent(tEplApiEventType EventType_p,    // IN: event type (enum)
+                     tEplApiEventArg *pEventArg_p,     // IN: event argument (union)
+                     void GENERIC *pUserArg_p);
 
-tEplKernel PUBLIC AppCbSync(void);
+tEplKernel AppCbSync(void);
 
 static int __init EplLinInit(void);
 static void __exit EplLinExit(void);
@@ -484,9 +484,9 @@ static void __exit EplLinExit(void)
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC AppCbEvent(tEplApiEventType EventType_p,     // IN: event type (enum)
-                            tEplApiEventArg * pEventArg_p,     // IN: event argument (union)
-                            void GENERIC * pUserArg_p)
+tEplKernel AppCbEvent(tEplApiEventType EventType_p,    // IN: event type (enum)
+                     tEplApiEventArg *pEventArg_p,     // IN: event argument (union)
+                     void GENERIC *pUserArg_p)
 {
        tEplKernel EplRet = kEplSuccessful;
 
@@ -802,7 +802,7 @@ tEplKernel PUBLIC AppCbEvent(tEplApiEventType EventType_p,  // IN: event type (en
 //
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC AppCbSync(void)
+tEplKernel AppCbSync(void)
 {
        tEplKernel EplRet = kEplSuccessful;
 
index 4eb64ecab0f3676fea199a65fecf488ea6459e5a..9cd6b890ee01617d735222442002f0223880f978 100644 (file)
 #endif
 
 #define REENTRANT
-#define PUBLIC
 
 #define TRACE  printk
 
index 4a67ef88b97a01e2899975fdf68bdf15b56b5590..b9d53dc6085ccb7a64b233b933dd99d8d42bc27c 100644 (file)
 //---------------------------------------------------------------------------
 
 // init function
-tEplKernel PUBLIC EplErrorHandlerkInit(void);
+tEplKernel EplErrorHandlerkInit(void);
 
 // add instance
-tEplKernel PUBLIC EplErrorHandlerkAddInstance(void);
+tEplKernel EplErrorHandlerkAddInstance(void);
 
 // delete instance
-tEplKernel PUBLIC EplErrorHandlerkDelInstance(void);
+tEplKernel EplErrorHandlerkDelInstance(void);
 
 // processes error events
-tEplKernel PUBLIC EplErrorHandlerkProcess(tEplEvent * pEvent_p);
+tEplKernel EplErrorHandlerkProcess(tEplEvent *pEvent_p);
 
 #endif // #ifndef _EPL_ERRORHANDLERK_H_
index 1d25aaa2ed4960aa8498d7e5cf7e2ad0d86d86e1..29c3e94de08700fc103ff71412d776813bc3f44c 100644 (file)
 //---------------------------------------------------------------------------
 
 // init function
-tEplKernel PUBLIC EplEventkInit(tEplSyncCb fpSyncCb);
+tEplKernel EplEventkInit(tEplSyncCb fpSyncCb);
 
 // add instance
-tEplKernel PUBLIC EplEventkAddInstance(tEplSyncCb fpSyncCb);
+tEplKernel EplEventkAddInstance(tEplSyncCb fpSyncCb);
 
 // delete instance
-tEplKernel PUBLIC EplEventkDelInstance(void);
+tEplKernel EplEventkDelInstance(void);
 
 // Kernelthread that dispatches events in kernelspace
-tEplKernel PUBLIC EplEventkProcess(tEplEvent * pEvent_p);
+tEplKernel EplEventkProcess(tEplEvent *pEvent_p);
 
 // post events from kernelspace
-tEplKernel PUBLIC EplEventkPost(tEplEvent * pEvent_p);
+tEplKernel EplEventkPost(tEplEvent *pEvent_p);
 
 // post errorevents from kernelspace
-tEplKernel PUBLIC EplEventkPostError(tEplEventSource EventSource_p,
-                                    tEplKernel EplError_p,
-                                    unsigned int uiArgSize_p, void *pArg_p);
+tEplKernel EplEventkPostError(tEplEventSource EventSource_p,
+                             tEplKernel EplError_p,
+                             unsigned int uiArgSize_p, void *pArg_p);
 
 #endif // #ifndef _EPL_EVENTK_H_
index 53409cc8992191ae6d856ab63c9af81a54523058..599ee8c246bd44b68779c24efd260c6c2117df9b 100644 (file)
 // function prototypes
 //---------------------------------------------------------------------------
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR);
+EPLDLLEXPORT tEplKernel EplNmtkInit(EPL_MCO_DECL_PTR_INSTANCE_PTR);
 
-EPLDLLEXPORT tEplKernel PUBLIC
-EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR);
+EPLDLLEXPORT tEplKernel EplNmtkAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR);
 
-EPLDLLEXPORT tEplKernel PUBLIC
-EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR);
+EPLDLLEXPORT tEplKernel EplNmtkDelInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR);
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_
-                                             tEplEvent * pEvent_p);
+EPLDLLEXPORT tEplKernel EplNmtkProcess(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplEvent *pEvent_p);
 
-EPLDLLEXPORT tEplNmtState PUBLIC
-EplNmtkGetNmtState(EPL_MCO_DECL_PTR_INSTANCE_PTR);
+EPLDLLEXPORT tEplNmtState EplNmtkGetNmtState(EPL_MCO_DECL_PTR_INSTANCE_PTR);
 
 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0)
 
index cf9f5837dd38dabd4eb724509a26fdd088671b80..eafd0bf54bea4b510b49a2b0d5b9ea06879e2d8f 100644 (file)
@@ -92,104 +92,83 @@ extern BYTE MEM abEplObdTrashObject_g[8];
 //---------------------------------------------------------------------------
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_
-                                         tEplObdInitParam MEM * pInitParam_p);
+EPLDLLEXPORT tEplKernel EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_
-                                                tEplObdInitParam MEM *
-                                                pInitParam_p);
+EPLDLLEXPORT tEplKernel EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_ tEplObdInitParam MEM *pInitParam_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR);
+EPLDLLEXPORT tEplKernel EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                               unsigned int uiIndex_p,
-                                               unsigned int uiSubIndex_p,
-                                               void *pSrcData_p,
-                                               tEplObdSize Size_p);
+EPLDLLEXPORT tEplKernel EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                        unsigned int uiSubIndex_p,
+                                        void *pSrcData_p,
+                                        tEplObdSize Size_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                              unsigned int uiIndex_p,
-                                              unsigned int uiSubIndex_p,
-                                              void *pDstData_p,
-                                              tEplObdSize * pSize_p);
+EPLDLLEXPORT tEplKernel EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                       unsigned int uiSubIndex_p,
+                                       void *pDstData_p,
+                                       tEplObdSize *pSize_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC
-EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_
-                             tEplObdStoreLoadObjCallback fpCallback_p);
+EPLDLLEXPORT tEplKernel EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdStoreLoadObjCallback fpCallback_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_
-                                                 tEplObdPart ObdPart_p,
-                                                 tEplObdDir Direction_p);
+EPLDLLEXPORT tEplKernel EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdPart ObdPart_p,
+                                          tEplObdDir Direction_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_
-                                              tEplVarParam MEM * pVarParam_p);
+EPLDLLEXPORT tEplKernel EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_ tEplVarParam MEM *pVarParam_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT void *PUBLIC EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_
-                                                unsigned int uiIndex_p,
-                                                unsigned int uiSubIndex_p);
+EPLDLLEXPORT void *EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                         unsigned int uiSubIndex_p);
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_
-                                                   tEplObdEntryPtr pUserOd_p);
+EPLDLLEXPORT tEplKernel EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdEntryPtr pUserOd_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT void PUBLIC EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                           tEplObdVarEntry MEM * pVarEntry_p,
-                                           tEplObdType Type_p,
-                                           tEplObdSize ObdSize_p);
+EPLDLLEXPORT void EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ tEplObdVarEntry MEM *pVarEntry_p,
+                                    tEplObdType Type_p,
+                                    tEplObdSize ObdSize_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplObdSize PUBLIC EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_
-                                                 unsigned int uiIndex_p,
-                                                 unsigned int uiSubIndex_p);
+EPLDLLEXPORT tEplObdSize EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                          unsigned int uiSubIndex_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT unsigned int PUBLIC EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR);
+EPLDLLEXPORT unsigned int EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdSetNodeId(EPL_MCO_DECL_INSTANCE_PTR_
-                                              unsigned int uiNodeId_p,
-                                              tEplObdNodeIdType NodeIdType_p);
+EPLDLLEXPORT tEplKernel EplObdSetNodeId(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiNodeId_p,
+                                       tEplObdNodeIdType NodeIdType_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_
-                                                unsigned int uiIndex_p,
-                                                unsigned int uiSubIndex_p,
-                                                BOOL * pfEntryNumerical);
+EPLDLLEXPORT tEplKernel EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                         unsigned int uiSubIndex_p,
+                                         BOOL *pfEntryNumerical);
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_
-                                                     unsigned int uiIndex_p,
-                                                     unsigned int uiSubIndex_p,
-                                                     void *pSrcData_p,
-                                                     tEplObdSize Size_p);
+EPLDLLEXPORT tEplKernel EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                              unsigned int uiSubIndex_p,
+                                              void *pSrcData_p,
+                                              tEplObdSize Size_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_
-                                                  unsigned int uiIndex_p,
-                                                  unsigned int uiSubIndex_p,
-                                                  void *pDstData_p,
-                                                  tEplObdSize * pSize_p);
+EPLDLLEXPORT tEplKernel EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                           unsigned int uiSubIndex_p,
+                                           void *pDstData_p,
+                                           tEplObdSize *pSize_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_
-                                                  unsigned int uiIndex_p,
-                                                  unsigned int uiSubIndex_p,
-                                                  tEplObdAccess *
-                                                  pAccessTyp_p);
+EPLDLLEXPORT tEplKernel EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                           unsigned int uiSubIndex_p,
+                                           tEplObdAccess *pAccessTyp_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                                   unsigned int uiIndex_p,
-                                                   unsigned int uiSubindex_p,
-                                                   tEplObdVarEntry MEM **
-                                                   ppVarEntry_p);
+EPLDLLEXPORT tEplKernel EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
+                                            unsigned int uiSubindex_p,
+                                            tEplObdVarEntry MEM **ppVarEntry_p);
 
 #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
 
index d5d046d4d370fab6d66c771eb8632f75b4bfee33..64fb52bef819f64db3a60dd532759e1771660766 100644 (file)
 // function prototypes
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimerHighReskInit(void);
+tEplKernel EplTimerHighReskInit(void);
 
-tEplKernel PUBLIC EplTimerHighReskAddInstance(void);
+tEplKernel EplTimerHighReskAddInstance(void);
 
-tEplKernel PUBLIC EplTimerHighReskDelInstance(void);
+tEplKernel EplTimerHighReskDelInstance(void);
 
-tEplKernel PUBLIC EplTimerHighReskSetTimerNs(tEplTimerHdl * pTimerHdl_p,
-                                            unsigned long long ullTimeNs_p,
-                                            tEplTimerkCallback pfnCallback_p,
-                                            unsigned long ulArgument_p,
-                                            BOOL fContinuously_p);
+tEplKernel EplTimerHighReskSetTimerNs(tEplTimerHdl *pTimerHdl_p,
+                                     unsigned long long ullTimeNs_p,
+                                     tEplTimerkCallback pfnCallback_p,
+                                     unsigned long ulArgument_p,
+                                     BOOL fContinuously_p);
 
-tEplKernel PUBLIC EplTimerHighReskModifyTimerNs(tEplTimerHdl * pTimerHdl_p,
-                                               unsigned long long ullTimeNs_p,
-                                               tEplTimerkCallback
-                                               pfnCallback_p,
-                                               unsigned long ulArgument_p,
-                                               BOOL fContinuously_p);
+tEplKernel EplTimerHighReskModifyTimerNs(tEplTimerHdl *pTimerHdl_p,
+                                        unsigned long long ullTimeNs_p,
+                                        tEplTimerkCallback pfnCallback_p,
+                                        unsigned long ulArgument_p,
+                                        BOOL fContinuously_p);
 
-tEplKernel PUBLIC EplTimerHighReskDeleteTimer(tEplTimerHdl * pTimerHdl_p);
+tEplKernel EplTimerHighReskDeleteTimer(tEplTimerHdl *pTimerHdl_p);
 
 #endif // #ifndef _EPLTIMERHIGHRESK_H_
index 9160e7260de8b7cc35efbc7dcdc214ce0237ee08..c3d4ef7071de82c9fb24e1c44457477cae370900 100644 (file)
 // function prototypes
 //---------------------------------------------------------------------------
 #if EPL_TIMER_USE_USER == FALSE
-tEplKernel PUBLIC EplTimerkInit(void);
+tEplKernel EplTimerkInit(void);
 
-tEplKernel PUBLIC EplTimerkAddInstance(void);
+tEplKernel EplTimerkAddInstance(void);
 
-tEplKernel PUBLIC EplTimerkDelInstance(void);
+tEplKernel EplTimerkDelInstance(void);
 
-tEplKernel PUBLIC EplTimerkSetTimerMs(tEplTimerHdl * pTimerHdl_p,
-                                     unsigned long ulTime_p,
-                                     tEplTimerArg Argument_p);
+tEplKernel EplTimerkSetTimerMs(tEplTimerHdl *pTimerHdl_p,
+                              unsigned long ulTime_p,
+                              tEplTimerArg Argument_p);
 
-tEplKernel PUBLIC EplTimerkModifyTimerMs(tEplTimerHdl * pTimerHdl_p,
-                                        unsigned long ulTime_p,
-                                        tEplTimerArg Argument_p);
+tEplKernel EplTimerkModifyTimerMs(tEplTimerHdl *pTimerHdl_p,
+                                 unsigned long ulTime_p,
+                                 tEplTimerArg Argument_p);
 
-tEplKernel PUBLIC EplTimerkDeleteTimer(tEplTimerHdl * pTimerHdl_p);
+tEplKernel EplTimerkDeleteTimer(tEplTimerHdl *pTimerHdl_p);
 #endif
 #endif // #ifndef _EPLTIMERK_H_
index deff8720e37f9d7d7cc89a56e90751b8dd8d4430..c6c5433fe9ff65d8d78e60f0d21567616c16c8f4 100644 (file)
@@ -87,9 +87,9 @@
 
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
 
-tEplKernel PUBLIC VEthAddInstance(tEplDllkInitParam * pInitParam_p);
+tEplKernel VEthAddInstance(tEplDllkInitParam *pInitParam_p);
 
-tEplKernel PUBLIC VEthDelInstance(void);
+tEplKernel VEthDelInstance(void);
 
 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_VETH)) != 0)
 
index f4910332d3c6e4d700597cce8fbb533c59a2dd4f..c08453d54903660dccf203af187c762874504b90 100644 (file)
@@ -145,10 +145,10 @@ static int EplLinProcRead(char *pcBuffer_p, char **ppcStart_p, off_t Offset_p,
 static int EplLinProcWrite(struct file *file, const char __user * buffer,
                           unsigned long count, void *data);
 
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
-void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p);
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p);
+void TgtDbgPostTraceValue(DWORD dwTraceValue_p);
 
-EPLDLLEXPORT DWORD PUBLIC EplIdentuGetRunningRequests(void);
+EPLDLLEXPORT DWORD EplIdentuGetRunningRequests(void);
 
 //=========================================================================//
 //                                                                         //
@@ -191,7 +191,7 @@ tEplKernel EplLinProcFree(void)
 //---------------------------------------------------------------------------
 
 #ifdef _DBG_TRACE_POINTS_
-void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p)
+void TgtDbgSignalTracePoint(BYTE bTracePointNumber_p)
 {
 
        if (bTracePointNumber_p >=
@@ -207,7 +207,7 @@ void PUBLIC TgtDbgSignalTracePoint(BYTE bTracePointNumber_p)
 
 }
 
-void PUBLIC TgtDbgPostTraceValue(DWORD dwTraceValue_p)
+void TgtDbgPostTraceValue(DWORD dwTraceValue_p)
 {
 
        spin_lock_irqsave(&spinlockDbgTraceValue_l, ulDbTraceValueFlags_l);
index d25a1e9d36cf534aa68d818f93f993dae24e739d..cafe60f094b631cce6f52164f2080df69bb564e7 100644 (file)
@@ -86,8 +86,8 @@
 #define EPL_CFGMA_MAX_TIMEOUT   3
 
 //callbackfunction, called if configuration is finished
-typedef void (PUBLIC * tfpEplCfgMaCb) (unsigned int uiNodeId_p,
-                                      tEplKernel Errorstate_p);
+typedef void (* tfpEplCfgMaCb)(unsigned int uiNodeId_p,
+                              tEplKernel Errorstate_p);
 
 //State for configuartion manager Statemachine
 typedef enum {
@@ -166,7 +166,7 @@ typedef struct {
 //
 // Returns:     tEplKernel              = error code
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplCfgMaInit();
+tEplKernel EplCfgMaInit(void);
 
 //---------------------------------------------------------------------------
 // Function:    EplCfgMaAddInstance()
@@ -177,7 +177,7 @@ tEplKernel PUBLIC EplCfgMaInit();
 //
 // Returns:     tEplKernel              = error code
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplCfgMaAddInstance();
+tEplKernel EplCfgMaAddInstance(void);
 
 //---------------------------------------------------------------------------
 // Function:    EplCfgMaDelInstance()
@@ -188,7 +188,7 @@ tEplKernel PUBLIC EplCfgMaAddInstance();
 //
 // Returns:     tEplKernel              = error code
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplCfgMaDelInstance();
+tEplKernel plCfgMaDelInstance(void);
 
 //---------------------------------------------------------------------------
 // Function:    EplCfgMaStartConfig()
@@ -204,11 +204,11 @@ tEplKernel PUBLIC EplCfgMaDelInstance();
 //
 // Returns:     tCopKernel              = error code
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplCfgMaStartConfig(unsigned int uiNodeId_p,
-                                     BYTE * pbConcise_p,
-                                     tfpEplCfgMaCb fpCfgMaCb_p,
-                                     tEplObdSize SizeOfConcise_p,
-                                     tEplCfgMaDcfTyp DcfType_p);
+tEplKernel EplCfgMaStartConfig(unsigned int uiNodeId_p,
+                              BYTE * pbConcise_p,
+                              tfpEplCfgMaCb fpCfgMaCb_p,
+                              tEplObdSize SizeOfConcise_p,
+                              tEplCfgMaDcfTyp DcfType_p);
 
 //---------------------------------------------------------------------------
 // Function:    CfgMaStartConfigurationNode()
@@ -222,9 +222,9 @@ tEplKernel PUBLIC EplCfgMaStartConfig(unsigned int uiNodeId_p,
 //
 // Returns:     tCopKernel              = error code
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplCfgMaStartConfigNode(unsigned int uiNodeId_p,
-                                         tfpEplCfgMaCb fpCfgMaCb_p,
-                                         tEplCfgMaDcfTyp DcfType_p);
+tEplKernel EplCfgMaStartConfigNode(unsigned int uiNodeId_p,
+                                  tfpEplCfgMaCb fpCfgMaCb_p,
+                                  tEplCfgMaDcfTyp DcfType_p);
 
 //---------------------------------------------------------------------------
 // Function:    EplCfgMaStartConfigNodeDcf()
@@ -240,11 +240,11 @@ tEplKernel PUBLIC EplCfgMaStartConfigNode(unsigned int uiNodeId_p,
 //
 // Returns:     tCopKernel              = error code
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplCfgMaStartConfigNodeDcf(unsigned int uiNodeId_p,
-                                            BYTE * pbConcise_p,
-                                            tfpEplCfgMaCb fpCfgMaCb_p,
-                                            tEplObdSize SizeOfConcise_p,
-                                            tEplCfgMaDcfTyp DcfType_p);
+tEplKernel EplCfgMaStartConfigNodeDcf(unsigned int uiNodeId_p,
+                                     BYTE * pbConcise_p,
+                                     tfpEplCfgMaCb fpCfgMaCb_p,
+                                     tEplObdSize SizeOfConcise_p,
+                                     tEplCfgMaDcfTyp DcfType_p);
 
 //---------------------------------------------------------------------------
 // Function:    EplCfgMaLinkDcf()
@@ -258,10 +258,10 @@ tEplKernel PUBLIC EplCfgMaStartConfigNodeDcf(unsigned int uiNodeId_p,
 //
 // Returns:     tCopKernel              = error code
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplCfgMaLinkDcf(unsigned int uiNodeId_p,
-                                 BYTE * pbConcise_p,
-                                 tEplObdSize SizeOfConcise_p,
-                                 tEplCfgMaDcfTyp DcfType_p);
+tEplKernel EplCfgMaLinkDcf(unsigned int uiNodeId_p,
+                          BYTE * pbConcise_p,
+                          tEplObdSize SizeOfConcise_p,
+                          tEplCfgMaDcfTyp DcfType_p);
 
 //---------------------------------------------------------------------------
 // Function:    EplCfgMaCheckDcf()
@@ -274,8 +274,7 @@ tEplKernel PUBLIC EplCfgMaLinkDcf(unsigned int uiNodeId_p,
 //
 // Returns:     tCopKernel              = error code
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplCfgMaCheckDcf(unsigned int uiNodeId_p,
-                                  tEplCfgMaDcfTyp DcfType_p);
+tEplKernel EplCfgMaCheckDcf(unsigned int uiNodeId_p, tEplCfgMaDcfTyp DcfType_p);
 
 #endif // #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_CFGMA)) != 0)
 
index 36f8bb76f7ca418d122086a66a71ea8dd773fa28..ea1f2c09d8ce1c078905dbdebc95c45c8778241a 100644 (file)
@@ -81,7 +81,7 @@
 // typedef
 //---------------------------------------------------------------------------
 
-typedef tEplKernel(PUBLIC * tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p);
+typedef tEplKernel(* tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p);
 
 //---------------------------------------------------------------------------
 // function prototypes
index b1dcd0609573483485395f596123d4a9b6229b85..2b2232d02bbc2e1df7f24441577c90de9a1b0b6f 100644 (file)
@@ -82,7 +82,7 @@
 // typedef
 //---------------------------------------------------------------------------
 
-typedef tEplKernel(PUBLIC * tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p);
+typedef tEplKernel(* tEplDlluCbAsnd) (tEplFrameInfo * pFrameInfo_p);
 
 //---------------------------------------------------------------------------
 // function prototypes
index 322cffd11874e15ef335c48dfc95afc7e43c7bf8..1a72f1f82f58238d761fdb617fa8d8d553d3db28 100644 (file)
 // function prototypes
 //---------------------------------------------------------------------------
 // init function
-tEplKernel PUBLIC EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p);
+tEplKernel EplEventuInit(tEplProcessEventCb pfnApiProcessEventCb_p);
 
 // add instance
-tEplKernel PUBLIC EplEventuAddInstance(tEplProcessEventCb
-                                      pfnApiProcessEventCb_p);
+tEplKernel EplEventuAddInstance(tEplProcessEventCb pfnApiProcessEventCb_p);
 
 // delete instance
-tEplKernel PUBLIC EplEventuDelInstance(void);
+tEplKernel EplEventuDelInstance(void);
 
 // Task that dispatches events in userspace
-tEplKernel PUBLIC EplEventuProcess(tEplEvent * pEvent_p);
+tEplKernel EplEventuProcess(tEplEvent * pEvent_p);
 
 // post events from userspace
-tEplKernel PUBLIC EplEventuPost(tEplEvent * pEvent_p);
+tEplKernel EplEventuPost(tEplEvent * pEvent_p);
 
 // post errorevents from userspace
-tEplKernel PUBLIC EplEventuPostError(tEplEventSource EventSource_p,
-                                    tEplKernel EplError_p,
-                                    unsigned int uiArgSize_p, void *pArg_p);
+tEplKernel EplEventuPostError(tEplEventSource EventSource_p,
+                             tEplKernel EplError_p,
+                             unsigned int uiArgSize_p, void *pArg_p);
 
 #endif // #ifndef _EPL_EVENTU_H_
index e7302106c74123ceaa390e4d8e919b219fb4416e..973e4b34ecd984205678f034614753813ca2c3b1 100644 (file)
@@ -81,7 +81,7 @@
 // typedef
 //---------------------------------------------------------------------------
 
-typedef tEplKernel(PUBLIC * tEplIdentuCbResponse) (unsigned int uiNodeId_p,
+typedef tEplKernel(* tEplIdentuCbResponse) (unsigned int uiNodeId_p,
                                                   tEplIdentResponse *
                                                   pIdentResponse_p);
 
@@ -89,20 +89,18 @@ typedef tEplKernel(PUBLIC * tEplIdentuCbResponse) (unsigned int uiNodeId_p,
 // function prototypes
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplIdentuInit(void);
+tEplKernel EplIdentuInit(void);
 
-tEplKernel PUBLIC EplIdentuAddInstance(void);
+tEplKernel EplIdentuAddInstance(void);
 
-tEplKernel PUBLIC EplIdentuDelInstance(void);
+tEplKernel EplIdentuDelInstance(void);
 
-tEplKernel PUBLIC EplIdentuReset(void);
+tEplKernel EplIdentuReset(void);
 
-tEplKernel PUBLIC EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
-                                           tEplIdentResponse **
-                                           ppIdentResponse_p);
+tEplKernel EplIdentuGetIdentResponse(unsigned int uiNodeId_p,
+                                    tEplIdentResponse **ppIdentResponse_p);
 
-tEplKernel PUBLIC EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
-                                               tEplIdentuCbResponse
-                                               pfnCbResponse_p);
+tEplKernel EplIdentuRequestIdentResponse(unsigned int uiNodeId_p,
+                                        tEplIdentuCbResponse pfnCbResponse_p);
 
 #endif // #ifndef _EPLIDENTU_H_
index 78e70d064459dcefa14ee654bc4ae7e8c84a21f6..87fd02f6819f6b4d0f1207d25b8fda6a906c6fcf 100644 (file)
@@ -83,7 +83,7 @@
 // typedef
 //---------------------------------------------------------------------------
 
-typedef tEplKernel(PUBLIC * tEplLeduStateChangeCallback) (tEplLedType LedType_p,
+typedef tEplKernel(* tEplLeduStateChangeCallback) (tEplLedType LedType_p,
                                                          BOOL fOn_p);
 
 //---------------------------------------------------------------------------
@@ -92,17 +92,15 @@ typedef tEplKernel(PUBLIC * tEplLeduStateChangeCallback) (tEplLedType LedType_p,
 
 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
 
-tEplKernel PUBLIC EplLeduInit(tEplLeduStateChangeCallback pfnCbStateChange_p);
+tEplKernel EplLeduInit(tEplLeduStateChangeCallback pfnCbStateChange_p);
 
-tEplKernel PUBLIC EplLeduAddInstance(tEplLeduStateChangeCallback
-                                    pfnCbStateChange_p);
+tEplKernel EplLeduAddInstance(tEplLeduStateChangeCallback pfnCbStateChange_p);
 
-tEplKernel PUBLIC EplLeduDelInstance(void);
+tEplKernel EplLeduDelInstance(void);
 
-tEplKernel PUBLIC EplLeduCbNmtStateChange(tEplEventNmtStateChange
-                                         NmtStateChange_p);
+tEplKernel EplLeduCbNmtStateChange(tEplEventNmtStateChange NmtStateChange_p);
 
-tEplKernel PUBLIC EplLeduProcessEvent(tEplEvent * pEplEvent_p);
+tEplKernel EplLeduProcessEvent(tEplEvent * pEplEvent_p);
 
 #endif // #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0)
 
index e508055b5b8f05f0568e8251cf336610b42a585e..d7e7402638856e447cc2411e671214d532305280 100644 (file)
 
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_CN)) != 0)
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuInit(unsigned int uiNodeId_p);
+EPLDLLEXPORT tEplKernel EplNmtCnuInit(unsigned int uiNodeId_p);
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuAddInstance(unsigned int uiNodeId_p);
+EPLDLLEXPORT tEplKernel EplNmtCnuAddInstance(unsigned int uiNodeId_p);
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuDelInstance(void);
+EPLDLLEXPORT tEplKernel EplNmtCnuDelInstance(void);
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p,
-                                                      tEplNmtCommand
-                                                      NmtCommand_p);
+EPLDLLEXPORT tEplKernel EplNmtCnuSendNmtRequest(unsigned int uiNodeId_p,
+                                               tEplNmtCommand NmtCommand_p);
 
-EPLDLLEXPORT tEplKernel PUBLIC
+EPLDLLEXPORT tEplKernel
 EplNmtCnuRegisterCheckEventCb(tEplNmtuCheckEventCallback
                              pfnEplNmtCheckEventCb_p);
 
index c54efeba303f662a08c28d42c4e51e6c5d46dfa5..478baae2121dd82517bfe496c8e8e45a9afafaaf 100644 (file)
 // typedef
 //---------------------------------------------------------------------------
 
-typedef tEplKernel(PUBLIC * tEplNmtMnuCbNodeEvent) (unsigned int uiNodeId_p,
-                                                   tEplNmtNodeEvent
-                                                   NodeEvent_p,
-                                                   tEplNmtState NmtState_p,
-                                                   WORD wErrorCode_p,
-                                                   BOOL fMandatory_p);
-
-typedef tEplKernel(PUBLIC *
-                  tEplNmtMnuCbBootEvent) (tEplNmtBootEvent BootEvent_p,
-                                          tEplNmtState NmtState_p,
-                                          WORD wErrorCode_p);
+typedef tEplKernel(* tEplNmtMnuCbNodeEvent) (unsigned int uiNodeId_p,
+                                            tEplNmtNodeEvent NodeEvent_p,
+                                            tEplNmtState NmtState_p,
+                                            WORD wErrorCode_p,
+                                            BOOL fMandatory_p);
+
+typedef tEplKernel(* tEplNmtMnuCbBootEvent) (tEplNmtBootEvent BootEvent_p,
+                                            tEplNmtState NmtState_p,
+                                            WORD wErrorCode_p);
 
 //---------------------------------------------------------------------------
 // function prototypes
@@ -107,7 +105,7 @@ tEplKernel EplNmtMnuAddInstance(tEplNmtMnuCbNodeEvent pfnCbNodeEvent_p,
 
 tEplKernel EplNmtMnuDelInstance(void);
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtMnuProcessEvent(tEplEvent * pEvent_p);
+EPLDLLEXPORT tEplKernel EplNmtMnuProcessEvent(tEplEvent * pEvent_p);
 
 tEplKernel EplNmtMnuSendNmtCommand(unsigned int uiNodeId_p,
                                   tEplNmtCommand NmtCommand_p);
@@ -115,12 +113,12 @@ tEplKernel EplNmtMnuSendNmtCommand(unsigned int uiNodeId_p,
 tEplKernel EplNmtMnuTriggerStateChange(unsigned int uiNodeId_p,
                                       tEplNmtNodeCommand NodeCommand_p);
 
-tEplKernel PUBLIC EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange
+tEplKernel EplNmtMnuCbNmtStateChange(tEplEventNmtStateChange
                                            NmtStateChange_p);
 
-tEplKernel PUBLIC EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p);
+tEplKernel EplNmtMnuCbCheckEvent(tEplNmtEvent NmtEvent_p);
 
-tEplKernel PUBLIC EplNmtMnuGetDiagnosticInfo(unsigned int
+tEplKernel EplNmtMnuGetDiagnosticInfo(unsigned int
                                             *puiMandatorySlaveCount_p,
                                             unsigned int
                                             *puiSignalSlaveCount_p,
index 5a56c58306035ec4327ba999bad4ccdf803790d5..fd63899d2841ffcd4210a322e2e0cd8141567733 100644 (file)
@@ -121,12 +121,9 @@ typedef enum {
        kEplNmtCmdInvalidService = 0xFF
 } tEplNmtCommand;
 
-typedef tEplKernel(PUBLIC *
-                  tEplNmtuStateChangeCallback) (tEplEventNmtStateChange
-                                                NmtStateChange_p);
+typedef tEplKernel(* tEplNmtuStateChangeCallback) (tEplEventNmtStateChange NmtStateChange_p);
 
-typedef tEplKernel(PUBLIC *
-                  tEplNmtuCheckEventCallback) (tEplNmtEvent NmtEvent_p);
+typedef tEplKernel(* tEplNmtuCheckEventCallback) (tEplNmtEvent NmtEvent_p);
 
 //---------------------------------------------------------------------------
 // function prototypes
@@ -134,21 +131,19 @@ typedef tEplKernel(PUBLIC *
 
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuInit(void);
+EPLDLLEXPORT tEplKernel EplNmtuInit(void);
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuAddInstance(void);
+EPLDLLEXPORT tEplKernel EplNmtuAddInstance(void);
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuDelInstance(void);
+EPLDLLEXPORT tEplKernel EplNmtuDelInstance(void);
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p);
+EPLDLLEXPORT tEplKernel EplNmtuNmtEvent(tEplNmtEvent NmtEvent_p);
 
-EPLDLLEXPORT tEplNmtState PUBLIC EplNmtuGetNmtState(void);
+EPLDLLEXPORT tEplNmtState EplNmtuGetNmtState(void);
 
-EPLDLLEXPORT tEplKernel PUBLIC EplNmtuProcessEvent(tEplEvent * pEplEvent_p);
+EPLDLLEXPORT tEplKernel EplNmtuProcessEvent(tEplEvent * pEplEvent_p);
 
-EPLDLLEXPORT tEplKernel PUBLIC
-EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback
-                            pfnEplNmtStateChangeCb_p);
+EPLDLLEXPORT tEplKernel EplNmtuRegisterStateChangeCb(tEplNmtuStateChangeCallback pfnEplNmtStateChangeCb_p);
 
 #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0)
 
index c881582702bbe98dcc536baf3c377a2460c970ad..d8c125e042f3f1fd7faa65f12c86deb41df25689 100644 (file)
@@ -86,6 +86,6 @@
 //---------------------------------------------------------------------------
 // function prototypes
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplNmtState PUBLIC EplNmtkCalGetNmtState(void);
+EPLDLLEXPORT tEplNmtState EplNmtkCalGetNmtState(void);
 
 #endif // #ifndef _EPLNMTUCAL_H_
index bc1e1730301725d1ceb3dc9b3fcd32c7107b68e0..c9138cb084efb0909fbe4124664bfd55746d71ea 100644 (file)
 #error "EPL OBDu module enabled, but OBD_USE_KERNEL == TRUE"
 #endif
 
-EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntry(unsigned int uiIndex_p,
-                                                unsigned int uiSubIndex_p,
-                                                void *pSrcData_p,
-                                                tEplObdSize Size_p);
+EPLDLLEXPORT tEplKernel EplObduWriteEntry(unsigned int uiIndex_p,
+                                         unsigned int uiSubIndex_p,
+                                         void *pSrcData_p,
+                                         tEplObdSize Size_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntry(unsigned int uiIndex_p,
-                                               unsigned int uiSubIndex_p,
-                                               void *pDstData_p,
-                                               tEplObdSize * pSize_p);
+EPLDLLEXPORT tEplKernel EplObduReadEntry(unsigned int uiIndex_p,
+                                        unsigned int uiSubIndex_p,
+                                        void *pDstData_p,
+                                        tEplObdSize *pSize_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduAccessOdPart(tEplObdPart ObdPart_p,
-                                                  tEplObdDir Direction_p);
+EPLDLLEXPORT tEplKernel EplObduAccessOdPart(tEplObdPart ObdPart_p,
+                                           tEplObdDir Direction_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduDefineVar(tEplVarParam MEM * pVarParam_p);
+EPLDLLEXPORT tEplKernel EplObduDefineVar(tEplVarParam MEM * pVarParam_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT void *PUBLIC EplObduGetObjectDataPtr(unsigned int uiIndex_p,
-                                                 unsigned int uiSubIndex_p);
+EPLDLLEXPORT void *EplObduGetObjectDataPtr(unsigned int uiIndex_p,
+                                          unsigned int uiSubIndex_p);
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p);
+EPLDLLEXPORT tEplKernel EplObduRegisterUserOd(tEplObdEntryPtr pUserOd_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT void PUBLIC EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p,
-                                            BYTE bType_p,
-                                            tEplObdSize ObdSize_p);
+EPLDLLEXPORT void EplObduInitVarEntry(tEplObdVarEntry MEM * pVarEntry_p,
+                                     BYTE bType_p, tEplObdSize ObdSize_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplObdSize PUBLIC EplObduGetDataSize(unsigned int uiIndex_p,
-                                                  unsigned int uiSubIndex_p);
+EPLDLLEXPORT tEplObdSize EplObduGetDataSize(unsigned int uiIndex_p,
+                                           unsigned int uiSubIndex_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT unsigned int PUBLIC EplObduGetNodeId(void);
+EPLDLLEXPORT unsigned int EplObduGetNodeId(void);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduSetNodeId(unsigned int uiNodeId_p,
-                                               tEplObdNodeIdType NodeIdType_p);
+EPLDLLEXPORT tEplKernel EplObduSetNodeId(unsigned int uiNodeId_p,
+                                        tEplObdNodeIdType NodeIdType_p);
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduGetAccessType(unsigned int uiIndex_p,
-                                                   unsigned int uiSubIndex_p,
-                                                   tEplObdAccess *
-                                                   pAccessTyp_p);
+EPLDLLEXPORT tEplKernel EplObduGetAccessType(unsigned int uiIndex_p,
+                                            unsigned int uiSubIndex_p,
+                                            tEplObdAccess *pAccessTyp_p);
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduReadEntryToLe(unsigned int uiIndex_p,
-                                                   unsigned int uiSubIndex_p,
-                                                   void *pDstData_p,
-                                                   tEplObdSize * pSize_p);
+EPLDLLEXPORT tEplKernel EplObduReadEntryToLe(unsigned int uiIndex_p,
+                                            unsigned int uiSubIndex_p,
+                                            void *pDstData_p,
+                                            tEplObdSize *pSize_p);
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduWriteEntryFromLe(unsigned int uiIndex_p,
-                                                      unsigned int
-                                                      uiSubIndex_p,
-                                                      void *pSrcData_p,
-                                                      tEplObdSize Size_p);
+EPLDLLEXPORT tEplKernel EplObduWriteEntryFromLe(unsigned int uiIndex_p,
+                                               unsigned int uiSubIndex_p,
+                                               void *pSrcData_p,
+                                               tEplObdSize Size_p);
 
 // ---------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
-                                                    unsigned int uiIndex_p,
-                                                    unsigned int uiSubindex_p,
-                                                    tEplObdVarEntry MEM **
-                                                    ppVarEntry_p);
+EPLDLLEXPORT tEplKernel EplObduSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
+                                             unsigned int uiIndex_p,
+                                             unsigned int uiSubindex_p,
+                                             tEplObdVarEntry MEM **ppVarEntry_p);
 
 #elif EPL_OBD_USE_KERNEL != FALSE
 #include "../kernel/EplObdk.h"
index 498e0112fac348978b704cf3783a710c100aceb7..367ecc56d15f8d15df3e4f5b401f858818c0fef6 100644 (file)
 //---------------------------------------------------------------------------
 // function prototypes
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntry(unsigned int uiIndex_p,
-                                                   unsigned int uiSubIndex_p,
-                                                   void *pSrcData_p,
-                                                   tEplObdSize Size_p);
+EPLDLLEXPORT tEplKernel EplObduCalWriteEntry(unsigned int uiIndex_p,
+                                            unsigned int uiSubIndex_p,
+                                            void *pSrcData_p,
+                                            tEplObdSize Size_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntry(unsigned int uiIndex_p,
-                                                  unsigned int uiSubIndex_p,
-                                                  void *pDstData_p,
-                                                  tEplObdSize * pSize_p);
+EPLDLLEXPORT tEplKernel EplObduCalReadEntry(unsigned int uiIndex_p,
+                                           unsigned int uiSubIndex_p,
+                                           void *pDstData_p,
+                                           tEplObdSize * pSize_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
-                                                     tEplObdDir Direction_p);
+EPLDLLEXPORT tEplKernel EplObduCalAccessOdPart(tEplObdPart ObdPart_p,
+                                              tEplObdDir Direction_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalDefineVar(tEplVarParam MEM *
-                                                  pVarParam_p);
+EPLDLLEXPORT tEplKernel EplObduCalDefineVar(tEplVarParam MEM *pVarParam_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT void *PUBLIC EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
-                                                    unsigned int uiSubIndex_p);
+EPLDLLEXPORT void *EplObduCalGetObjectDataPtr(unsigned int uiIndex_p,
+                                             unsigned int uiSubIndex_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalRegisterUserOd(tEplObdEntryPtr
-                                                       pUserOd_p);
+EPLDLLEXPORT tEplKernel EplObduCalRegisterUserOd(tEplObdEntryPtr pUserOd_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT void PUBLIC EplObduCalInitVarEntry(tEplObdVarEntry MEM *
-                                               pVarEntry_p, BYTE bType_p,
-                                               tEplObdSize ObdSize_p);
+EPLDLLEXPORT void EplObduCalInitVarEntry(tEplObdVarEntry MEM *pVarEntry_p,
+                                        BYTE bType_p, tEplObdSize ObdSize_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplObdSize PUBLIC EplObduCalGetDataSize(unsigned int uiIndex_p,
-                                                     unsigned int
-                                                     uiSubIndex_p);
+EPLDLLEXPORT tEplObdSize EplObduCalGetDataSize(unsigned int uiIndex_p,
+                                              unsigned int uiSubIndex_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT unsigned int PUBLIC EplObduCalGetNodeId(void);
+EPLDLLEXPORT unsigned int EplObduCalGetNodeId(void);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalSetNodeId(unsigned int uiNodeId_p,
-                                                  tEplObdNodeIdType
-                                                  NodeIdType_p);
+EPLDLLEXPORT tEplKernel EplObduCalSetNodeId(unsigned int uiNodeId_p,
+                                           tEplObdNodeIdType NodeIdType_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalGetAccessType(unsigned int uiIndex_p,
-                                                      unsigned int
-                                                      uiSubIndex_p,
-                                                      tEplObdAccess *
-                                                      pAccessTyp_p);
+EPLDLLEXPORT tEplKernel EplObduCalGetAccessType(unsigned int uiIndex_p,
+                                               unsigned int uiSubIndex_p,
+                                               tEplObdAccess *pAccessTyp_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalReadEntryToLe(unsigned int uiIndex_p,
-                                                      unsigned int
-                                                      uiSubIndex_p,
-                                                      void *pDstData_p,
-                                                      tEplObdSize * pSize_p);
+EPLDLLEXPORT tEplKernel EplObduCalReadEntryToLe(unsigned int uiIndex_p,
+                                               unsigned int uiSubIndex_p,
+                                               void *pDstData_p,
+                                               tEplObdSize *pSize_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObduCalWriteEntryFromLe(unsigned int
-                                                         uiIndex_p,
-                                                         unsigned int
-                                                         uiSubIndex_p,
-                                                         void *pSrcData_p,
-                                                         tEplObdSize Size_p);
+EPLDLLEXPORT tEplKernel EplObduCalWriteEntryFromLe(unsigned int uiIndex_p,
+                                                  unsigned int uiSubIndex_p,
+                                                  void *pSrcData_p,
+                                                  tEplObdSize Size_p);
 //---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC
+EPLDLLEXPORT tEplKernel
 EplObduCalSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_ unsigned int uiIndex_p,
                         unsigned int uiSubindex_p,
                         tEplObdVarEntry MEM ** ppVarEntry_p);
index 11de4862e8bbf5b48bda6043e43191f9927cf0ed..ebc6cd021f46c06f67517f7dfa225cce7477116e 100644 (file)
@@ -89,7 +89,7 @@ tEplKernel EplPdouAddInstance(void);
 tEplKernel EplPdouDelInstance(void);
 
 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOU)) != 0)
-tEplKernel PUBLIC EplPdouCbObdAccess(tEplObdCbParam MEM * pParam_p);
+tEplKernel EplPdouCbObdAccess(tEplObdCbParam MEM * pParam_p);
 #else
 #define EplPdouCbObdAccess             NULL
 #endif
index e34959f42792cb41d15150bfd79892ba289a4175..6049e5852ed213e765cefec3c17678d06ec8d271 100644 (file)
 //---------------------------------------------------------------------------
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_ASND)) != 0)
 
-tEplKernel PUBLIC EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p);
+tEplKernel EplSdoAsnduInit(tEplSequLayerReceiveCb fpReceiveCb_p);
 
-tEplKernel PUBLIC EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p);
+tEplKernel EplSdoAsnduAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p);
 
-tEplKernel PUBLIC EplSdoAsnduDelInstance(void);
+tEplKernel EplSdoAsnduDelInstance(void);
 
-tEplKernel PUBLIC EplSdoAsnduInitCon(tEplSdoConHdl * pSdoConHandle_p,
-                                    unsigned int uiTargetNodeId_p);
+tEplKernel EplSdoAsnduInitCon(tEplSdoConHdl *pSdoConHandle_p,
+                             unsigned int uiTargetNodeId_p);
 
-tEplKernel PUBLIC EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p,
-                                     tEplFrame * pSrcData_p,
-                                     DWORD dwDataSize_p);
+tEplKernel EplSdoAsnduSendData(tEplSdoConHdl SdoConHandle_p,
+                              tEplFrame *pSrcData_p,
+                              DWORD dwDataSize_p);
 
-tEplKernel PUBLIC EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p);
+tEplKernel EplSdoAsnduDelCon(tEplSdoConHdl SdoConHandle_p);
 
 #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_ASND)) != 0)
 
index 4658b5f8c538eaf1d96fb9fb09026662070fa49c..0a957ba2fdd66d2e4d44f9da60e5681ca428d6ec 100644 (file)
 //---------------------------------------------------------------------------
 // function prototypes
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p,
-                                  tEplSdoComConCb fpSdoComConCb_p);
+tEplKernel EplSdoAsySeqInit(tEplSdoComReceiveCb fpSdoComCb_p,
+                           tEplSdoComConCb fpSdoComConCb_p);
 
-tEplKernel PUBLIC EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p,
-                                         tEplSdoComConCb fpSdoComConCb_p);
+tEplKernel EplSdoAsySeqAddInstance(tEplSdoComReceiveCb fpSdoComCb_p,
+                                  tEplSdoComConCb fpSdoComConCb_p);
 
-tEplKernel PUBLIC EplSdoAsySeqDelInstance(void);
+tEplKernel EplSdoAsySeqDelInstance(void);
 
-tEplKernel PUBLIC EplSdoAsySeqInitCon(tEplSdoSeqConHdl * pSdoSeqConHdl_p,
-                                     unsigned int uiNodeId_p,
-                                     tEplSdoType SdoType);
+tEplKernel EplSdoAsySeqInitCon(tEplSdoSeqConHdl *pSdoSeqConHdl_p,
+                              unsigned int uiNodeId_p,
+                              tEplSdoType SdoType);
 
-tEplKernel PUBLIC EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p,
-                                      unsigned int uiDataSize_p,
-                                      tEplFrame * pData_p);
+tEplKernel EplSdoAsySeqSendData(tEplSdoSeqConHdl SdoSeqConHdl_p,
+                               unsigned int uiDataSize_p,
+                               tEplFrame *pData_p);
 
-tEplKernel PUBLIC EplSdoAsySeqProcessEvent(tEplEvent * pEvent_p);
+tEplKernel EplSdoAsySeqProcessEvent(tEplEvent *pEvent_p);
 
-tEplKernel PUBLIC EplSdoAsySeqDelCon(tEplSdoSeqConHdl SdoSeqConHdl_p);
+tEplKernel EplSdoAsySeqDelCon(tEplSdoSeqConHdl SdoSeqConHdl_p);
 
 #endif // #ifndef _EPLSDOASYSEQU_H_
index 3e454c7a3559f0912bcd7ea955a7171ca8d333b1..9e45e99a978a41ea68f47fbe94d9c1bebdfd9bcc 100644 (file)
 //---------------------------------------------------------------------------
 // function prototypes
 //---------------------------------------------------------------------------
-tEplKernel PUBLIC EplSdoComInit(void);
+tEplKernel EplSdoComInit(void);
 
-tEplKernel PUBLIC EplSdoComAddInstance(void);
+tEplKernel EplSdoComAddInstance(void);
 
-tEplKernel PUBLIC EplSdoComDelInstance(void);
+tEplKernel EplSdoComDelInstance(void);
 
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)
 
-tEplKernel PUBLIC EplSdoComDefineCon(tEplSdoComConHdl * pSdoComConHdl_p,
-                                    unsigned int uiTargetNodeId_p,
-                                    tEplSdoType ProtType_p);
+tEplKernel EplSdoComDefineCon(tEplSdoComConHdl *pSdoComConHdl_p,
+                             unsigned int uiTargetNodeId_p,
+                             tEplSdoType ProtType_p);
 
-tEplKernel PUBLIC EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex *
-                                              pSdoComTransParam_p);
+tEplKernel EplSdoComInitTransferByIndex(tEplSdoComTransParamByIndex *pSdoComTransParam_p);
 
-tEplKernel PUBLIC EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p);
+tEplKernel EplSdoComUndefineCon(tEplSdoComConHdl SdoComConHdl_p);
 
-tEplKernel PUBLIC EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p,
-                                   tEplSdoComFinished * pSdoComFinished_p);
+tEplKernel EplSdoComGetState(tEplSdoComConHdl SdoComConHdl_p,
+                            tEplSdoComFinished *pSdoComFinished_p);
 
-tEplKernel PUBLIC EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p,
-                                   DWORD dwAbortCode_p);
+tEplKernel EplSdoComSdoAbort(tEplSdoComConHdl SdoComConHdl_p,
+                            DWORD dwAbortCode_p);
 
 #endif
 
 // for future extention
 /*
-tEplKernel PUBLIC EplSdoComInitTransferAllByIndex(tEplSdoComTransParamAllByIndex* pSdoComTransParam_p);
+tEplKernel EplSdoComInitTransferAllByIndex(tEplSdoComTransParamAllByIndex* pSdoComTransParam_p);
 
-tEplKernel PUBLIC EplSdoComInitTransferByName(tEplSdoComTransParamByName* pSdoComTransParam_p);
+tEplKernel EplSdoComInitTransferByName(tEplSdoComTransParamByName* pSdoComTransParam_p);
 
-tEplKernel PUBLIC EplSdoComInitTransferFile(tEplSdoComTransParamFile* pSdoComTransParam_p);
+tEplKernel EplSdoComInitTransferFile(tEplSdoComTransParamFile* pSdoComTransParam_p);
 
 */
 
index 2d77b6fff199a9e6a14607070d7cd758a019bdef..22091d4f317e767d501000d88c167b91ece7c079 100644 (file)
 //---------------------------------------------------------------------------
 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0)
 
-tEplKernel PUBLIC EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p);
+tEplKernel EplSdoUdpuInit(tEplSequLayerReceiveCb fpReceiveCb_p);
 
-tEplKernel PUBLIC EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p);
+tEplKernel EplSdoUdpuAddInstance(tEplSequLayerReceiveCb fpReceiveCb_p);
 
-tEplKernel PUBLIC EplSdoUdpuDelInstance(void);
+tEplKernel EplSdoUdpuDelInstance(void);
 
-tEplKernel PUBLIC EplSdoUdpuConfig(unsigned long ulIpAddr_p,
-                                  unsigned int uiPort_p);
+tEplKernel EplSdoUdpuConfig(unsigned long ulIpAddr_p,
+                           unsigned int uiPort_p);
 
-tEplKernel PUBLIC EplSdoUdpuInitCon(tEplSdoConHdl * pSdoConHandle_p,
-                                   unsigned int uiTargetNodeId_p);
+tEplKernel EplSdoUdpuInitCon(tEplSdoConHdl *pSdoConHandle_p,
+                            unsigned int uiTargetNodeId_p);
 
-tEplKernel PUBLIC EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p,
-                                    tEplFrame * pSrcData_p,
-                                    DWORD dwDataSize_p);
+tEplKernel EplSdoUdpuSendData(tEplSdoConHdl SdoConHandle_p,
+                             tEplFrame *pSrcData_p, DWORD dwDataSize_p);
 
-tEplKernel PUBLIC EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p);
+tEplKernel EplSdoUdpuDelCon(tEplSdoConHdl SdoConHandle_p);
 
 #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0)
 
index d211935f0e834d6fde09acd7af774e3959a916ad..6b98ff9b963623e6dfbe63d4c9e20edcb7d63432 100644 (file)
 // typedef
 //---------------------------------------------------------------------------
 
-typedef tEplKernel(PUBLIC * tEplStatusuCbResponse) (unsigned int uiNodeId_p,
-                                                   tEplStatusResponse *
-                                                   pStatusResponse_p);
+typedef tEplKernel(* tEplStatusuCbResponse) (unsigned int uiNodeId_p,
+                                            tEplStatusResponse *pStatusResponse_p);
 
 //---------------------------------------------------------------------------
 // function prototypes
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplStatusuInit(void);
+tEplKernel EplStatusuInit(void);
 
-tEplKernel PUBLIC EplStatusuAddInstance(void);
+tEplKernel EplStatusuAddInstance(void);
 
-tEplKernel PUBLIC EplStatusuDelInstance(void);
+tEplKernel EplStatusuDelInstance(void);
 
-tEplKernel PUBLIC EplStatusuReset(void);
+tEplKernel EplStatusuReset(void);
 
-tEplKernel PUBLIC EplStatusuRequestStatusResponse(unsigned int uiNodeId_p,
-                                                 tEplStatusuCbResponse
-                                                 pfnCbResponse_p);
+tEplKernel EplStatusuRequestStatusResponse(unsigned int uiNodeId_p,
+                                          tEplStatusuCbResponse pfnCbResponse_p);
 
 #endif // #ifndef _EPLSTATUSU_H_
index 404495501b8df69b90cbe8978f0ce03e66ef6d72..65273e5f9c8129c207479822ae4d998b989b9fdd 100644 (file)
 // function prototypes
 //---------------------------------------------------------------------------
 
-tEplKernel PUBLIC EplTimeruInit(void);
+tEplKernel EplTimeruInit(void);
 
-tEplKernel PUBLIC EplTimeruAddInstance(void);
+tEplKernel EplTimeruAddInstance(void);
 
-tEplKernel PUBLIC EplTimeruDelInstance(void);
+tEplKernel EplTimeruDelInstance(void);
 
-tEplKernel PUBLIC EplTimeruSetTimerMs(tEplTimerHdl * pTimerHdl_p,
-                                     unsigned long ulTime_p,
-                                     tEplTimerArg Argument_p);
+tEplKernel EplTimeruSetTimerMs(tEplTimerHdl *pTimerHdl_p,
+                              unsigned long ulTime_p,
+                              tEplTimerArg Argument_p);
 
-tEplKernel PUBLIC EplTimeruModifyTimerMs(tEplTimerHdl * pTimerHdl_p,
-                                        unsigned long ulTime_p,
-                                        tEplTimerArg Argument_p);
+tEplKernel EplTimeruModifyTimerMs(tEplTimerHdl *pTimerHdl_p,
+                                 unsigned long ulTime_p,
+                                 tEplTimerArg Argument_p);
 
-tEplKernel PUBLIC EplTimeruDeleteTimer(tEplTimerHdl * pTimerHdl_p);
+tEplKernel EplTimeruDeleteTimer(tEplTimerHdl *pTimerHdl_p);
 
-BOOL PUBLIC EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p);
+BOOL EplTimeruIsTimerActive(tEplTimerHdl TimerHdl_p);
 
 #endif // #ifndef _EPLTIMERU_H_