harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From odea...@apache.org
Subject svn commit: r810084 [1/3] - in /harmony/enhanced/classlib/trunk: depends/build/ modules/luni/src/main/native/launcher/shared/ modules/luni/src/main/native/launcher/unix/ modules/luni/src/main/native/luni/shared/ modules/portlib/ modules/portlib/src/mai...
Date Tue, 01 Sep 2009 15:06:18 GMT
Author: odeakin
Date: Tue Sep  1 15:06:16 2009
New Revision: 810084

URL: http://svn.apache.org/viewvc?rev=810084&view=rev
Log:
Apply patch for contribution in HARMONY-6311 ([classlib] Contribution of native code to port to additional platforms) with some minor tidy up.

Added:
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/atoe.c   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/atoe_utils.c   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/exports.txt   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/arpa/
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/arpa/inet.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/atoe.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/ctype.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/dirent.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/dlfcn.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/dll.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/fcntl.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/grp.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/langinfo.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/locale.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/netdb.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/pwd.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/stdio.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/stdlib.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/string.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/sys/
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/sys/ipc.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/sys/stat.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/sys/time.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/sys/utsname.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/time.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/headers/unistd.h   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/makefile   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/sysTranslate.c   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/port/unix/zos/
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/port/unix/zos/hymmap.c   (with props)
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/port/unix/zos/hysl.c   (with props)
Modified:
    harmony/enhanced/classlib/trunk/depends/build/defines.mk
    harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/shared/cmain.c
    harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/unix/makefile
    harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/bigint.c
    harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/cbigint.c
    harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/fltconst.h
    harmony/enhanced/classlib/trunk/modules/portlib/build.xml
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/common/shared/strhelp.c
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/include/shared/hyport.h
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/port/shared/hynls.c
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/port/shared/hyport.c
    harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/port/unix/hysysinfo.c

Modified: harmony/enhanced/classlib/trunk/depends/build/defines.mk
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/depends/build/defines.mk?rev=810084&r1=810083&r2=810084&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/depends/build/defines.mk (original)
+++ harmony/enhanced/classlib/trunk/depends/build/defines.mk Tue Sep  1 15:06:16 2009
@@ -58,6 +58,10 @@
 endif
 
 MDLLIBFILES = $(LIBPATH)libhycommon.a
+ifeq ($(HY_OS),zos)
+# On z/OS we need to link every module against the ascii2ebcdic library
+MDLLIBFILES += $(LIBPATH)libhya2e.x
+endif
 
 ifeq ($(HY_NO_THR),false)
 ifeq ($(HY_THR_NO_DEPLOY), true)

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/shared/cmain.c
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/shared/cmain.c?rev=810084&r1=810083&r2=810084&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/shared/cmain.c (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/shared/cmain.c Tue Sep  1 15:06:16 2009
@@ -17,12 +17,20 @@
 
 #include "hycomp.h"
 #include "hyport.h"
+
 #ifdef HY_NO_THR
 #include "main_hlp.h"
+#if defined(ZOS)
+/* Need ascii2ebcdic functions on zOS */
+#include "atoe.h"
+#endif
 #endif /* HY_NO_THR */
+
 #include <stdlib.h>             /* for malloc for atoe and abort */
 #include <stdio.h>
 
+
+
 struct haCmdlineOptions
 {
   int argc;
@@ -104,6 +112,21 @@
   UDATA portLibDescriptor;
   hyport_init_library_type port_init_library_func;
 
+#if defined(ZOS)
+  /* Initialise the ascii2ebcdic functions before doing anything else */
+  rc = iconv_init();
+  if (0 != rc) {
+#pragma convlit(suspend)
+      fprintf(stderr, "Failed to initialise atoe library\n");
+#pragma convlit(resume)
+      return rc;
+  }
+
+  /* Convert our command line options into ASCII - this function is
+     part of the hya2e library */
+  ConvertArgstoASCII(argc, argv);
+#endif
+
   /* determine which VM directory to use and add it to the path */
   rc = main_addVMDirToPath(argc, argv, envp);
   if ( 0 != rc ) {

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/unix/makefile
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/unix/makefile?rev=810084&r1=810083&r2=810084&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/unix/makefile (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/native/launcher/unix/makefile Tue Sep  1 15:06:16 2009
@@ -29,4 +29,9 @@
 endif
 EXENAME = $(EXEPATH)java
 
+ifeq ($(HY_OS),zos)
+# On z/OS statically link the a2e lib so it can be used before LIBPATH is set
+MDLLIBFILES = $(LIBPATH)libhya2e.a $(LIBPATH)libhycommon.a
+endif
+
 include $(HY_HDK)/build/make/rules.mk

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/bigint.c
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/bigint.c?rev=810084&r1=810083&r2=810084&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/bigint.c (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/bigint.c Tue Sep  1 15:06:16 2009
@@ -42,9 +42,15 @@
 #define LONG_DIV(u64, div) ((U_32)(*(U_64*)(u64) / (U_32)(div)))
 #define LONG_REM(u64, div) ((U_32)(*(U_64*)(u64) % (U_32)(div)))
 
-                /* 32 bit */
+#ifndef HY_WORD64
+/* 32 bit */
 #define IS_NEGATIVE(ar,len)     (((I_32*)ar)[at(len*2-1)] < 0)
 #define atx(i) (at(i))
+#else
+/* 64 bit */
+#define IS_NEGATIVE(ar,len)	(((I_64*)ar)[len-1] < 0L)
+#define atx(i) (i)
+#endif
 
 #define GET_LENGTH(obj) ((*env)->GetArrayLength(env,obj))
 #define GET_ELEMENTS(obj) ((U_32*)(*env)->GetLongArrayElements(env, obj, NULL))

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/cbigint.c
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/cbigint.c?rev=810084&r1=810083&r2=810084&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/cbigint.c (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/cbigint.c Tue Sep  1 15:06:16 2009
@@ -253,6 +253,34 @@
     }
 }
 
+#ifndef HY_LITTLE_ENDIAN
+void simpleMultiplyAddHighPrecisionBigEndianFix(U_64 *arg1, IDATA length, U_64 arg2, U_32 *result) {
+	/* Assumes result can hold the product and arg2 only holds 32 bits
+	   of information */
+	U_64 product;
+	IDATA index, resultIndex;
+
+	index = resultIndex = 0;
+	product = 0;
+
+	do {
+		product = HIGH_IN_U64(product) + result[halfAt(resultIndex)] + arg2 * LOW_U32_FROM_PTR(arg1 + index);
+		result[halfAt(resultIndex)] = LOW_U32_FROM_VAR(product);
+		++resultIndex;
+		product = HIGH_IN_U64(product) + result[halfAt(resultIndex)] + arg2 * HIGH_U32_FROM_PTR(arg1 + index);
+		result[halfAt(resultIndex)] = LOW_U32_FROM_VAR(product);
+		++resultIndex;
+	} while (++index < length);
+
+	result[halfAt(resultIndex)] += HIGH_U32_FROM_VAR(product);
+	if (result[halfAt(resultIndex)] < HIGH_U32_FROM_VAR(product)) {
+		/* must be careful with ++ operator and macro expansion */
+		++resultIndex;
+		while (++result[halfAt(resultIndex)] == 0) ++resultIndex;
+	}
+}
+#endif
+
 void
 multiplyHighPrecision (U_64 * arg1, IDATA length1, U_64 * arg2, IDATA length2,
                        U_64 * result, IDATA length)
@@ -281,10 +309,11 @@
     {
       simpleMultiplyAddHighPrecision (arg1, length1, LOW_IN_U64 (arg2[count]),
                                       resultIn32 + (++index));
-      simpleMultiplyAddHighPrecision (arg1, length1,
-                                      HIGH_IN_U64 (arg2[count]),
-                                      resultIn32 + (++index));
-
+#ifdef HY_LITTLE_ENDIAN
+      simpleMultiplyAddHighPrecision(arg1, length1, HIGH_IN_U64(arg2[count]), resultIn32 + (++index));
+#else
+      simpleMultiplyAddHighPrecisionBigEndianFix(arg1, length1, HIGH_IN_U64(arg2[count]), resultIn32 + (++index));
+#endif
     }
 }
 

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/fltconst.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/fltconst.h?rev=810084&r1=810083&r2=810084&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/fltconst.h (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/native/luni/shared/fltconst.h Tue Sep  1 15:06:16 2009
@@ -137,16 +137,23 @@
 #define SET_PINF_SNGL_PTR(fltptr) *U32P((fltptr)) = SINGLE_EXPONENT_MASK
 #define SET_NINF_SNGL_PTR(fltptr) *U32P((fltptr)) = (SINGLE_EXPONENT_MASK | SINGLE_SIGN_MASK)
 
-/* on some platforms (HP720) we cannot reference an unaligned float.  Build them by hand, one U_32 at a time. */
-#if defined(ATOMIC_FLOAT_ACCESS)
-#define PTR_DOUBLE_STORE(dstPtr, aDoublePtr) HIGH_U32_FROM_DBL_PTR(dstPtr) = HIGH_U32_FROM_DBL_PTR(aDoublePtr); LOW_U32_FROM_DBL_PTR(dstPtr) = LOW_U32_FROM_DBL_PTR(aDoublePtr)
-#define PTR_DOUBLE_VALUE(dstPtr, aDoublePtr) HIGH_U32_FROM_DBL_PTR(aDoublePtr) = HIGH_U32_FROM_DBL_PTR(dstPtr); LOW_U32_FROM_DBL_PTR(aDoublePtr) = LOW_U32_FROM_DBL_PTR(dstPtr)
+#if defined(HY_WORD64)
+ #define PTR_DOUBLE_VALUE(dstPtr, aDoublePtr) ((U64U32DBL *)(aDoublePtr))->u64val = ((U64U32DBL *)(dstPtr))->u64val
+ #define PTR_DOUBLE_STORE(dstPtr, aDoublePtr) ((U64U32DBL *)(dstPtr))->u64val = ((U64U32DBL *)(aDoublePtr))->u64val
+ #define STORE_LONG(dstPtr, hi, lo) ((U64U32DBL *)(dstPtr))->u64val = (((U_64)(hi)) << 32) | (lo)
 #else
-#define PTR_DOUBLE_STORE(dstPtr, aDoublePtr) (*(dstPtr) = *(aDoublePtr))
-#define PTR_DOUBLE_VALUE(dstPtr, aDoublePtr) (*(aDoublePtr) = *(dstPtr))
-#endif
+ /* on some platforms (HP720) we cannot reference an unaligned float.  Build them by hand, one U_32 at a time. */
+ #if defined(ATOMIC_FLOAT_ACCESS)
+ #define PTR_DOUBLE_STORE(dstPtr, aDoublePtr) HIGH_U32_FROM_DBL_PTR(dstPtr) = HIGH_U32_FROM_DBL_PTR(aDoublePtr); LOW_U32_FROM_DBL_PTR(dstPtr) = LOW_U32_FROM_DBL_PTR(aDoublePtr)
+ #define PTR_DOUBLE_VALUE(dstPtr, aDoublePtr) HIGH_U32_FROM_DBL_PTR(aDoublePtr) = HIGH_U32_FROM_DBL_PTR(dstPtr); LOW_U32_FROM_DBL_PTR(aDoublePtr) = LOW_U32_FROM_DBL_PTR(dstPtr)
+ #else
+ #define PTR_DOUBLE_STORE(dstPtr, aDoublePtr) (*(dstPtr) = *(aDoublePtr))
+ #define PTR_DOUBLE_VALUE(dstPtr, aDoublePtr) (*(aDoublePtr) = *(dstPtr))
+ #endif
+
+ #define STORE_LONG(dstPtr, hi, lo) HIGH_U32_FROM_LONG64_PTR(dstPtr) = (hi); LOW_U32_FROM_LONG64_PTR(dstPtr) = (lo)
+#endif /* HY_WORD64 */
 
-#define STORE_LONG(dstPtr, hi, lo) HIGH_U32_FROM_LONG64_PTR(dstPtr) = (hi); LOW_U32_FROM_LONG64_PTR(dstPtr) = (lo)
 #define PTR_SINGLE_VALUE(dstPtr, aSinglePtr) (*U32P(aSinglePtr) = *U32P(dstPtr))
 #define PTR_SINGLE_STORE(dstPtr, aSinglePtr) *((U_32 *)(dstPtr)) = (*U32P(aSinglePtr))
 

Modified: harmony/enhanced/classlib/trunk/modules/portlib/build.xml
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/portlib/build.xml?rev=810084&r1=810083&r2=810084&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/portlib/build.xml (original)
+++ harmony/enhanced/classlib/trunk/modules/portlib/build.xml Tue Sep  1 15:06:16 2009
@@ -52,7 +52,7 @@
             depends="-make-report-dir,-compile-native-tests,-run-native-tests" />
 
     <target name="copy-native-includes"
-            depends="-copy-thread-include,-copy-thread-stub-include" >
+            depends="-copy-thread-include,-copy-thread-stub-include, -copy-ascii-ebcdic-include" >
         <copy todir="${hy.hdk}/include" preservelastmodified="true">
             <fileset dir="src/main/native/include/shared">
                 <include name="hyport.h" />
@@ -92,10 +92,38 @@
         </copy>
     </target>
 
+    <target name="-copy-ascii-ebcdic-include" if="is.zos" >
+        <copy todir="${hy.hdk}/include" overwrite="yes">
+            <fileset dir="src/main/native/a2e/${hy.os.family}/headers">
+                <include name="atoe.h" />
+                <include name="ctype.h" />
+                <include name="dirent.h" />
+                <include name="dll.h" />
+                <include name="dlfcn.h" />
+                <include name="fcntl.h" />
+                <include name="grp.h" />
+                <include name="langinfo.h" />
+                <include name="locale.h" />
+                <include name="netdb.h" />
+                <include name="pwd.h" />
+                <include name="stdio.h" />
+                <include name="stdlib.h" />
+                <include name="string.h" />
+                <include name="time.h" />
+                <include name="unistd.h" />
+                <include name="arpa\inet.h" />
+                <include name="sys\ipc.h" />
+                <include name="sys\stat.h" />
+                <include name="sys\time.h" />
+                <include name="sys\utsname.h" />
+            </fileset>
+        </copy>
+    </target>
+
     <!-- Build the portlib native components -->
     <target name="build-native"
         depends="-build-native,-build-native-thread,-build-native-thrstub,-build-native-port" />
-    <target name="-build-native">
+    <target name="-build-native" depends="-build-ascii-ebcdic">
        <!-- Build common lib -->
         <make dir="src/main/native/common/${hy.os.family}" />
 
@@ -103,6 +131,23 @@
         <make dir="src/main/native/pool/${hy.os.family}" />
     </target>
 
+    <target name="-build-ascii-ebcdic" if="is.zos" >
+        <!-- Build a2e lib for zOS platforms -->
+        <make dir="src/main/native/a2e/${hy.os.family}" />
+
+        <copy todir="${hy.jdk}/jre/bin" overwrite="yes">
+            <fileset dir="src/main/native/a2e">
+                <include name="*${shlib.suffix}*" />
+                <exclude name="*${manifest.suffix}"/>
+            </fileset>
+        </copy>
+        <copy todir="${hy.hdk}/lib" overwrite="yes">
+            <fileset dir="src/main/native/a2e/${hy.os.family}">
+                <include name="*${linklib.suffix}" if="is.zos" />
+            </fileset>
+        </copy>
+    </target>
+
     <target name="-build-native-thread" unless="hy.skip.thr">
         <!-- Build thread dll -->
         <make dir="src/main/native/thread/${hy.os.family}" />
@@ -164,7 +209,7 @@
     </target>
 
     <!-- Clean natives -->
-    <target name="clean-native" depends="clean-native-includes">
+    <target name="clean-native" depends="clean-native-includes, -clean-native-ascii-ebcdic">
         <make dir="src/main/native/thread/${hy.os.family}" target="clean" />
         <make dir="src/main/native/thrstub/${hy.os.family}" target="clean" />
         <make dir="src/main/native/port/${hy.os.family}" target="clean" />
@@ -172,7 +217,12 @@
         <make dir="src/main/native/pool/${hy.os.family}" target="clean" />
     </target>
 
-    <target name="clean-native-includes">
+    <target name="-clean-native-ascii-ebcdic" if="is.zos" >
+        <!-- Clean a2e lib for zOS platforms -->
+        <make dir="src/main/native/a2e/${hy.os.family}" target="clean" />
+    </target>
+
+    <target name="clean-native-includes" depends="-clean-ascii-ebcdic-includes">
         <delete failonerror="false">
             <fileset dir="${hy.hdk}/include">
                 <include name="hyport.h" />
@@ -193,6 +243,34 @@
         </delete>
     </target>
 
+    <target name="-clean-ascii-ebcdic-includes" if="is.zos" >
+        <delete failonerror="false">
+            <fileset dir="${hy.hdk}/include">
+                <include name="atoe.h" />
+                <include name="ctype.h" />
+                <include name="dirent.h" />
+                <include name="dll.h" />
+                <include name="dlfcn.h" />
+                <include name="fcntl.h" />
+                <include name="grp.h" />
+                <include name="langinfo.h" />
+                <include name="locale.h" />
+                <include name="netdb.h" />
+                <include name="pwd.h" />
+                <include name="stdio.h" />
+                <include name="stdlib.h" />
+                <include name="string.h" />
+                <include name="time.h" />
+                <include name="unistd.h" />
+                <include name="arpa\inet.h" />
+                <include name="sys\ipc.h" />
+                <include name="sys\stat.h" />
+                <include name="sys\time.h" />
+                <include name="sys\utsname.h" />
+            </fileset>
+        </delete>
+    </target>
+
     <target name="-make-report-dir">
         <mkdir dir="${tests.output}" />
     </target>
@@ -235,11 +313,15 @@
         <exec-native test="hyipcmutex" />
         <exec-native test="hymmap" />
 	
-        <move todir="${tests.output}">
+        <copy todir="${tests.output}" outputencoding="UTF-8">
             <fileset dir=".">
                 <include name="TEST-*.xml"/>
             </fileset>
-        </move>
+        </copy>
+
+        <delete>
+            <fileset dir="${hy.portlib}" includes="TEST-*.xml" />
+        </delete>
 
         <antcall target="touch-errors-file" />
     </target>

Added: harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/atoe.c
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/atoe.c?rev=810084&view=auto
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/atoe.c (added)
+++ harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/atoe.c Tue Sep  1 15:06:16 2009
@@ -0,0 +1,2295 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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.
+ */
+
+/*
+ * DESCRIPTION:
+ * Generic ASCII to EBCDIC character conversion. This file defines
+ * a number of "wrapper" functions to transparently convert between
+ * ASCII and EBCDIC. Each function calls a platform specific function
+ * (defined elsewhere) to perform the actual conversion.
+ * ===========================================================================
+ */
+
+/*
+ * ======================================================================
+ * Disable the redefinition of the system IO functions, this
+ * prevents two ATOE functions calling themselves.
+ * ======================================================================
+ */
+#undef HY_ATOE
+
+/*
+ * ======================================================================
+ * Include all system header files.
+ * ======================================================================
+ */
+#define _OPEN_SYS_FILE_EXT  /* For SETCVTOFF */ 
+#ifndef __SUSV3  /* For dlfcn.h */
+#define __SUSV3
+#endif
+#include <unistd.h>
+#include <fcntl.h>          /* <--SETCVTOFF in here */
+#include <pthread.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <pwd.h>
+#include <grp.h>
+#include <dirent.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <locale.h>
+#include <netdb.h>
+#include <dll.h>
+#include <errno.h>
+#include <iconv.h>
+#include <langinfo.h>
+#include <arpa/inet.h>
+#include <sys/stat.h>
+#include <sys/utsname.h>
+#include <sys/ipc.h>
+#include <limits.h>             
+#include <_Ccsid.h>
+#include <dlfcn.h>
+
+#define check_fcntl_init() (1)
+#define set_SETCVTOFF()
+#define use_fcntl (0)
+
+int env_mutex_initialized = 0;
+
+/* Whether file tagging enabled by user */
+static int fileTaggingEnabled = 0; 
+/* CCSID for new files */
+static __ccsid_t newFileCCSID = 0;
+
+
+/*
+ * ======================================================================
+ * ASCII<=>EBCDIC translate tables built using iconv()
+ * ======================================================================
+ */
+#define BUFLEN 6144
+#define CONV_TABLE_SIZE 256
+char a2e_tab[CONV_TABLE_SIZE];
+char e2a_tab[CONV_TABLE_SIZE];
+
+/*
+ * ======================================================================
+ * Define ae2,e2a,a2e_string, e2a_string
+ * ======================================================================
+ */
+#include "atoe.h"
+
+int   atoe_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
+int   atoe_fprintf(FILE *, const char *, ...);
+struct passwd *etoa_passwd(struct passwd *e_passwd);
+
+/*
+ * ======================================================================
+ * A simple linked list of ascii environment variable entries;
+ * each entry is added as a result of a getenv() or putenv() as
+ * reflected through the EBCDIC environment maintained by the system.
+ * This improves performance by having each environment variable
+ * converted only once, and also avoids storage leaks with repeated
+ * calls which refer to the same variable.
+ * ======================================================================
+ */
+struct ascii_envvar {
+    struct ascii_envvar *next;
+    char *name;
+    char *value;
+};
+typedef struct ascii_envvar envvar_t;
+
+/* Anchor entry */
+envvar_t env_anchor = {NULL, NULL, NULL};
+
+/* Mutex for single-threading list updates */
+pthread_mutex_t env_mutex;
+
+
+char* sysTranslate(const char *source, int length, char *trtable, char* xlate_buf)
+{
+    return sysTranslateASM( source, length, trtable, xlate_buf );
+}
+
+
+/**************************************************************************
+ * name        - enumEnvvar
+ * description -
+ *              enumEnvvar() takes an input pointer that is either null for
+ *              the first call or contains the result returned from a previous
+ *              call. It will also modify two input pointer parameters to point
+ *              to the current envar name string and the envar value string. The
+ *              strings will contain ascii characters.
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+void *
+enumEnvvar(void * input_ptr, char ** name, char ** value) {
+    if (0 == env_anchor.next ) {   /* empty envar list case */
+        *name = 0;
+        *value= 0;
+        return(void *) 0;
+    }
+    if (0 == input_ptr) {      /* non-empty list, first call case */
+        *name = env_anchor.name;
+        *value = env_anchor.value;
+        return(void *) env_anchor.next;
+    } else {                                   /* walk the list case */
+        envvar_t * curr_env= (envvar_t *)input_ptr;
+        *name = curr_env->name;
+        *value = curr_env->value;
+        return(void *) curr_env->next;  /* next = 0 signals end of list */
+    }
+}
+
+/**************************************************************************
+ * name        - getEnvvar
+ * description -
+ *              getEnvvar() - returns a pointer to the ascii_envvar structure
+ *              for the environment variable specified by name, or NULL if there
+ *              is no entry for that name. No need to serialise this code.
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+envvar_t *
+getEnvvar(char *name)
+{
+    envvar_t *envvar = env_anchor.next;
+
+    while (envvar != NULL) {
+        if (strcmp(name, envvar->name) == 0)
+            break;
+        envvar = envvar->next;
+    }
+
+    return envvar;
+}
+
+/**************************************************************************
+ * name        - putEnvvar
+ * description -
+ *              putEnvvar() - updates the ascii_envvar structure for the variable
+ *              specified by name if it already exists, or creates a new ascii_envvar
+ *              structure if it does not, and returns a pointer to the entry.
+ *              This function is single_threaded.
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+envvar_t *
+putEnvvar(char *name, char *value, envvar_t *updvar)
+{
+    envvar_t *envvar;
+
+    if (!env_mutex_initialized) {
+        /* First time in - initialise the mutex */
+        pthread_mutexattr_t attr;
+
+        pthread_mutexattr_init(&attr);
+        pthread_mutex_init(&env_mutex, &attr);
+
+        env_mutex_initialized = 1;
+    }
+
+    /* Grab the lock */
+    pthread_mutex_lock(&env_mutex);
+
+    if (updvar != NULL) {
+        /* Update the existing entry */
+        envvar = updvar;
+        free(envvar->value);
+        envvar->value = strdup(value);
+    } else {
+        /* Add a new entry to the list */
+        envvar = &env_anchor;
+        while (envvar->next != NULL) {
+            envvar = envvar->next;
+        }
+        envvar->next = malloc(sizeof(envvar_t));
+        envvar = envvar->next;
+        envvar->next = NULL;
+        envvar->name = strdup(name);
+        envvar->value = strdup(value);
+    }
+
+    /* Release the lock */
+    pthread_mutex_unlock(&env_mutex);
+
+    return envvar;
+}
+
+/**************************************************************************
+ * name        - a2e_func 
+ * description - Function implementation of a2e macro, for use by DLLs
+ *               that don't want to have to link with sysTranslate.o
+ * parameters  - str, ASCII string to convert
+ *               len, Length of str
+ * returns     - Converted EBCDIC string
+ *************************************************************************/
+char *
+a2e_func(char *str, int len)
+{
+    return a2e(str, len);
+}
+
+/**************************************************************************
+ * name        - e2a_func 
+ * description - Function implementation of e2a macro, for use by DLLs
+ *               that don't want to have to link with sysTranslate.o
+ * parameters  - str, EBCIDC string to convert
+ *               len, Length of str
+ * returns     - Converted ASCII string
+ *************************************************************************/
+char *
+e2a_func(char *str, int len)
+{
+    return e2a(str, len);
+}
+
+/**************************************************************************
+ * name        - atoe_getenv
+ * description -
+ *              Returns a pointer to the value of the environment
+ *              variable specified by a_name. The ascii environment is searched first,
+ *              and the value is returned if found. If not, the EBCDIC environment
+ *              is checked, and an ascii entry is created if it is found. If not,
+ *              NULL is returned.
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+atoe_getenv(const char *name)
+{
+    char *value, *e_name, *e_value;
+    envvar_t *envvar;
+
+    if (name == NULL) {
+        return NULL;
+    }
+
+    if ((envvar = getEnvvar((char *)name)) != NULL) {
+        /* We already have the variable in ascii */
+        return envvar->value;
+    }
+
+    /* Get the EBCIDC value from the system */
+    e_name = a2e_string((char *)name);
+    e_value = getenv(e_name);
+    free(e_name);
+
+    if (e_value == NULL) {
+        /* Variable is not currently defined */
+        return NULL;
+    }
+
+    /* Create a new ascii environment variable entry */
+    value = e2a_string(e_value);
+    envvar = putEnvvar((char *)name, value, NULL);
+    free(value);
+
+    return envvar->value;
+}
+
+/**************************************************************************
+ * name        - atoe_putenv
+ * description -
+ *              Issues putenv() to set the system EBCDIC environment
+ *              then updates the ascii environment
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_putenv(const char *envstr)
+{
+    char *w_envstr, *name, *value;
+    envvar_t *envvar;
+    int result;
+
+    /* Set the system EBCDIC environment - don't free w_envstr as it's memory is held by the environment */
+    w_envstr = a2e_string((char *)envstr);
+    result = putenv(w_envstr);
+
+    if (result == 0) {
+        /* Update the ascii environment */
+        char *asciienv = strdup(envstr);
+
+        /*
+         * The name is everything upto the first '='s character and the value
+         * is everything after it.
+         */
+        name = asciienv;
+        value = strchr(asciienv, '=');
+        *value = '\0';                  /* Add '\0' so name is NULL termintated. */
+        value++;                        /* Value is now everything after the '='. */
+
+        envvar = putEnvvar(name, value, getEnvvar(name));
+        free(asciienv);
+    }
+
+    return result;
+}
+
+/**************************************************************************
+ * name        - atoe_perror
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+void
+atoe_perror( const char *string)
+{
+    char *e;
+
+    e = a2e_string((char *)string);
+    perror(e);
+
+    free(e);
+
+    return;
+}
+
+
+/**************************************************************************
+ * name        - atoe_enableFileTagging
+ * description - Enables tagging of all new files to the specified ccsid
+ * parameters  - ccsid - Required CCSID for file tags
+ * returns     - none
+ *************************************************************************/
+void 
+atoe_setFileTaggingCcsid(void *pccsid) { 
+   __ccsid_t ccsid = *(__ccsid_t*) pccsid; 
+    newFileCCSID = ccsid;
+}
+
+
+/**************************************************************************
+ * name        - fileTagRequired
+ * description - Determines whether or not a specified file needs tagging
+ * parameters  - filename (platform encoded)
+ * returns     - 1 if file tagging enabled and file doesn't already exist.
+ *               0 otherwise
+ *************************************************************************/
+static int 
+fileTagRequired(const char *filename) {
+    struct stat sbuf;
+    if (fileTaggingEnabled && newFileCCSID != 0 &&
+        (stat(filename,&sbuf) == -1 && errno == ENOENT) ) {
+        return 1;
+    }
+    return 0;
+}
+
+/**************************************************************************
+ * name        - setFileTag
+ * description - Sets the file tag to newFileCCSID for the specified file
+ *               descriptor
+ * parameters  - fd - open file descriptor of file for tagging
+ * returns     - none
+ *************************************************************************/
+static void 
+setFileTag(int fd) {
+    struct file_tag tag;
+    tag.ft_ccsid = newFileCCSID;
+    tag.ft_txtflag = 1;
+    tag.ft_deferred = 0;
+    tag.ft_rsvflags = 0;
+    fcntl(fd, F_SETTAG, &tag);
+}
+
+
+/**************************************************************************
+ * name        - atoe_tagged_open
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_open( const char *fname, int options, ...)
+{
+    int fd;
+    int mode;
+    int tagFile; 
+    va_list args;
+    char *f;
+
+    check_fcntl_init();                            
+
+    /* See if the file needs to be tagged */
+    tagFile = fileTagRequired(fname);
+
+    f = a2e_string((char *)fname);
+
+    va_start(args,options);
+
+    if ( options & O_CREAT ) {
+        mode = va_arg(args, int);
+    } else {
+        mode = 0;
+    }
+
+    va_end(args);
+
+    fd = open(f,options,mode);
+                                                   
+    if ( (fd != -1) &&                    /* file descriptor ok? */
+         (use_fcntl) )                    /* OS level is ok      */
+      {
+        set_SETCVTOFF();
+      }
+
+    if (fd != -1) { /* file descriptor ok? */
+        if (tagFile) {
+            setFileTag(fd);
+        }
+    }
+                                                   
+    free(f);
+
+    return fd;
+}
+
+/**************************************************************************
+ * name        - atoe_tempnam
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+atoe_tempnam( const char *dir, char *pfx)
+{
+    char *tempfn = 0;
+    char *a = 0;
+    char *d = a2e_string((char *)dir);
+    char *p = a2e_string(pfx);
+
+    if (( tempfn = tempnam(d,p)) == 0 ) {
+        atoe_fprintf(stderr,"Creation of temp file %s/%s failed.\n",dir,pfx);
+    } else {
+        a = e2a_string(tempfn);
+        free(tempfn);
+    }
+
+    free(d);
+    free(p);
+
+    return a;
+}
+
+
+/**************************************************************************
+ * name        - atoe_stat
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_stat( const char *pathname, struct stat *sbuf)
+{
+    int rc;
+    char *e;
+
+    e = a2e_string((char *)pathname);
+    rc = stat(e,sbuf);
+
+    free(e);
+
+    return rc;
+}
+
+/**************************************************************************
+ * name        - atoe_lstat
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_lstat( const char *pathname, struct stat *sbuf)
+{
+    int rc;
+    char *e;
+
+    e = a2e_string((char *)pathname);
+    rc = lstat(e,sbuf);
+
+    free(e);
+
+    return rc;
+}
+
+
+/**************************************************************************
+ * name        - atoe_fopen
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+FILE *
+atoe_fopen( const char *filename, char *mode)
+{
+    FILE *outfp;
+    char *f,*m;
+    int  fd = -1;         /* file descriptor */    
+
+    check_fcntl_init();                            
+
+    f = a2e_string((char *)filename);
+    m = a2e_string(mode);
+    outfp = fopen(f,m);
+
+    if ( (outfp != NULL) &&                        /* fopen() ok?    */
+         (use_fcntl)    &&                         /* OS level is ok */
+         ( (fd = fileno(outfp)) != -1))            /* have a file descriptor? */
+      {
+        set_SETCVTOFF();
+      }
+
+    free(f);
+    free(m);
+
+    return outfp;
+}
+
+/**************************************************************************
+ * name        - atoe_freopen
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+FILE *
+atoe_freopen(const char *filename, char *mode, FILE *stream)
+{
+    FILE *outfp;
+    char *f,*m;
+    int  fd = -1;         /* file descriptor */    
+
+    check_fcntl_init();                            
+
+    f = a2e_string((char *)filename);
+    m = a2e_string(mode);
+    outfp = freopen(f, m, stream);
+
+    if ( (outfp != NULL) &&                        /* fopen() ok?    */
+         (use_fcntl)    &&                         /* OS level is ok */
+         ( (fd = fileno(outfp)) != -1))            /* have a file descriptor? */
+      {
+        set_SETCVTOFF();
+      }
+
+    free(f);
+    free(m);
+
+    return outfp;
+}
+
+
+/**************************************************************************
+ * name        - atoe_mkdir
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_mkdir( const char *pathname, mode_t mode)
+{
+    int rc;
+    char *e;
+
+    e = a2e_string((char *)pathname);
+    rc = mkdir(e, mode);
+
+    free(e);
+
+    return rc;
+}
+
+/**************************************************************************
+ * name        - atoe_remove
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_remove( const char *pathname)
+{
+    int rc;
+    char *e;
+
+    e = a2e_string((char *)pathname);
+    rc = remove(e);
+
+    free(e);
+
+    return rc;
+}
+
+/**************************************************************************
+ * name        - atoe_strerror
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+#define ERRNO_CACHE_SIZE   250
+typedef struct ascii_errno_t {
+    int   errnum;
+    char *ascii_msg;
+} ascii_errno_t;
+static ascii_errno_t errno_cache[ERRNO_CACHE_SIZE];
+static int errno_cache_next = 0;
+static pthread_mutex_t strerror_mutex = PTHREAD_MUTEX_INITIALIZER;
+static int strerror_initialized = 0;
+char *
+atoe_strerror(int errnum)
+{
+    char *a,*e;
+    int index;
+
+    pthread_mutex_lock(&strerror_mutex);
+    if (0 == strerror_initialized) {
+        for (index=0; index<ERRNO_CACHE_SIZE; index++) {
+            errno_cache[index].errnum = -1;
+            errno_cache[index].ascii_msg = 0;
+        }
+        strerror_initialized = 1;
+    }
+
+    for (index=0;
+         index<ERRNO_CACHE_SIZE, errno_cache[index].errnum!=-1;
+         index++) {
+        if (errnum == errno_cache[index].errnum) {
+            pthread_mutex_unlock(&strerror_mutex);
+            return errno_cache[index].ascii_msg;
+        }
+    }
+
+    e = strerror(errnum);
+    a = e2a_string(e);
+
+    errno_cache[errno_cache_next].errnum = errnum;
+    if (errno_cache[errno_cache_next].ascii_msg)
+        free(errno_cache[errno_cache_next].ascii_msg);
+    errno_cache[errno_cache_next].ascii_msg = a;
+    if (++errno_cache_next == ERRNO_CACHE_SIZE)
+          errno_cache_next = 0;
+    pthread_mutex_unlock(&strerror_mutex);
+
+    return a;
+}
+
+/**************************************************************************
+ * name        - atoe_getcwd
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+atoe_getcwd(char *buffer, size_t size)
+{
+    char *abuf;
+
+    if (getcwd(buffer,size) == NULL) {     
+        atoe_fprintf(stderr,"atoe_getcwd error: %s\n",
+                     errno==ERANGE ? "buffer too small" : atoe_strerror(errno));
+        buffer = NULL;
+    } else {
+        abuf = e2a(buffer,size);
+        memcpy(buffer,abuf,size);
+        free(abuf);
+    }
+
+    return buffer;
+}
+
+/**************************************************************************
+ * name        - atoe_fgets
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+atoe_fgets (char *buffer, int num, FILE *file)
+{
+    char *abuf;
+
+    if (fgets(buffer, num, file)) {
+        int len = strlen(buffer);
+        abuf = e2a(buffer,len);
+        memcpy(buffer,abuf,len);
+
+        free(abuf);
+        return buffer;
+    }
+
+    return(char *)0;
+}
+
+
+/**************************************************************************
+ * name        - atoe_gets
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+atoe_gets(char *buffer)
+{
+    char *abuf;
+
+    if (gets(buffer)) {
+        int len = strlen(buffer);
+        abuf = e2a(buffer,len);
+        memcpy(buffer,abuf,len);
+
+        free(abuf);
+        return buffer;
+    }
+
+    return(char *)0;
+}
+
+/**************************************************************************
+ * name        - atoe_unlink
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_unlink( const char *pathname)
+{
+    int rc;
+    char *e;
+
+    e = a2e_string((char *)pathname);
+    rc = unlink(e);
+
+    free(e);
+
+    return rc;
+}
+
+
+/**************************************************************************
+ * name        - atoe_unlink
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_rmdir( const char *pathname)
+{
+    int rc;
+    char *e;
+
+    e = a2e_string((char *)pathname);
+    rc = rmdir(e);
+
+    free(e);
+
+    return rc;
+}
+
+
+/**************************************************************************
+ * name        - atoe_access
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_access( const char *pathname, int how)
+{
+    int rc;
+    char *e;
+
+    e = a2e_string((char *)pathname);
+    rc = access(e, how);
+
+    free(e);
+
+    return rc;
+}
+
+
+/**************************************************************************
+ * name        - atoe_opendir
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+DIR *
+atoe_opendir( const char *dirname)
+{
+    DIR *dir;
+    char *e;
+
+    e = a2e_string((char *)dirname);
+    dir = opendir(e);
+
+    free(e);
+
+    return dir;
+}
+
+
+/**************************************************************************
+ * name        - atoe_readdir
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+struct dirent *
+atoe_readdir(DIR *dir) {
+    struct dirent *d;
+    char * a;
+
+    d = readdir(dir);
+
+    if (d == NULL) return NULL;
+
+    a = e2a_string(d->d_name);
+
+    strcpy(d->d_name, a);
+    free(a);
+
+    return d;
+}
+
+/**************************************************************************
+ * name        - atoe_realpath
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+atoe_realpath(const char *file_name, char *resolved_name)
+{
+    char e_resolved_name[MAXPATHLEN];
+    char *e_file_name, *p;
+
+    e_file_name = a2e_string((char *)file_name);                   
+    p = realpath(e_file_name, e_resolved_name);                    
+
+    if (p == NULL) return p;
+
+    p = e2a_string(e_resolved_name);
+    strcpy(resolved_name, p);
+    free(p);
+
+    return resolved_name;
+}
+
+/**************************************************************************
+ * name        - atoe_rename
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_rename( const char *oldname, char *newname)
+{
+    int rc;
+    char *o,*n;
+
+    o = a2e_string((char *)oldname);
+    n = a2e_string(newname);
+    rc = rename(o, n);
+
+    free(o);
+    free(n);
+
+    return rc;
+}
+
+
+/**************************************************************************
+ * name        - atoe_getpwuid
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+struct passwd *
+atoe_getpwuid(uid_t uid) {
+    return etoa_passwd(getpwuid(uid));
+}
+
+/**************************************************************************
+ * name        - atoe_getpwnam
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+struct passwd *
+atoe_getpwnam(const char *name) {
+    struct passwd *e_passwd;
+    char *e_name;
+
+    e_name = a2e_string((char *)name);
+    e_passwd = getpwnam(e_name);
+    free(e_name);
+
+    return etoa_passwd(e_passwd);
+}
+
+/**************************************************************************
+ * name        - etoa_passwd
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+struct passwd *
+etoa_passwd(struct passwd *e_passwd) {
+    struct passwd *a_passwd = NULL;
+
+    if (e_passwd != NULL) {
+        a_passwd = (struct passwd *)malloc(sizeof(struct passwd));
+
+        if (a_passwd != NULL) {
+            a_passwd->pw_name  = e2a_string(e_passwd->pw_name);
+            a_passwd->pw_uid   = e_passwd->pw_uid;
+            a_passwd->pw_gid   = e_passwd->pw_gid;
+            a_passwd->pw_dir   = e2a_string(e_passwd->pw_dir);
+            a_passwd->pw_shell = e2a_string(e_passwd->pw_shell);
+        }
+    }
+
+    return a_passwd;
+}
+
+/**************************************************************************
+ * name        - atoe_getlogin
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+atoe_getlogin(void)
+{
+    char *e_login;
+    char *a_login = NULL;
+
+    e_login = getlogin();
+
+    if (e_login != NULL) {
+        a_login = e2a_string(e_login);
+    }
+
+    return a_login;
+}
+
+/**************************************************************************
+ * name        - etoa_group
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+struct group *
+e2a_group(struct group *e_group) {
+    struct group *a_group = NULL;
+
+    if (e_group != NULL) {
+        a_group = (struct group *)malloc(sizeof(struct group));
+
+        if (a_group != NULL) {
+            char **e_member = NULL;
+            char **a_member = NULL;
+            int arraySize = 0;
+            a_group->gr_name  = e2a_string(e_group->gr_name);
+            a_group->gr_gid   = e_group->gr_gid;
+            for(e_member = e_group->gr_mem; *e_member != NULL; e_member++) {
+                arraySize++;
+            }
+            a_group->gr_mem = (char **)malloc((arraySize+1)*sizeof(char*));
+            if (a_group->gr_mem != NULL) {
+		for(e_member = e_group->gr_mem, a_member = a_group->gr_mem;
+		    *e_member != NULL; 
+		    e_member++, a_member++) {
+		    *a_member = e2a_string(*e_member);
+		}
+		*(++a_member) = NULL;
+            }
+        }
+    }
+
+    return a_group;
+}
+
+/**************************************************************************
+ * name        - atoe_getgrgid
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+struct group *
+atoe_getgrgid(gid_t gid)
+{
+    struct group *e_group;
+    struct group *a_group = NULL;
+
+    e_group = getgrgid(gid);
+
+    if (e_group != NULL) {
+        a_group = e2a_group(e_group);
+    }
+
+    return a_group;
+}
+
+/**************************************************************************
+ * name        - atoe_putchar
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_putchar(int ch)
+{
+    return putchar((int)a2e_tab[ch]);
+}
+
+
+/**************************************************************************
+ * name        - atoe_fprintf
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_fprintf(FILE *file, const char *ascii_chars, ...)
+{
+    va_list args;
+    char buf[BUFLEN];
+    char *ebuf;
+    int len;
+
+    va_start(args,ascii_chars);
+
+    len = atoe_vsnprintf(buf,BUFLEN,ascii_chars,args);
+
+    /* Abort if failed... */
+    if (len == -1) return len;
+
+    ebuf = a2e(buf,len);
+#pragma convlit(suspend)
+    len = fprintf(file,"%s", ebuf);
+#pragma convlit(resume)
+    free(ebuf);
+
+    va_end(args);
+
+    return len;
+}
+
+
+/**************************************************************************
+ * name        - atoe_printf
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_printf( const char *ascii_chars, ...)
+{
+    va_list args;
+    char buf[BUFLEN];
+    char *ebuf;
+    int len;
+
+    va_start(args,ascii_chars);
+
+    len = atoe_vsnprintf(buf,BUFLEN,ascii_chars,args);
+
+    /* Abort if failed... */
+    if (len==-1) return len;
+
+    ebuf = a2e(buf,len);
+#pragma convlit(suspend)
+    len = printf("%s", ebuf);
+#pragma convlit(resume)
+    free(ebuf);
+
+    va_end(args);
+
+    return len;
+}
+
+/*************************************************************************
+ * name        - std_sprintf
+ * description -
+ *              This function does not need to convert ascii -> EBCDIC
+ *              as there is no IO
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+std_sprintf( const char *buf, char *ascii_chars, ...)
+{
+    int len;
+    va_list args;
+    va_start(args,ascii_chars);
+
+    len = sprintf((char *)buf, ascii_chars,args);
+
+    va_end(args);
+
+    return len;
+}
+
+/**************************************************************************
+ * name        - atoe_sprintf
+ * description -
+ *              This function does not need to convert ascii -> EBCDIC
+ *              as there is no IO
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_sprintf( const char *buf, char *ascii_chars, ...)
+{
+    int len;
+    char wrkbuf[BUFLEN];
+
+    va_list args;
+    va_start(args,ascii_chars);
+
+    len = atoe_vsnprintf(wrkbuf,BUFLEN,ascii_chars,args);
+
+    va_end(args);
+    if (-1 == len) return len;                               
+
+    strcpy((char *)buf, wrkbuf);
+
+    return len;
+}
+
+/**************************************************************************
+ * name        - atoe_vprintf
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_vprintf(const char *ascii_chars, va_list args)
+{
+    return atoe_vfprintf(stdout, ascii_chars, args); 
+}
+
+/**************************************************************************
+ * name        - atoe_vfprintf
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_vfprintf(FILE *file, const char *ascii_chars, va_list args)
+{
+    char buf[BUFLEN];
+    char *ebuf;
+    int len;
+
+    len = atoe_vsnprintf(buf,BUFLEN,ascii_chars,args);
+
+    if (len == -1) return len;
+
+    ebuf = a2e(buf,len);
+#pragma convlit(suspend)
+    len = fprintf(file,"%s", ebuf);
+#pragma convlit(resume)
+
+    free(ebuf);
+
+    return len;
+}
+
+/**************************************************************************
+ * name        - atoe_vsprintf                                    
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_vsprintf(char *target, const char *ascii_chars, va_list args)
+{
+    char buf[BUFLEN];                                     
+    int  bsize = 0;                                       
+
+    bsize = atoe_vsnprintf(buf,BUFLEN,ascii_chars,args);  
+    if (-1 == bsize) return bsize;                        
+    strcpy(target,buf);                                   
+    return(bsize);                                        
+}
+
+/**************************************************************************
+ * name        - atoe_sscanf                              
+ * description -
+ * parameters  -
+ * returns     -
+ * RESTRICTIONS - At the time of writing, there is no requirement to support
+ *                character or string formatting, so I have opted to avoid
+ *                the pain of trawling the format string along with the
+ *                argument list in order to convert characters/strings from
+ *                EBCDIC back to ASCII after calling the RTL sscanf().
+ *************************************************************************/
+int
+atoe_sscanf(const char *buffer, const char *format, va_list args)
+{
+    char *e_buffer = a2e_string((char *)buffer);
+    char *e_format = a2e_string((char *)format);
+    int len = sscanf((const char *)e_buffer, (const char *)e_format, args);
+    free(e_buffer);
+    free(e_format);
+    return len;
+}
+
+/**************************************************************************
+ * name        - atoe_strftime
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+size_t
+atoe_strftime(char *buf, size_t buflen,
+              const char *format, const struct tm *timeptr)
+{
+    size_t num;
+    char *e,*a;
+
+    e = a2e_string((char *)format);
+    num = strftime(buf, buflen, e, timeptr);
+    a = e2a(buf,num);
+    memcpy(buf,a,num);
+
+    free(e);
+    free(a);
+
+    return num;
+}
+
+/**************************************************************************
+ * name        - atoe_fwrite
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+size_t
+atoe_fwrite(const void *buffer, size_t size, size_t count, FILE *stream)
+{
+    int numwritten;
+    char *e;
+
+    e = a2e((void *)buffer,size*count);      
+    numwritten = fwrite(e,size,count,stream);
+
+    free(e);
+
+    return numwritten;
+}
+
+/**************************************************************************
+ * name        - atoe_fread
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+size_t
+atoe_fread(void *buffer, size_t size, size_t count, FILE *stream)
+{
+    int numread;
+    char *a;
+
+    numread = fread(buffer,size,count,stream);
+    a = e2a((char *)buffer,numread);
+    memcpy(buffer,a,numread);
+
+    free(a);
+
+    return numread;
+}
+
+/**************************************************************************
+ * name        - atoe_system
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_system( char * cmd)
+{
+    char *eb;
+    int result;
+
+    eb = a2e_string(cmd);
+    result = system(eb) ;
+
+    free(eb);
+
+    return result;
+}
+
+/**************************************************************************
+ * name        - atoe_setlocale
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+atoe_setlocale(int category, const char *locale)
+{
+    char *eb, *result;
+
+    eb = a2e_string((char *)locale);
+    result = setlocale(category, eb) ;
+
+    return e2a_string(result);
+}
+
+/**************************************************************************
+ * name        - atoe_ctime
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+atoe_ctime(const time_t * t_in)
+{
+    char *eb;
+
+    eb = ctime(t_in);
+
+    return e2a_string(eb);
+}
+
+/**************************************************************************
+ * name        - atoe_strtod
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+double atoe_strtod( char * s, char ** p)
+{
+    char * sebcdic;
+    char * pebcdic;
+    double d;
+
+    sebcdic = a2e_string(s);
+    d = strtod(sebcdic,&pebcdic);
+    if (p != NULL) {
+        *p = s + (pebcdic - sebcdic);
+    }
+    free(sebcdic);
+
+    return d;
+}
+
+/**************************************************************************
+ * name        - atoe_strtol                                      
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int atoe_strtol(const char * s, char ** p, int b)
+{
+    char * sebcdic;
+    char * pebcdic;
+    int  i;
+
+    sebcdic = a2e_string((char *)s);
+    i = strtol((const char *)sebcdic, &pebcdic, b);
+    if (p != NULL) {
+        *p = (char *)s + (pebcdic - sebcdic);
+    }
+    free(sebcdic);
+
+    return i;
+}
+
+/**************************************************************************
+ * name        - atoe_strtoul                                     
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+unsigned long atoe_strtoul(const char * s, char ** p, int b)
+{
+    char * sebcdic;
+    char * pebcdic;
+    unsigned long  i;
+
+    sebcdic = a2e_string((char *)s);
+    i = strtoul((const char *)sebcdic, &pebcdic, b);
+    if (p != NULL) {
+        *p = (char *)s + (pebcdic - sebcdic);
+    }
+    free(sebcdic);
+
+    return i;
+}
+
+/**************************************************************************
+ * name        - atoe_strtoull
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+unsigned long long atoe_strtoull(const char * s, char ** p, int b)
+{
+    char * sebcdic;
+    char * pebcdic;
+    unsigned long long i;
+
+    sebcdic = a2e_string((char *)s);
+    i = strtoull((const char *)sebcdic, &pebcdic, b);
+    if (p != NULL) {
+        *p = (char *)s + (pebcdic - sebcdic);
+    }
+    free(sebcdic);
+
+    return i;
+}
+
+/*************************************************************************
+ * name        - atoe_atof
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+double
+atoe_atof(char * ascii_string)
+{
+    double rc;
+    char * ebcdic_string;
+
+    ebcdic_string = a2e_string(ascii_string);
+    rc = atof(ebcdic_string);
+    free(ebcdic_string);
+
+    return rc;
+}
+
+/**************************************************************************
+ * name        - atoe_atoi
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_atoi(char * ascii_string)
+{
+    int rc;
+    char * ebcdic_string;
+
+    ebcdic_string = a2e_string(ascii_string);
+    rc = atoi(ebcdic_string);
+    free(ebcdic_string);
+
+    return rc;
+}
+
+/*************************************************************************
+ * name        - atoe_atol
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+long
+atoe_atol(char * ascii_string)
+{
+    long rc;
+    char * ebcdic_string;
+
+    ebcdic_string = a2e_string(ascii_string);
+    rc = atol(ebcdic_string);
+    free(ebcdic_string);
+
+    return rc;
+}
+
+/**************************************************************************
+ * name        - atoe_gethostname
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+atoe_gethostname(char *name, int namelen)
+{
+    int rc = gethostname(name, namelen);
+
+    char *ascii_name = e2a(name, namelen);
+
+    strcpy(name, ascii_name);
+    free(ascii_name);
+
+    return rc;
+}
+
+/**************************************************************************
+ * name        - atoe_gethostbyname                             
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+#define HOSTBYNAME_CACHE_SIZE   50
+typedef struct hostbyname_t {
+    char *hostname;
+    struct hostent h;
+} hostbyname_t;
+static hostbyname_t hostbyname_cache[HOSTBYNAME_CACHE_SIZE];
+static int hostbyname_cache_next = 0;
+static pthread_mutex_t hostbyname_mutex = PTHREAD_MUTEX_INITIALIZER;
+static int hostbyname_initialized = 0;
+struct hostent*
+atoe_gethostbyname(const char *hostname) {
+    char *h;
+    struct hostent *hostptr = NULL, *hostptr_a = NULL;
+    int index;
+
+    pthread_mutex_lock(&hostbyname_mutex);
+    if (0 == hostbyname_initialized) {
+        /* initialize cache in static storage */
+        for (index=0; index<HOSTBYNAME_CACHE_SIZE; index++) {
+            hostbyname_cache[index].hostname = NULL;
+            memset(&hostbyname_cache[index].h, 0, sizeof(struct hostent));
+        }
+        hostbyname_initialized = 1;
+    }
+
+    /* see if we are already using a cache entry for this hostname */
+    for (index=0;
+         index<HOSTBYNAME_CACHE_SIZE, hostbyname_cache[index].hostname!=NULL;
+         index++) {
+        if (0 == strcmp(hostname, hostbyname_cache[index].hostname)) {
+            hostptr_a = &hostbyname_cache[index].h;
+            break;
+        }
+    }
+    if (NULL == hostptr_a) {
+        /* use next cache slot for this hostname */
+        if (hostbyname_cache[hostbyname_cache_next].hostname) {
+            free(hostbyname_cache[hostbyname_cache_next].hostname);
+        }
+        hostbyname_cache[hostbyname_cache_next].hostname = strdup(hostname);
+        if (!hostbyname_cache[hostbyname_cache_next].hostname) {
+            pthread_mutex_unlock(&hostbyname_mutex);
+            return NULL;
+        }
+        hostptr_a = &hostbyname_cache[hostbyname_cache_next].h;
+        if (++hostbyname_cache_next == HOSTBYNAME_CACHE_SIZE) {
+            hostbyname_cache_next = 0;
+        }
+    }
+
+    /* convert the input hostname to ebcdic */
+    h = a2e_string(hostname);
+    /* and issue the system call */
+    hostptr = gethostbyname(h);
+    /* don't need the ebcdic copy of hostname any more */
+    free(h);
+
+    /* if the system call worked save the results, otherwise return NULL */
+    if (hostptr) {
+        /* if we're re-using a cache slot, free any previously saved name */
+        if (hostptr_a->h_name) {
+            free(hostptr_a->h_name);
+        }
+        /* copy the system returned hostent into our cache */
+        memcpy(hostptr_a, hostptr, sizeof(struct hostent));
+        /* convert the system returned name to ascii and save it in our cache */
+        hostptr_a->h_name = e2a_string(hostptr->h_name);
+        /* if everything worked return the address of the cache entry */
+        if (hostptr_a->h_name) {
+            hostptr = hostptr_a;
+        } else {
+            hostptr = NULL;
+        }
+    }
+
+    pthread_mutex_unlock(&hostbyname_mutex);
+
+    return hostptr;
+}
+
+/**************************************************************************
+ * name        - atoe_gethostbyname_r                           
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+struct hostent*
+atoe_gethostbyname_r(char *hostname, struct hostent *hentptr,     
+                     char *buf, int bufsize, int *h_error) {
+    char *h, *h_n;
+    struct hostent *hostptr;
+
+    h = a2e_string(hostname);
+
+    if ((hostptr = gethostbyname(h)) == NULL) {                   
+    hentptr = NULL;                                            
+    } else if ((strlen(hostptr->h_name) + 1) > bufsize) {      
+    *h_error = errno = ERANGE;                                 
+    hentptr = NULL;                                            
+    } else {                                                   
+    memcpy(hentptr, hostptr, sizeof(struct hostent));          
+
+        h_n = e2a_string(hostptr->h_name);
+    strcpy(buf, h_n);                                          
+    free(h_n);                                                 
+
+    hentptr->h_name = buf;                                     
+    }
+
+    free(h);
+
+    return hentptr;                                            
+}
+
+/**************************************************************************
+ * name        - atoe_gethostbyaddr
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+struct hostent*
+atoe_gethostbyaddr(const void *address, int addrlen, int domain,
+                   struct hostent *hentptr, char *buf, int bufsize,
+                   int *h_error) {
+    char *h_n;
+    struct hostent *hostptr;
+
+    if ((hostptr = gethostbyaddr(address,addrlen,domain)) == NULL){
+    hentptr = NULL;                                            
+    } else if ((strlen(hostptr->h_name) + 1) > bufsize) {      
+    *h_error = errno = ERANGE;                                 
+    hentptr = NULL;                                            
+    } else {                                                   
+    memcpy(hentptr, hostptr, sizeof(struct hostent));          
+
+        h_n = e2a_string(hostptr->h_name);
+    strcpy(buf, h_n);                                          
+    free(h_n);                                                 
+
+    hentptr->h_name = buf;                                     
+    }
+
+    return hentptr;                                            
+}
+
+/**************************************************************************
+ * name        - atoe_getprotobyname
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+struct protoent *
+atoe_getprotobyname(const char *name) {
+    struct protoent *pent;
+    char *e_name, *p_n;
+
+    e_name = a2e_string((char *)name);
+
+    if ((pent = getprotobyname(e_name)) != 0) {
+        p_n = e2a_string(pent->p_name);
+        pent->p_name = p_n;
+    }
+
+    free(e_name);
+
+    return pent;
+}
+
+/**************************************************************************
+ * name        - atoe_inet_addr
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+unsigned long
+atoe_inet_addr(char *hostname)
+{
+    unsigned long iaddr = -1;
+    char *h = a2e_string(hostname);
+
+    iaddr = inet_addr(h);
+
+    free(h);
+
+    return iaddr;
+}
+
+#define _ISALNUM_ASCII  0x0001
+#define _ISALPHA_ASCII  0x0002
+#define _ISCNTRL_ASCII  0x0004
+#define _ISDIGIT_ASCII  0x0008
+#define _ISGRAPH_ASCII  0x0010
+#define _ISLOWER_ASCII  0x0020
+#define _ISPRINT_ASCII  0x0040
+#define _ISPUNCT_ASCII  0x0080
+#define _ISSPACE_ASCII  0x0100
+#define _ISUPPER_ASCII  0x0200
+#define _ISXDIGIT_ASCII 0x0400
+
+#define _XUPPER_ASCII   0xdf                                        
+#define _XLOWER_ASCII   0x20                                        
+
+/* Check for iconv_init() already done   */
+int iconv_initialised = 0;
+
+/* Table for integer test macros      */
+int _ascii_is_tab[CONV_TABLE_SIZE];
+
+#pragma convlit(suspend)
+/**************************************************************************
+ * name        - iconv_init
+ * description -
+ *              Allocate code conversion descriptors for iconv()
+ *              and build translate tables.
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+iconv_init(void)
+{
+    char *asciiSet = "ISO8859-1";
+    char *defaultSet = "IBM-1047";
+    char *ebcdicSet, *inptr, *outptr;
+    size_t inleft, outleft;
+    iconv_t atoe_cd = (iconv_t)(-1);  
+    iconv_t etoa_cd = (iconv_t)(-1);  
+    char init_tab[CONV_TABLE_SIZE];
+    int i;
+
+    /* Need to save start locale setting      */   
+    char *slc = NULL;
+    /* Get the current locale setting    */        
+    char *clc = setlocale(LC_ALL, NULL); 
+
+    if (iconv_initialised) {
+        return 0;
+    }
+
+    /*
+     * Test whether we're running with an DBCS codepage
+     * If so, use default IBM-1047 EBCDIC SBCS codepage to build translate table.
+     */
+    {
+        char a[] = {97,0}; /* ASCII "a" */
+
+        /* Copy the start locale setting to reset it later          */
+        slc = strdup(clc);
+        if ( !slc ) return -1;
+
+        /* Set the locale to whatever is set by the env. vars       */
+        setlocale(LC_ALL, "") ;
+
+        if (( __atoe(a) < 1) && (errno == EINVAL)) {
+            /* The current locale does not describe a single-byte character set.*/
+            /* This test does not always give the correct result*/
+            ebcdicSet = defaultSet;
+        } else {
+        char *encoding = NULL;                                    
+        char *lc;
+        char *p;
+        int i;
+
+        lc = getenv("LC_ALL");
+        if (lc == NULL) {
+        lc = getenv("LC_CTYPE");
+        if (lc == NULL) {
+            lc = getenv("LANG");
+        }
+        }
+
+        if (lc != NULL) {
+
+        /* We now have a string with the format
+         * language_region.encoding@variant any part of which
+         * may be missing. We need to extract the encoding part
+         */
+
+        lc = strdup(lc);
+        if ((p = strchr(lc, '.')) != NULL) {
+            encoding = p+1;                                   
+        }
+        if ((p = strchr(lc, '@')) != NULL) {
+            *p = '\0';
+        }
+        }
+
+        lc = encoding;
+
+        /* If lc is still NULL or we have "C" encoding
+         * use the default encoding.
+         */
+        if (lc == NULL || !strcmp(lc, "C")) {
+        ebcdicSet = defaultSet;
+        } else {
+        ebcdicSet = lc;
+        }
+    }
+    }
+
+    /* reset the locale to start setting                           */
+    clc = setlocale(LC_ALL, slc );
+    free( slc );
+
+    if (((etoa_cd = iconv_open(asciiSet, ebcdicSet)) == (iconv_t)(-1)) ||
+        ((atoe_cd = iconv_open(ebcdicSet, asciiSet)) == (iconv_t)(-1))) {
+        /* Retry with default ebcdicSet                              */
+        if (strcmp(ebcdicSet,defaultSet) == 0) {
+            return -1;
+    }
+        /* Close conversion descriptors just in case one of them succeeded */
+        if (etoa_cd != (iconv_t)(-1)) {                              
+            iconv_close(etoa_cd);                                    
+    }                                                             
+
+        if (atoe_cd != (iconv_t)(-1)) {                           
+            iconv_close(atoe_cd);                                 
+    }                                                             
+
+        if (((etoa_cd = iconv_open(asciiSet, defaultSet)) == (iconv_t)(-1)) ||
+            ((atoe_cd = iconv_open(defaultSet, asciiSet)) == (iconv_t)(-1))) {
+      return -1;
+    }                                                            
+    }
+
+    /* Build initial table x'00' - x'ff'   */
+    for (i = 0; i < CONV_TABLE_SIZE; i++) {
+        init_tab[i] = i;
+    }
+
+    /* Create conversion table for ASCII=>EBCDIC */
+    inptr = init_tab;
+    outptr = a2e_tab;
+    inleft = outleft = CONV_TABLE_SIZE;
+    if (iconv(atoe_cd, &inptr, &inleft, &outptr, &outleft) == -1) {
+        /* atoe conversion failed */
+        if (errno == E2BIG) {                                        
+        /* The EBCDIC codepage is probably DBCS */
+            /* Close conversion descriptors */
+            iconv_close(atoe_cd);
+            iconv_close(etoa_cd);
+            /* Retry with default IBM-1047 */
+            if (((etoa_cd = iconv_open(asciiSet, defaultSet)) == (iconv_t)(-1)) ||
+                ((atoe_cd = iconv_open(defaultSet, asciiSet)) == (iconv_t)(-1))) {
+                return -1;
+            }
+            inptr = init_tab;
+            outptr = a2e_tab;
+            inleft = outleft = CONV_TABLE_SIZE;
+            if (iconv(atoe_cd, &inptr, &inleft, &outptr, &outleft) == -1) {
+               return -1;
+        }
+    }                                                           
+    }
+
+    /* Create conversion table for EBCDIC=>ASCII */
+    inptr = init_tab;
+    outptr = e2a_tab;
+    inleft = outleft = CONV_TABLE_SIZE;
+
+    /* Try to create a complete translate table for this codepage */
+    /* if an EILSEQ return is received for a codepoint bypass and */
+    /* move on to the next one.                                   */
+    while (inleft>0) {
+      size_t ret;
+      ret = iconv(etoa_cd, &inptr, &inleft, &outptr, &outleft);
+      if (ret != (size_t)-1) break;
+      if (errno == EILSEQ) {
+        inptr  += 1;
+        inleft -= 1;
+        outptr  += 1;
+        outleft -= 1;
+      }
+      else {
+        /* etoa conversion failed */
+        return -1;
+      }
+    }
+
+    /* Close conversion descriptors */
+    iconv_close(atoe_cd);
+    iconv_close(etoa_cd);
+
+    /* Build integer test macros flag table */
+    for (i = 0; i < CONV_TABLE_SIZE; i++) {
+        _ascii_is_tab[i] = 0;
+        if (isalnum(a2e_tab[i])) _ascii_is_tab[i] |=  _ISALNUM_ASCII;
+        if (isalpha(a2e_tab[i])) _ascii_is_tab[i] |=  _ISALPHA_ASCII;
+        if (iscntrl(a2e_tab[i])) _ascii_is_tab[i] |=  _ISCNTRL_ASCII;
+        if (isdigit(a2e_tab[i])) _ascii_is_tab[i] |=  _ISDIGIT_ASCII;
+        if (isgraph(a2e_tab[i])) _ascii_is_tab[i] |=  _ISGRAPH_ASCII;
+        if (islower(a2e_tab[i])) _ascii_is_tab[i] |=  _ISLOWER_ASCII;
+        if (isprint(a2e_tab[i])) _ascii_is_tab[i] |=  _ISPRINT_ASCII;
+        if (ispunct(a2e_tab[i])) _ascii_is_tab[i] |=  _ISPUNCT_ASCII;
+        if (isspace(a2e_tab[i])) _ascii_is_tab[i] |=  _ISSPACE_ASCII;
+        if (isupper(a2e_tab[i])) _ascii_is_tab[i] |=  _ISUPPER_ASCII;
+        if (isxdigit(a2e_tab[i])) _ascii_is_tab[i] |=  _ISXDIGIT_ASCII;
+    }
+
+    /* If we get here, then we are initialised.                    */
+    iconv_initialised = 1;                                         
+
+    return 0;
+}
+#pragma convlit(resume)
+
+/**************************************************************************
+ * name        - atoe_dlopen
+ * description - Load the DLL specified in dllName by converting it to EBCDIC,
+ *               then calling the system dlopen
+ * parameters  - dllName   the DLL name
+ *               mode      describes the mode by which the DLL will be loaded
+ * returns     - a handle to the loaded DLL if successful, NULL otherwise
+ *************************************************************************/
+void*
+atoe_dlopen(const char * dllName, int mode) 
+{
+    void *handle;
+    char *d = a2e_string(dllName);
+
+    handle = dlopen(d, mode);
+    free(d);
+    return handle;
+}
+
+void *
+atoe_dlsym(void *descriptor, const char *name) 
+{
+    void *address;
+    char *ebcdicName = a2e_string(name);
+
+    address = dlsym(descriptor, ebcdicName);
+    free(ebcdicName);
+    return address;
+}
+
+/**************************************************************************
+ * name        - atoe_dllload
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+dllhandle*
+atoe_dllload(char * dllName)
+{
+    dllhandle *handle;
+    char *d = a2e_string(dllName);
+
+    handle = dllload(d);
+    free(d);
+    return handle; 
+}
+
+void *atoe_dllqueryvar(dllhandle* dllHandle, char* varName)
+{
+    char *n = a2e_string(varName);
+    void *r = dllqueryvar(dllHandle, n);
+
+    free(n);
+
+    return r;
+}
+
+
+void (*
+      atoe_dllqueryfn(dllhandle* dllHandle, char* funcName)) ()
+{
+    char *n = a2e_string(funcName);
+    void (*r)() = dllqueryfn(dllHandle, n);
+
+    free(n);
+
+    return r;
+}
+
+/**************************************************************************
+ * name        - atoe_execv
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int        
+atoe_execv (const char *path, char *const argv[])
+{
+    char *ebcdicPath = a2e_string(path);
+    char **ebcdicArgv;
+    int size = 0, i, rc;
+
+    /* Calculate the size of argv. argv always ends with a null pointer. */
+    while (*(argv+size)) {
+        size++;
+    }
+
+    /* Allocate space for the new array and populate */
+    ebcdicArgv = (char**) malloc(size+1);
+    for (i=0; i<size; i++) {
+        *(ebcdicArgv+i) = strdup(a2e_string(argv[i]));
+    }
+
+    /* Null terminate the new array */
+    *(ebcdicArgv+size) = NULL;
+
+    rc = execv(ebcdicPath, ebcdicArgv);
+
+    return rc;
+}
+
+/**************************************************************************
+ * name        - atoe_execvp
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int        
+atoe_execvp (const char *file, char *const argv[])
+{
+    char *ebcdicFile = a2e_string(file);
+    char **ebcdicArgv;
+    int size = 0, i, rc;
+
+    /* Calculate the size of argv. argv always ends with a null pointer. */
+    while (*(argv+size)) {
+        size++;
+    }
+
+    /* Allocate space for the new array and populate */
+    ebcdicArgv = (char**) malloc(size+1);
+    for (i=0; i<size; i++) {
+        *(ebcdicArgv+i) = strdup(a2e_string(argv[i]));
+    }
+
+    /* Null terminate the new array */
+    *(ebcdicArgv+size) = NULL;
+
+    rc = execvp(ebcdicFile, ebcdicArgv);
+
+    return rc;
+}
+
+/**************************************************************************
+ * name        - etoa_uname                    
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+etoa_uname(struct utsname *a) {
+    struct utsname e;
+    int rc = 0;
+
+    rc = uname(&e);
+    if (rc == 0 && a != NULL) {
+        char *temp = NULL;
+        temp  = e2a_string(e.sysname);
+        strcpy(a->sysname,temp);
+    free(temp);
+        temp  = e2a_string(e.nodename);
+        strcpy(a->nodename,temp);
+    free(temp);
+        temp  = e2a_string(e.release);
+        strcpy(a->release,temp);
+    free(temp);
+        temp  = e2a_string(e.version);
+        strcpy(a->version,temp);
+    free(temp);
+        temp  = e2a_string(e.machine);
+        strcpy(a->machine,temp);
+    free(temp);
+    }
+
+    return rc;
+}
+
+/**************************************************************************
+ * name        - etoa_nl_langinfo              
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+char *
+etoa_nl_langinfo(int nl_item) {
+
+    char *retVal = NULL;
+    retVal = nl_langinfo(nl_item);
+    return(retVal != NULL) ? e2a_string(retVal) : NULL;
+}
+
+/*********************************************************************/
+/* name        - atoe_utimes                                         */
+/*                                                                   */
+/* description - provide a version of the utimes() system function   */
+/*               that converts the specified path from an ascii to   */
+/*               an ebcdic string.                                   */
+/*                                                                   */
+/* parameters  - path:  ascii string representing the path name      */
+/*               times: times to be used in setting the modification */
+/*                      times of the specified file                  */
+/*                                                                   */
+/* returns     - int: 0 (success) or -1 (failure)                    */
+/*********************************************************************/
+
+int atoe_utimes(const char *path, const struct timeval *times)
+
+{
+   char *ep;
+
+   ep = a2e_string(path);
+
+   return utimes(ep, times);
+}
+
+/*********************************************************************/
+/* name        - atoe_chmod                                          */
+/*                                                                   */
+/* description - provide a version of the chmod() system function    */
+/*               that converts the specified path from an ascii to   */
+/*               an ebcdic string.                                   */
+/*                                                                   */
+/* parameters  - path: ascii string representing the path name       */
+/*               mode: bit set representing mode to be set on the    */
+/*                     specified file                                */
+/*                                                                   */
+/* returns     - int: 0 (success) or -1 (failure)                    */
+/*********************************************************************/
+
+int atoe_chmod(const char *path, mode_t mode)
+
+{
+   char *ep;
+
+   ep = a2e_string(path);
+
+   return chmod(ep, mode);
+}
+
+/*********************************************************************/
+/* name        - atoe_chdir                                          */
+/*                                                                   */
+/* description - provide a version of the chdir() system function    */
+/*               that converts the specified path from an ascii to   */
+/*               an ebcdic string.                                   */
+/*                                                                   */
+/* parameters  - path: ascii string representing the path name       */
+/*                                                                   */
+/* returns     - int: 0 (success) or -1 (failure)                    */
+/*********************************************************************/
+
+int atoe_chdir(const char *path)
+
+{
+   int  rc;
+   char *ep;
+
+   ep = a2e_string(path);
+
+   rc = chdir(ep);
+
+   free(ep);
+
+   return rc;
+}
+
+/*********************************************************************/
+/* name        - atoe_chown                                          */
+/*                                                                   */
+/* description - provide a version of the chown() system function    */
+/*               that converts the specified path from an ascii to   */
+/*               an ebcdic string.                                   */
+/*                                                                   */
+/* parameters  - path: ascii string representing the path name       */
+/*               uid: new user id (-1 for no change)                 */
+/*               gid: new group id (-1 for no change)                */
+/*                                                                   */
+/* returns     - int: 0 (success) or -1 (failure)                    */
+/*********************************************************************/
+
+int atoe_chown(const char *path, uid_t uid, gid_t gid)
+
+{
+   int  rc;
+   char *ep;
+
+   ep = a2e_string(path);
+
+   rc = chown(ep, uid, gid);
+
+   free(ep);
+
+   return rc;
+}
+
+/**************************************************************************
+ * name        - atoe_ftok
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+
+key_t atoe_ftok(const char *pathname, int id)
+
+{
+    key_t key;
+    char  *e;
+
+    e   = a2e_string((char *) pathname);
+    key = ftok(e, id);
+
+    free(e);
+
+    return key;
+}
+
+/**************************************************************************
+ * name        - etoa___osname                                 
+ * description -
+ * parameters  -
+ * returns     -
+ *************************************************************************/
+int
+etoa___osname(struct utsname *a) {
+    struct utsname e;
+    int rc = 0;
+
+    rc = __osname(&e);
+    if (rc == 0 && a != NULL) {
+        char *temp = NULL;
+        temp  = e2a_string(e.sysname);
+        strcpy(a->sysname,temp);
+    free(temp);
+        temp  = e2a_string(e.nodename);
+        strcpy(a->nodename,temp);
+    free(temp);
+        temp  = e2a_string(e.release);
+        strcpy(a->release,temp);
+    free(temp);
+        temp  = e2a_string(e.version);
+        strcpy(a->version,temp);
+    free(temp);
+        temp  = e2a_string(e.machine);
+        strcpy(a->machine,temp);
+    free(temp);
+    }
+
+    return rc;
+}
+
+
+/* END OF FILE */

Propchange: harmony/enhanced/classlib/trunk/modules/portlib/src/main/native/a2e/unix/atoe.c
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message