/* ACC -- Automatic Compiler Configuration Copyright (C) 1996-2003 Markus Franz Xaver Johannes Oberhumer All Rights Reserved. This software is a copyrighted work licensed under the terms of the GNU General Public License. Please consult the file "ACC_LICENSE" for details. Markus F.X.J. Oberhumer http://www.oberhumer.com/ */ #if !defined(ACC_VERSION) # if defined ACC_CONFIG_INCLUDE # include ACC_CONFIG_INCLUDE("acc.h") # else # include "acc.h" # endif #endif #ifndef __ACC_INCD_H_INCLUDED # include ACC_CONFIG_INCLUDE("acc_incd.h") #endif #ifndef __ACC_INCE_H_INCLUDED # include ACC_CONFIG_INCLUDE("acc_ince.h") #endif #ifndef __ACC_INCI_H_INCLUDED # include ACC_CONFIG_INCLUDE("acc_inci.h") #endif #ifndef __ACC_LIB_H_INCLUDED # include ACC_CONFIG_INCLUDE("acc_lib.h") #endif #if !defined(ACCLIB_PUBLIC) # define ACCLIB_PUBLIC(r,f) r __ACCLIB_FUNCNAME(f) #endif /*********************************************************************** // halloc ************************************************************************/ ACCLIB_PUBLIC(acc_hvoid_p, acc_halloc) (acc_hsize_t size) { acc_hvoid_p p = 0; if (size <= 0) return p; #if 0 && defined(__palmos__) p = MemPtrNew(size); #elif !defined(ACC_HAVE_MM_HUGE_PTR) if (size < (size_t) -1) p = malloc((size_t) size); #else #if (ACC_CC_MSC && _MSC_VER >= 700) p = _halloc(size, 1); #elif (ACC_CC_MSC || ACC_CC_WATCOMC) p = halloc(size, 1); #elif (ACC_CC_DMC || ACC_CC_SYMANTECC || ACC_CC_ZORTECHC) p = farmalloc(size); #elif (ACC_CC_BORLANDC || ACC_CC_TURBOC) p = farmalloc(size); #elif defined(ACC_CC_AZTECC) p = lmalloc(size); #else if (size < (size_t) -1) p = malloc((size_t) size); #endif #endif return p; } ACCLIB_PUBLIC(int, acc_hfree) (acc_hvoid_p p) { int r = 0; if (!p) return r; #if 0 && defined(__palmos__) r = MemPtrFree(p); #elif !defined(ACC_HAVE_MM_HUGE_PTR) free(p); #else #if (ACC_CC_MSC && _MSC_VER >= 700) _hfree(p); #elif (ACC_CC_MSC || ACC_CC_WATCOMC) hfree(p); #elif (ACC_CC_DMC || ACC_CC_SYMANTECC || ACC_CC_ZORTECHC) farfree((void __far*) p); #elif (ACC_CC_BORLANDC || ACC_CC_TURBOC) farfree((void __far*) p); #elif defined(ACC_CC_AZTECC) lfree(p); #else free(p); #endif #endif return r; } /*********************************************************************** // dos_alloc ************************************************************************/ #if (ACC_OS_DOS16) #if !defined(ACC_CC_AZTECC) ACCLIB_PUBLIC(void __far*, acc_dos_alloc) (unsigned long size) { void __far* p = 0; union REGS ri, ro; if ((long)size <= 0) return p; size = (size + 15) >> 4; if (size > 0xffffu) return p; ri.x.ax = 0x4800; ri.x.bx = (unsigned short) size; ro.x.cflag = 1; int86(0x21, &ri, &ro); if ((ro.x.cflag & 1) == 0) /* if carry flag not set */ p = (void __far*) ACC_MK_FP(ro.x.ax, 0); return p; } ACCLIB_PUBLIC(int, acc_dos_free) (void __far* p) { union REGS ri, ro; struct SREGS rs; if (!p) return 0; if (ACC_FP_OFF(p) != 0) return -1; segread(&rs); ri.x.ax = 0x4900; rs.es = ACC_FP_SEG(p); ro.x.cflag = 1; int86x(0x21, &ri, &ro, &rs); if (ro.x.cflag & 1) /* if carry flag set */ return -1; return 0; } #endif #endif #if (ACC_OS_OS216) ACCLIB_PUBLIC(void __far*, acc_dos_alloc) (unsigned long size) { void __far* p = 0; unsigned short sel = 0; unsigned long pmask = 0xffffu >> ACC_MM_AHSHIFT; /* 8191 */ if ((long)size <= 0) return p; size = (size + pmask) &~ pmask; /* align up to paragraph size */ if (DosAllocHuge((unsigned short)(size >> 16), (unsigned short)size, &sel, 0, 0) == 0) p = (void __far*) ACC_MK_FP(sel, 0); return p; } ACCLIB_PUBLIC(int, acc_dos_free) (void __far* p) { if (!p) return 0; if (ACC_FP_OFF(p) != 0) return -1; if (DosFreeSeg(ACC_FP_SEG(p)) != 0) return -1; return 0; } #endif /*********************************************************************** // huge pointer layer - string.h ************************************************************************/ ACCLIB_PUBLIC(int, acc_hmemcmp) (const acc_hvoid_p s1, const acc_hvoid_p s2, acc_hsize_t len) { #if (ACC_HAVE_MM_HUGE_PTR) || !defined(HAVE_MEMCMP) const acc_hbyte_p p1 = (const acc_hbyte_p) s1; const acc_hbyte_p p2 = (const acc_hbyte_p) s2; if (len > 0) do { int d = *p1 - *p2; if (d != 0) return d; p1++; p2++; } while (--len > 0); return 0; #else return memcmp(s1, s2, len); #endif } ACCLIB_PUBLIC(acc_hvoid_p, acc_hmemcpy) (acc_hvoid_p dest, const acc_hvoid_p src, acc_hsize_t len) { #if (ACC_HAVE_MM_HUGE_PTR) || !defined(HAVE_MEMCPY) acc_hbyte_p p1 = (acc_hbyte_p) dest; const acc_hbyte_p p2 = (const acc_hbyte_p) src; if (len <= 0 || p1 == p2) return dest; do *p1++ = *p2++; while (--len > 0); return dest; #else return memcpy(dest, src, len); #endif } ACCLIB_PUBLIC(acc_hvoid_p, acc_hmemmove) (acc_hvoid_p dest, const acc_hvoid_p src, acc_hsize_t len) { #if (ACC_HAVE_MM_HUGE_PTR) || !defined(HAVE_MEMMOVE) acc_hbyte_p p1 = (acc_hbyte_p) dest; const acc_hbyte_p p2 = (const acc_hbyte_p) src; if (len <= 0 || p1 == p2) return dest; if (p1 < p2) { do *p1++ = *p2++; while (--len > 0); } else { p1 += len; p2 += len; do *--p1 = *--p2; while (--len > 0); } return dest; #else return memmove(dest, src, len); #endif } ACCLIB_PUBLIC(acc_hvoid_p, acc_hmemset) (acc_hvoid_p s, int c, acc_hsize_t len) { #if (ACC_HAVE_MM_HUGE_PTR) || !defined(HAVE_MEMSET) acc_hbyte_p p = (acc_hbyte_p) s; if (len > 0) do *p++ = (unsigned char) c; while (--len > 0); return s; #else return memset(s, c, len); #endif } /*********************************************************************** // huge pointer layer - stdio.h ************************************************************************/ ACCLIB_PUBLIC(acc_hsize_t, acc_hfread) (FILE* 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) acc_hbyte_p b = (acc_hbyte_p) buf; acc_hsize_t l = 0; while (l < size) { size_t n; n = ACC_FP_OFF(b); n = (n <= 1) ? 0x8000u : (0u - n); if ((acc_hsize_t) n > size - l) n = (size_t) (size - l); n = fread((void __far*)b, 1, n, fp); if (n == 0) break; b += n; l += n; } return l; #else unsigned char tmp[512]; acc_hsize_t l = 0; while (l < size) { size_t n = size - l > sizeof(tmp) ? sizeof(tmp) : (size_t) (size - l); n = fread(tmp, 1, n, fp); if (n == 0) break; acc_hmemcpy((acc_hbyte_p)buf + l, tmp, (acc_hsize_t)n); l += n; } return l; #endif #else return fread(buf, 1, size, fp); #endif } ACCLIB_PUBLIC(acc_hsize_t, acc_hfwrite) (FILE* 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) const acc_hbyte_p b = (const acc_hbyte_p) buf; acc_hsize_t l = 0; while (l < size) { size_t n; n = ACC_FP_OFF(b); n = (n <= 1) ? 0x8000u : (0u - n); if ((acc_hsize_t) n > size - l) n = (size_t) (size - l); n = fwrite((void __far*)b, 1, n, fp); if (n == 0) break; b += n; l += n; } return l; #else unsigned char tmp[512]; acc_hsize_t l = 0; while (l < size) { size_t n = size - l > sizeof(tmp) ? sizeof(tmp) : (size_t) (size - l); acc_hmemcpy(tmp, (const acc_hbyte_p)buf + l, (acc_hsize_t)n); n = fwrite(tmp, 1, n, fp); if (n == 0) break; l += n; } return l; #endif #else return fwrite(buf, 1, size, fp); #endif } /*********************************************************************** // huge pointer layer - read/write ************************************************************************/ #if (ACC_HAVE_MM_HUGE_PTR) ACCLIB_PUBLIC(long, acc_hread) (int fd, acc_hvoid_p buf, long size) { #if (ACC_MM_COMPACT || ACC_MM_LARGE || ACC_MM_HUGE) acc_hbyte_p b = (acc_hbyte_p) buf; long l = 0; while (l < size) { unsigned n; n = ACC_FP_OFF(b); n = (n <= 1) ? 0x8000u : (0u - n); if ((long) n > size - l) n = (unsigned) (size - l); n = read(fd, (void __far*)b, n); if (n == 0) break; if (n == (unsigned)-1) return -1; b += n; l += n; } return l; #else unsigned char tmp[512]; long l = 0; while (l < size) { int n = size - l > (long)sizeof(tmp) ? (int) sizeof(tmp) : (int) (size - l); n = read(fd, tmp, n); if (n == 0) break; if (n < 0) return -1; acc_hmemcpy((acc_hbyte_p)buf + l, tmp, (acc_hsize_t)n); l += n; } return l; #endif } ACCLIB_PUBLIC(long, acc_hwrite) (int fd, const acc_hvoid_p buf, long size) { #if (ACC_MM_COMPACT || ACC_MM_LARGE || ACC_MM_HUGE) const acc_hbyte_p b = (const acc_hbyte_p) buf; long l = 0; while (l < size) { unsigned n; n = ACC_FP_OFF(b); n = (n <= 1) ? 0x8000u : (0u - n); if ((long) n > size - l) n = (unsigned) (size - l); n = write(fd, (void __far*)b, n); if (n == 0) break; if (n == (unsigned)-1) return -1; b += n; l += n; } return l; #else unsigned char tmp[512]; long l = 0; while (l < size) { int n = size - l > (long)sizeof(tmp) ? (int) sizeof(tmp) : (int) (size - l); acc_hmemcpy(tmp, (const acc_hbyte_p)buf + l, (acc_hsize_t)n); n = write(fd, tmp, n); if (n == 0) break; if (n < 0) return -1; l += n; } return l; #endif } #endif /************************************************************************* // wrap **************************************************************************/ #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) { size_t l; char* p; f->f_name[0] = 0; buf[0] = 0; l = strlen(path); if (l == 0 || bufsize <= 4 || l >= bufsize - 4) return -1; strcpy(buf, path); p = buf + l; if (p[-1] == ':' || p[-1] == '\\' || p[-1] == '/') strcpy(p, "*.*"); else strcpy(p, "\\*.*"); return 0; } #endif #endif #if defined(__ACCLIB_USE_OPENDIR) ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path) { f->u_dirp = opendir(path); if (!f->u_dirp) return -2; return __ACCLIB_FUNCNAME(acc_readdir)(f); } ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f) { const struct dirent* dp; f->f_name[0] = 0; if (!f->u_dirp) return -1; dp = (const struct dirent*) readdir((DIR*) f->u_dirp); if (!dp) return -1; if (!dp->d_name[0] || strlen(dp->d_name) >= sizeof(f->f_name)) return -1; strcpy(f->f_name, dp->d_name); #if (ACC_CC_WATCOMC) ACC_COMPILE_TIME_ASSERT(sizeof(f->f_name) >= sizeof(dp->d_name)) f->f_time = dp->d_time; f->f_date = dp->d_date; f->f_size = dp->d_size; #endif return 0; } ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f) { int r = -1; if (f->u_dirp) r = closedir((DIR*) f->u_dirp); f->u_dirp = 0; return r; } #elif (ACC_OS_WIN32 || ACC_OS_WIN64) ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path) { WIN32_FIND_DATAA d; HANDLE h; if (__ACCLIB_FUNCNAME(acc_opendir_init)(f, path, f->f_name, sizeof(f->f_name)) != 0) return -1; h = FindFirstFileA(f->f_name, &d); f->f_name[0] = 0; if ((f->u_handle = (long) h) == -1) return -1; if (!d.cFileName[0] || strlen(d.cFileName) >= sizeof(f->f_name)) return -1; strcpy(f->f_name, d.cFileName); f->f_attr = d.dwFileAttributes; f->f_size_high = d.nFileSizeHigh; f->f_size_low = d.nFileSizeLow; return 0; } ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f) { WIN32_FIND_DATAA d; f->f_name[0] = 0; if (f->u_handle == -1 || FindNextFileA((HANDLE) f->u_handle, &d) == 0) return -1; if (!d.cFileName[0] || strlen(d.cFileName) >= sizeof(f->f_name)) return -1; strcpy(f->f_name, d.cFileName); f->f_attr = d.dwFileAttributes; f->f_size_high = d.nFileSizeHigh; f->f_size_low = d.nFileSizeLow; return 0; } ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f) { int r = -1; if (f->u_handle != -1) r = FindClose((HANDLE) f->u_handle); f->u_handle = -1; return r; } #elif (ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_WIN16) ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path) { char tmp[ACC_FN_PATH_MAX+1]; int r; f->u_dirp = 0; if (__ACCLIB_FUNCNAME(acc_opendir_init)(f, path, tmp, sizeof(tmp)) != 0) return -1; #if (ACC_CC_AZTECC || ACC_CC_PACIFICC) r = -1; #elif (ACC_CC_BORLANDC || ACC_CC_TURBOC) r = findfirst(tmp, (struct ffblk*) f->u_dta, FA_HIDDEN|FA_SYSTEM|FA_RDONLY|FA_DIREC); #else r = _dos_findfirst(tmp, _A_HIDDEN|_A_SYSTEM|_A_RDONLY|_A_SUBDIR, (struct find_t*) f->u_dta); #endif if (r != 0) f->f_name[0] = 0; if (!f->f_name[0]) return -1; f->u_dirp = 1; return 0; } ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f) { int r; f->f_name[0] = 0; if (!f->u_dirp) return -1; #if (ACC_CC_AZTECC || ACC_CC_PACIFICC) r = -1; #elif (ACC_CC_BORLANDC || ACC_CC_TURBOC) r = findnext((struct ffblk*) f->u_dta); #else r = _dos_findnext((struct find_t*) f->u_dta); #endif if (r != 0) f->f_name[0] = 0; if (!f->f_name[0]) return -1; return 0; } ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f) { ACC_COMPILE_TIME_ASSERT(sizeof(*f) == 44); f->f_name[0] = 0; f->u_dirp = 0; return 0; } #elif (ACC_OS_TOS) ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path) { char tmp[ACC_FN_PATH_MAX+1]; int r; DTA* olddta; f->u_dirp = 0; if (__ACCLIB_FUNCNAME(acc_opendir_init)(f, path, tmp, sizeof(tmp)) != 0) return -1; olddta = Fgetdta(); Fsetdta((DTA*) f->u_dta); r = Fsfirst(tmp, FA_HIDDEN|FA_SYSTEM|FA_READONLY|FA_SUBDIR); Fsetdta(olddta); if (r != 0) f->f_name[0] = 0; if (!f->f_name[0]) return -1; f->u_dirp = 1; return 0; } ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f) { int r; DTA* olddta; f->f_name[0] = 0; if (!f->u_dirp) return -1; olddta = Fgetdta(); Fsetdta((DTA*) f->u_dta); r = Fsnext(); Fsetdta(olddta); if (r != 0) f->f_name[0] = 0; if (!f->f_name[0]) return -1; return 0; } ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f) { ACC_COMPILE_TIME_ASSERT(sizeof(*f) == 44); f->f_name[0] = 0; f->u_dirp = 0; return 0; } #else ACCLIB_PUBLIC(int, acc_opendir) (acc_dir_t* f, const char* path) { ACC_UNUSED(path); f->f_name[0] = 0; return -3; } ACCLIB_PUBLIC(int, acc_readdir) (acc_dir_t* f) { f->f_name[0] = 0; return -1; } ACCLIB_PUBLIC(int, acc_closedir) (acc_dir_t* f) { f->u_dirp = 0; return -1; } #endif /************************************************************************* // wrap **************************************************************************/ /************************************************************************* // wrap **************************************************************************/ /************************************************************************* // wrap misc **************************************************************************/ ACCLIB_PUBLIC(long, acc_get_osfhandle) (int fd) { if (fd < 0) return -1; #if (ACC_OS_CYGWIN) return get_osfhandle(fd); #elif (ACC_OS_EMX && defined(__RSXNT__)) /* FIXME */ return -1; #elif (ACC_OS_WIN32 || ACC_OS_WIN64) # if (ACC_CC_WATCOMC && __WATCOMC__ < 1100) /* FIXME */ return -1; # else return _get_osfhandle(fd); # endif #else return fd; #endif } ACCLIB_PUBLIC(int, acc_set_binmode) (int fd, int binary) { #if (ACC_OS_TOS && defined(__MINT__)) int old_binary; FILE* f; if (fd == STDIN_FILENO) f = stdin; else if (fd == STDOUT_FILENO) f = stdout; else if (fd == STDERR_FILENO) f = stderr; else return -1; old_binary = f->__mode.__binary; __set_binmode(f, binary ? 1 : 0); return old_binary ? 1 : 0; #elif (ACC_OS_TOS) ACC_UNUSED(fd); ACC_UNUSED(binary); return -1; #elif (ACC_OS_DOS16 && (ACC_CC_AZTECC || ACC_CC_PACIFICC)) ACC_UNUSED(fd); ACC_UNUSED(binary); return -1; #elif defined(__DJGPP__) int r; unsigned old_flags = __djgpp_hwint_flags; ACC_COMPILE_TIME_ASSERT(O_BINARY > 0) ACC_COMPILE_TIME_ASSERT(O_TEXT > 0) if (fd < 0) return -1; r = setmode(fd, binary ? O_BINARY : O_TEXT); if ((old_flags & 1u) != (__djgpp_hwint_flags & 1u)) __djgpp_set_ctrl_c(!(old_flags & 1)); if (r == -1) return -1; return (r & O_TEXT) ? 0 : 1; #elif (ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64 || ACC_OS_CYGWIN || ACC_OS_EMX) int r; #if !defined(ACC_CC_ZORTECHC) ACC_COMPILE_TIME_ASSERT(O_BINARY > 0) #endif ACC_COMPILE_TIME_ASSERT(O_TEXT > 0) if (fd < 0) return -1; r = setmode(fd, binary ? O_BINARY : O_TEXT); if (r == -1) return -1; return (r & O_TEXT) ? 0 : 1; #else if (fd < 0) return -1; ACC_UNUSED(binary); return 1; #endif } ACCLIB_PUBLIC(int, acc_isatty) (int fd) { /* work around library implementations that think that * any character device like `nul' is a tty */ if (fd < 0) return 0; #if (ACC_OS_DOS16 && !defined(ACC_CC_AZTECC)) { union REGS ri, ro; ri.x.ax = 0x4400; ri.x.bx = fd; ro.x.ax = 0; ro.x.cflag = 1; int86(0x21, &ri, &ro); if ((ro.x.cflag & 1) == 0) /* if carry flag not set */ if ((ro.x.ax & 0x83) != 0x83) return 0; } #elif (ACC_H_WINDOWS_H) { long h = __ACCLIB_FUNCNAME(acc_get_osfhandle)(fd); if (h != -1) { DWORD d = 0; int r = GetConsoleMode((HANDLE)h, &d); if (!r) return 0; /* GetConsoleMode failed -> not a tty */ } } #endif return (isatty(fd)) ? 1 : 0; } ACCLIB_PUBLIC(int, acc_mkdir) (const char* name, unsigned mode) { #if (ACC_OS_TOS && (ACC_CC_PUREC || ACC_CC_TURBOC)) ACC_UNUSED(mode); return Dcreate(name); #elif defined(__DJGPP__) return mkdir(name, mode); #elif (ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64) ACC_UNUSED(mode); return mkdir(name); #else return mkdir(name, mode); #endif } #if 0 ACCLIB_PUBLIC(int, acc_response) (int* argc, char*** argv) { } #endif /************************************************************************* // some linear congruential pseudo random number generators (PRNG) **************************************************************************/ ACCLIB_PUBLIC(void, acc_srand31) (acc_rand31_t* r, acc_uint32l_t seed) { r->seed = seed & ACC_UINT32L_C(0xffffffff); } ACCLIB_PUBLIC(acc_uint32l_t, acc_rand31) (acc_rand31_t* r) { r->seed = (r->seed * ACC_UINT32L_C(1103515245)) + 12345; r->seed &= ACC_UINT32L_C(0x7fffffff); return r->seed; } #if defined(acc_uint64l_t) ACCLIB_PUBLIC(void, acc_srand48) (acc_rand48_t* 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) { r->seed = (r->seed * ACC_UINT64L_C(25214903917)) + 11; r->seed &= ACC_UINT64L_C(0xffffffffffff); return (acc_uint32l_t) (r->seed >> 17); } #endif /* defined(acc_uint64l_t) */ #if defined(acc_uint64l_t) ACCLIB_PUBLIC(void, acc_srand64) (acc_rand64_t* r, acc_uint64l_t seed) { r->seed = seed & ACC_UINT64L_C(0xffffffffffffffff); } ACCLIB_PUBLIC(acc_uint32l_t, acc_rand64) (acc_rand64_t* r) { r->seed = (r->seed * ACC_UINT64L_C(6364136223846793005)) + 1; r->seed &= ACC_UINT64L_C(0xffffffffffffffff); return (acc_uint32l_t) (r->seed >> 33); } #endif /* defined(acc_uint64l_t) */ /* vi:ts=4:et */