diff --git a/src/acc/acc.h b/src/acc/acc.h
index 90e8185c..81ec03ab 100644
--- a/src/acc/acc.h
+++ b/src/acc/acc.h
@@ -25,7 +25,7 @@
 #ifndef __ACC_H_INCLUDED
 #define __ACC_H_INCLUDED
 
-#define ACC_VERSION     20030831L
+#define ACC_VERSION     20030913L
 
 #if !defined(ACC_CONFIG_INCLUDE)
 #  define ACC_CONFIG_INCLUDE(file)     file
diff --git a/src/acc/acc_arch.h b/src/acc/acc_arch.h
index c3642216..15955766 100644
--- a/src/acc/acc_arch.h
+++ b/src/acc/acc_arch.h
@@ -33,6 +33,8 @@
  * Note that this list is not exhaustive - actually we only really care
  * about architectures which allows unaligned memory access at reasonable
  * speed (for the moment this means IA16 and IA32).
+ *
+ * FIXME: Need some hard facts on unaligned-timings for AMD64.
  */
 
 #if (ACC_OS_DOS16 || ACC_OS_OS216 || ACC_OS_WIN16)
diff --git a/src/acc/acc_chkr.ch b/src/acc/acc_chkr.ch
index c66a068e..07f57d87 100644
--- a/src/acc/acc_chkr.ch
+++ b/src/acc/acc_chkr.ch
@@ -47,7 +47,7 @@ static int __ACCCHKR_FUNCNAME(assert_fail)(const char* s, unsigned l)
 
 /* avoid inlining */
 static int __ACCCHKR_FUNCNAME(schedule_insns_bug)(void);
-static int __ACCCHKR_FUNCNAME(strength_reduce_bug)(int *);
+static int __ACCCHKR_FUNCNAME(strength_reduce_bug)(int*);
 
 
 /*************************************************************************
@@ -89,7 +89,7 @@ static int __ACCCHKR_FUNCNAME(schedule_insns_bug)(void)
 }
 
 
-static int __ACCCHKR_FUNCNAME(strength_reduce_bug)(int *x)
+static int __ACCCHKR_FUNCNAME(strength_reduce_bug)(int* x)
 {
 #if 0 && (ACC_CC_DMC || ACC_CC_SYMANTECC || ACC_CC_ZORTECHC)
     ACC_UNUSED(x); return 0;
diff --git a/src/acc/acc_lib.h b/src/acc/acc_lib.h
index ac69c208..0f53cbe1 100644
--- a/src/acc/acc_lib.h
+++ b/src/acc/acc_lib.h
@@ -25,6 +25,16 @@
 #endif
 
 
+#if !defined(__ACCLIB_CONST_CAST_RETURN)
+#if (ACC_CC_GNUC)
+#  define __ACCLIB_CONST_CAST_RETURN(type,var) \
+        { union { type a; const type b; } u; u.b = (var); return u.a; }
+#else
+#  define __ACCLIB_CONST_CAST_RETURN(type,var) return (type) (var);
+#endif
+#endif
+
+
 #if (ACC_OS_WIN64)
 #  define acclib_handle_t       acc_int64l_t
 #  define acclib_uhandle_t      acc_uint64l_t
@@ -43,7 +53,7 @@
 // huge pointer layer
 **************************************************************************/
 
-#if !defined(acc_hsize_t)
+#ifndef acc_hsize_t
 #if (ACC_HAVE_MM_HUGE_PTR)
 #  define acc_hsize_t  unsigned long
 #  define acc_hvoid_p  void __huge *
@@ -58,35 +68,51 @@
 #  define acc_hbyte_p  unsigned char *
 #endif
 #endif
+#ifndef ACC_FILE_P
+#define ACC_FILE_P FILE *
+#endif
 
 /* halloc */
-ACCLIB_EXTERN(acc_hvoid_p, acc_halloc) (acc_hsize_t size);
-ACCLIB_EXTERN(void, acc_hfree) (acc_hvoid_p p);
+ACCLIB_EXTERN(acc_hvoid_p, acc_halloc) (acc_hsize_t);
+ACCLIB_EXTERN(void, acc_hfree) (acc_hvoid_p);
 
 /* dos_alloc */
 #if (ACC_OS_DOS16 || ACC_OS_OS216)
-ACCLIB_EXTERN(void __far*, acc_dos_alloc) (unsigned long size);
-ACCLIB_EXTERN(int, acc_dos_free) (void __far* p);
+ACCLIB_EXTERN(void __far*, acc_dos_alloc) (unsigned long);
+ACCLIB_EXTERN(int, acc_dos_free) (void __far*);
 #endif
 
 /* string */
-ACCLIB_EXTERN(int, acc_hmemcmp) (const acc_hvoid_p s1, const acc_hvoid_p s2, acc_hsize_t len);
-ACCLIB_EXTERN(acc_hvoid_p, acc_hmemcpy) (acc_hvoid_p dest, const acc_hvoid_p src, acc_hsize_t len);
-ACCLIB_EXTERN(acc_hvoid_p, acc_hmemmove) (acc_hvoid_p dest, const acc_hvoid_p src, acc_hsize_t len);
-ACCLIB_EXTERN(acc_hvoid_p, acc_hmemset) (acc_hvoid_p s, int c, acc_hsize_t len);
+ACCLIB_EXTERN(int, acc_hmemcmp) (const acc_hvoid_p, const acc_hvoid_p, acc_hsize_t);
+ACCLIB_EXTERN(acc_hvoid_p, acc_hmemcpy) (acc_hvoid_p, const acc_hvoid_p, acc_hsize_t);
+ACCLIB_EXTERN(acc_hvoid_p, acc_hmemmove) (acc_hvoid_p, const acc_hvoid_p, acc_hsize_t);
+ACCLIB_EXTERN(acc_hvoid_p, acc_hmemset) (acc_hvoid_p, int, acc_hsize_t);
 
 /* string */
-ACCLIB_EXTERN(acc_hchar_p, acc_hstrpbrk) (const acc_hchar_p, const acc_hchar_p);
-ACCLIB_EXTERN(acc_hchar_p, acc_hstrsep) (acc_hchar_pp, const acc_hchar_p);
+ACCLIB_EXTERN(acc_hsize_t, acc_hstrlen) (const acc_hchar_p);
+ACCLIB_EXTERN(acc_hsize_t, acc_hstrlcpy) (acc_hchar_p, const acc_hchar_p, acc_hsize_t);
+ACCLIB_EXTERN(acc_hsize_t, acc_hstrlcat) (acc_hchar_p, const acc_hchar_p, acc_hsize_t);
+ACCLIB_EXTERN(int, acc_hstrscpy) (acc_hchar_p, const acc_hchar_p, acc_hsize_t);
+ACCLIB_EXTERN(int, acc_hstrscat) (acc_hchar_p, const acc_hchar_p, acc_hsize_t);
+ACCLIB_EXTERN(acc_hchar_p, acc_hstrchr)  (const acc_hchar_p, int);
+ACCLIB_EXTERN(acc_hchar_p, acc_hstrrchr) (const acc_hchar_p, int);
+ACCLIB_EXTERN(acc_hsize_t, acc_hstrspn)  (const acc_hchar_p, const acc_hchar_p);
+ACCLIB_EXTERN(acc_hsize_t, acc_hstrrspn) (const acc_hchar_p, const acc_hchar_p);
+ACCLIB_EXTERN(acc_hsize_t, acc_hstrcspn)  (const acc_hchar_p, const acc_hchar_p);
+ACCLIB_EXTERN(acc_hsize_t, acc_hstrrcspn) (const acc_hchar_p, const acc_hchar_p);
+ACCLIB_EXTERN(acc_hchar_p, acc_hstrpbrk)  (const acc_hchar_p, const acc_hchar_p);
+ACCLIB_EXTERN(acc_hchar_p, acc_hstrrpbrk) (const acc_hchar_p, const acc_hchar_p);
+ACCLIB_EXTERN(acc_hchar_p, acc_hstrsep)  (acc_hchar_pp, const acc_hchar_p);
+ACCLIB_EXTERN(acc_hchar_p, acc_hstrrsep) (acc_hchar_pp, const acc_hchar_p);
 
 /* stdio */
-ACCLIB_EXTERN(acc_hsize_t, acc_hfread) (FILE* fp, acc_hvoid_p buf, acc_hsize_t size);
-ACCLIB_EXTERN(acc_hsize_t, acc_hfwrite) (FILE* fp, const acc_hvoid_p buf, acc_hsize_t size);
+ACCLIB_EXTERN(acc_hsize_t, acc_hfread) (ACC_FILE_P, acc_hvoid_p, acc_hsize_t);
+ACCLIB_EXTERN(acc_hsize_t, acc_hfwrite) (ACC_FILE_P, const acc_hvoid_p, acc_hsize_t);
 
 /* io */
 #if (ACC_HAVE_MM_HUGE_PTR)
-ACCLIB_EXTERN(long, acc_hread) (int fd, acc_hvoid_p buf, long size);
-ACCLIB_EXTERN(long, acc_hwrite) (int fd, const acc_hvoid_p buf, long size);
+ACCLIB_EXTERN(long, acc_hread) (int, acc_hvoid_p, long);
+ACCLIB_EXTERN(long, acc_hwrite) (int, const acc_hvoid_p, long);
 #endif
 
 
@@ -170,19 +196,13 @@ typedef struct
 #endif
 } acc_dir_t;
 
-ACCLIB_EXTERN(int, acc_opendir)  (acc_dir_t* d, const char* path);
-ACCLIB_EXTERN(int, acc_readdir)  (acc_dir_t* d);
-ACCLIB_EXTERN(int, acc_closedir) (acc_dir_t* d);
+#ifndef acc_dir_p
+#define acc_dir_p acc_dir_t *
+#endif
 
-
-/*************************************************************************
-// wrap <fnmatch.h>
-**************************************************************************/
-
-
-/*************************************************************************
-// wrap <getopt.h>
-**************************************************************************/
+ACCLIB_EXTERN(int, acc_opendir)  (acc_dir_p, const char*);
+ACCLIB_EXTERN(int, acc_readdir)  (acc_dir_p);
+ACCLIB_EXTERN(int, acc_closedir) (acc_dir_p);
 
 
 /*************************************************************************
@@ -198,11 +218,11 @@ ACCLIB_EXTERN(int, acc_closedir) (acc_dir_t* d);
 #  define acc_alloca(x)     alloca((x))
 #endif
 
-ACCLIB_EXTERN(acclib_handle_t, acc_get_osfhandle) (int fd);
-ACCLIB_EXTERN(int,  acc_isatty) (int fd);
-ACCLIB_EXTERN(int,  acc_mkdir) (const char* name, unsigned mode);
-ACCLIB_EXTERN(int,  acc_response) (int* argc, char*** argv);
-ACCLIB_EXTERN(int,  acc_set_binmode) (int fd, int binary);
+ACCLIB_EXTERN(acclib_handle_t, acc_get_osfhandle) (int);
+ACCLIB_EXTERN(int,  acc_isatty) (int);
+ACCLIB_EXTERN(int,  acc_mkdir) (const char*, unsigned);
+ACCLIB_EXTERN(int,  acc_response) (int*, char***);
+ACCLIB_EXTERN(int,  acc_set_binmode) (int, int);
 
 ACCLIB_EXTERN(acc_int32l_t, acc_muldiv32) (acc_int32l_t, acc_int32l_t, acc_int32l_t);
 ACCLIB_EXTERN(acc_uint32l_t, acc_umuldiv32) (acc_uint32l_t, acc_uint32l_t, acc_uint32l_t);
@@ -235,10 +255,17 @@ typedef struct { /* all private */
 #endif
 } acc_uclock_t;
 
-ACCLIB_EXTERN(int, acc_uclock_open)  (acc_uclock_handle_t*);
-ACCLIB_EXTERN(int, acc_uclock_close) (acc_uclock_handle_t*);
-ACCLIB_EXTERN(void, acc_uclock_read) (acc_uclock_handle_t*, acc_uclock_t*);
-ACCLIB_EXTERN(double, acc_uclock_get_elapsed) (acc_uclock_handle_t*, const acc_uclock_t*, const acc_uclock_t*);
+#ifndef acc_uclock_handle_p
+#define acc_uclock_handle_p acc_uclock_handle_t *
+#endif
+#ifndef acc_uclock_p
+#define acc_uclock_p acc_uclock_t *
+#endif
+
+ACCLIB_EXTERN(int, acc_uclock_open)  (acc_uclock_handle_p);
+ACCLIB_EXTERN(int, acc_uclock_close) (acc_uclock_handle_p);
+ACCLIB_EXTERN(void, acc_uclock_read) (acc_uclock_handle_p, acc_uclock_p);
+ACCLIB_EXTERN(double, acc_uclock_get_elapsed) (acc_uclock_handle_p, const acc_uclock_p, const acc_uclock_p);
 
 
 /*************************************************************************
@@ -267,9 +294,9 @@ ACCLIB_EXTERN(void, acc_set_le64) (acc_hvoid_p, acc_uint64l_t);
 /* inline versions */
 #if (ACC_ARCH_IA32)
 #  define ACC_GET_LE16(p)       (* (const unsigned short *) (p))
-#  define ACC_GET_LE32(p)       (* (const unsigned int *) (p))
+#  define ACC_GET_LE32(p)       (* (const acc_uint32e_t *) (p))
 #  define ACC_SET_LE16(p,v)     (* (unsigned short *) (p) = (unsigned short) (v))
-#  define ACC_SET_LE32(p,v)     (* (unsigned int *) (p) = (unsigned int) (v))
+#  define ACC_SET_LE32(p,v)     (* (acc_uint32e_t *) (p) = (acc_uint32e_t) (v))
 #endif
 
 
@@ -280,34 +307,46 @@ ACCLIB_EXTERN(void, acc_set_le64) (acc_hvoid_p, acc_uint64l_t);
 typedef struct {
     acc_uint32l_t seed;
 } acc_rand31_t;
-ACCLIB_EXTERN(void, acc_srand31) (acc_rand31_t* r, acc_uint32l_t seed);
-ACCLIB_EXTERN(acc_uint32l_t, acc_rand31) (acc_rand31_t* r);
+#ifndef acc_rand31_p
+#define acc_rand31_p acc_rand31_t *
+#endif
+ACCLIB_EXTERN(void, acc_srand31) (acc_rand31_p, acc_uint32l_t);
+ACCLIB_EXTERN(acc_uint32l_t, acc_rand31) (acc_rand31_p);
 
 #if defined(acc_uint64l_t)
 typedef struct {
     acc_uint64l_t seed;
 } acc_rand48_t;
-ACCLIB_EXTERN(void, acc_srand48) (acc_rand48_t* r, acc_uint32l_t seed);
-ACCLIB_EXTERN(acc_uint32l_t, acc_rand48) (acc_rand48_t* r);
-ACCLIB_EXTERN(acc_uint32l_t, acc_rand48_r32) (acc_rand48_t* r);
+#ifndef acc_rand48_p
+#define acc_rand48_p acc_rand48_t *
+#endif
+ACCLIB_EXTERN(void, acc_srand48) (acc_rand48_p, acc_uint32l_t);
+ACCLIB_EXTERN(acc_uint32l_t, acc_rand48) (acc_rand48_p);
+ACCLIB_EXTERN(acc_uint32l_t, acc_rand48_r32) (acc_rand48_p);
 #endif
 
 #if defined(acc_uint64l_t)
 typedef struct {
     acc_uint64l_t seed;
 } acc_rand64_t;
-ACCLIB_EXTERN(void, acc_srand64) (acc_rand64_t* r, acc_uint64l_t seed);
-ACCLIB_EXTERN(acc_uint32l_t, acc_rand64) (acc_rand64_t* r);
-ACCLIB_EXTERN(acc_uint32l_t, acc_rand64_r32) (acc_rand64_t* r);
+#ifndef acc_rand64_p
+#define acc_rand64_p acc_rand64_t *
+#endif
+ACCLIB_EXTERN(void, acc_srand64) (acc_rand64_p, acc_uint64l_t);
+ACCLIB_EXTERN(acc_uint32l_t, acc_rand64) (acc_rand64_p);
+ACCLIB_EXTERN(acc_uint32l_t, acc_rand64_r32) (acc_rand64_p);
 #endif
 
 typedef struct {
     unsigned n;
     acc_uint32l_t s[624];
 } acc_randmt_t;
-ACCLIB_EXTERN(void, acc_srandmt) (acc_randmt_t* r, acc_uint32l_t seed);
-ACCLIB_EXTERN(acc_uint32l_t, acc_randmt) (acc_randmt_t* r);
-ACCLIB_EXTERN(acc_uint32l_t, acc_randmt_r32) (acc_randmt_t* r);
+#ifndef acc_randmt_p
+#define acc_randmt_p acc_randmt_t *
+#endif
+ACCLIB_EXTERN(void, acc_srandmt) (acc_randmt_p, acc_uint32l_t);
+ACCLIB_EXTERN(acc_uint32l_t, acc_randmt) (acc_randmt_p);
+ACCLIB_EXTERN(acc_uint32l_t, acc_randmt_r32) (acc_randmt_p);
 
 
 #endif /* already included */
diff --git a/src/acc/acc_mm.h b/src/acc/acc_mm.h
index 627d8253..64328523 100644
--- a/src/acc/acc_mm.h
+++ b/src/acc/acc_mm.h
@@ -81,7 +81,7 @@
 #elif (ACC_CC_TURBOC && (__TURBOC__ < 0x0295))
 #  undef ACC_HAVE_MM_HUGE_ARRAY
 #elif (ACC_CC_WATCOMC && (__WATCOMC__ >= 1200))
-   /* pointer arithmetics with __huge arrays seems broken in OpenWatcom 1.0 */
+   /* pointer arithmetics with __huge arrays seems broken in OpenWatcom 1.x */
 #  undef ACC_HAVE_MM_HUGE_ARRAY
 #endif
 
diff --git a/src/acc/acclib/bele.ch b/src/acc/acclib/bele.ch
index 1b6ba6ec..d5086f08 100644
--- a/src/acc/acclib/bele.ch
+++ b/src/acc/acclib/bele.ch
@@ -87,7 +87,7 @@ ACCLIB_PUBLIC(acc_uint32l_t, acc_get_le24) (const acc_hvoid_p p)
 ACCLIB_PUBLIC(acc_uint32l_t, acc_get_le32) (const acc_hvoid_p p)
 {
 #if (ACC_ARCH_IA32)
-    return (* (const unsigned int *) (p));
+    return (* (const acc_uint32e_t *) (p));
 #else
     const acc_hbyte_p b = (const acc_hbyte_p) p;
     return ((acc_uint32l_t)b[0]) | ((acc_uint32l_t)b[1] << 8) | ((acc_uint32l_t)b[2] << 16) | ((acc_uint32l_t)b[3] << 24);
@@ -118,7 +118,7 @@ ACCLIB_PUBLIC(void, acc_set_le24) (acc_hvoid_p p, acc_uint32l_t v)
 ACCLIB_PUBLIC(void, acc_set_le32) (acc_hvoid_p p, acc_uint32l_t v)
 {
 #if (ACC_ARCH_IA32)
-    (* (unsigned int *) (p) = (unsigned int) (v));
+    (* (acc_uint32e_t *) (p) = (acc_uint32e_t) (v));
 #else
     acc_hbyte_p b = (acc_hbyte_p) p;
     b[0] = (unsigned char) ((v >>  0) & 0xff);
@@ -135,12 +135,21 @@ ACCLIB_PUBLIC(void, acc_set_le32) (acc_hvoid_p p, acc_uint32l_t v)
 ACCLIB_PUBLIC(acc_uint64l_t, acc_get_be64) (const acc_hvoid_p p)
 {
     const acc_hbyte_p b = (const acc_hbyte_p) p;
-    return ((acc_uint64l_t)b[0]) | ((acc_uint64l_t)b[1] << 8) | ((acc_uint64l_t)b[2] << 16) | ((acc_uint64l_t)b[3] << 24) | ((acc_uint64l_t)b[4] << 32) | ((acc_uint64l_t)b[5] << 40) | ((acc_uint64l_t)b[6] << 48) | ((acc_uint64l_t)b[7] << 56);
+#if (SIZEOF_LONG >= 8) || (SIZEOF_SIZE_T >= 8)
+    return ((acc_uint64l_t)b[7]) | ((acc_uint64l_t)b[6] << 8) | ((acc_uint64l_t)b[5] << 16) | ((acc_uint64l_t)b[4] << 24) | ((acc_uint64l_t)b[3] << 32) | ((acc_uint64l_t)b[2] << 40) | ((acc_uint64l_t)b[1] << 48) | ((acc_uint64l_t)b[0] << 56);
+#else
+    acc_uint32l_t v0, v1;
+    v1 = ((acc_uint32l_t)b[3]) | ((acc_uint32l_t)b[2] << 8) | ((acc_uint32l_t)b[1] << 16) | ((acc_uint32l_t)b[0] << 24);
+    b += 4;
+    v0 = ((acc_uint32l_t)b[3]) | ((acc_uint32l_t)b[2] << 8) | ((acc_uint32l_t)b[1] << 16) | ((acc_uint32l_t)b[0] << 24);
+    return ((acc_uint64l_t)v0) | ((acc_uint64l_t)v1 << 32);
+#endif
 }
 
 ACCLIB_PUBLIC(void, acc_set_be64) (acc_hvoid_p p, acc_uint64l_t v)
 {
     acc_hbyte_p b = (acc_hbyte_p) p;
+#if (SIZEOF_LONG >= 8) || (SIZEOF_SIZE_T >= 8)
     b[7] = (unsigned char) ((v >>  0) & 0xff);
     b[6] = (unsigned char) ((v >>  8) & 0xff);
     b[5] = (unsigned char) ((v >> 16) & 0xff);
@@ -149,18 +158,47 @@ ACCLIB_PUBLIC(void, acc_set_be64) (acc_hvoid_p p, acc_uint64l_t v)
     b[2] = (unsigned char) ((v >> 40) & 0xff);
     b[1] = (unsigned char) ((v >> 48) & 0xff);
     b[0] = (unsigned char) ((v >> 56) & 0xff);
+#else
+    acc_uint32l_t x;
+    x = (acc_uint32l_t) (v >>  0);
+    b[7] = (unsigned char) ((x >>  0) & 0xff);
+    b[6] = (unsigned char) ((x >>  8) & 0xff);
+    b[5] = (unsigned char) ((x >> 16) & 0xff);
+    b[4] = (unsigned char) ((x >> 24) & 0xff);
+    x = (acc_uint32l_t) (v >> 32);
+    b[3] = (unsigned char) ((x >>  0) & 0xff);
+    b[2] = (unsigned char) ((x >>  8) & 0xff);
+    b[1] = (unsigned char) ((x >> 16) & 0xff);
+    b[0] = (unsigned char) ((x >> 24) & 0xff);
+#endif
 }
 
 
 
 ACCLIB_PUBLIC(acc_uint64l_t, acc_get_le64) (const acc_hvoid_p p)
 {
+#if (ACC_ARCH_IA32)
+    const acc_uint32e_t* b = (const acc_uint32e_t*) p;
+    return ((acc_uint64l_t)b[0]) | ((acc_uint64l_t)b[1] << 32);
+#elif (SIZEOF_LONG >= 8) || (SIZEOF_SIZE_T >= 8)
     const acc_hbyte_p b = (const acc_hbyte_p) p;
-    return ((acc_uint64l_t)b[7]) | ((acc_uint64l_t)b[6] << 8) | ((acc_uint64l_t)b[5] << 16) | ((acc_uint64l_t)b[4] << 24) | ((acc_uint64l_t)b[3] << 32) | ((acc_uint64l_t)b[2] << 40) | ((acc_uint64l_t)b[1] << 48) | ((acc_uint64l_t)b[0] << 56);
+    return ((acc_uint64l_t)b[0]) | ((acc_uint64l_t)b[1] << 8) | ((acc_uint64l_t)b[2] << 16) | ((acc_uint64l_t)b[3] << 24) | ((acc_uint64l_t)b[4] << 32) | ((acc_uint64l_t)b[5] << 40) | ((acc_uint64l_t)b[6] << 48) | ((acc_uint64l_t)b[7] << 56);
+#else
+    const acc_hbyte_p b = (const acc_hbyte_p) p;
+    acc_uint32l_t v0, v1;
+    v0 = ((acc_uint32l_t)b[0]) | ((acc_uint32l_t)b[1] << 8) | ((acc_uint32l_t)b[2] << 16) | ((acc_uint32l_t)b[3] << 24);
+    b += 4;
+    v1 = ((acc_uint32l_t)b[0]) | ((acc_uint32l_t)b[1] << 8) | ((acc_uint32l_t)b[2] << 16) | ((acc_uint32l_t)b[3] << 24);
+    return ((acc_uint64l_t)v0) | ((acc_uint64l_t)v1 << 32);
+#endif
 }
 
 ACCLIB_PUBLIC(void, acc_set_le64) (acc_hvoid_p p, acc_uint64l_t v)
 {
+#if (ACC_ARCH_IA32)
+    (((acc_uint32e_t *)(p))[0] = (acc_uint32e_t) (v >>  0));
+    (((acc_uint32e_t *)(p))[1] = (acc_uint32e_t) (v >> 32));
+#elif (SIZEOF_LONG >= 8) || (SIZEOF_SIZE_T >= 8)
     acc_hbyte_p b = (acc_hbyte_p) p;
     b[0] = (unsigned char) ((v >>  0) & 0xff);
     b[1] = (unsigned char) ((v >>  8) & 0xff);
@@ -170,6 +208,20 @@ ACCLIB_PUBLIC(void, acc_set_le64) (acc_hvoid_p p, acc_uint64l_t v)
     b[5] = (unsigned char) ((v >> 40) & 0xff);
     b[6] = (unsigned char) ((v >> 48) & 0xff);
     b[7] = (unsigned char) ((v >> 56) & 0xff);
+#else
+    acc_hbyte_p b = (acc_hbyte_p) p;
+    acc_uint32l_t x;
+    x = (acc_uint32l_t) (v >>  0);
+    b[0] = (unsigned char) ((x >>  0) & 0xff);
+    b[1] = (unsigned char) ((x >>  8) & 0xff);
+    b[2] = (unsigned char) ((x >> 16) & 0xff);
+    b[3] = (unsigned char) ((x >> 24) & 0xff);
+    x = (acc_uint32l_t) (v >> 32);
+    b[4] = (unsigned char) ((x >>  0) & 0xff);
+    b[5] = (unsigned char) ((x >>  8) & 0xff);
+    b[6] = (unsigned char) ((x >> 16) & 0xff);
+    b[7] = (unsigned char) ((x >> 24) & 0xff);
+#endif
 }
 
 
diff --git a/src/acc/acclib/hfread.ch b/src/acc/acclib/hfread.ch
index 25c359c5..6c2bbaef 100644
--- a/src/acc/acclib/hfread.ch
+++ b/src/acc/acclib/hfread.ch
@@ -22,7 +22,7 @@
 // huge pointer layer - stdio.h
 ************************************************************************/
 
-ACCLIB_PUBLIC(acc_hsize_t, acc_hfread) (FILE* fp, acc_hvoid_p buf, acc_hsize_t size)
+ACCLIB_PUBLIC(acc_hsize_t, acc_hfread) (ACC_FILE_P fp, acc_hvoid_p buf, acc_hsize_t size)
 {
 #if (ACC_HAVE_MM_HUGE_PTR)
 #if (ACC_MM_COMPACT || ACC_MM_LARGE || ACC_MM_HUGE)
@@ -62,7 +62,7 @@ ACCLIB_PUBLIC(acc_hsize_t, acc_hfread) (FILE* fp, acc_hvoid_p buf, acc_hsize_t s
 }
 
 
-ACCLIB_PUBLIC(acc_hsize_t, acc_hfwrite) (FILE* fp, const acc_hvoid_p buf, acc_hsize_t size)
+ACCLIB_PUBLIC(acc_hsize_t, acc_hfwrite) (ACC_FILE_P fp, const acc_hvoid_p buf, acc_hsize_t size)
 {
 #if (ACC_HAVE_MM_HUGE_PTR)
 #if (ACC_MM_COMPACT || ACC_MM_LARGE || ACC_MM_HUGE)
diff --git a/src/acc/acclib/hmemcpy.ch b/src/acc/acclib/hmemcpy.ch
index 32ff2307..8c491f01 100644
--- a/src/acc/acclib/hmemcpy.ch
+++ b/src/acc/acclib/hmemcpy.ch
@@ -19,7 +19,7 @@
 
 
 /***********************************************************************
-// huge pointer layer: memcmp, memcpy, memmove, memset
+// memcmp, memcpy, memmove, memset
 ************************************************************************/
 
 ACCLIB_PUBLIC(int, acc_hmemcmp) (const acc_hvoid_p s1, const acc_hvoid_p s2, acc_hsize_t len)
diff --git a/src/acc/acclib/hstring.ch b/src/acc/acclib/hstring.ch
index 333ef67c..681f3403 100644
--- a/src/acc/acclib/hstring.ch
+++ b/src/acc/acclib/hstring.ch
@@ -19,28 +19,230 @@
 
 
 /***********************************************************************
-//
+// strlen
+************************************************************************/
+
+ACCLIB_PUBLIC(acc_hsize_t, acc_hstrlen) (const acc_hchar_p s)
+{
+    /* TODO: which one is the fastest generic version? */
+#if 1
+    acc_hsize_t n = 0; while (*s) ++s, ++n; return n;
+#elif 1
+    acc_hsize_t n = 0; while (s[n]) ++n; return n;
+#else
+    const acc_hchar_p start = s; while (*s) ++s;
+    return (acc_hsize_t) (s - start);
+#endif
+}
+
+
+/***********************************************************************
+// strlcpy, strlcat
+************************************************************************/
+
+ACCLIB_PUBLIC(acc_hsize_t, acc_hstrlcpy) (acc_hchar_p d, const acc_hchar_p s, acc_hsize_t size)
+{
+    acc_hsize_t n = 0;
+    if (n != size) {
+        do {
+            if ((*d = *s) == 0) return n;
+            ++d; ++s; ++n;
+        } while (n != size);
+        d[-1] = 0;
+    }
+    while (*s) ++s, ++n;
+    return n;
+}
+
+
+ACCLIB_PUBLIC(acc_hsize_t, acc_hstrlcat) (acc_hchar_p d, const acc_hchar_p s, acc_hsize_t size)
+{
+    acc_hsize_t n = 0;
+    while (*d && n != size) ++d, ++n;
+    if (n != size) {
+        do {
+            if ((*d = *s) == 0) return n;
+            ++d; ++s; ++n;
+        } while (n != size);
+        d[-1] = 0;
+    }
+    while (*s) ++s, ++n;
+    return n;
+}
+
+
+/***********************************************************************
+// strscpy, strscat - same as strlcpy/strlcat, but just return -1
+// in case of failure
+************************************************************************/
+
+ACCLIB_PUBLIC(int, acc_hstrscpy) (acc_hchar_p d, const acc_hchar_p s, acc_hsize_t size)
+{
+    acc_hsize_t n = 0;
+    if (n != size) {
+        do {
+            if ((*d = *s) == 0) return 0;
+            ++d; ++s; ++n;
+        } while (n != size);
+        d[-1] = 0;
+    }
+    return -1;
+}
+
+
+ACCLIB_PUBLIC(int, acc_hstrscat) (acc_hchar_p d, const acc_hchar_p s, acc_hsize_t size)
+{
+    acc_hsize_t n = 0;
+    while (*d && n != size) ++d, ++n;
+    if (n != size) {
+        do {
+            if ((*d = *s) == 0) return 0;
+            ++d; ++s; ++n;
+        } while (n != size);
+        d[-1] = 0;
+    }
+    return -1;
+}
+
+
+/***********************************************************************
+// strchr, strrchr
+************************************************************************/
+
+ACCLIB_PUBLIC(acc_hchar_p, acc_hstrchr) (const acc_hchar_p s, int c)
+{
+    for ( ; *s; ++s) {
+        if (*s == (char) c)
+            __ACCLIB_CONST_CAST_RETURN(acc_hchar_p, s)
+    }
+    if ((char) c == 0) __ACCLIB_CONST_CAST_RETURN(acc_hchar_p, s)
+    return (acc_hchar_p)0;
+}
+
+
+ACCLIB_PUBLIC(acc_hchar_p, acc_hstrrchr) (const acc_hchar_p s, int c)
+{
+    const acc_hchar_p start = s;
+    while (*s) ++s;
+    if ((char) c == 0) __ACCLIB_CONST_CAST_RETURN(acc_hchar_p, s)
+    for (;;) {
+        if (s == start) break; --s;
+        if (*s == (char) c)
+            __ACCLIB_CONST_CAST_RETURN(acc_hchar_p, s)
+    }
+    return (acc_hchar_p)0;
+}
+
+
+/***********************************************************************
+// strspn, strrspn
+************************************************************************/
+
+ACCLIB_PUBLIC(acc_hsize_t, acc_hstrspn) (const acc_hchar_p s, const acc_hchar_p accept)
+{
+    acc_hsize_t n = 0;
+    for ( ; *s; ++s) {
+        const acc_hchar_p a;
+        for (a = accept; *a; ++a)
+            if (*s == *a)
+                goto acc_label_next;
+        break;
+    acc_label_next:
+        ++n;
+    }
+    return n;
+}
+
+
+ACCLIB_PUBLIC(acc_hsize_t, acc_hstrrspn) (const acc_hchar_p s, const acc_hchar_p accept)
+{
+    acc_hsize_t n = 0;
+    const acc_hchar_p start = s;
+    while (*s) ++s;
+    for (;;) {
+        const acc_hchar_p a;
+        if (s == start) break; --s;
+        for (a = accept; *a; ++a)
+            if (*s == *a)
+                goto acc_label_next;
+        break;
+    acc_label_next:
+        ++n;
+    }
+    return n;
+}
+
+
+/***********************************************************************
+// strcspn, strrcspn
+************************************************************************/
+
+ACCLIB_PUBLIC(acc_hsize_t, acc_hstrcspn) (const acc_hchar_p s, const acc_hchar_p reject)
+{
+    acc_hsize_t n = 0;
+    for ( ; *s; ++s, ++n) {
+        const acc_hchar_p r;
+        for (r = reject; *r; ++r)
+            if (*s == *r)
+                return n;
+    }
+    return n;
+}
+
+
+ACCLIB_PUBLIC(acc_hsize_t, acc_hstrrcspn) (const acc_hchar_p s, const acc_hchar_p reject)
+{
+    acc_hsize_t n = 0;
+    const acc_hchar_p start = s;
+    while (*s) ++s;
+    for ( ; ; ++n) {
+        const acc_hchar_p r;
+        if (s == start) break; --s;
+        for (r = reject; *r; ++r)
+            if (*s == *r)
+                return n;
+    }
+    return n;
+}
+
+
+/***********************************************************************
+// strpbrk, strrpbrk
 ************************************************************************/
 
 ACCLIB_PUBLIC(acc_hchar_p, acc_hstrpbrk) (const acc_hchar_p s, const acc_hchar_p accept)
 {
     for ( ; *s; ++s) {
-        const acc_hchar_p a = accept;
-        for ( ; *a; ++a) {
-            if (*s == *a) {
-#if (ACC_CC_GNUC)
-                union { acc_hchar_p p; const acc_hchar_p c; } u;
-                u.c = s; return u.p; /* UNCONST */
-#else
-                return (acc_hchar_p)s; /* UNCONST */
-#endif
-            }
+        const acc_hchar_p a;
+        for (a = accept; *a; ++a) {
+            if (*s == *a)
+                __ACCLIB_CONST_CAST_RETURN(acc_hchar_p, s)
         }
     }
     return (acc_hchar_p)0;
 }
 
 
+ACCLIB_PUBLIC(acc_hchar_p, acc_hstrrpbrk) (const acc_hchar_p s, const acc_hchar_p accept)
+{
+    const acc_hchar_p start = s;
+    while (*s) ++s;
+    for (;;) {
+        const acc_hchar_p a;
+        if (s == start) break; --s;
+        for (a = accept; *a; ++a) {
+            if (*s == *a)
+                __ACCLIB_CONST_CAST_RETURN(acc_hchar_p, s)
+        }
+    }
+    return (acc_hchar_p)0;
+}
+
+
+/***********************************************************************
+// strsep, strrsep
+************************************************************************/
+
 ACCLIB_PUBLIC(acc_hchar_p, acc_hstrsep) (acc_hchar_pp ss, const acc_hchar_p delim)
 {
     acc_hchar_p s = *ss;
@@ -53,6 +255,21 @@ ACCLIB_PUBLIC(acc_hchar_p, acc_hstrsep) (acc_hchar_pp ss, const acc_hchar_p deli
 }
 
 
+ACCLIB_PUBLIC(acc_hchar_p, acc_hstrrsep) (acc_hchar_pp ss, const acc_hchar_p delim)
+{
+    acc_hchar_p s = *ss;
+    if (s) {
+        acc_hchar_p p = __ACCLIB_FUNCNAME(acc_hstrrpbrk)(s, delim);
+        if (p) {
+            *p++ = 0;
+            return p;
+        }
+        *ss = (acc_hchar_p)0;
+    }
+    return s;
+}
+
+
 /*
 vi:ts=4:et
 */
diff --git a/src/acc/acclib/opendir.ch b/src/acc/acclib/opendir.ch
index 401cd209..7b1a4889 100644
--- a/src/acc/acclib/opendir.ch
+++ b/src/acc/acclib/opendir.ch
@@ -25,7 +25,7 @@
 #if !defined(__ACCLIB_USE_OPENDIR)
 #if (ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_TOS || ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64)
 
-static int __ACCLIB_FUNCNAME(acc_opendir_init)(acc_dir_t* f, const char* path, char* buf, size_t bufsize)
+static int __ACCLIB_FUNCNAME(acc_opendir_init)(acc_dir_p f, const char* path, char* buf, size_t bufsize)
 {
     size_t l; char* p;
     f->f_name[0] = 0; buf[0] = 0;
@@ -46,7 +46,7 @@ static int __ACCLIB_FUNCNAME(acc_opendir_init)(acc_dir_t* f, const char* path, c
 
 #if defined(__ACCLIB_USE_OPENDIR)
 
-ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path)
+ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_p f, const char* path)
 {
     f->u_dirp = opendir(path);
     if (!f->u_dirp)
@@ -54,7 +54,7 @@ ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path)
     return __ACCLIB_FUNCNAME(acc_readdir)(f);
 }
 
-ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_p f)
 {
     const struct dirent* dp;
     f->f_name[0] = 0;
@@ -75,7 +75,7 @@ ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f)
     return 0;
 }
 
-ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_p f)
 {
     int r = -1;
     if (f->u_dirp)
@@ -87,7 +87,7 @@ ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f)
 
 #elif (ACC_OS_WIN32 || ACC_OS_WIN64)
 
-ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path)
+ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_p f, const char* path)
 {
     WIN32_FIND_DATAA d;
     HANDLE h;
@@ -106,7 +106,7 @@ ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path)
     return 0;
 }
 
-ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_p f)
 {
     WIN32_FIND_DATAA d;
     f->f_name[0] = 0;
@@ -121,7 +121,7 @@ ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f)
     return 0;
 }
 
-ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_p f)
 {
     int r = -1;
     if (f->u_handle != -1)
@@ -133,7 +133,7 @@ ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f)
 
 #elif (ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_WIN16)
 
-ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path)
+ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_p f, const char* path)
 {
     char tmp[ACC_FN_PATH_MAX+1];
     int r;
@@ -153,7 +153,7 @@ ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path)
     return 0;
 }
 
-ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_p f)
 {
     int r;
     f->f_name[0] = 0;
@@ -171,7 +171,7 @@ ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f)
     return 0;
 }
 
-ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_p f)
 {
     ACC_COMPILE_TIME_ASSERT(sizeof(*f) == 44);
     f->f_name[0] = 0;
@@ -182,7 +182,7 @@ ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f)
 
 #elif (ACC_OS_TOS)
 
-ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path)
+ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_p f, const char* path)
 {
     char tmp[ACC_FN_PATH_MAX+1];
     int r;
@@ -200,7 +200,7 @@ ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path)
     return 0;
 }
 
-ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_p f)
 {
     int r;
     DTA* olddta;
@@ -216,7 +216,7 @@ ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f)
     return 0;
 }
 
-ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_p f)
 {
     ACC_COMPILE_TIME_ASSERT(sizeof(*f) == 44);
     f->f_name[0] = 0;
@@ -227,20 +227,20 @@ ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f)
 
 #else
 
-ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path)
+ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_p f, const char* path)
 {
     ACC_UNUSED(path);
     f->f_name[0] = 0;
     return -3;
 }
 
-ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_p f)
 {
     f->f_name[0] = 0;
     return -1;
 }
 
-ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f)
+ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_p f)
 {
     f->u_dirp = 0;
     return -1;
diff --git a/src/acc/acclib/rand.ch b/src/acc/acclib/rand.ch
index c447fe09..951e5449 100644
--- a/src/acc/acclib/rand.ch
+++ b/src/acc/acclib/rand.ch
@@ -22,12 +22,12 @@
 // some linear congruential pseudo random number generators (PRNG)
 **************************************************************************/
 
-ACCLIB_PUBLIC(void, acc_srand31) (acc_rand31_t* r, acc_uint32l_t seed)
+ACCLIB_PUBLIC(void, acc_srand31) (acc_rand31_p r, acc_uint32l_t seed)
 {
     r->seed = seed & ACC_UINT32L_C(0xffffffff);
 }
 
-ACCLIB_PUBLIC(acc_uint32l_t, acc_rand31) (acc_rand31_t* r)
+ACCLIB_PUBLIC(acc_uint32l_t, acc_rand31) (acc_rand31_p r)
 {
     r->seed = r->seed * ACC_UINT32L_C(1103515245) + 12345;
     r->seed &= ACC_UINT32L_C(0x7fffffff);
@@ -37,20 +37,20 @@ ACCLIB_PUBLIC(acc_uint32l_t, acc_rand31) (acc_rand31_t* r)
 
 #if defined(acc_uint64l_t)
 
-ACCLIB_PUBLIC(void, acc_srand48) (acc_rand48_t* r, acc_uint32l_t seed)
+ACCLIB_PUBLIC(void, acc_srand48) (acc_rand48_p r, acc_uint32l_t seed)
 {
     r->seed = seed & ACC_UINT32L_C(0xffffffff);
     r->seed <<= 16; r->seed |= 0x330e;
 }
 
-ACCLIB_PUBLIC(acc_uint32l_t, acc_rand48) (acc_rand48_t* r)
+ACCLIB_PUBLIC(acc_uint32l_t, acc_rand48) (acc_rand48_p r)
 {
     r->seed = r->seed * ACC_UINT64L_C(25214903917) + 11;
     r->seed &= ACC_UINT64L_C(0xffffffffffff);
     return (acc_uint32l_t) (r->seed >> 17);
 }
 
-ACCLIB_PUBLIC(acc_uint32l_t, acc_rand48_r32) (acc_rand48_t* r)
+ACCLIB_PUBLIC(acc_uint32l_t, acc_rand48_r32) (acc_rand48_p r)
 {
     r->seed = r->seed * ACC_UINT64L_C(25214903917) + 11;
     r->seed &= ACC_UINT64L_C(0xffffffffffff);
@@ -62,19 +62,19 @@ ACCLIB_PUBLIC(acc_uint32l_t, acc_rand48_r32) (acc_rand48_t* r)
 
 #if defined(acc_uint64l_t)
 
-ACCLIB_PUBLIC(void, acc_srand64) (acc_rand64_t* r, acc_uint64l_t seed)
+ACCLIB_PUBLIC(void, acc_srand64) (acc_rand64_p r, acc_uint64l_t seed)
 {
     r->seed = seed & ACC_UINT64L_C(0xffffffffffffffff);
 }
 
-ACCLIB_PUBLIC(acc_uint32l_t, acc_rand64) (acc_rand64_t* r)
+ACCLIB_PUBLIC(acc_uint32l_t, acc_rand64) (acc_rand64_p r)
 {
     r->seed = r->seed * ACC_UINT64L_C(6364136223846793005) + 1;
     r->seed &= ACC_UINT64L_C(0xffffffffffffffff);
     return (acc_uint32l_t) (r->seed >> 33);
 }
 
-ACCLIB_PUBLIC(acc_uint32l_t, acc_rand64_r32) (acc_rand64_t* r)
+ACCLIB_PUBLIC(acc_uint32l_t, acc_rand64_r32) (acc_rand64_p r)
 {
     r->seed = r->seed * ACC_UINT64L_C(6364136223846793005) + 1;
     r->seed &= ACC_UINT64L_C(0xffffffffffffffff);
@@ -88,7 +88,7 @@ ACCLIB_PUBLIC(acc_uint32l_t, acc_rand64_r32) (acc_rand64_t* r)
 // mersenne twister PRNG
 **************************************************************************/
 
-ACCLIB_PUBLIC(void, acc_srandmt) (acc_randmt_t* r, acc_uint32l_t seed)
+ACCLIB_PUBLIC(void, acc_srandmt) (acc_randmt_p r, acc_uint32l_t seed)
 {
     unsigned i = 0;
     do {
@@ -99,12 +99,12 @@ ACCLIB_PUBLIC(void, acc_srandmt) (acc_randmt_t* r, acc_uint32l_t seed)
     r->n = i;
 }
 
-ACCLIB_PUBLIC(acc_uint32l_t, acc_randmt) (acc_randmt_t* r)
+ACCLIB_PUBLIC(acc_uint32l_t, acc_randmt) (acc_randmt_p r)
 {
     return (__ACCLIB_FUNCNAME(acc_randmt_r32)(r)) >> 1;
 }
 
-ACCLIB_PUBLIC(acc_uint32l_t, acc_randmt_r32) (acc_randmt_t* r)
+ACCLIB_PUBLIC(acc_uint32l_t, acc_randmt_r32) (acc_randmt_p r)
 {
     acc_uint32l_t v;
     if (r->n == 624) {
diff --git a/src/acc/acclib/uclock.ch b/src/acc/acclib/uclock.ch
index c3e0948f..ed94068d 100644
--- a/src/acc/acclib/uclock.ch
+++ b/src/acc/acclib/uclock.ch
@@ -26,7 +26,7 @@
 
 #if (ACC_OS_DOS16 || ACC_OS_WIN16)
 #elif (ACC_OS_DOS32 && defined(__DJGPP__))
-#elif (ACC_OS_DOS32 || ACC_OS_OS2 || ACC_OS_OS216)
+#elif (ACC_OS_DOS32 || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_TOS)
 #  define __ACCLIB_UCLOCK_USE_CLOCK 1
 #elif (ACC_H_WINDOWS_H) && (ACC_OS_WIN32 || ACC_OS_WIN64)
 #  if (ACC_CC_DMC || ACC_CC_LCC)
@@ -45,12 +45,20 @@
 #  endif
 #endif
 
+#if (__ACCLIB_UCLOCK_USE_CLOCK) && !defined(CLOCKS_PER_SEC)
+#  if defined(CLK_TCK)
+#    define CLOCKS_PER_SEC CLK_TCK
+#  else
+#    undef __ACCLIB_UCLOCK_USE_CLOCK
+#  endif
+#endif
+
 
 /*************************************************************************
 //
 **************************************************************************/
 
-ACCLIB_PUBLIC(int, acc_uclock_open) (acc_uclock_handle_t* h)
+ACCLIB_PUBLIC(int, acc_uclock_open) (acc_uclock_handle_p h)
 {
     acc_uclock_t c;
     int i;
@@ -66,6 +74,7 @@ ACCLIB_PUBLIC(int, acc_uclock_open) (acc_uclock_handle_t* h)
     }
 #endif
     h->h = 1;
+    h->mode = 0;
 
     /* warm up */
     i = 100;
@@ -80,15 +89,15 @@ ACCLIB_PUBLIC(int, acc_uclock_open) (acc_uclock_handle_t* h)
 }
 
 
-ACCLIB_PUBLIC(int, acc_uclock_close) (acc_uclock_handle_t* h)
+ACCLIB_PUBLIC(int, acc_uclock_close) (acc_uclock_handle_p h)
 {
     h->h = 0;
-    h->mode = 0;
+    h->mode = -1;
     return 0;
 }
 
 
-ACCLIB_PUBLIC(void, acc_uclock_read) (acc_uclock_handle_t* h, acc_uclock_t* c)
+ACCLIB_PUBLIC(void, acc_uclock_read) (acc_uclock_handle_p h, acc_uclock_p c)
 {
 #if (__ACCLIB_UCLOCK_USE_QPC)
     if (h->qpf > 0.0) {
@@ -135,12 +144,14 @@ ACCLIB_PUBLIC(void, acc_uclock_read) (acc_uclock_handle_t* h, acc_uclock_t* c)
 }
 
 
-ACCLIB_PUBLIC(double, acc_uclock_get_elapsed) (acc_uclock_handle_t* h, const acc_uclock_t* start, const acc_uclock_t* stop)
+ACCLIB_PUBLIC(double, acc_uclock_get_elapsed) (acc_uclock_handle_p h, const acc_uclock_p start, const acc_uclock_p stop)
 {
     double d;
 
-    if (!h->h)
+    if (!h->h) {
+        h->mode = -1;
         return 0.0;
+    }
 
 #if (__ACCLIB_UCLOCK_USE_QPC)
     if (h->qpf > 0.0) {