harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ge...@apache.org
Subject svn commit: r350181 [163/198] - in /incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core: ./ depends/ depends/files/ depends/jars/ depends/libs/ depends/libs/linux.IA32/ depends/libs/win.IA32/ depends/oss/ depends/oss/linux.IA32/ depends/oss/win....
Date Thu, 01 Dec 2005 06:04:00 GMT
Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/port/ut_hyprt.h
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/port/ut_hyprt.h?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/port/ut_hyprt.h (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/port/ut_hyprt.h Wed Nov 30 21:29:27 2005
@@ -0,0 +1,1169 @@
+/* Copyright 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(_UTE_MODULE_HEADER_)
+#define _UTE_MODULE_HEADER_
+#include "ute_module.h"
+#if !defined(UT_TRACE_OVERHEAD)
+#define UT_TRACE_OVERHEAD 0
+#endif
+
+#if !defined(UT_THREAD)
+#define UT_THREAD(thr) (void *)thr
+#endif /* UT_THREAD */
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_PortInitStages_Event1() do { \
+	if ((unsigned char) hyprt_UtActive[0] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((0 << 8) | hyprt_UtActive[0]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_PortInitStages_Event1() /* tracepoint name: hyprt.0 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_file_open_Entry(P1, P2, P3) do { \
+	if ((unsigned char) hyprt_UtActive[1] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((1 << 8) | hyprt_UtActive[1]), "\377\4\4", P1, P2, P3);} \
+	} while(0)
+#else
+#define Trc_PRT_file_open_Entry(P1, P2, P3)     /* tracepoint name: hyprt.1 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_file_open_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[2] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((2 << 8) | hyprt_UtActive[2]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_file_open_Exit(P1)      /* tracepoint name: hyprt.2 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_file_open_Exit1(P1) do { \
+	if ((unsigned char) hyprt_UtActive[3] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((3 << 8) | hyprt_UtActive[3]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_file_open_Exit1(P1)     /* tracepoint name: hyprt.3 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_file_open_Exit2(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[4] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((4 << 8) | hyprt_UtActive[4]), "\4\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_file_open_Exit2(P1, P2) /* tracepoint name: hyprt.4 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_file_open_Exit3(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[5] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((5 << 8) | hyprt_UtActive[5]), "\4\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_file_open_Exit3(P1, P2) /* tracepoint name: hyprt.5 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_file_open_Exit4() do { \
+	if ((unsigned char) hyprt_UtActive[6] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((6 << 8) | hyprt_UtActive[6]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_file_open_Exit4()       /* tracepoint name: hyprt.6 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createFile_Entry() do { \
+	if ((unsigned char) hyprt_UtActive[7] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((7 << 8) | hyprt_UtActive[7]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createFile_Entry()        /* tracepoint name: hyprt.7 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createFile_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[8] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((8 << 8) | hyprt_UtActive[8]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createFile_Exit1()        /* tracepoint name: hyprt.8 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createFile_Exit2(P1) do { \
+	if ((unsigned char) hyprt_UtActive[9] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((9 << 8) | hyprt_UtActive[9]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createFile_Exit2(P1)      /* tracepoint name: hyprt.9 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createFile_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[10] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((10 << 8) | hyprt_UtActive[10]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createFile_Exit() /* tracepoint name: hyprt.10 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Entry() do { \
+	if ((unsigned char) hyprt_UtActive[11] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((11 << 8) | hyprt_UtActive[11]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Entry()        /* tracepoint name: hyprt.11 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_ftok(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[12] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((12 << 8) | hyprt_UtActive[12]), "\377\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_ftok(P1, P2)   /* tracepoint name: hyprt.12 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[13] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((13 << 8) | hyprt_UtActive[13]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Exit1()        /* tracepoint name: hyprt.13 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Exit2() do { \
+	if ((unsigned char) hyprt_UtActive[14] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((14 << 8) | hyprt_UtActive[14]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Exit2()        /* tracepoint name: hyprt.14 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Exit3() do { \
+	if ((unsigned char) hyprt_UtActive[15] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((15 << 8) | hyprt_UtActive[15]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Exit3()        /* tracepoint name: hyprt.15 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Exit4() do { \
+	if ((unsigned char) hyprt_UtActive[16] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((16 << 8) | hyprt_UtActive[16]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Exit4()        /* tracepoint name: hyprt.16 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_shmget(P1, P2, P3) do { \
+	if ((unsigned char) hyprt_UtActive[17] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((17 << 8) | hyprt_UtActive[17]), "\4\4\4", P1, P2, P3);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_shmget(P1, P2, P3)     /* tracepoint name: hyprt.17 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_shmget_Event1(P1) do { \
+	if ((unsigned char) hyprt_UtActive[18] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((18 << 8) | hyprt_UtActive[18]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_shmget_Event1(P1)      /* tracepoint name: hyprt.18 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Exit5(P1) do { \
+	if ((unsigned char) hyprt_UtActive[19] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((19 << 8) | hyprt_UtActive[19]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Exit5(P1)      /* tracepoint name: hyprt.19 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Exit6(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[20] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((20 << 8) | hyprt_UtActive[20]), "\4\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Exit6(P1, P2)  /* tracepoint name: hyprt.20 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Event1(P1) do { \
+	if ((unsigned char) hyprt_UtActive[21] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((21 << 8) | hyprt_UtActive[21]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Event1(P1)     /* tracepoint name: hyprt.21 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Exit7() do { \
+	if ((unsigned char) hyprt_UtActive[22] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((22 << 8) | hyprt_UtActive[22]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Exit7()        /* tracepoint name: hyprt.22 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Exit8() do { \
+	if ((unsigned char) hyprt_UtActive[23] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((23 << 8) | hyprt_UtActive[23]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Exit8()        /* tracepoint name: hyprt.23 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_createSharedMemory_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[24] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((24 << 8) | hyprt_UtActive[24]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_createSharedMemory_Exit() /* tracepoint name: hyprt.24 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_attach_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[25] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((25 << 8) | hyprt_UtActive[25]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_attach_Entry(P1)  /* tracepoint name: hyprt.25 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_attach_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[26] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((26 << 8) | hyprt_UtActive[26]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_attach_Exit(P1)   /* tracepoint name: hyprt.26 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_attach_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[27] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((27 << 8) | hyprt_UtActive[27]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_attach_Exit1()    /* tracepoint name: hyprt.27 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_attach_Exit2(P1) do { \
+	if ((unsigned char) hyprt_UtActive[28] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((28 << 8) | hyprt_UtActive[28]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_attach_Exit2(P1)  /* tracepoint name: hyprt.28 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_attach_Debug1(P1) do { \
+	if ((unsigned char) hyprt_UtActive[29] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((29 << 8) | hyprt_UtActive[29]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_attach_Debug1(P1) /* tracepoint name: hyprt.29 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_close_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[30] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((30 << 8) | hyprt_UtActive[30]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_close_Entry(P1)   /* tracepoint name: hyprt.30 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_close_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[31] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((31 << 8) | hyprt_UtActive[31]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_close_Exit()      /* tracepoint name: hyprt.31 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_destroy_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[32] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((32 << 8) | hyprt_UtActive[32]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_destroy_Entry(P1) /* tracepoint name: hyprt.32 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_destroy_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[33] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((33 << 8) | hyprt_UtActive[33]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_destroy_Exit()    /* tracepoint name: hyprt.33 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_destroy_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[34] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((34 << 8) | hyprt_UtActive[34]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_destroy_Exit1()   /* tracepoint name: hyprt.34 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_destroy_Debug1(P1, P2, P3) do { \
+	if ((unsigned char) hyprt_UtActive[35] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((35 << 8) | hyprt_UtActive[35]), "\377\4\4", P1, P2, P3);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_destroy_Debug1(P1, P2, P3)        /* tracepoint name: hyprt.35 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_detach_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[36] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((36 << 8) | hyprt_UtActive[36]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_detach_Entry(P1)  /* tracepoint name: hyprt.36 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_detach_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[37] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((37 << 8) | hyprt_UtActive[37]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_detach_Exit()     /* tracepoint name: hyprt.37 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_detach_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[38] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((38 << 8) | hyprt_UtActive[38]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_detach_Exit1()    /* tracepoint name: hyprt.38 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findclose_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[39] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((39 << 8) | hyprt_UtActive[39]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findclose_Entry(P1)       /* tracepoint name: hyprt.39 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findclose_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[40] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((40 << 8) | hyprt_UtActive[40]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findclose_Exit()  /* tracepoint name: hyprt.40 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findfirst_Entry() do { \
+	if ((unsigned char) hyprt_UtActive[41] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((41 << 8) | hyprt_UtActive[41]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findfirst_Entry() /* tracepoint name: hyprt.41 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findfirst_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[42] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((42 << 8) | hyprt_UtActive[42]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findfirst_Exit1() /* tracepoint name: hyprt.42 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findfirst_Exit2() do { \
+	if ((unsigned char) hyprt_UtActive[43] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((43 << 8) | hyprt_UtActive[43]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findfirst_Exit2() /* tracepoint name: hyprt.43 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findfirst_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[44] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((44 << 8) | hyprt_UtActive[44]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findfirst_Exit()  /* tracepoint name: hyprt.44 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findnext_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[45] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((45 << 8) | hyprt_UtActive[45]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findnext_Entry(P1)        /* tracepoint name: hyprt.45 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findnext_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[46] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((46 << 8) | hyprt_UtActive[46]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findnext_Exit1()  /* tracepoint name: hyprt.46 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findnext_Exit2() do { \
+	if ((unsigned char) hyprt_UtActive[47] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((47 << 8) | hyprt_UtActive[47]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findnext_Exit2()  /* tracepoint name: hyprt.47 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_findnext_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[48] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((48 << 8) | hyprt_UtActive[48]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_findnext_Exit()   /* tracepoint name: hyprt.48 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_open_Entry(P1, P2, P3) do { \
+	if ((unsigned char) hyprt_UtActive[49] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((49 << 8) | hyprt_UtActive[49]), "\377\4\4", P1, P2, P3);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_open_Entry(P1, P2, P3)    /* tracepoint name: hyprt.49 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_open_Event1(P1) do { \
+	if ((unsigned char) hyprt_UtActive[50] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((50 << 8) | hyprt_UtActive[50]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_open_Event1(P1)   /* tracepoint name: hyprt.50 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_open_Event2(P1) do { \
+	if ((unsigned char) hyprt_UtActive[51] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((51 << 8) | hyprt_UtActive[51]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_open_Event2(P1)   /* tracepoint name: hyprt.51 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_open_Event3(P1) do { \
+	if ((unsigned char) hyprt_UtActive[52] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((52 << 8) | hyprt_UtActive[52]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_open_Event3(P1)   /* tracepoint name: hyprt.52 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_open_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[53] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((53 << 8) | hyprt_UtActive[53]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_open_Exit1()      /* tracepoint name: hyprt.53 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_open_Exit2() do { \
+	if ((unsigned char) hyprt_UtActive[54] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((54 << 8) | hyprt_UtActive[54]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_open_Exit2()      /* tracepoint name: hyprt.54 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_open_Exit(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[55] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((55 << 8) | hyprt_UtActive[55]), "\4\6", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_open_Exit(P1, P2) /* tracepoint name: hyprt.55 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_stat_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[56] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((56 << 8) | hyprt_UtActive[56]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_stat_Entry(P1)    /* tracepoint name: hyprt.56 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_stat_Exit1(P1) do { \
+	if ((unsigned char) hyprt_UtActive[57] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((57 << 8) | hyprt_UtActive[57]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_stat_Exit1(P1)    /* tracepoint name: hyprt.57 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_stat_Exit2(P1) do { \
+	if ((unsigned char) hyprt_UtActive[58] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((58 << 8) | hyprt_UtActive[58]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_stat_Exit2(P1)    /* tracepoint name: hyprt.58 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_stat_Exit3(P1) do { \
+	if ((unsigned char) hyprt_UtActive[59] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((59 << 8) | hyprt_UtActive[59]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_stat_Exit3(P1)    /* tracepoint name: hyprt.59 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_stat_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[60] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((60 << 8) | hyprt_UtActive[60]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_stat_Exit()       /* tracepoint name: hyprt.60 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_open_Entry(P1, P2, P3) do { \
+	if ((unsigned char) hyprt_UtActive[61] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((61 << 8) | hyprt_UtActive[61]), "\377\4\4", P1, P2, P3);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_open_Entry(P1, P2, P3)    /* tracepoint name: hyprt.61 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_open_Debug1(P1) do { \
+	if ((unsigned char) hyprt_UtActive[62] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((62 << 8) | hyprt_UtActive[62]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_open_Debug1(P1)   /* tracepoint name: hyprt.62 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_open_Event1(P1) do { \
+	if ((unsigned char) hyprt_UtActive[63] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((63 << 8) | hyprt_UtActive[63]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_open_Event1(P1)   /* tracepoint name: hyprt.63 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_open_Event2(P1) do { \
+	if ((unsigned char) hyprt_UtActive[64] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((64 << 8) | hyprt_UtActive[64]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_open_Event2(P1)   /* tracepoint name: hyprt.64 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_open_Event3(P1) do { \
+	if ((unsigned char) hyprt_UtActive[65] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((65 << 8) | hyprt_UtActive[65]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_open_Event3(P1)   /* tracepoint name: hyprt.65 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_open_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[66] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((66 << 8) | hyprt_UtActive[66]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_open_Exit1()      /* tracepoint name: hyprt.66 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_open_Exit2() do { \
+	if ((unsigned char) hyprt_UtActive[67] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((67 << 8) | hyprt_UtActive[67]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_open_Exit2()      /* tracepoint name: hyprt.67 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_open_Exit(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[68] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((68 << 8) | hyprt_UtActive[68]), "\4\6", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_open_Exit(P1, P2) /* tracepoint name: hyprt.68 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_close_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[69] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((69 << 8) | hyprt_UtActive[69]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_close_Entry(P1)   /* tracepoint name: hyprt.69 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_close_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[70] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((70 << 8) | hyprt_UtActive[70]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_close_Exit()      /* tracepoint name: hyprt.70 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_destroy_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[71] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((71 << 8) | hyprt_UtActive[71]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_destroy_Entry(P1) /* tracepoint name: hyprt.71 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_destroy_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[72] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((72 << 8) | hyprt_UtActive[72]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_destroy_Exit()    /* tracepoint name: hyprt.72 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_destroy_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[73] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((73 << 8) | hyprt_UtActive[73]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_destroy_Exit1()   /* tracepoint name: hyprt.73 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_destroy_Debug1(P1, P2, P3) do { \
+	if ((unsigned char) hyprt_UtActive[74] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((74 << 8) | hyprt_UtActive[74]), "\377\4\4", P1, P2, P3);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_destroy_Debug1(P1, P2, P3)        /* tracepoint name: hyprt.74 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_getVal_Entry(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[75] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((75 << 8) | hyprt_UtActive[75]), "\6\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_getVal_Entry(P1, P2)      /* tracepoint name: hyprt.75 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_getVal_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[76] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((76 << 8) | hyprt_UtActive[76]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_getVal_Exit1()    /* tracepoint name: hyprt.76 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_getVal_Exit2() do { \
+	if ((unsigned char) hyprt_UtActive[77] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((77 << 8) | hyprt_UtActive[77]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_getVal_Exit2()    /* tracepoint name: hyprt.77 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_getVal_Exit3(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[78] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((78 << 8) | hyprt_UtActive[78]), "\4\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_getVal_Exit3(P1, P2)      /* tracepoint name: hyprt.78 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_getVal_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[79] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((79 << 8) | hyprt_UtActive[79]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_getVal_Exit(P1)   /* tracepoint name: hyprt.79 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_post_Entry(P1, P2, P3) do { \
+	if ((unsigned char) hyprt_UtActive[80] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((80 << 8) | hyprt_UtActive[80]), "\6\4\4", P1, P2, P3);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_post_Entry(P1, P2, P3)    /* tracepoint name: hyprt.80 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_post_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[81] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((81 << 8) | hyprt_UtActive[81]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_post_Exit1()      /* tracepoint name: hyprt.81 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_post_Exit2() do { \
+	if ((unsigned char) hyprt_UtActive[82] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((82 << 8) | hyprt_UtActive[82]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_post_Exit2()      /* tracepoint name: hyprt.82 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_post_Exit3(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[83] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((83 << 8) | hyprt_UtActive[83]), "\4\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_post_Exit3(P1, P2)        /* tracepoint name: hyprt.83 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_post_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[84] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((84 << 8) | hyprt_UtActive[84]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_post_Exit(P1)     /* tracepoint name: hyprt.84 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_setVal_Entry(P1, P2, P3) do { \
+	if ((unsigned char) hyprt_UtActive[85] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((85 << 8) | hyprt_UtActive[85]), "\6\4\4", P1, P2, P3);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_setVal_Entry(P1, P2, P3)  /* tracepoint name: hyprt.85 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_setVal_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[86] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((86 << 8) | hyprt_UtActive[86]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_setVal_Exit1()    /* tracepoint name: hyprt.86 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_setVal_Exit2() do { \
+	if ((unsigned char) hyprt_UtActive[87] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((87 << 8) | hyprt_UtActive[87]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_setVal_Exit2()    /* tracepoint name: hyprt.87 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_setVal_Exit3(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[88] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((88 << 8) | hyprt_UtActive[88]), "\4\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_setVal_Exit3(P1, P2)      /* tracepoint name: hyprt.88 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_setVal_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[89] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((89 << 8) | hyprt_UtActive[89]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_setVal_Exit(P1)   /* tracepoint name: hyprt.89 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_wait_Entry(P1, P2, P3) do { \
+	if ((unsigned char) hyprt_UtActive[90] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((90 << 8) | hyprt_UtActive[90]), "\6\4\4", P1, P2, P3);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_wait_Entry(P1, P2, P3)    /* tracepoint name: hyprt.90 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_wait_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[91] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((91 << 8) | hyprt_UtActive[91]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_wait_Exit1()      /* tracepoint name: hyprt.91 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_wait_Exit2() do { \
+	if ((unsigned char) hyprt_UtActive[92] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((92 << 8) | hyprt_UtActive[92]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_wait_Exit2()      /* tracepoint name: hyprt.92 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_wait_Exit3(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[93] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((93 << 8) | hyprt_UtActive[93]), "\4\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_wait_Exit3(P1, P2)        /* tracepoint name: hyprt.93 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_wait_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[94] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((94 << 8) | hyprt_UtActive[94]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_wait_Exit(P1)     /* tracepoint name: hyprt.94 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_ensureDirectory_path(P1) do { \
+	if ((unsigned char) hyprt_UtActive[95] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((95 << 8) | hyprt_UtActive[95]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_ensureDirectory_path(P1)  /* tracepoint name: hyprt.95 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_mem_hymem_allocate_memory_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[96] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((96 << 8) | hyprt_UtActive[96]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_mem_hymem_allocate_memory_Entry(P1)     /* tracepoint name: hyprt.96 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_mem_hymem_allocate_memory_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[97] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((97 << 8) | hyprt_UtActive[97]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_mem_hymem_allocate_memory_Exit(P1)      /* tracepoint name: hyprt.97 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_mem_hymem_free_memory_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[98] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((98 << 8) | hyprt_UtActive[98]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_mem_hymem_free_memory_Entry(P1) /* tracepoint name: hyprt.98 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_mem_hymem_free_memory_Exit() do { \
+	if ((unsigned char) hyprt_UtActive[99] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((99 << 8) | hyprt_UtActive[99]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_mem_hymem_free_memory_Exit()    /* tracepoint name: hyprt.99 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_mem_hymem_allocate_memory_callSite_Entry(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[100] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((100 << 8) | hyprt_UtActive[100]), "\4\377", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_mem_hymem_allocate_memory_callSite_Entry(P1, P2)        /* tracepoint name: hyprt.100 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_mem_hymem_allocate_memory_callSite_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[101] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((101 << 8) | hyprt_UtActive[101]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_mem_hymem_allocate_memory_callSite_Exit(P1)     /* tracepoint name: hyprt.101 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_mem_hymem_reallocate_memory_Entry(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[102] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((102 << 8) | hyprt_UtActive[102]), "\6\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_mem_hymem_reallocate_memory_Entry(P1, P2)       /* tracepoint name: hyprt.102 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_mem_hymem_reallocate_memory_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[103] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((103 << 8) | hyprt_UtActive[103]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_mem_hymem_reallocate_memory_Exit(P1)    /* tracepoint name: hyprt.103 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Entry(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[104] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((104 << 8) | hyprt_UtActive[104]), "\6\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Entry(P1, P2)        /* tracepoint name: hyprt.104 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit1() do { \
+	if ((unsigned char) hyprt_UtActive[105] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((105 << 8) | hyprt_UtActive[105]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit1()      /* tracepoint name: hyprt.105 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit2(P1) do { \
+	if ((unsigned char) hyprt_UtActive[106] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((106 << 8) | hyprt_UtActive[106]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit2(P1)    /* tracepoint name: hyprt.106 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit3(P1) do { \
+	if ((unsigned char) hyprt_UtActive[107] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((107 << 8) | hyprt_UtActive[107]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit3(P1)    /* tracepoint name: hyprt.107 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit4() do { \
+	if ((unsigned char) hyprt_UtActive[108] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((108 << 8) | hyprt_UtActive[108]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit4()      /* tracepoint name: hyprt.108 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[109] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((109 << 8) | hyprt_UtActive[109]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_reserve_memory_Exit(P1)     /* tracepoint name: hyprt.109 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_free_memory_Entry(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[110] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((110 << 8) | hyprt_UtActive[110]), "\6\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_free_memory_Entry(P1, P2)   /* tracepoint name: hyprt.110 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_free_memory_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[111] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((111 << 8) | hyprt_UtActive[111]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_free_memory_Exit(P1)        /* tracepoint name: hyprt.111 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_commit_memory_Entry(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[112] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((112 << 8) | hyprt_UtActive[112]), "\6\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_commit_memory_Entry(P1, P2) /* tracepoint name: hyprt.112 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_commit_memory_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[113] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((113 << 8) | hyprt_UtActive[113]), "\6", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_commit_memory_Exit(P1)      /* tracepoint name: hyprt.113 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_decommit_memory_Entry(P1, P2) do { \
+	if ((unsigned char) hyprt_UtActive[114] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((114 << 8) | hyprt_UtActive[114]), "\6\4", P1, P2);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_decommit_memory_Entry(P1, P2)       /* tracepoint name: hyprt.114 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_vmem_hyvmem_decommit_memory_Exit(P1) do { \
+	if ((unsigned char) hyprt_UtActive[115] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((115 << 8) | hyprt_UtActive[115]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_vmem_hyvmem_decommit_memory_Exit(P1)    /* tracepoint name: hyprt.115 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shared_ensureDirectory_Entry(P1) do { \
+	if ((unsigned char) hyprt_UtActive[116] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((116 << 8) | hyprt_UtActive[116]), "\377", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shared_ensureDirectory_Entry(P1)        /* tracepoint name: hyprt.116 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shared_changeDirectoryPermission_Event1(P1) do { \
+	if ((unsigned char) hyprt_UtActive[117] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((117 << 8) | hyprt_UtActive[117]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shared_changeDirectoryPermission_Event1(P1)     /* tracepoint name: hyprt.117 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shared_ensureDirectory_Event1() do { \
+	if ((unsigned char) hyprt_UtActive[118] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((118 << 8) | hyprt_UtActive[118]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shared_ensureDirectory_Event1() /* tracepoint name: hyprt.118 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shared_ensureDirectory_Event2(P1) do { \
+	if ((unsigned char) hyprt_UtActive[119] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((119 << 8) | hyprt_UtActive[119]), "\4", P1);} \
+	} while(0)
+#else
+#define Trc_PRT_shared_ensureDirectory_Event2(P1)       /* tracepoint name: hyprt.119 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shmem_hyshmem_open_Exit3() do { \
+	if ((unsigned char) hyprt_UtActive[120] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((120 << 8) | hyprt_UtActive[120]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shmem_hyshmem_open_Exit3()      /* tracepoint name: hyprt.120 */
+#endif
+
+#if (UT_TRACE_OVERHEAD>=1)
+#define Trc_PRT_shsem_hyshsem_open_Exit3() do { \
+	if ((unsigned char) hyprt_UtActive[121] != 0){ \
+		hyprt_UtModuleInfo.intf->Trace((void *)NULL, &hyprt_UtModuleInfo, ((121 << 8) | hyprt_UtActive[121]), NULL);} \
+	} while(0)
+#else
+#define Trc_PRT_shsem_hyshsem_open_Exit3()      /* tracepoint name: hyprt.121 */
+#endif
+
+#if defined(_UTE_STATIC_)
+  unsigned char hyprt_UtActive[122] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0,
+    0, 0
+  };
+  unsigned char hyprt_UtLevels[122] = {
+    1, 4, 4, 1, 1, 1, 1, 1, 1, 1, 4, 1, 4, 1, 1, 1, 1, 4, 4, 1, 1, 4, 1, 1, 4,
+    4, 4, 1, 1, 5,
+    4, 4, 4, 4, 4, 4, 4, 4, 1, 4, 4, 4, 1, 4, 4, 4, 1, 4, 4, 4, 4, 4, 4, 1, 1,
+    1, 4, 1, 1, 1,
+    4, 4, 4, 4, 4, 4, 1, 1, 1, 4, 4, 4, 4, 4, 4, 4, 1, 1, 1, 1, 4, 1, 1, 1, 1,
+    4, 1, 1, 1, 1,
+    4, 1, 1, 1, 1, 4, 10, 10, 10, 10, 8, 8, 4, 4, 4, 2, 2, 2, 2, 4, 4, 4, 4,
+    4, 4, 4, 4, 1, 1, 1,
+    1, 1
+  };
+  UtModuleInfo hyprt_UtModuleInfo =
+    { "hyprt", 5, NULL, NULL, NULL };
+#else                           /* !_UTE_STATIC_ */
+  extern UtModuleInfo hyprt_UtModuleInfo;
+  extern unsigned char hyprt_UtActive[122];
+#endif                          /* !_UTE_STATIC_ */
+
+#if !defined(UT_MODULE_INFO)
+#define UT_MODULE_INFO hyprt_UtModuleInfo
+#endif                          /* UT_MODULE_INFO */
+
+#if defined(__cplusplus)
+}                               /* extern "C" */
+#endif
+#endif                          /* !_UTE_MODULE_HEADER_ */
+
+

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/port/ut_hyprt.inc
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/port/ut_hyprt.inc?rev=350181&view=auto
==============================================================================
    (empty)

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/hysig.exp
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/hysig.exp?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/hysig.exp (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/hysig.exp Wed Nov 30 21:29:27 2005
@@ -0,0 +1,16 @@
+HYSIG_0.1 {
+	global :
+		jsig_handler;
+		jsig_primary_signal;
+		signal;
+		jsig_primary_sigaction;
+		bsd_signal;
+		sysv_signal;
+		sigaction;
+		sigignore;
+		sigset;
+		__sysv_signal;
+		ssignal;
+		sigvec;
+	local : *;
+};

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsig_copyright.c
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsig_copyright.c?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsig_copyright.c (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsig_copyright.c Wed Nov 30 21:29:27 2005
@@ -0,0 +1,19 @@
+/* Copyright 1991, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* A copyright string included in each DLL and executable */
+
+const char hyCopyright[] =
+  "(c) Copyright 1991, 2005 The Apache Software Foundation or its licensors, as applicable.";

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsiglinux.c
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsiglinux.c?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsiglinux.c (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsiglinux.c Wed Nov 30 21:29:27 2005
@@ -0,0 +1,221 @@
+/* Copyright 2003, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined(LINUX)
+#define _GNU_SOURCE 1
+#endif
+
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <dlfcn.h>
+
+#include "jsigunix.h"
+
+/**************************/
+/* PRIVATE JSIG FUNCTIONS */
+/**************************/
+
+/*********************************************************************/
+/* Function Name: real_sigaction()                                   */
+/*                                                                   */
+/* Description:   Calls the real sigaction.                          */
+/*                                                                   */
+/* Parameters:    sig - Signal number                                */
+/*                act - sigaction for signal handler to be installed */
+/*                oact - sigaction for previously installed handler  */
+/*                                                                   */
+/* Returns:       return code from sigaction function                */
+/*********************************************************************/
+int
+real_sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
+{
+  extern int jsig_sigaction_isdefault (void);
+  static sigactionfunc_t real_sigaction_fn = 0;
+  if (real_sigaction_fn == 0)
+    {
+      if (jsig_sigaction_isdefault ())
+        {
+          real_sigaction_fn =
+            (sigactionfunc_t) dlsym (RTLD_NEXT, "sigaction");
+          if (real_sigaction_fn == 0)
+            {
+              real_sigaction_fn =
+                (sigactionfunc_t) dlsym (RTLD_DEFAULT, "sigaction");
+            }
+        }
+      else
+        {
+          real_sigaction_fn =
+            (sigactionfunc_t) dlsym (RTLD_DEFAULT, "sigaction");
+          if (real_sigaction_fn == 0)
+            {
+              real_sigaction_fn =
+                (sigactionfunc_t) dlsym (RTLD_NEXT, "sigaction");
+            }
+        }
+      if (real_sigaction_fn == 0)
+        {
+          fprintf (stderr, "libjsig unable to find sigaction - %s\n",
+                   dlerror ());
+          abort ();
+        }
+    }
+  return (*real_sigaction_fn) (sig, act, oact);
+}
+
+/*********************************************************************/
+/* Function Name: real_sigprocmask()                                 */
+/*                                                                   */
+/* Description:   Calls the real sigprocmask. This just calls        */
+/*                sigprocmask for all platforms except on AIX        */
+/*                where sigthreadmask is called                      */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:       return code from sigprocmask function              */
+/*********************************************************************/
+int
+real_sigprocmask (int option, const sigset_t * new_set, sigset_t * old_set)
+{
+  return sigprocmask (option, new_set, old_set);
+}
+
+/*************************/
+/* PUBLIC JSIG FUNCTIONS */
+/*************************/
+
+/*********************************************************************/
+/* Function Name: signal()                                           */
+/*                                                                   */
+/* Description:   Interposed signal system function.                 */
+/*                Note this is implemented with sigaction            */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+sig_handler_t
+signal (int sig, sig_handler_t disp)
+{
+  return bsd_signal (sig, disp);
+}
+
+/*********************************************************************/
+/* Function Name: ssignal()                                          */
+/*                                                                   */
+/* Description:   Interposed signal system function.                 */
+/*                Note this is implemented with sigaction            */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+sig_handler_t
+ssignal (int sig, sig_handler_t disp)
+{
+  return bsd_signal (sig, disp);
+}
+
+/*********************************************************************/
+/* Function Name: __sysv_signal()                                    */
+/*                                                                   */
+/* Description:   Interposed signal system function.                 */
+/*                Note this is implemented with sigaction            */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+sig_handler_t
+__sysv_signal (int sig, sig_handler_t disp)
+{
+  return sysv_signal (sig, disp);
+}
+
+/*********************************************************************/
+/* Function Name: sigvec()                                           */
+/*                                                                   */
+/* Description:   Interposed signal system function.                 */
+/*                Note this is implemented with sigaction            */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+int
+sigvec (int sig, const struct sigvec *invec, struct sigvec *outvec)
+{
+  int i;
+  int status;
+  struct sigaction act;
+  struct sigaction oact;
+
+  memset (&act, 0, sizeof (struct sigaction));
+  if (invec)
+    {
+      sigemptyset (&act.sa_mask);
+      for (i = 0; i < sizeof (invec->sv_mask) * 8; i++)
+        {
+          if (invec->sv_mask & (1 << i))
+            {
+              sigaddset (&act.sa_mask, i + 1);
+            }
+        }
+      act.sa_handler = invec->sv_handler;
+      if (invec->sv_flags & SV_ONSTACK)
+        act.sa_flags |= SA_ONSTACK;
+      if (!(invec->sv_flags & SV_INTERRUPT))
+        act.sa_flags |= SA_RESTART;
+      if (invec->sv_flags & SV_RESETHAND)
+        act.sa_flags |= SA_RESETHAND;
+    }
+
+  memset (&oact, 0, sizeof (struct sigaction));
+  if (invec)
+    {
+      status = sigaction (sig, &act, &oact);
+    }
+  else
+    {
+      status = sigaction (sig, 0, &oact);
+    }
+
+  if (status == 0 && outvec)
+    {
+      sigemptyset (&act.sa_mask);
+      for (i = 0; i < sizeof (int) * 8; i++)
+        {
+          if (sigismember (&oact.sa_mask, i + 1))
+            {
+              outvec->sv_mask |= (1 << i);
+            }
+        }
+      outvec->sv_handler = oact.sa_handler;
+      outvec->sv_flags = 0;
+      if (oact.sa_flags & SA_ONSTACK)
+        outvec->sv_flags |= SV_ONSTACK;
+      if (!(oact.sa_flags & SA_RESTART))
+        outvec->sv_flags |= SV_INTERRUPT;
+      if (oact.sa_flags & SA_RESETHAND)
+        outvec->sv_flags |= SV_RESETHAND;
+    }
+
+  return status;
+}
+
+/***************/
+/* End of File */
+/***************/

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsigunix.c
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsigunix.c?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsigunix.c (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsigunix.c Wed Nov 30 21:29:27 2005
@@ -0,0 +1,622 @@
+/* Copyright 2003, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*****************/
+/* Header files. */
+/*****************/
+
+#if defined(LINUX)
+#define _GNU_SOURCE 1
+#endif
+
+#include <stdio.h>
+#include <signal.h>
+#include <pthread.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#if defined(LINUX)
+#include <bits/signum.h>
+#endif
+
+#include "jsigunix.h"
+
+/*********************/
+/* Local Definitions */
+/*********************/
+
+/* signal handler function types */
+typedef void (*sigact_handler_t) (int, siginfo_t *, void *);
+
+/* saved non-primary signal handlers */
+static struct sigaction *saved_sigaction = (struct sigaction *) 0;
+
+/* Array of bits indicating whether or not the a primnary or application signal handler is installed */
+static sigset_t primary_sigs;
+static sigset_t appl_sigs;
+#define MAX_SIGNAL (sizeof(primary_sigs)*8 - 1)
+
+#define SET_PRIMARY_HANDLER(sig) sigaddset(&primary_sigs, sig);
+#define CLEAR_PRIMARY_HANDLER(sig) sigdelset(&primary_sigs, sig);
+#define PRIMARY_HANDLER_INSTALLED(sig) ((sigismember(&primary_sigs, sig) == 1) ? 1 : 0)
+#define SET_APPL_HANDLER(sig) sigaddset(&appl_sigs, sig);
+#define APPL_HANDLER_INSTALLED(sig) ((sigismember(&appl_sigs, sig) == 1) ? 1 : 0)
+
+/* Macro to add a sigset_t mask to another sigset_t mask */
+#define SIGADDMASK(mask, addmask) \
+    { int i; \
+      for (i=0; i < sizeof(sigset_t)*8; i++) { \
+          if (sigismember(&addmask, i)) sigaddset(&mask, i); \
+      } \
+    }
+
+/* Macros for locking */
+static pthread_mutex_t jsig_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+#define SIGACTION_LOCK pthread_mutex_lock(&jsig_mutex);
+#define SIGACTION_UNLOCK pthread_mutex_unlock(&jsig_mutex);
+
+/**************************/
+/* PRIVATE JSIG FUNCTIONS */
+/**************************/
+
+/*********************************************************************/
+/* Function Name: jsig_init()                                        */
+/*                                                                   */
+/* Description:   Initialises the jsig signal handler list. It       */
+/*                assumes that it is called within SIGACTION_LOCK    */
+/*                                                                   */
+/* Parameters:    None                                               */
+/*                                                                   */
+/* Returns:       None                                               */
+/*********************************************************************/
+static void
+jsig_init (void)
+{
+  if (saved_sigaction == 0)
+    {
+      saved_sigaction =
+        (struct sigaction *) malloc ((MAX_SIGNAL + 1) *
+                                     (size_t) sizeof (struct sigaction));
+      if (saved_sigaction == 0)
+        {
+          fprintf (stderr, "libjsig unable to allocate memory\n");
+          abort ();
+        }
+      memset (saved_sigaction, 0,
+              (MAX_SIGNAL + 1) * (size_t) sizeof (struct sigaction));
+    }
+
+  sigemptyset (&primary_sigs);
+}
+
+static int jsig_sigaction_avail = 0;
+#define INVALID_TEST_SIGNAL -2
+
+/*********************************************************************/
+/* Function Name: jsig_sigaction_isdefault()                         */
+/*                                                                   */
+/* Description:   Returns TRUE(1) if the jsig library sigaction 		 */
+/*                function is the application's default, otherwise   */
+/*                FALSE(0).                                          */
+/*                Note that this is used by the Linux platform to    */
+/*                determine whether or not the application has been  */
+/*                linked such that jsig's sigaction is function is   */
+/*                being picked up by default                         */
+/*                                                                   */
+/* Parameters:    None                                               */
+/*                                                                   */
+/* Returns:       None                                               */
+/*********************************************************************/
+
+int
+jsig_sigaction_isdefault ()
+{
+  sigaction (INVALID_TEST_SIGNAL, 0, 0);
+  return jsig_sigaction_avail;
+}
+
+/*************************/
+/* PUBLIC JSIG FUNCTIONS */
+/*************************/
+
+/*********************************************************************/
+/* Function Name: jsig_handler()                                     */
+/*                                                                   */
+/* Description:   jsig's signal handler, responsible for chaining    */
+/*                the installed signal handlers for the passed       */
+/*                signal.                                            */
+/*                Note that this can be called by the JVM            */
+/*                to explicitly chain to the other application       */
+/*                signal handlers                                    */
+/*                Note also that for Linux when SA_NODEFER is set    */
+/*                the sa_mask specified to sigaction is ignored.     */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:       Value indicating whether default OS action is      */
+/*                required by application or whether it has handled  */
+/*                (or ignored) the signal                            */
+/*********************************************************************/
+int
+jsig_handler (int sig, void *siginfo, void *uc)
+{
+  int rc = JSIG_RC_DEFAULT_ACTION_REQUIRED;
+  sigset_t save_set;
+  sigset_t mask;
+  struct sigaction act;
+
+  /* jsig not initialized, so do nothing */
+  if (0 == saved_sigaction)
+    {
+      return rc;
+    }
+
+  act = saved_sigaction[sig];
+
+  /* Reset the signal handler if required */
+  if (saved_sigaction[sig].sa_flags & SA_RESETHAND)
+    {
+      memset (&saved_sigaction[sig], 0, sizeof (struct sigaction));
+    }
+
+  /* Append signals to mask, according to SA_NODEFER and */
+  /* specified in sa_mask for the handler                */
+  real_sigprocmask (SIG_SETMASK, 0, &save_set);
+  mask = save_set;
+  if (act.sa_flags & SA_NODEFER)
+    {
+      sigdelset (&mask, sig);   /* Don't block signal by default */
+    }
+  else
+    {
+      sigaddset (&mask, sig);   /* Block the signal */
+    }
+#if defined(LINUX)
+  if (!(act.sa_flags & SA_NODEFER))
+#endif
+
+    SIGADDMASK (mask, act.sa_mask);     /* Add required set of signals to mask */
+  real_sigprocmask (SIG_SETMASK, &mask, 0);
+
+  /* Call the required signal handler */
+  if (act.sa_flags & SA_SIGINFO)
+    {
+      if (act.sa_sigaction != 0)
+        {
+          rc = JSIG_RC_SIGNAL_HANDLED;
+          act.sa_sigaction (sig, (siginfo_t *) siginfo, uc);
+        }
+    }
+  else
+    {
+      if (act.sa_handler != 0 &&
+          act.sa_handler != (sig_handler_t) SIG_DFL &&
+          act.sa_handler != (sig_handler_t) SIG_IGN)
+        {
+          rc = JSIG_RC_SIGNAL_HANDLED;
+          act.sa_handler (sig);
+        }
+      else
+        {
+          if (act.sa_handler != (sig_handler_t) SIG_DFL)
+            {
+              rc = JSIG_RC_SIGNAL_HANDLED;
+            }
+        }
+    }
+
+  /* Restore the signal mask */
+  real_sigprocmask (SIG_SETMASK, &save_set, 0);
+
+  /* Note: The return value is only really necessary and used on Linux */
+  return rc;
+}
+
+/*********************************************************************/
+/* Function Name: jsig_primary_sigaction()                           */
+/*                                                                   */
+/* Description:   Installs the primary signal handler for the        */
+/*                specified signal.                                  */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:       0 if successful, -1 if an error occurred           */
+/*********************************************************************/
+int
+jsig_primary_sigaction (int sig, const struct sigaction *act,
+                        struct sigaction *oact)
+{
+  struct sigaction oldact;
+  int status = 0;
+  int primaryPreviouslyInstalled;
+  int applPreviouslyInstalled;
+
+  if (sig < 0 || sig > MAX_SIGNAL)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  SIGACTION_LOCK
+    /* Initialise jsig if this is the first call */
+    if (saved_sigaction == 0)
+    jsig_init ();
+
+  primaryPreviouslyInstalled = PRIMARY_HANDLER_INSTALLED (sig);
+
+  applPreviouslyInstalled = APPL_HANDLER_INSTALLED (sig);
+
+  if (act != 0)
+    {
+      /* New handler details have been provided                  */
+      if (!(act->sa_flags & SA_SIGINFO) &&
+          (act->sa_handler == (sig_handler_t) SIG_DFL ||
+           act->sa_handler == (sig_handler_t) SIG_IGN))
+        {
+          /* Request to set to Default or Ignore.  Check further */
+          /* to determine what needs to be done                  */
+          if (applPreviouslyInstalled)
+            {
+              /* Application handler has been installed for this */
+              /* signal.  If Primary was previously installed    */
+              /* reset OS to application handler, otherwise do   */
+              /* nothing as it is already installed for OS       */
+              if (primaryPreviouslyInstalled)
+                {
+                  status =
+                    real_sigaction (sig, &saved_sigaction[sig], &oldact);
+                  if (status == 0)
+                    {
+                      memset (&saved_sigaction[sig], 0,
+                              sizeof (struct sigaction));
+                    }
+                }
+            }
+          else
+            {
+              /* No application handler has been installed, so   */
+              /* if a jvm handler has been installed, reset the  */
+              /* handler to its previous value.  If a jvm handler */
+              /* has not previously been installed, install the  */
+              /* requested action as long as the current action  */
+              /* is SIG_DFL (This is to support a calling        */
+              /* application which has installed a handler, but  */
+              /* hasn't linked with jsig                         */
+              if (primaryPreviouslyInstalled &&
+                  ((saved_sigaction[sig].sa_flags & SA_SIGINFO) ||
+                   (saved_sigaction[sig].sa_handler != (sig_handler_t) SIG_DFL
+                    && saved_sigaction[sig].sa_handler !=
+                    (sig_handler_t) SIG_IGN)))
+                {
+                  status =
+                    real_sigaction (sig, &saved_sigaction[sig], &oldact);
+                  if (status == 0)
+                    {
+                      memset (&saved_sigaction[sig], 0,
+                              sizeof (struct sigaction));
+                    }
+                }
+              else
+                {
+                  status = real_sigaction (sig, NULL, &oldact);
+                  if (!primaryPreviouslyInstalled &&
+                      status == 0 &&
+                      ((oldact.sa_flags & SA_SIGINFO) ||
+                       oldact.sa_handler != (sig_handler_t) SIG_DFL))
+                    {
+                      /* do nothing a handler has been installed without going through JSIG */
+                    }
+                  else
+                    {
+                      status = real_sigaction (sig, act, &oldact);
+                    }
+                }
+            }
+          CLEAR_PRIMARY_HANDLER (sig);
+        }
+      else
+        {
+          /* Request to install handler, so install it */
+          status = real_sigaction (sig, act, &oldact);
+          if (status == 0 && !primaryPreviouslyInstalled)
+            {
+              saved_sigaction[sig] = oldact;
+              SET_PRIMARY_HANDLER (sig);
+            }
+        }
+    }
+  else
+    {
+      status = real_sigaction (sig, NULL, &oldact);
+    }
+
+  /* If a primary handler was previously installed then return */
+  /* as oact to caller otherwise return nothing                */
+  if (oact != 0)
+    {
+      if (primaryPreviouslyInstalled ||
+          (!(oldact.sa_flags & SA_SIGINFO) &&
+           (oldact.sa_handler == (sig_handler_t) SIG_DFL ||
+            oldact.sa_handler == (sig_handler_t) SIG_IGN)))
+        {
+          *oact = oldact;
+        }
+      else
+        {
+          memset (oact, 0, sizeof (struct sigaction));
+        }
+    }
+
+  SIGACTION_UNLOCK
+    if (oact != NULL
+        && &oact->sa_handler != (void (**)(int)) &oact->sa_sigaction)
+    {
+      if (oact->sa_flags & SA_SIGINFO)
+        {
+          oact->sa_handler = (void (*)(int)) oact->sa_sigaction;
+        }
+      else
+        {
+          oact->sa_sigaction =
+            (void (*)(int, siginfo_t *, void *)) oact->sa_handler;
+        }
+    }
+
+  return status;
+}
+
+/*********************************************************************/
+/* Function Name: jsig_primary_signal()                              */
+/*                                                                   */
+/* Description:   Installs the primary signal handler for the        */
+/*                specified signal. This function allows the         */
+/*                use of a "signal" equivalent call.                 */
+/*                Note this is implemented with sigaction.           */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+sig_handler_t
+jsig_primary_signal (int sig, sig_handler_t disp)
+{
+  struct sigaction act;
+  struct sigaction oact;
+
+  act.sa_handler = disp;
+  sigemptyset (&act.sa_mask);
+  act.sa_flags = SA_RESTART;
+  memset (&oact, 0, sizeof (struct sigaction));
+  if (jsig_primary_sigaction (sig, &act, &oact) != 0)
+    {
+      oact.sa_handler = SIG_ERR;
+    }
+
+  return oact.sa_handler;
+}
+
+/*********************************************************************/
+/* Function Name: sigaction()                                        */
+/*                                                                   */
+/* Description:   Interposed sigaction system function. This only    */
+/*                installs the required signal handler if there is   */
+/*                no primary signal handler.                         */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+int
+sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
+{
+  int status = 0;
+  struct sigaction oldact;
+
+  if (sig == INVALID_TEST_SIGNAL)
+    {
+      jsig_sigaction_avail = 1;
+      errno = EINVAL;
+      return -1;
+    }
+
+  if (sig < 0 || sig > MAX_SIGNAL)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  SIGACTION_LOCK
+    /* Initialise jsig if this is the first call */
+    if (saved_sigaction == 0)
+    jsig_init ();
+
+  /* If primary signal handler installed then just save the passed */
+  /* signal info and return the previously saved signal info       */
+  /* Otherwise just call the real sigaction function               */
+  if (PRIMARY_HANDLER_INSTALLED (sig))
+    {
+      if (oact != 0)
+        *oact = saved_sigaction[sig];
+      if (act != 0)
+        saved_sigaction[sig] = *act;
+    }
+  else
+    {
+      status = real_sigaction (sig, act, oact);
+    }
+
+  /* NOTE: The application handler is a latch that can be set      */
+  /*       and left if sigaction is called, even if the latest     */
+  /*       action is SIG_DFL or SIG_IGN                            */
+  SET_APPL_HANDLER (sig);
+
+  SIGACTION_UNLOCK
+    if (oact != NULL
+        && &oact->sa_handler != (void (**)(int)) &oact->sa_sigaction)
+    {
+      if (oact->sa_flags & SA_SIGINFO)
+        {
+          oact->sa_handler = (void (*)(int)) oact->sa_sigaction;
+        }
+      else
+        {
+          oact->sa_sigaction =
+            (void (*)(int, siginfo_t *, void *)) oact->sa_handler;
+        }
+    }
+
+  return status;
+}
+
+/*********************************************************************/
+/* Function Name: sysv_signal()                                      */
+/*                                                                   */
+/* Description:   sysv_signal system function, used to implement     */
+/*                the interposed signal system function for          */
+/*                System 5 Unix                                      */
+/*                Note this is implemented with sigaction            */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+sig_handler_t
+sysv_signal (int sig, sig_handler_t disp)
+{
+  struct sigaction act;
+  struct sigaction oact;
+
+  act.sa_handler = disp;
+  sigemptyset (&act.sa_mask);
+  act.sa_flags = SA_RESETHAND | SA_NODEFER;
+  memset (&oact, 0, sizeof (struct sigaction));
+  if (sigaction (sig, &act, &oact) != 0)
+    {
+      oact.sa_handler = SIG_ERR;
+    }
+
+  return oact.sa_handler;
+}
+
+/*********************************************************************/
+/* Function Name: bsd_signal()                                       */
+/*                                                                   */
+/* Description:   bsd_signal system function, used to implement      */
+/*                the interposed signal system function for          */
+/*                BSD Unix                                           */
+/*                Note this is implemented with sigaction            */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+sig_handler_t
+bsd_signal (int sig, sig_handler_t disp)
+{
+  struct sigaction act;
+  struct sigaction oact;
+
+  act.sa_handler = disp;
+  sigemptyset (&act.sa_mask);
+  act.sa_flags = SA_RESTART;
+  memset (&oact, 0, sizeof (struct sigaction));
+  if (sigaction (sig, &act, &oact) != 0)
+    {
+      oact.sa_handler = SIG_ERR;
+    }
+
+  return oact.sa_handler;
+}
+
+/*********************************************************************/
+/* Function Name: sigset()                                           */
+/*                                                                   */
+/* Description:   Interposed signal system function.                 */
+/*                Note this is implemented with sigaction            */
+/*                Note also that for Linux only when disp is         */
+/*                specified as SIG_HOLD, SIG_HOLD is always returned */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+sig_handler_t
+sigset (int sig, sig_handler_t disp)
+{
+  struct sigaction act;
+  struct sigaction oact;
+
+  if (disp == SIG_HOLD)
+    {
+      sigset_t mask;
+      real_sigprocmask (SIG_SETMASK, 0, &mask);
+      if (sigismember (&mask, sig))
+        {
+          oact.sa_handler = SIG_HOLD;
+        }
+      else
+        {
+          memset (&oact, 0, sizeof (struct sigaction));
+          if (sigaction (sig, 0, &oact) != 0)
+            {
+              oact.sa_handler = SIG_ERR;
+            }
+#if defined(LINUX)
+          else
+            {
+              oact.sa_handler = SIG_HOLD;
+            }
+#endif
+
+        }
+      sigaddset (&mask, sig);
+      real_sigprocmask (SIG_SETMASK, &mask, 0);
+    }
+  else
+    {
+      act.sa_handler = disp;
+      sigemptyset (&act.sa_mask);
+      act.sa_flags = 0;
+      memset (&oact, 0, sizeof (struct sigaction));
+      if (sigaction (sig, &act, &oact) != 0)
+        {
+          oact.sa_handler = SIG_ERR;
+        }
+    }
+
+  return oact.sa_handler;
+}
+
+/*********************************************************************/
+/* Function Name: sigignore()                                        */
+/*                                                                   */
+/* Description:   Interposed sigignore system function.              */
+/*                Note this assumes standard ANSI rules              */
+/*                (i.e. not BSD) and is implemented with sigaction   */
+/*                                                                   */
+/* Parameters:                                                       */
+/*                                                                   */
+/* Returns:                                                          */
+/*********************************************************************/
+int
+sigignore (int sig)
+{
+  return (signal (sig, SIG_IGN) != (sig_handler_t) - 1) ? 0 : -1;
+}
+
+/***************/
+/* End of File */
+/***************/

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsigunix.h
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsigunix.h?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsigunix.h (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/jsigunix.h Wed Nov 30 21:29:27 2005
@@ -0,0 +1,37 @@
+/* Copyright 2003, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(jsigunix_h)
+#define jsigunix_h
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+#include "jsig.h"
+/* Unix specific types */
+  typedef int (*sigactionfunc_t) (int, const struct sigaction *,
+                                  struct sigaction *);
+/* Shared Unix functions */
+  sig_handler_t bsd_signal (int, sig_handler_t);
+  sig_handler_t sysv_signal (int, sig_handler_t);
+/* Platform dependent Unix functions */
+  int real_sigaction (int sig, const struct sigaction *act,
+                      struct sigaction *oact);
+  int real_sigprocmask (int option, const sigset_t * new_set,
+                        sigset_t * old_set);
+#if defined(__cplusplus)
+}
+#endif
+#endif                          /* jsigunix_h */

Added: incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/makefile
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/makefile?rev=350181&view=auto
==============================================================================
--- incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/makefile (added)
+++ incubator/harmony/enhanced/trunk/sandbox/contribs/ibm_core/native-src/linux.IA32/sig/makefile Wed Nov 30 21:29:27 2005
@@ -0,0 +1,56 @@
+# Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#
+# Makefile for module 'jsig'
+#
+
+include ../makefile.include
+
+DLLFILENAME=libhysig.so# declaration
+
+DLLNAME=../libhysig.so# declaration
+
+LIBNAME=hysig# declaration
+
+LIBPATH=../lib/# declaration
+
+CFLAGS=-fpic -O1 -march=pentium3 -DLINUX -D_REENTRANT -DIPv6_FUNCTION_SUPPORT -DHYX86 -I../include $(VMDEBUG)
+
+.SUFFIXES:.cpp
+.cpp.o:
+	$(CXX) -fpic -O1 -march=pentium3 -fno-exceptions -fno-rtti -DLINUX -D_REENTRANT -DIPv6_FUNCTION_SUPPORT -DHYX86 -I../include $(VMDEBUG) -c $<
+
+ASFLAGS= -o $@
+
+.SUFFIXES:.asm
+.asm.o:
+	perl ../masm2gas/masm2gas.pl   -I../include  $*.asm
+	$(AS) $(ASFLAGS) -o $*.o $*.s
+	-rm $*.s
+
+BUILDFILES1 = jsig_copyright.o jsiglinux.o jsigunix.o
+
+all: \
+	 $(DLLNAME)
+
+BUILDLIB: $(DLLNAME)
+
+$(DLLNAME): $(BUILDFILES1) 
+	 $(DLL_LD) -shared -Wl,--version-script,$(LIBNAME).exp -Wl,-soname=$(DLLFILENAME) $(VMLINK) -L.  -o $(DLLNAME) \
+	$(BUILDFILES1) -Xlinker --start-group -Xlinker --end-group  -lc -lm -ldl
+
+clean:
+	-rm -f *.o 
+	-rm -f ../libhysig.so



Mime
View raw message