commit: r423 - in trunk/stdutil: . src src/stdutil src/stdutil/private
[email protected] Thu, 04 Jun 2009 17:22:26 -0400
| Newsgroups | gmane.network.spread.cvs |
|---|---|
| Message-ID | <[email protected]> |
Author: jonathan Date: 2009-06-04 17:22:26 -0400 (Thu, 04 Jun 2009) New Revision: 423 Added: trunk/stdutil/CHANGELOG Modified: trunk/stdutil/Makefile trunk/stdutil/README trunk/stdutil/STDUTIL_LICENSE trunk/stdutil/configure trunk/stdutil/configure.in trunk/stdutil/src/Makefile.in trunk/stdutil/src/stdarr.c trunk/stdutil/src/stdcarr.c trunk/stdutil/src/stddll.c trunk/stdutil/src/stderror.c trunk/stdutil/src/stdfd.c trunk/stdutil/src/stdhash.c trunk/stdutil/src/stdit.c trunk/stdutil/src/stdskl.c trunk/stdutil/src/stdthread.c trunk/stdutil/src/stdtime.c trunk/stdutil/src/stdutil.c trunk/stdutil/src/stdutil/private/stdarch.h trunk/stdutil/src/stdutil/private/stdarch_autoconf.h.in trunk/stdutil/src/stdutil/private/stdarch_wintel32.h trunk/stdutil/src/stdutil/private/stdarr_p.h trunk/stdutil/src/stdutil/private/stdcarr_p.h trunk/stdutil/src/stdutil/private/stddll_p.h trunk/stdutil/src/stdutil/private/stdhash_p.h trunk/stdutil/src/stdutil/private/stdit_p.h trunk/stdutil/src/stdutil/private/stdskl_p.h trunk/stdutil/src/stdutil/private/stdthread_p.h trunk/stdutil/src/stdutil/stdarr.h trunk/stdutil/src/stdutil/stdcarr.h trunk/stdutil/src/stdutil/stddefines.h trunk/stdutil/src/stdutil/stddll.h trunk/stdutil/src/stdutil/stderror.h trunk/stdutil/src/stdutil/stdfd.h trunk/stdutil/src/stdutil/stdhash.h trunk/stdutil/src/stdutil/stdit.h trunk/stdutil/src/stdutil/stdskl.h trunk/stdutil/src/stdutil/stdthread.h trunk/stdutil/src/stdutil/stdtime.h trunk/stdutil/src/stdutil/stdutil.h Log: Merge Stdutil 1.1.0 release into Spread trunk Copied: trunk/stdutil/CHANGELOG (from rev 422, vendor/stdutil/current/CHANGELOG) =================================================================== --- trunk/stdutil/CHANGELOG (rev 0) +++ trunk/stdutil/CHANGELOG 2009-06-04 21:22:26 UTC (rev 423) @@ -0,0 +1,14 @@ +v1.1.0, May 2009 + +Changed the build so that the functions in stdthread.h are always defined, but most will simply +return error codes when not built in a reentrant manner. Added a "null mutex" that does nothing +to allow user programs to always successfully call at least the mutex functions even in a +non-reentrant build. + +v1.0.1, November 2007 + +Fixed a few minor bugs. + +v1.0.0, November 2006 + +First major release of StdUtil library. Modified: trunk/stdutil/Makefile =================================================================== --- trunk/stdutil/Makefile 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/Makefile 2009-06-04 21:22:26 UTC (rev 423) @@ -1,5 +1,5 @@ all: - cd src; $(MAKE) + cd src; $(MAKE) all clean: rm -f *~ core* Modified: trunk/stdutil/README =================================================================== --- trunk/stdutil/README 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/README 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -This is the v1.0.0 (November 2006) distribution of the StdUtil library. +This is the v1.1.0 (May 2009) distribution of the StdUtil library. DESCRIPTION: @@ -14,13 +14,15 @@ Documentation is currently incomplete but will be available in a subsequent release in HTML format in the docs directory. The -documentation will also be available at +documentation will also be available at: + http://www.cnds.jhu.edu/software/stdutil/docs BUILDING: StdUtil uses the standard configure/make process for building on unix -type systems. +type systems, although it builds in place and does not have a make install +option. PROBLEMS: @@ -30,4 +32,4 @@ Enjoy, John Schultz <[email protected]> -November 2006 +May 2009 Modified: trunk/stdutil/STDUTIL_LICENSE =================================================================== --- trunk/stdutil/STDUTIL_LICENSE 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/STDUTIL_LICENSE 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The Original Software is: Modified: trunk/stdutil/configure =================================================================== --- trunk/stdutil/configure 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/configure 2009-06-04 21:22:26 UTC (rev 423) @@ -3496,14 +3496,14 @@ SHLDFLAGS="$SHLDFLAGS $LDFLAGS" SHLIBS=$LIBS DYNLIBEXT=dylib - STANDARD_LIBS="\$(STATIC_THREADED_RELEASE_LIB) \$(SHARED_THREADED_RELEASE_LIB)" + STANDARD_LIBS="\$(STATIC_THREADED_DEBUG_LIB) \$(STATIC_THREADED_RELEASE_LIB) \$(SHARED_THREADED_DEBUG_LIB) \$(SHARED_THREADED_RELEASE_LIB)" SHARED_LIBS="\$(SHARED_LIBS)" ;; mips-sgi-irix*) CC=cc CFLAGS="-n32 -signed" DYNLIBEXT= - STANDARD_LIBS="\$(STATIC_THREADED_RELEASE_LIB)" + STANDARD_LIBS="\$(STATIC_THREADED_DEBUG_LIB) \$(STATIC_THREADED_RELEASE_LIB)" SHARED_LIBS= ;; *-*-*) @@ -3514,7 +3514,7 @@ SHLDFLAGS="$SHLDFLAGS $LDFLAGS" SHLIBS=$LIBS DYNLIBEXT=so - STANDARD_LIBS="\$(STATIC_THREADED_RELEASE_LIB) \$(SHARED_THREADED_RELEASE_LIB)" + STANDARD_LIBS="\$(STATIC_THREADED_DEBUG_LIB) \$(STATIC_THREADED_RELEASE_LIB) \$(SHARED_THREADED_DEBUG_LIB) \$(SHARED_THREADED_RELEASE_LIB)" SHARED_LIBS="\$(SHARED_LIBS)" ;; esac Modified: trunk/stdutil/configure.in =================================================================== --- trunk/stdutil/configure.in 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/configure.in 2009-06-04 21:22:26 UTC (rev 423) @@ -57,14 +57,14 @@ SHLDFLAGS="$SHLDFLAGS $LDFLAGS" SHLIBS=$LIBS DYNLIBEXT=dylib - STANDARD_LIBS="\$(STATIC_THREADED_RELEASE_LIB) \$(SHARED_THREADED_RELEASE_LIB)" + STANDARD_LIBS="\$(STATIC_THREADED_DEBUG_LIB) \$(STATIC_THREADED_RELEASE_LIB) \$(SHARED_THREADED_DEBUG_LIB) \$(SHARED_THREADED_RELEASE_LIB)" SHARED_LIBS="\$(SHARED_LIBS)" ;; mips-sgi-irix*) CC=cc CFLAGS="-n32 -signed" DYNLIBEXT= - STANDARD_LIBS="\$(STATIC_THREADED_RELEASE_LIB)" + STANDARD_LIBS="\$(STATIC_THREADED_DEBUG_LIB) \$(STATIC_THREADED_RELEASE_LIB)" SHARED_LIBS= ;; *-*-*) @@ -75,7 +75,7 @@ SHLDFLAGS="$SHLDFLAGS $LDFLAGS" SHLIBS=$LIBS DYNLIBEXT=so - STANDARD_LIBS="\$(STATIC_THREADED_RELEASE_LIB) \$(SHARED_THREADED_RELEASE_LIB)" + STANDARD_LIBS="\$(STATIC_THREADED_DEBUG_LIB) \$(STATIC_THREADED_RELEASE_LIB) \$(SHARED_THREADED_DEBUG_LIB) \$(SHARED_THREADED_RELEASE_LIB)" SHARED_LIBS="\$(SHARED_LIBS)" ;; esac Modified: trunk/stdutil/src/Makefile.in =================================================================== --- trunk/stdutil/src/Makefile.in 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/Makefile.in 2009-06-04 21:22:26 UTC (rev 423) @@ -1,7 +1,7 @@ .SUFFIXES: .do .to .tdo .lo .ldo .lto .ltdo .PHONY: all standard libdir clean distclean uberclean -LIBVERSION=1.0 +LIBVERSION=1.1 ############################################ PROGRAMS ######################################### @@ -89,6 +89,7 @@ $(STATIC_THREADED_DEBUG_LIB): $(STATIC_THREADED_DEBUG_OBJS) $(AR) rvs $@ $(STATIC_THREADED_DEBUG_OBJS) + $(SOFTLINK) -f $@ $(LIBDIR)/libstdutil-debug.a $(SHARED_NOTHREAD_RELEASE_LIB): $(SHARED_NOTHREAD_RELEASE_OBJS) $(SHLD) $(SHLDFLAGS) -o $@ $(SHARED_NOTHREAD_RELEASE_OBJS) $(SHLIBS) @@ -102,9 +103,10 @@ $(SHARED_THREADED_DEBUG_LIB): $(SHARED_THREADED_DEBUG_OBJS) $(SHLD) $(SHLDFLAGS) -o $@ $(SHARED_THREADED_DEBUG_OBJS) $(SHLIBS) $(THLIBS) + $(SOFTLINK) -f $@ $(LIBDIR)/libstdutil-debug.@DYNLIBEXT@ clean: - rm -f *.o *.do *.to *.tdo *.lo *.ldo *.lto *.ltdo core* *~ $(ALLTARGETS) $(LIBDIR)/libstdutil.a $(LIBDIR)/libstdutil.@DYNLIBEXT@ + rm -f *.o *.do *.to *.tdo *.lo *.ldo *.lto *.ltdo core* *~ stdutil/*~ stdutil/private/*~ $(ALLTARGETS) $(LIBDIR)/libstdutil.a $(LIBDIR)/libstdutil.@DYNLIBEXT@ $(LIBDIR)/libstdutil-debug.a $(LIBDIR)/libstdutil-debug.@DYNLIBEXT@ distclean: clean rm -f Makefile stdutil/private/stdarch_autoconf.h Modified: trunk/stdutil/src/stdarr.c =================================================================== --- trunk/stdutil/src/stdarr.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdarr.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdcarr.c =================================================================== --- trunk/stdutil/src/stdcarr.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdcarr.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stddll.c =================================================================== --- trunk/stdutil/src/stddll.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stddll.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). @@ -216,8 +216,9 @@ { stddll_node * curr = erase_end->prev; stddll_node * prev; + stdsize ne = num_erase; - while (num_erase-- != 0) { + while (ne-- != 0) { STDBOUNDS_CHECK(curr != STDDLL_LEND(l)); /* check for an illegal erasure */ prev = curr; curr = curr->prev; Modified: trunk/stdutil/src/stderror.c =================================================================== --- trunk/stdutil/src/stderror.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stderror.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdfd.c =================================================================== --- trunk/stdutil/src/stdfd.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdfd.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,366 +1,366 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University - * All rights reserved. - * - * The contents of this file are subject to a license (the ``License''). - * You may not use this file except in compliance with the License. The - * specific language governing the rights and limitations of the License - * can be found in the file ``STDUTIL_LICENSE'' found in this - * distribution. - * - * Software distributed under the License is distributed on an AS IS - * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. - * - * The Original Software is: - * The Stdutil Library - * - * Contributors: - * Creator - John Lane Schultz ([email protected]) - * The Center for Networking and Distributed Systems - * (CNDS - http://www.cnds.jhu.edu) - */ - -#include <fcntl.h> -#include <sys/types.h> -#include <sys/stat.h> - -#include <stdutil/stderror.h> -#include <stdutil/stdfd.h> - -#ifdef __cplusplus -extern "C" { -#endif - -#if defined(_WIN32) -# include <io.h> -# include <sys/locking.h> -# define STDFILENO(s) _fileno(s) -# define STDFSYNC(fd) _commit(fd) -#else -# include <unistd.h> -# define STDFILENO(s) fileno(s) -# define STDFSYNC(fd) fsync(fd) -#endif - -/************************************************************************************************ - * stdfd_open: Open a file descriptor. - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_open(stdfd *fd, const char *path, stdfd_access_type mode) -{ - stdcode ret = STDESUCCESS; - const char * fopen_mode; - - switch (mode) { - case STDFD_READ_ONLY: - fopen_mode = "rb"; - break; - - case STDFD_READ_WRITE_EXISTING: - fopen_mode = "rb+"; - break; - - case STDFD_WRITE_ONLY: - fopen_mode = "wb"; - break; - - case STDFD_READ_WRITE_NEW: - fopen_mode = "wb+"; - break; - - case STDFD_APPEND_ONLY: - fopen_mode = "ab"; - break; - - case STDFD_READ_APPEND: - fopen_mode = "ab+"; - break; - - default: - ret = STDEINVAL; - goto stdfd_open_end; - } - - if ((fd->stream = fopen(path, fopen_mode)) != NULL) { - fd->fd = STDFILENO(fd->stream); - - } else { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - stdfd_open_end: - return ret; -} - -/************************************************************************************************ - * stdfd_close: Close a file descriptor. - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_close(stdfd *fd) -{ - stdcode ret = STDESUCCESS; - - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - if (fclose(fd->stream) != 0) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - fd->stream = NULL; - fd->fd = -1; - - return ret; -} - -/************************************************************************************************ - * stdfd_read: Read 'nmemb' entries of 'nsize' bytes each from a file - * descriptor into 'ptr.' - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_read(stdfd *fd, void *ptr, stdsize nsize, stdsize nmemb, stdsize *num) -{ - stdcode ret; - - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - if ((*num = fread(ptr, nsize, nmemb, fd->stream)) == nmemb) { - ret = STDESUCCESS; - - } else if (feof(fd->stream)) { - ret = STDEOF; - - } else if (ferror(fd->stream)) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - - } else { - ret = STDEINTR; /* wrong count but not EOF or error? alert user! */ - } - - return ret; -} - -/************************************************************************************************ - * stdfd_write: Write 'nmemb' entries of 'nsize' bytes each from 'ptr' - * to a file descriptor. - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_write(stdfd *fd, const void *ptr, stdsize nsize, stdsize nmemb, stdsize *num) -{ - stdcode ret; - - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - if ((*num = fwrite(ptr, nsize, nmemb, fd->stream)) == nmemb) { - ret = STDESUCCESS; - - } else if (feof(fd->stream)) { - ret = STDEOF; - - } else if (ferror(fd->stream)) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - - } else { - ret = STDEINTR; /* wrong count but not EOF or error? alert user! */ - } - - return ret; -} - -/************************************************************************************************ - * stdfd_flush: Flush any user space data on a file descriptor to the OS. - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_flush(stdfd *fd) -{ - stdcode ret = STDESUCCESS; - - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - if (fflush(fd->stream) != 0) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - return ret; -} - -/************************************************************************************************ - * stdfd_sync: Flush user space data to the OS and force the OS to - * flush all data to disk. - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_sync(stdfd *fd) -{ - stdcode ret = STDESUCCESS; - - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - if (fflush(fd->stream) != 0 || STDFSYNC(fd->fd) != 0) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - return ret; -} - -/************************************************************************************************ - * stdfd_seek: Move the read/write head position of a file descriptor. - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_seek(stdfd *fd, long offset, stdfd_whence whence) -{ - stdcode ret = STDESUCCESS; - - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - if (fseek(fd->stream, offset, whence) != 0) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - return ret; -} - -/************************************************************************************************ - * stdfd_tell: Get the read/write head position of a file descriptor. - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_tell(stdfd *fd, long *pos) -{ - stdcode ret = STDESUCCESS; - - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - if ((*pos = ftell(fd->stream)) == -1) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - return ret; -} - -/************************************************************************************************ - * stdfd_eof: Return whether or not the EOF indicator on a file descriptor is set. - ***********************************************************************************************/ - -STDINLINE stdbool stdfd_eof(stdfd *fd) -{ - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - return (feof(fd->stream) != 0); -} - -/************************************************************************************************ - * stdfd_err: Return whether or not an error indicator on a file descriptor is set. - ***********************************************************************************************/ - -STDINLINE stdbool stdfd_err(stdfd *fd) -{ - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - return (ferror(fd->stream) != 0); -} - -/************************************************************************************************ - * stdfd_clr_err: Clear any error indicator on a file descriptor. - ***********************************************************************************************/ - -STDINLINE void stdfd_clr_err(stdfd *fd) -{ - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - clearerr(fd->stream); -} - -/************************************************************************************************ - * stdfd_trylock: Try to acquire an advisory lock on a file - * descriptor's underlying file. - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_trylock(stdfd *fd) -#if defined(_WIN32) -{ - stdcode ret = STDESUCCESS; - - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - if (_locking(fd->fd, _LK_NBLCK, 1) != 0) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - return ret; -} -#else -{ - struct flock lock = { 0 }; - stdcode ret = STDESUCCESS; - - lock.l_type = F_WRLCK; - - if (fcntl(fd->fd, F_SETLK, &lock) != 0) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - return ret; -} -#endif - -/************************************************************************************************ - * stdfd_unlock: Release an advisory lock on a file descriptor's - * underlying file. - ***********************************************************************************************/ - -STDINLINE stdcode stdfd_unlock(stdfd *fd) -#if defined(_WIN32) -{ - stdcode ret = STDESUCCESS; - - STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); - - if (_locking(fd->fd, _LK_UNLCK, 1) != 0) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - return ret; -} -#else -{ - struct flock lock = { 0 }; - stdcode ret = STDESUCCESS; - - lock.l_type = F_UNLCK; - - if (fcntl(fd->fd, F_SETLK, &lock) != 0) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - return ret; - } -#endif - -/************************************************************************************************ - * stdfile_unlink: Erase a file. - ***********************************************************************************************/ - -STDINLINE stdcode stdfile_unlink(const char *path) -{ - stdcode ret = STDESUCCESS; - - if (remove(path) != 0) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - } - - return ret; -} - -#ifdef __cplusplus -} -#endif +/* Copyright (c) 2000-2009, The Johns Hopkins University + * All rights reserved. + * + * The contents of this file are subject to a license (the ``License''). + * You may not use this file except in compliance with the License. The + * specific language governing the rights and limitations of the License + * can be found in the file ``STDUTIL_LICENSE'' found in this + * distribution. + * + * Software distributed under the License is distributed on an AS IS + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * The Original Software is: + * The Stdutil Library + * + * Contributors: + * Creator - John Lane Schultz ([email protected]) + * The Center for Networking and Distributed Systems + * (CNDS - http://www.cnds.jhu.edu) + */ + +#include <fcntl.h> +#include <sys/types.h> +#include <sys/stat.h> + +#include <stdutil/stderror.h> +#include <stdutil/stdfd.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(_WIN32) +# include <io.h> +# include <sys/locking.h> +# define STDFILENO(s) _fileno(s) +# define STDFSYNC(fd) _commit(fd) +#else +# include <unistd.h> +# define STDFILENO(s) fileno(s) +# define STDFSYNC(fd) fsync(fd) +#endif + +/************************************************************************************************ + * stdfd_open: Open a file descriptor. + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_open(stdfd *fd, const char *path, stdfd_access_type mode) +{ + stdcode ret = STDESUCCESS; + const char * fopen_mode; + + switch (mode) { + case STDFD_READ_ONLY: + fopen_mode = "rb"; + break; + + case STDFD_READ_WRITE_EXISTING: + fopen_mode = "rb+"; + break; + + case STDFD_WRITE_ONLY: + fopen_mode = "wb"; + break; + + case STDFD_READ_WRITE_NEW: + fopen_mode = "wb+"; + break; + + case STDFD_APPEND_ONLY: + fopen_mode = "ab"; + break; + + case STDFD_READ_APPEND: + fopen_mode = "ab+"; + break; + + default: + ret = STDEINVAL; + goto stdfd_open_end; + } + + if ((fd->stream = fopen(path, fopen_mode)) != NULL) { + fd->fd = STDFILENO(fd->stream); + + } else { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + stdfd_open_end: + return ret; +} + +/************************************************************************************************ + * stdfd_close: Close a file descriptor. + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_close(stdfd *fd) +{ + stdcode ret = STDESUCCESS; + + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + if (fclose(fd->stream) != 0) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + fd->stream = NULL; + fd->fd = -1; + + return ret; +} + +/************************************************************************************************ + * stdfd_read: Read 'nmemb' entries of 'nsize' bytes each from a file + * descriptor into 'ptr.' + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_read(stdfd *fd, void *ptr, stdsize nsize, stdsize nmemb, stdsize *num) +{ + stdcode ret; + + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + if ((*num = fread(ptr, nsize, nmemb, fd->stream)) == nmemb) { + ret = STDESUCCESS; + + } else if (feof(fd->stream)) { + ret = STDEOF; + + } else if (ferror(fd->stream)) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + + } else { + ret = STDEINTR; /* wrong count but not EOF or error? alert user! */ + } + + return ret; +} + +/************************************************************************************************ + * stdfd_write: Write 'nmemb' entries of 'nsize' bytes each from 'ptr' + * to a file descriptor. + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_write(stdfd *fd, const void *ptr, stdsize nsize, stdsize nmemb, stdsize *num) +{ + stdcode ret; + + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + if ((*num = fwrite(ptr, nsize, nmemb, fd->stream)) == nmemb) { + ret = STDESUCCESS; + + } else if (feof(fd->stream)) { + ret = STDEOF; + + } else if (ferror(fd->stream)) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + + } else { + ret = STDEINTR; /* wrong count but not EOF or error? alert user! */ + } + + return ret; +} + +/************************************************************************************************ + * stdfd_flush: Flush any user space data on a file descriptor to the OS. + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_flush(stdfd *fd) +{ + stdcode ret = STDESUCCESS; + + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + if (fflush(fd->stream) != 0) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + return ret; +} + +/************************************************************************************************ + * stdfd_sync: Flush user space data to the OS and force the OS to + * flush all data to disk. + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_sync(stdfd *fd) +{ + stdcode ret = STDESUCCESS; + + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + if (fflush(fd->stream) != 0 || STDFSYNC(fd->fd) != 0) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + return ret; +} + +/************************************************************************************************ + * stdfd_seek: Move the read/write head position of a file descriptor. + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_seek(stdfd *fd, long offset, stdfd_whence whence) +{ + stdcode ret = STDESUCCESS; + + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + if (fseek(fd->stream, offset, whence) != 0) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + return ret; +} + +/************************************************************************************************ + * stdfd_tell: Get the read/write head position of a file descriptor. + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_tell(stdfd *fd, long *pos) +{ + stdcode ret = STDESUCCESS; + + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + if ((*pos = ftell(fd->stream)) == -1) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + return ret; +} + +/************************************************************************************************ + * stdfd_eof: Return whether or not the EOF indicator on a file descriptor is set. + ***********************************************************************************************/ + +STDINLINE stdbool stdfd_eof(stdfd *fd) +{ + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + return (feof(fd->stream) != 0); +} + +/************************************************************************************************ + * stdfd_err: Return whether or not an error indicator on a file descriptor is set. + ***********************************************************************************************/ + +STDINLINE stdbool stdfd_err(stdfd *fd) +{ + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + return (ferror(fd->stream) != 0); +} + +/************************************************************************************************ + * stdfd_clr_err: Clear any error indicator on a file descriptor. + ***********************************************************************************************/ + +STDINLINE void stdfd_clr_err(stdfd *fd) +{ + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + clearerr(fd->stream); +} + +/************************************************************************************************ + * stdfd_trylock: Try to acquire an advisory lock on a file + * descriptor's underlying file. + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_trylock(stdfd *fd) +#if defined(_WIN32) +{ + stdcode ret = STDESUCCESS; + + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + if (_locking(fd->fd, _LK_NBLCK, 1) != 0) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + return ret; +} +#else +{ + struct flock lock = { 0 }; + stdcode ret = STDESUCCESS; + + lock.l_type = F_WRLCK; + + if (fcntl(fd->fd, F_SETLK, &lock) != 0) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + return ret; +} +#endif + +/************************************************************************************************ + * stdfd_unlock: Release an advisory lock on a file descriptor's + * underlying file. + ***********************************************************************************************/ + +STDINLINE stdcode stdfd_unlock(stdfd *fd) +#if defined(_WIN32) +{ + stdcode ret = STDESUCCESS; + + STDSAFETY_CHECK(fd->stream != NULL && fd->fd >= 0); + + if (_locking(fd->fd, _LK_UNLCK, 1) != 0) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + return ret; +} +#else +{ + struct flock lock = { 0 }; + stdcode ret = STDESUCCESS; + + lock.l_type = F_UNLCK; + + if (fcntl(fd->fd, F_SETLK, &lock) != 0) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + return ret; + } +#endif + +/************************************************************************************************ + * stdfile_unlink: Erase a file. + ***********************************************************************************************/ + +STDINLINE stdcode stdfile_unlink(const char *path) +{ + stdcode ret = STDESUCCESS; + + if (remove(path) != 0) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + } + + return ret; +} + +#ifdef __cplusplus +} +#endif Modified: trunk/stdutil/src/stdhash.c =================================================================== --- trunk/stdutil/src/stdhash.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdhash.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdit.c =================================================================== --- trunk/stdutil/src/stdit.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdit.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdskl.c =================================================================== --- trunk/stdutil/src/stdskl.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdskl.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). @@ -481,7 +481,7 @@ * erase. ***********************************************************************************************/ -STDINLINE static void stdskl_low_erase(stdskl *l, stdit *b, stdit *e, stdsize num_erase) +STDINLINE static stdsize stdskl_low_erase(stdskl *l, stdit *b, stdit *e, stdsize num_erase) { stdskl_node * ers; stdskl_node * prev = b->impl.skl.node->prevs[0]; @@ -509,7 +509,7 @@ /* update list size */ - l->size -= num_erase; + l->size -= erased; /* stitch together the left and right portions of the list */ @@ -539,6 +539,8 @@ if (e != NULL) { e->impl.skl.node = ers; } + + return erased; } /************************************************************************************************ @@ -1038,28 +1040,31 @@ * stdskl_erase_seq: Erase a sequence from a list. ***********************************************************************************************/ -STDINLINE void stdskl_erase_seq(stdskl *l, stdit *b, stdit *e) +STDINLINE stdsize stdskl_erase_seq(stdskl *l, stdit *b, stdit *e) { STDSAFETY_CHECK(STDSKL_IS_LEGAL(l) && STDIT_SKL_IS_LEGAL(b) && STDSKL_IT_IS_LEGAL(l, &b->impl.skl) && (stdit_eq(b, e) || STDTRUE)); - stdskl_low_erase(l, b, e, (stdsize) -1); + return stdskl_low_erase(l, b, e, (stdsize) -1); } /************************************************************************************************ * stdskl_erase_key: Erase all entries of a key from a list. ***********************************************************************************************/ -STDINLINE void stdskl_erase_key(stdskl *l, const void *key) +STDINLINE stdsize stdskl_erase_key(stdskl *l, const void *key) { - stdit it; + stdsize ret = 0; + stdit it; STDSAFETY_CHECK(STDSKL_IS_LEGAL(l)); stdskl_lowerb(l, &it, key); - while (it.impl.skl.node != l->end_node && stdskl_low_key_cmp(l, key, STDSKL_NKEY(it.impl.skl.node)) == 0) { + for (; it.impl.skl.node != l->end_node && stdskl_low_key_cmp(l, key, STDSKL_NKEY(it.impl.skl.node)) == 0; ++ret) { stdskl_erase(l, &it); /* advances 'it' */ } + + return ret; } /************************************************************************************************ Modified: trunk/stdutil/src/stdthread.c =================================================================== --- trunk/stdutil/src/stdthread.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdthread.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). @@ -19,10 +19,115 @@ * (CNDS - http://www.cnds.jhu.edu) */ -#if defined(_REENTRANT) +#include <stdlib.h> +#include <stdutil/stderror.h> +#include <stdutil/stdthread.h> -# include <stdlib.h> +#ifdef __cplusplus +extern "C" { +#endif +/* TODO: Need to implement code for STDMUTEX_NULL for threaded versions */ +/* TODO: Need to implement code for STDCOND_NULL */ +/* TODO: Need to break out the different implementations into their + own sections of code (i.e. - multiple implementations of each + function) like we did for !defined(_REENTRANT) +*/ + +#if !defined(_REENTRANT) + +STDINLINE stdcode stdthread_spawn(stdthread * thr_ptr, stdthread_id * id, + stdthread_fcn thr_fcn, void * fcn_arg) +{ + return STDENOSYS; +} + +STDINLINE stdcode stdthread_detach(stdthread thr) +{ + return STDENOSYS; +} + +STDINLINE stdcode stdthread_join(stdthread thr, void ** exitval_ptr) +{ + return STDENOSYS; +} + +STDINLINE void stdthread_exit(void * exitval) +{ + exit(0); +} + +STDINLINE stdthread_id stdthread_self(void) +{ + return STDENOSYS; +} + +STDINLINE stdbool stdthread_eq(stdthread_id id1, stdthread_id id2) +{ + return STDENOSYS; +} + +STDINLINE stdcode stdmutex_construct(stdmutex *mut, stdmutex_type t) +{ + return (t == STDMUTEX_NULL ? STDESUCCESS : STDENOSYS); +} + +STDINLINE stdcode stdmutex_destruct(stdmutex *mut) +{ + return STDESUCCESS; +} + +STDINLINE stdcode stdmutex_grab(stdmutex *mut) +{ + return STDESUCCESS; +} + +STDINLINE stdcode stdmutex_trygrab(stdmutex *mut) +{ + return STDESUCCESS; +} + +STDINLINE stdcode stdmutex_drop(stdmutex *mut) +{ + return STDESUCCESS; +} + +STDINLINE stdcode stdmutex_is_owner(stdmutex *mut, unsigned * grab_cnt) +{ + *grab_cnt = (unsigned) -1; + + return STDESUCCESS; +} + +STDINLINE stdcode stdcond_construct(stdcond *cond) +{ + return STDENOSYS; +} + +STDINLINE stdcode stdcond_destruct(stdcond *cond) +{ + return STDENOSYS; +} + +STDINLINE stdcode stdcond_wake_one(stdcond *cond) +{ + return STDENOSYS; +} + +STDINLINE stdcode stdcond_wake_all(stdcond *cond) +{ + return STDENOSYS; +} + +STDINLINE stdcode stdcond_wait(stdcond *cond, stdmutex *mut) +{ + return STDENOSYS; +} + +/*STDINLINE stdcode stdcond_timedwait(stdcond *cond, stdmutex *mut, long ns);*/ + +#else + # if defined(_WIN32) # include <process.h> # define STDSLEEPERS_BEGIN(cond) ((cond)->sleepers_end.next) @@ -32,13 +137,6 @@ # include <sys/time.h> # endif -# include <stdutil/stderror.h> -# include <stdutil/stdthread.h> - -#ifdef __cplusplus -extern "C" { -#endif - /************************************************************************************************ * stdthread_spawn: Create a new thread and start its execution. ***********************************************************************************************/ @@ -439,7 +537,7 @@ * stdmutex_fast_cond_wait: Wait on a condition protected by a fast mutex. ***********************************************************************************************/ -STDINLINE stdcode stdmutex_fast_cond_wait(stdmutex *mut, stdcond *cond) +STDINLINE static stdcode stdmutex_fast_cond_wait(stdmutex *mut, stdcond *cond) # if defined(_WIN32) { /* NOTE: this WIN32 code works for both fast and recursive mutexes: @@ -799,8 +897,7 @@ * stdmutex_rcrsv_cond_wait: Atomically unlock a 'mut' and wait on 'cond.' ***********************************************************************************************/ -STDINLINE stdcode stdmutex_rcrsv_cond_wait(stdmutex *mut, stdcond *cond) - +STDINLINE static stdcode stdmutex_rcrsv_cond_wait(stdmutex *mut, stdcond *cond) # if defined(_WIN32) { /* NOTE: the WIN32 code works for both fast and recursive mutexes: @@ -863,6 +960,7 @@ stdcode ret = STDEINVAL; switch (t) { + case STDMUTEX_FAST: ret = stdmutex_fast_init(mut); break; @@ -870,6 +968,10 @@ case STDMUTEX_RCRSV: ret = stdmutex_rcrsv_init(mut); break; + + case STDMUTEX_NULL: + ret = STDESUCCESS; + break; } return ret; @@ -884,6 +986,7 @@ stdcode ret = STDEINVAL; switch (mut->mut_type) { + case STDMUTEX_FAST: ret = stdmutex_fast_fini(mut); break; @@ -891,6 +994,10 @@ case STDMUTEX_RCRSV: ret = stdmutex_rcrsv_fini(mut); break; + + case STDMUTEX_NULL: + ret = STDESUCCESS; + break; } return ret; @@ -905,6 +1012,7 @@ stdcode ret = STDEINVAL; switch (mut->mut_type) { + case STDMUTEX_FAST: ret = stdmutex_fast_grab(mut, STDTRUE); break; @@ -912,6 +1020,10 @@ case STDMUTEX_RCRSV: ret = stdmutex_rcrsv_grab(mut, STDTRUE); break; + + case STDMUTEX_NULL: + ret = STDESUCCESS; + break; } return ret; @@ -926,6 +1038,7 @@ stdcode ret = STDEINVAL; switch (mut->mut_type) { + case STDMUTEX_FAST: ret = stdmutex_fast_grab(mut, STDFALSE); break; @@ -933,6 +1046,10 @@ case STDMUTEX_RCRSV: ret = stdmutex_rcrsv_grab(mut, STDFALSE); break; + + case STDMUTEX_NULL: + ret = STDESUCCESS; + break; } return ret; @@ -947,6 +1064,7 @@ stdcode ret = STDEINVAL; switch (mut->mut_type) { + case STDMUTEX_FAST: ret = stdmutex_fast_drop(mut); break; @@ -954,6 +1072,10 @@ case STDMUTEX_RCRSV: ret = stdmutex_rcrsv_drop(mut); break; + + case STDMUTEX_NULL: + ret = STDESUCCESS; + break; } return ret; @@ -968,6 +1090,7 @@ stdcode ret = STDEINVAL; switch (mut->mut_type) { + case STDMUTEX_FAST: ret = STDENOSYS; break; @@ -975,6 +1098,11 @@ case STDMUTEX_RCRSV: ret = stdmutex_rcrsv_is_owner(mut, grab_cnt); break; + + case STDMUTEX_NULL: + *grab_cnt = (unsigned) -1; + ret = STDESUCCESS; + break; } return ret; @@ -1070,6 +1198,7 @@ stdcode ret = STDEINVAL; switch (mut->mut_type) { + case STDMUTEX_FAST: ret = stdmutex_fast_cond_wait(mut, cond); break; @@ -1077,6 +1206,10 @@ case STDMUTEX_RCRSV: ret = stdmutex_rcrsv_cond_wait(mut, cond); break; + + case STDMUTEX_NULL: + ret = STDESUCCESS; + break; } return ret; @@ -1094,6 +1227,7 @@ stdcode ret = STDEINVAL; switch (mut->mut_type) { + case STDMUTEX_FAST: ret = stdmutex_fast_cond_wait_timed(mut, cond); break; @@ -1101,6 +1235,10 @@ case STDMUTEX_RCRSV: ret = stdmutex_rcrsv_cond_wait_timed(mut, cond); break; + + case STDMUTEX_NULL: + ret = STDESUCCESS; + break; } return ret; @@ -1189,10 +1327,8 @@ # endif #endif +#endif + #ifdef __cplusplus } #endif - -#else -int stdthread_trnsl_dummy; /* avoids empty translation unit error #if !defined(_REENTRANT) */ -#endif Modified: trunk/stdutil/src/stdtime.c =================================================================== --- trunk/stdutil/src/stdtime.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdtime.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,334 +1,334 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University - * All rights reserved. - * - * The contents of this file are subject to a license (the ``License''). - * You may not use this file except in compliance with the License. The - * specific language governing the rights and limitations of the License - * can be found in the file ``STDUTIL_LICENSE'' found in this - * distribution. - * - * Software distributed under the License is distributed on an AS IS - * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. - * - * The Original Software is: - * The Stdutil Library - * - * Contributors: - * Creator - John Lane Schultz ([email protected]) - * The Center for Networking and Distributed Systems - * (CNDS - http://www.cnds.jhu.edu) - */ - -#if defined(_WIN32) -# include <windows.h> -# include <sys/types.h> -# include <sys/timeb.h> -#else -# include <time.h> -# include <sys/time.h> -#endif - -#include <stdutil/stderror.h> -#include <stdutil/stdtime.h> - -#ifdef __cplusplus -extern "C" { -#endif - -/* stdtime: sec == STDINT64_MIN -> nano == 0 - sec < 0 -> -STD1BILLION < nano <= 0 - sec == 0 -> -STD1BILLION < nano < STD1BILLION - sec > 0 -> 0 <= nano < STD1BILLION -*/ - -#define STDTIME_IS_LEGAL(t) ( ((t).sec != STDINT64_MIN || (t).nano == 0) && \ - (((t).sec >= 0 && (t).nano >= 0 && (t).nano < STD1BILLION) || \ - ((t).sec <= 0 && (t).nano <= 0 && (t).nano > -STD1BILLION)) ) - -/************************************************************************************************ - * stdtime: Get the current system time since UTC 00:00:00, Jan 1, 1970. - ***********************************************************************************************/ - -STDINLINE stdcode stdtime_now(stdtime *abs_time) -#if defined(_WIN32) -{ - struct _timeb t; - - _ftime(&t); - - abs_time->sec = t.time; - abs_time->nano = t.millitm * STD1MILLION; - - return STDESUCCESS; -} -#else -{ - stdcode ret = STDESUCCESS; - struct timeval t; - - if (gettimeofday(&t, NULL) != STDESUCCESS) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - goto stdtime_now_end; - } - - abs_time->sec = t.tv_sec; - abs_time->nano = t.tv_usec * STD1THOUSAND; - -stdtime_now_end: - return ret; -} -#endif - -/************************************************************************************************ - * stdtime_time64: Return a stdtime created from a stdtime_time64. - * - * NOTE: '/' and '%' aren't uniformly defined for negative operands so we negate as needed - ***********************************************************************************************/ - -STDINLINE stdtime stdtime_time64(stdtime64 src) -{ - stdtime64 cpy = (src >= 0 ? src : -src); - stdtime ret; - - ret.sec = cpy / STD1BILLION; - ret.nano = (stdint32) cpy % (stdint32) STD1BILLION; - - if (src < 0) { - ret.sec = -ret.sec; - ret.nano = -ret.nano; - } - - return ret; -} - -/************************************************************************************************ - * stdtime_cmp: Compare two stdtimes. - ***********************************************************************************************/ - -STDINLINE int stdtime_cmp(stdtime ls, stdtime rs) -{ - STDSAFETY_CHECK(STDTIME_IS_LEGAL(ls) && STDTIME_IS_LEGAL(rs)); - - if (ls.sec == rs.sec) { - - if (ls.nano == rs.nano) { - return 0; - } - - return (ls.nano < rs.nano ? -1 : 1); - } - - return (ls.sec < rs.sec ? -1 : 1); -} - -/************************************************************************************************ - * stdtime_sign: Get the sign (-1: negative, 0: none, 1: positive) of a stdtime. - ***********************************************************************************************/ - -STDINLINE int stdtime_sign(stdtime t) -{ - stdtime t2 = { 0, 0 }; - - return stdtime_cmp(t, t2); -} - -/************************************************************************************************ - * stdtime_neg: Return the negation of a stdtime. - ***********************************************************************************************/ - -STDINLINE stdtime stdtime_neg(stdtime t) -{ - STDSAFETY_CHECK(STDTIME_IS_LEGAL(t)); - - t.sec = -t.sec; - t.nano = -t.nano; - - return t; -} - -/************************************************************************************************ - * stdtime_add: Return the addition of two stdtimes. - ***********************************************************************************************/ - -STDINLINE stdtime stdtime_add(stdtime ls, stdtime rs) -{ - stdtime ret; - - STDSAFETY_CHECK(STDTIME_IS_LEGAL(ls) && STDTIME_IS_LEGAL(rs)); - - /* do the addition */ - - ret.sec = ls.sec + rs.sec; - ret.nano = ls.nano + rs.nano; - - /* ensure -STD1BILLION < nano < STD1BILLION */ - - if (ret.nano >= STD1BILLION) { - ++ret.sec; - ret.nano -= STD1BILLION; - - } else if (ret.nano <= -STD1BILLION) { - --ret.sec; - ret.nano += STD1BILLION; - } - - /* check for non-agreement in signs */ - - if (ret.sec > 0) { - - if (ret.nano < 0) { - --ret.sec; - ret.nano += STD1BILLION; - } - - } else if (ret.sec != 0) { - - if (ret.nano > 0) { - ++ret.sec; - ret.nano -= STD1BILLION; - } - } - - /* check for nasty edge case and wrap around if not exactly minimum representation */ - - if (ret.sec == STDINT64_MIN && ret.nano != 0) { - --ret.sec; - ret.nano += STD1BILLION; - } - - return ret; -} - -/************************************************************************************************ - * stdtime_sub: Return the difference of two stdtimes. - ***********************************************************************************************/ - -STDINLINE stdtime stdtime_sub(stdtime ls, stdtime rs) -{ - return stdtime_add(ls, stdtime_neg(rs)); -} - -/************************************************************************************************ - * stdtime64_now: Get the current system time since UTC 00:00:00, Jan 1, 1970. - ***********************************************************************************************/ - -STDINLINE stdcode stdtime64_now(stdtime64 *abs_time) -{ - stdtime t; - stdcode ret = stdtime_now(&t); - - if (ret == STDESUCCESS) { - *abs_time = stdtime64_time(t); - } - - return ret; -} - -/************************************************************************************************ - * stdtime64_time: Return a stdtime64 from a stdtime. - ***********************************************************************************************/ - -STDINLINE stdtime64 stdtime64_time(stdtime t) -{ - STDSAFETY_CHECK(STDTIME_IS_LEGAL(t)); - - return (stdtime64) t.sec * STD1BILLION + t.nano; -} - -/************************************************************************************************ - * stdsleep: Sleep for a period of time. On error, remndr will be - * filled if non-NULL. - ***********************************************************************************************/ - -STDINLINE stdcode stdsleep(stdtime delta, stdtime *remndr) -# if defined(_WIN32) -{ - stdcode ret = STDESUCCESS; - stdtime start_time = { 0, 0 }; - stdtime end_time = { 0, 0 }; - DWORD milli_sleep; - - if (delta.sec < 0 || delta.nano < 0 || delta.nano >= STD1BILLION) { - ret = STDEINVAL; - goto stdsleep_fail; - } - - /* conditional +1 for possible nanosecond division trunctation */ - - milli_sleep = (DWORD) (delta.sec * STD1THOUSAND + delta.nano / STD1MILLION) + (delta.nano != 0 ? 1 : 0); - - Sleep(milli_sleep); - - goto stdsleep_end; - - /* error handling and return */ - - stdsleep_fail: - if (remndr != NULL) { - *remndr = delta; - } - - stdsleep_end: - return ret; -} -#else -{ - stdcode ret; - struct timespec d; - struct timespec r; - - if (delta.sec < 0 || delta.nano < 0 || delta.nano >= STD1BILLION) { - ret = STDEINVAL; - goto stdsleep_fail; - } - - d.tv_sec = (time_t) delta.sec; - d.tv_nsec = delta.nano; - - if ((ret = nanosleep(&d, &r)) != STDESUCCESS) { - ret = errno; - STDSAFETY_CHECK(ret != STDESUCCESS); - - if (remndr != NULL) { - remndr->sec = r.tv_sec; - remndr->nano = r.tv_nsec; - } - } - - goto stdsleep_end; - - /* error handling and return */ - - stdsleep_fail: - if (remndr != NULL) { - *remndr = delta; - } - - stdsleep_end: - return ret; -} -#endif - -/************************************************************************************************ - * stdsleep64: Sleep for a number of nanoseconds. - ***********************************************************************************************/ - -STDINLINE stdcode stdsleep64(stdtime64 delta, stdtime64 *remndr) -{ - stdcode ret; - stdtime t_delta = stdtime_time64(delta); - stdtime t_remndr; - - ret = stdsleep(t_delta, (remndr != NULL ? &t_remndr : NULL)); - - if (ret != STDESUCCESS && remndr != NULL) { - *remndr = stdtime64_time(t_remndr); - } - - return ret; -} - -#ifdef __cplusplus -} -#endif +/* Copyright (c) 2000-2009, The Johns Hopkins University + * All rights reserved. + * + * The contents of this file are subject to a license (the ``License''). + * You may not use this file except in compliance with the License. The + * specific language governing the rights and limitations of the License + * can be found in the file ``STDUTIL_LICENSE'' found in this + * distribution. + * + * Software distributed under the License is distributed on an AS IS + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * The Original Software is: + * The Stdutil Library + * + * Contributors: + * Creator - John Lane Schultz ([email protected]) + * The Center for Networking and Distributed Systems + * (CNDS - http://www.cnds.jhu.edu) + */ + +#if defined(_WIN32) +# include <windows.h> +# include <sys/types.h> +# include <sys/timeb.h> +#else +# include <time.h> +# include <sys/time.h> +#endif + +#include <stdutil/stderror.h> +#include <stdutil/stdtime.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* stdtime: sec == STDINT64_MIN -> nano == 0 + sec < 0 -> -STD1BILLION < nano <= 0 + sec == 0 -> -STD1BILLION < nano < STD1BILLION + sec > 0 -> 0 <= nano < STD1BILLION +*/ + +#define STDTIME_IS_LEGAL(t) ( ((t).sec != STDINT64_MIN || (t).nano == 0) && \ + (((t).sec >= 0 && (t).nano >= 0 && (t).nano < STD1BILLION) || \ + ((t).sec <= 0 && (t).nano <= 0 && (t).nano > -STD1BILLION)) ) + +/************************************************************************************************ + * stdtime: Get the current system time since UTC 00:00:00, Jan 1, 1970. + ***********************************************************************************************/ + +STDINLINE stdcode stdtime_now(stdtime *abs_time) +#if defined(_WIN32) +{ + struct _timeb t; + + _ftime(&t); + + abs_time->sec = t.time; + abs_time->nano = t.millitm * STD1MILLION; + + return STDESUCCESS; +} +#else +{ + stdcode ret = STDESUCCESS; + struct timeval t; + + if (gettimeofday(&t, NULL) != STDESUCCESS) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + goto stdtime_now_end; + } + + abs_time->sec = t.tv_sec; + abs_time->nano = t.tv_usec * STD1THOUSAND; + +stdtime_now_end: + return ret; +} +#endif + +/************************************************************************************************ + * stdtime_time64: Return a stdtime created from a stdtime_time64. + * + * NOTE: '/' and '%' aren't uniformly defined for negative operands so we negate as needed + ***********************************************************************************************/ + +STDINLINE stdtime stdtime_time64(stdtime64 src) +{ + stdtime64 cpy = (src >= 0 ? src : -src); + stdtime ret; + + ret.sec = cpy / STD1BILLION; + ret.nano = (stdint32) (cpy % STD1BILLION); + + if (src < 0) { + ret.sec = -ret.sec; + ret.nano = -ret.nano; + } + + return ret; +} + +/************************************************************************************************ + * stdtime_cmp: Compare two stdtimes. + ***********************************************************************************************/ + +STDINLINE int stdtime_cmp(stdtime ls, stdtime rs) +{ + STDSAFETY_CHECK(STDTIME_IS_LEGAL(ls) && STDTIME_IS_LEGAL(rs)); + + if (ls.sec == rs.sec) { + + if (ls.nano == rs.nano) { + return 0; + } + + return (ls.nano < rs.nano ? -1 : 1); + } + + return (ls.sec < rs.sec ? -1 : 1); +} + +/************************************************************************************************ + * stdtime_sign: Get the sign (-1: negative, 0: none, 1: positive) of a stdtime. + ***********************************************************************************************/ + +STDINLINE int stdtime_sign(stdtime t) +{ + stdtime t2 = { 0, 0 }; + + return stdtime_cmp(t, t2); +} + +/************************************************************************************************ + * stdtime_neg: Return the negation of a stdtime. + ***********************************************************************************************/ + +STDINLINE stdtime stdtime_neg(stdtime t) +{ + STDSAFETY_CHECK(STDTIME_IS_LEGAL(t)); + + t.sec = -t.sec; + t.nano = -t.nano; + + return t; +} + +/************************************************************************************************ + * stdtime_add: Return the addition of two stdtimes. + ***********************************************************************************************/ + +STDINLINE stdtime stdtime_add(stdtime ls, stdtime rs) +{ + stdtime ret; + + STDSAFETY_CHECK(STDTIME_IS_LEGAL(ls) && STDTIME_IS_LEGAL(rs)); + + /* do the addition */ + + ret.sec = ls.sec + rs.sec; + ret.nano = ls.nano + rs.nano; + + /* ensure -STD1BILLION < nano < STD1BILLION */ + + if (ret.nano >= STD1BILLION) { + ++ret.sec; + ret.nano -= STD1BILLION; + + } else if (ret.nano <= -STD1BILLION) { + --ret.sec; + ret.nano += STD1BILLION; + } + + /* check for non-agreement in signs */ + + if (ret.sec > 0) { + + if (ret.nano < 0) { + --ret.sec; + ret.nano += STD1BILLION; + } + + } else if (ret.sec != 0) { + + if (ret.nano > 0) { + ++ret.sec; + ret.nano -= STD1BILLION; + } + } + + /* check for nasty edge case and wrap around if not exactly minimum representation */ + + if (ret.sec == STDINT64_MIN && ret.nano != 0) { + --ret.sec; + ret.nano += STD1BILLION; + } + + return ret; +} + +/************************************************************************************************ + * stdtime_sub: Return the difference of two stdtimes. + ***********************************************************************************************/ + +STDINLINE stdtime stdtime_sub(stdtime ls, stdtime rs) +{ + return stdtime_add(ls, stdtime_neg(rs)); +} + +/************************************************************************************************ + * stdtime64_now: Get the current system time since UTC 00:00:00, Jan 1, 1970. + ***********************************************************************************************/ + +STDINLINE stdcode stdtime64_now(stdtime64 *abs_time) +{ + stdtime t; + stdcode ret = stdtime_now(&t); + + if (ret == STDESUCCESS) { + *abs_time = stdtime64_time(t); + } + + return ret; +} + +/************************************************************************************************ + * stdtime64_time: Return a stdtime64 from a stdtime. + ***********************************************************************************************/ + +STDINLINE stdtime64 stdtime64_time(stdtime t) +{ + STDSAFETY_CHECK(STDTIME_IS_LEGAL(t)); + + return (stdtime64) t.sec * STD1BILLION + t.nano; +} + +/************************************************************************************************ + * stdsleep: Sleep for a period of time. On error, remndr will be + * filled if non-NULL. + ***********************************************************************************************/ + +STDINLINE stdcode stdsleep(stdtime delta, stdtime *remndr) +# if defined(_WIN32) +{ + stdcode ret = STDESUCCESS; + stdtime start_time = { 0, 0 }; + stdtime end_time = { 0, 0 }; + DWORD milli_sleep; + + if (delta.sec < 0 || delta.nano < 0 || delta.nano >= STD1BILLION) { + ret = STDEINVAL; + goto stdsleep_fail; + } + + /* conditional +1 for possible nanosecond division trunctation */ + + milli_sleep = (DWORD) (delta.sec * STD1THOUSAND + delta.nano / STD1MILLION) + (delta.nano != 0 ? 1 : 0); + + Sleep(milli_sleep); + + goto stdsleep_end; + + /* error handling and return */ + + stdsleep_fail: + if (remndr != NULL) { + *remndr = delta; + } + + stdsleep_end: + return ret; +} +#else +{ + stdcode ret; + struct timespec d; + struct timespec r; + + if (delta.sec < 0 || delta.nano < 0 || delta.nano >= STD1BILLION) { + ret = STDEINVAL; + goto stdsleep_fail; + } + + d.tv_sec = (time_t) delta.sec; + d.tv_nsec = delta.nano; + + if ((ret = nanosleep(&d, &r)) != STDESUCCESS) { + ret = errno; + STDSAFETY_CHECK(ret != STDESUCCESS); + + if (remndr != NULL) { + remndr->sec = r.tv_sec; + remndr->nano = r.tv_nsec; + } + } + + goto stdsleep_end; + + /* error handling and return */ + + stdsleep_fail: + if (remndr != NULL) { + *remndr = delta; + } + + stdsleep_end: + return ret; +} +#endif + +/************************************************************************************************ + * stdsleep64: Sleep for a number of nanoseconds. + ***********************************************************************************************/ + +STDINLINE stdcode stdsleep64(stdtime64 delta, stdtime64 *remndr) +{ + stdcode ret; + stdtime t_delta = stdtime_time64(delta); + stdtime t_remndr; + + ret = stdsleep(t_delta, (remndr != NULL ? &t_remndr : NULL)); + + if (ret != STDESUCCESS && remndr != NULL) { + *remndr = stdtime64_time(t_remndr); + } + + return ret; +} + +#ifdef __cplusplus +} +#endif Modified: trunk/stdutil/src/stdutil/private/stdarch.h =================================================================== --- trunk/stdutil/src/stdutil/private/stdarch.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stdarch.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/private/stdarch_autoconf.h.in =================================================================== --- trunk/stdutil/src/stdutil/private/stdarch_autoconf.h.in 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stdarch_autoconf.h.in 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/private/stdarch_wintel32.h =================================================================== --- trunk/stdutil/src/stdutil/private/stdarch_wintel32.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stdarch_wintel32.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/private/stdarr_p.h =================================================================== --- trunk/stdutil/src/stdutil/private/stdarr_p.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stdarr_p.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/private/stdcarr_p.h =================================================================== --- trunk/stdutil/src/stdutil/private/stdcarr_p.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stdcarr_p.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/private/stddll_p.h =================================================================== --- trunk/stdutil/src/stdutil/private/stddll_p.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stddll_p.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/private/stdhash_p.h =================================================================== --- trunk/stdutil/src/stdutil/private/stdhash_p.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stdhash_p.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/private/stdit_p.h =================================================================== --- trunk/stdutil/src/stdutil/private/stdit_p.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stdit_p.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/private/stdskl_p.h =================================================================== --- trunk/stdutil/src/stdutil/private/stdskl_p.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stdskl_p.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,95 +1,95 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University - * All rights reserved. - * - * The contents of this file are subject to a license (the ``License''). - * You may not use this file except in compliance with the License. The - * specific language governing the rights and limitations of the License - * can be found in the file ``STDUTIL_LICENSE'' found in this - * distribution. - * - * Software distributed under the License is distributed on an AS IS - * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. - * - * The Original Software is: - * The Stdutil Library - * - * Contributors: - * Creator - John Lane Schultz ([email protected]) - * The Center for Networking and Distributed Systems - * (CNDS - http://www.cnds.jhu.edu) - */ - -#ifndef stdskl_p_h_2005_06_07_15_09_42_jschultz_at_cnds_jhu_edu -#define stdskl_p_h_2005_06_07_15_09_42_jschultz_at_cnds_jhu_edu - -/* stdskl_node: A type that contains a key-value pair and node linking information. - - height - 0 based height of this node; size of (prevs, nexts) arrays minus 1 - prevs - an array of pointers to previous elements in the list - nexts - an array of pointers to later elements in the list - key - pointer to the node's key - val - pointer to the node's val - - NOTE: The prevs and nexts arrays are appended onto the end of the - node in memory. - - NOTE: The key and value are then appended onto the end of this node in - memory after the prevs and nexts arrays (w/ padding as necessary). -*/ - -typedef struct stdskl_node -{ - stdint8 height; - struct stdskl_node ** prevs; - struct stdskl_node ** nexts; - - const void * key; - void * val; - -} stdskl_node; - -/* stdskl: A skiplist based dictionary that maps non-unique keys to values. - - end_node - pointer to sentinel end node of list - size - number of key-value pairs contained - ksize - size in bytes of key type contained - vsize - size in bytes of value type contained - cmp_fcn - user defined key comparison function - seed - state used to generate pseudo-random numbers - rand_bits - a random number that contains random bits - bits_left - how many unused bits remain in rand_bits -*/ - -typedef struct stdskl -{ - stdskl_node * end_node; - - stdsize size; - - stdsize ksize; - stdsize vsize; - - stdcmp_fcn cmp_fcn; - - stduint16 seed[3]; - stduint32 rand_bits; - stdint8 bits_left; - -} stdskl; - -/* stdskl_it: An iterator for a stdskl. - - node - pointer to the reference node in the list - ksize - size in bytes of referenced key type - vsize - size in bytes of referenced value type -*/ - -typedef struct -{ - stdskl_node * node; - stdsize ksize; - stdsize vsize; - -} stdskl_it; - -#endif +/* Copyright (c) 2000-2009, The Johns Hopkins University + * All rights reserved. + * + * The contents of this file are subject to a license (the ``License''). + * You may not use this file except in compliance with the License. The + * specific language governing the rights and limitations of the License + * can be found in the file ``STDUTIL_LICENSE'' found in this + * distribution. + * + * Software distributed under the License is distributed on an AS IS + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * The Original Software is: + * The Stdutil Library + * + * Contributors: + * Creator - John Lane Schultz ([email protected]) + * The Center for Networking and Distributed Systems + * (CNDS - http://www.cnds.jhu.edu) + */ + +#ifndef stdskl_p_h_2005_06_07_15_09_42_jschultz_at_cnds_jhu_edu +#define stdskl_p_h_2005_06_07_15_09_42_jschultz_at_cnds_jhu_edu + +/* stdskl_node: A type that contains a key-value pair and node linking information. + + height - 0 based height of this node; size of (prevs, nexts) arrays minus 1 + prevs - an array of pointers to previous elements in the list + nexts - an array of pointers to later elements in the list + key - pointer to the node's key + val - pointer to the node's val + + NOTE: The prevs and nexts arrays are appended onto the end of the + node in memory. + + NOTE: The key and value are then appended onto the end of this node in + memory after the prevs and nexts arrays (w/ padding as necessary). +*/ + +typedef struct stdskl_node +{ + stdint8 height; + struct stdskl_node ** prevs; + struct stdskl_node ** nexts; + + const void * key; + void * val; + +} stdskl_node; + +/* stdskl: A skiplist based dictionary that maps non-unique keys to values. + + end_node - pointer to sentinel end node of list + size - number of key-value pairs contained + ksize - size in bytes of key type contained + vsize - size in bytes of value type contained + cmp_fcn - user defined key comparison function + seed - state used to generate pseudo-random numbers + rand_bits - a random number that contains random bits + bits_left - how many unused bits remain in rand_bits +*/ + +typedef struct stdskl +{ + stdskl_node * end_node; + + stdsize size; + + stdsize ksize; + stdsize vsize; + + stdcmp_fcn cmp_fcn; + + stduint16 seed[3]; + stduint32 rand_bits; + stdint8 bits_left; + +} stdskl; + +/* stdskl_it: An iterator for a stdskl. + + node - pointer to the reference node in the list + ksize - size in bytes of referenced key type + vsize - size in bytes of referenced value type +*/ + +typedef struct +{ + stdskl_node * node; + stdsize ksize; + stdsize vsize; + +} stdskl_it; + +#endif Modified: trunk/stdutil/src/stdutil/private/stdthread_p.h =================================================================== --- trunk/stdutil/src/stdutil/private/stdthread_p.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/private/stdthread_p.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). @@ -22,7 +22,16 @@ #ifndef stdthread_p_h_2000_05_18_12_57_48_jschultz_at_cnds_jhu_edu #define stdthread_p_h_2000_05_18_12_57_48_jschultz_at_cnds_jhu_edu -#if defined(_WIN32) +#if !defined(_REENTRANT) + +# define STDTHREAD_FCN + +typedef int stdthread; +typedef int stdthread_id; +typedef int stdmutex_impl; +typedef int stdcond_impl; + +#elif defined(_WIN32) # include <windows.h> # define STDTHREAD_FCN __stdcall @@ -97,4 +106,4 @@ typedef stdcond_impl stdcond; -# endif +#endif Modified: trunk/stdutil/src/stdutil/stdarr.h =================================================================== --- trunk/stdutil/src/stdutil/stdarr.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stdarr.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/stdcarr.h =================================================================== --- trunk/stdutil/src/stdutil/stdcarr.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stdcarr.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/stddefines.h =================================================================== --- trunk/stdutil/src/stdutil/stddefines.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stddefines.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). @@ -69,21 +69,21 @@ typedef stdarch_int32 stdint32; typedef stdarch_uint32 stduint32; -#define STDINT32_MAX (STDINT32_MIN - 1) +#define STDINT32_MAX ((stdint32) ((stduint32) STDINT32_MIN - 1)) #define STDINT32_MIN ((stdint32) ((stduint32) 0x1 << 31)) #define STDUINT32_MAX ((stduint32) -1) typedef stdarch_int64 stdint64; typedef stdarch_uint64 stduint64; -#define STDINT64_MAX (STDINT64_MIN - 1) +#define STDINT64_MAX ((stdint64) ((stduint64) STDINT64_MIN - 1)) #define STDINT64_MIN ((stdint64) ((stduint64) 0x1 << 63)) #define STDUINT64_MAX ((stduint64) -1) typedef size_t stdsize; typedef stdarch_ssize stdssize; /* a signed version of size_t */ -#define STDSSIZE_MAX (STDSSIZE_MIN - 1) +#define STDSSIZE_MAX ((stdssize) ((stdsize) STDSSIZE_MIN - 1)) #define STDSSIZE_MIN ((stdssize) ((stdsize) 0x1 << (sizeof(stdssize) * 8 - 1)) #define STDSIZE_MAX ((stdsize) -1) Modified: trunk/stdutil/src/stdutil/stddll.h =================================================================== --- trunk/stdutil/src/stdutil/stddll.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stddll.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/stderror.h =================================================================== --- trunk/stdutil/src/stdutil/stderror.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stderror.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). @@ -124,6 +124,12 @@ # define STDEINTR 507 #endif +#if defined(ETIMEDOUT) +# define STDETIMEDOUT ETIMEDOUT +#else +# define STDETIMEDOUT 508 +#endif + #ifdef __cplusplus } #endif Modified: trunk/stdutil/src/stdutil/stdfd.h =================================================================== --- trunk/stdutil/src/stdutil/stdfd.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stdfd.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,89 +1,89 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University - * All rights reserved. - * - * The contents of this file are subject to a license (the ``License''). - * You may not use this file except in compliance with the License. The - * specific language governing the rights and limitations of the License - * can be found in the file ``STDUTIL_LICENSE'' found in this - * distribution. - * - * Software distributed under the License is distributed on an AS IS - * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. - * - * The Original Software is: - * The Stdutil Library - * - * Contributors: - * Creator - John Lane Schultz ([email protected]) - * The Center for Networking and Distributed Systems - * (CNDS - http://www.cnds.jhu.edu) - */ - -#ifndef stdfd_h_2003_10_20_13_49_08_jschultz_at_cnds_jhu_edu -#define stdfd_h_2003_10_20_13_49_08_jschultz_at_cnds_jhu_edu - -#include <stdio.h> -#include <stdutil/stddefines.h> - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct -{ - int fd; - FILE * stream; - -} stdfd; - -#define STDFD_INIT() { -1, NULL } - -typedef enum -{ - STDFD_READ_ONLY = 2000, /* rb */ - STDFD_READ_WRITE_EXISTING, /* rb+ */ - STDFD_WRITE_ONLY, /* wb */ - STDFD_READ_WRITE_NEW, /* wb+ */ - STDFD_APPEND_ONLY, /* ab */ - STDFD_READ_APPEND /* ab+ */ - -} stdfd_access_type; /* as per fopen(): redefined for static enum check warnings */ - -typedef enum -{ - STDSEEK_SET = SEEK_SET, - STDSEEK_CUR = SEEK_CUR, - STDSEEK_END = SEEK_END - -} stdfd_whence; /* as per fseek(): redefined for static enum check warnings */ - -/* File Descriptor Operations */ - -STDINLINE stdcode stdfd_open(stdfd *fd, const char *path, stdfd_access_type mode); -STDINLINE stdcode stdfd_close(stdfd *fd); - -STDINLINE stdcode stdfd_read(stdfd *fd, void *ptr, stdsize nsize, stdsize nmemb, stdsize *num); -STDINLINE stdcode stdfd_write(stdfd *fd, const void *ptr, stdsize nsize, stdsize nmemb, stdsize *num); - -STDINLINE stdcode stdfd_flush(stdfd *fd); -STDINLINE stdcode stdfd_sync(stdfd *fd); - -STDINLINE stdcode stdfd_seek(stdfd *fd, long offset, stdfd_whence whence); -STDINLINE stdcode stdfd_tell(stdfd *fd, long *pos); - -STDINLINE stdbool stdfd_eof(stdfd *fd); -STDINLINE stdbool stdfd_err(stdfd *fd); -STDINLINE void stdfd_clr_err(stdfd *fd); - -STDINLINE stdcode stdfd_trylock(stdfd *fd); -STDINLINE stdcode stdfd_unlock(stdfd *fd); - -/* File Operations */ - -STDINLINE stdcode stdfile_unlink(const char * path); - -#ifdef __cplusplus -} -#endif - -#endif +/* Copyright (c) 2000-2009, The Johns Hopkins University + * All rights reserved. + * + * The contents of this file are subject to a license (the ``License''). + * You may not use this file except in compliance with the License. The + * specific language governing the rights and limitations of the License + * can be found in the file ``STDUTIL_LICENSE'' found in this + * distribution. + * + * Software distributed under the License is distributed on an AS IS + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * The Original Software is: + * The Stdutil Library + * + * Contributors: + * Creator - John Lane Schultz ([email protected]) + * The Center for Networking and Distributed Systems + * (CNDS - http://www.cnds.jhu.edu) + */ + +#ifndef stdfd_h_2003_10_20_13_49_08_jschultz_at_cnds_jhu_edu +#define stdfd_h_2003_10_20_13_49_08_jschultz_at_cnds_jhu_edu + +#include <stdio.h> +#include <stdutil/stddefines.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct +{ + int fd; + FILE * stream; + +} stdfd; + +#define STDFD_INIT() { -1, NULL } + +typedef enum +{ + STDFD_READ_ONLY = 2000, /* rb */ + STDFD_READ_WRITE_EXISTING, /* rb+ */ + STDFD_WRITE_ONLY, /* wb */ + STDFD_READ_WRITE_NEW, /* wb+ */ + STDFD_APPEND_ONLY, /* ab */ + STDFD_READ_APPEND /* ab+ */ + +} stdfd_access_type; /* as per fopen(): redefined for static enum check warnings */ + +typedef enum +{ + STDSEEK_SET = SEEK_SET, + STDSEEK_CUR = SEEK_CUR, + STDSEEK_END = SEEK_END + +} stdfd_whence; /* as per fseek(): redefined for static enum check warnings */ + +/* File Descriptor Operations */ + +STDINLINE stdcode stdfd_open(stdfd *fd, const char *path, stdfd_access_type mode); +STDINLINE stdcode stdfd_close(stdfd *fd); + +STDINLINE stdcode stdfd_read(stdfd *fd, void *ptr, stdsize nsize, stdsize nmemb, stdsize *num); +STDINLINE stdcode stdfd_write(stdfd *fd, const void *ptr, stdsize nsize, stdsize nmemb, stdsize *num); + +STDINLINE stdcode stdfd_flush(stdfd *fd); +STDINLINE stdcode stdfd_sync(stdfd *fd); + +STDINLINE stdcode stdfd_seek(stdfd *fd, long offset, stdfd_whence whence); +STDINLINE stdcode stdfd_tell(stdfd *fd, long *pos); + +STDINLINE stdbool stdfd_eof(stdfd *fd); +STDINLINE stdbool stdfd_err(stdfd *fd); +STDINLINE void stdfd_clr_err(stdfd *fd); + +STDINLINE stdcode stdfd_trylock(stdfd *fd); +STDINLINE stdcode stdfd_unlock(stdfd *fd); + +/* File Operations */ + +STDINLINE stdcode stdfile_unlink(const char * path); + +#ifdef __cplusplus +} +#endif + +#endif Modified: trunk/stdutil/src/stdutil/stdhash.h =================================================================== --- trunk/stdutil/src/stdutil/stdhash.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stdhash.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/stdit.h =================================================================== --- trunk/stdutil/src/stdutil/stdit.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stdit.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil/stdskl.h =================================================================== --- trunk/stdutil/src/stdutil/stdskl.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stdskl.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,105 +1,105 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University - * All rights reserved. - * - * The contents of this file are subject to a license (the ``License''). - * You may not use this file except in compliance with the License. The - * specific language governing the rights and limitations of the License - * can be found in the file ``STDUTIL_LICENSE'' found in this - * distribution. - * - * Software distributed under the License is distributed on an AS IS - * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. - * - * The Original Software is: - * The Stdutil Library - * - * Contributors: - * Creator - John Lane Schultz ([email protected]) - * The Center for Networking and Distributed Systems - * (CNDS - http://www.cnds.jhu.edu) - */ - -#ifndef stdskl_h_2004_07_24_13_13_49_jschultz_at_cnds_jhu_edu -#define stdskl_h_2004_07_24_13_13_49_jschultz_at_cnds_jhu_edu - -#include <stdutil/stdit.h> - -# ifdef __cplusplus -extern "C" { -# endif - -/* Structors */ - -STDINLINE stdcode stdskl_construct(stdskl *l, stdsize ksize, stdsize vsize, stdcmp_fcn kcmp); -STDINLINE stdcode stdskl_copy_construct(stdskl *dst, const stdskl *src); -STDINLINE void stdskl_destruct(stdskl *l); - -/* Assigners */ - -STDINLINE stdcode stdskl_set_eq(stdskl *dst, const stdskl *src); -STDINLINE void stdskl_swap(stdskl *l1, stdskl *l2); - -/* Iterators */ - -STDINLINE stdit * stdskl_begin(const stdskl *l, stdit *it); -STDINLINE stdit * stdskl_last(const stdskl *l, stdit *it); -STDINLINE stdit * stdskl_end(const stdskl *l, stdit *it); -STDINLINE stdit * stdskl_get(const stdskl *l, stdit *it, size_t elem_num); /* O(n) */ - -STDINLINE stdbool stdskl_is_begin(const stdskl *l, const stdit *it); -STDINLINE stdbool stdskl_is_end(const stdskl *l, const stdit *it); - -/* Size Information */ - -STDINLINE stdsize stdskl_size(const stdskl *l); -STDINLINE stdbool stdskl_empty(const stdskl *l); - -/* Size Operations */ - -STDINLINE void stdskl_clear(stdskl *l); - -/* Dictionary Operations: O(lg n) */ - -STDINLINE stdit * stdskl_find(const stdskl *l, stdit *it, const void *key); -STDINLINE stdit * stdskl_lowerb(const stdskl *l, stdit *it, const void *key); -STDINLINE stdit * stdskl_upperb(const stdskl *l, stdit *it, const void *key); -STDINLINE stdbool stdskl_contains(const stdskl *l, const void *key); - -STDINLINE stdcode stdskl_put(stdskl *l, stdit *it, const void *key, const void *val, stdbool hint); -STDINLINE stdcode stdskl_put_n(stdskl *l, stdit *it, const void *keys, const void *vals, stdsize num_put, stdbool hint); -STDINLINE stdcode stdskl_put_seq(stdskl *l, stdit *it, const stdit *b, const stdit *e, stdbool hint); -STDINLINE stdcode stdskl_put_seq_n(stdskl *l, stdit *it, const stdit *b, stdsize num_put, stdbool hint); - -STDINLINE stdcode stdskl_insert(stdskl *l, stdit *it, const void *key, const void *val, stdbool hint); -STDINLINE stdcode stdskl_insert_n(stdskl *l, stdit *it, const void *keys, const void *vals, stdsize num_insert, stdbool hint); -STDINLINE stdcode stdskl_insert_seq(stdskl *l, stdit *it, const stdit *b, const stdit *e, stdbool hint); -STDINLINE stdcode stdskl_insert_seq_n(stdskl *l, stdit *it, const stdit *b, stdsize num_insert, stdbool hint); -STDINLINE stdcode stdskl_insert_rep(stdskl *l, stdit *it, const void *key, const void *val, stdsize num_times, stdbool hint); - -STDINLINE void stdskl_erase(stdskl *l, stdit *it); -STDINLINE void stdskl_erase_n(stdskl *l, stdit *it, stdsize num_erase); -STDINLINE void stdskl_erase_seq(stdskl *l, stdit *b, stdit *e); -STDINLINE void stdskl_erase_key(stdskl *l, const void *key); - -/* Randomization */ - -STDINLINE void stdskl_dseed(stdskl *l, const void *seed, stdsize sizeof_seed); - -/* Iterator Fcns */ - -STDINLINE const void * stdskl_it_key(const stdit *it); -STDINLINE stdsize stdskl_it_key_size(const stdit *it); -STDINLINE void * stdskl_it_val(const stdit *it); -STDINLINE stdsize stdskl_it_val_size(const stdit *it); -STDINLINE stdbool stdskl_it_eq(const stdit *it1, const stdit *it2); - -STDINLINE stdit * stdskl_it_next(stdit *it); -STDINLINE stdit * stdskl_it_advance(stdit *it, stdsize num_advance); -STDINLINE stdit * stdskl_it_prev(stdit *it); -STDINLINE stdit * stdskl_it_retreat(stdit *it, stdsize num_retreat); - -# ifdef __cplusplus -} -# endif - -#endif +/* Copyright (c) 2000-2009, The Johns Hopkins University + * All rights reserved. + * + * The contents of this file are subject to a license (the ``License''). + * You may not use this file except in compliance with the License. The + * specific language governing the rights and limitations of the License + * can be found in the file ``STDUTIL_LICENSE'' found in this + * distribution. + * + * Software distributed under the License is distributed on an AS IS + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * The Original Software is: + * The Stdutil Library + * + * Contributors: + * Creator - John Lane Schultz ([email protected]) + * The Center for Networking and Distributed Systems + * (CNDS - http://www.cnds.jhu.edu) + */ + +#ifndef stdskl_h_2004_07_24_13_13_49_jschultz_at_cnds_jhu_edu +#define stdskl_h_2004_07_24_13_13_49_jschultz_at_cnds_jhu_edu + +#include <stdutil/stdit.h> + +# ifdef __cplusplus +extern "C" { +# endif + +/* Structors */ + +STDINLINE stdcode stdskl_construct(stdskl *l, stdsize ksize, stdsize vsize, stdcmp_fcn kcmp); +STDINLINE stdcode stdskl_copy_construct(stdskl *dst, const stdskl *src); +STDINLINE void stdskl_destruct(stdskl *l); + +/* Assigners */ + +STDINLINE stdcode stdskl_set_eq(stdskl *dst, const stdskl *src); +STDINLINE void stdskl_swap(stdskl *l1, stdskl *l2); + +/* Iterators */ + +STDINLINE stdit * stdskl_begin(const stdskl *l, stdit *it); +STDINLINE stdit * stdskl_last(const stdskl *l, stdit *it); +STDINLINE stdit * stdskl_end(const stdskl *l, stdit *it); +STDINLINE stdit * stdskl_get(const stdskl *l, stdit *it, size_t elem_num); /* O(n) */ + +STDINLINE stdbool stdskl_is_begin(const stdskl *l, const stdit *it); +STDINLINE stdbool stdskl_is_end(const stdskl *l, const stdit *it); + +/* Size Information */ + +STDINLINE stdsize stdskl_size(const stdskl *l); +STDINLINE stdbool stdskl_empty(const stdskl *l); + +/* Size Operations */ + +STDINLINE void stdskl_clear(stdskl *l); + +/* Dictionary Operations: O(lg n) */ + +STDINLINE stdit * stdskl_find(const stdskl *l, stdit *it, const void *key); +STDINLINE stdit * stdskl_lowerb(const stdskl *l, stdit *it, const void *key); +STDINLINE stdit * stdskl_upperb(const stdskl *l, stdit *it, const void *key); +STDINLINE stdbool stdskl_contains(const stdskl *l, const void *key); + +STDINLINE stdcode stdskl_put(stdskl *l, stdit *it, const void *key, const void *val, stdbool hint); +STDINLINE stdcode stdskl_put_n(stdskl *l, stdit *it, const void *keys, const void *vals, stdsize num_put, stdbool hint); +STDINLINE stdcode stdskl_put_seq(stdskl *l, stdit *it, const stdit *b, const stdit *e, stdbool hint); +STDINLINE stdcode stdskl_put_seq_n(stdskl *l, stdit *it, const stdit *b, stdsize num_put, stdbool hint); + +STDINLINE stdcode stdskl_insert(stdskl *l, stdit *it, const void *key, const void *val, stdbool hint); +STDINLINE stdcode stdskl_insert_n(stdskl *l, stdit *it, const void *keys, const void *vals, stdsize num_insert, stdbool hint); +STDINLINE stdcode stdskl_insert_seq(stdskl *l, stdit *it, const stdit *b, const stdit *e, stdbool hint); +STDINLINE stdcode stdskl_insert_seq_n(stdskl *l, stdit *it, const stdit *b, stdsize num_insert, stdbool hint); +STDINLINE stdcode stdskl_insert_rep(stdskl *l, stdit *it, const void *key, const void *val, stdsize num_times, stdbool hint); + +STDINLINE void stdskl_erase(stdskl *l, stdit *it); +STDINLINE void stdskl_erase_n(stdskl *l, stdit *it, stdsize num_erase); +STDINLINE stdsize stdskl_erase_seq(stdskl *l, stdit *b, stdit *e); +STDINLINE stdsize stdskl_erase_key(stdskl *l, const void *key); + +/* Randomization */ + +STDINLINE void stdskl_dseed(stdskl *l, const void *seed, stdsize sizeof_seed); + +/* Iterator Fcns */ + +STDINLINE const void * stdskl_it_key(const stdit *it); +STDINLINE stdsize stdskl_it_key_size(const stdit *it); +STDINLINE void * stdskl_it_val(const stdit *it); +STDINLINE stdsize stdskl_it_val_size(const stdit *it); +STDINLINE stdbool stdskl_it_eq(const stdit *it1, const stdit *it2); + +STDINLINE stdit * stdskl_it_next(stdit *it); +STDINLINE stdit * stdskl_it_advance(stdit *it, stdsize num_advance); +STDINLINE stdit * stdskl_it_prev(stdit *it); +STDINLINE stdit * stdskl_it_retreat(stdit *it, stdsize num_retreat); + +# ifdef __cplusplus +} +# endif + +#endif Modified: trunk/stdutil/src/stdutil/stdthread.h =================================================================== --- trunk/stdutil/src/stdutil/stdthread.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stdthread.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). @@ -22,22 +22,21 @@ #ifndef stdthread_h_2000_03_14_12_28_17_jschultz_at_cnds_jhu_edu #define stdthread_h_2000_03_14_12_28_17_jschultz_at_cnds_jhu_edu -#if defined(_REENTRANT) /* NOTE: these types and functions are only declared+defined when _REENTRANT is defined */ +#include <stdutil/stddefines.h> -# include <stdutil/stddefines.h> - -# ifdef __cplusplus +#ifdef __cplusplus extern "C" { -# endif +#endif typedef enum { + STDMUTEX_NULL = (int) 0xe38a690cUL, STDMUTEX_FAST = (int) 0xa720c831UL, STDMUTEX_RCRSV = (int) 0x3f6c20deUL } stdmutex_type; -# include <stdutil/private/stdthread_p.h> +#include <stdutil/private/stdthread_p.h> /* Declare thread entry functions like this: void * STDTHREAD_FCN foo(void * arg); */ @@ -80,4 +79,3 @@ # endif #endif -#endif Modified: trunk/stdutil/src/stdutil/stdtime.h =================================================================== --- trunk/stdutil/src/stdutil/stdtime.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stdtime.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,62 +1,62 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University - * All rights reserved. - * - * The contents of this file are subject to a license (the ``License''). - * You may not use this file except in compliance with the License. The - * specific language governing the rights and limitations of the License - * can be found in the file ``STDUTIL_LICENSE'' found in this - * distribution. - * - * Software distributed under the License is distributed on an AS IS - * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. - * - * The Original Software is: - * The Stdutil Library - * - * Contributors: - * Creator - John Lane Schultz ([email protected]) - * The Center for Networking and Distributed Systems - * (CNDS - http://www.cnds.jhu.edu) - */ - -#ifndef stdtime_h_2003_12_18_18_09_56_jschultz_at_cnds_jhu_edu -#define stdtime_h_2003_12_18_18_09_56_jschultz_at_cnds_jhu_edu - -#include <stdutil/stddefines.h> - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct -{ - stdint64 sec; - stdint32 nano; - -} stdtime; - -typedef stdint64 stdtime64; /* time represented in nanoseconds */ - -STDINLINE stdcode stdtime_now(stdtime *abs_time); -STDINLINE stdtime stdtime_time64(stdtime64 src); - -STDINLINE int stdtime_cmp(stdtime ls, stdtime rs); -STDINLINE int stdtime_sign(stdtime t); - -STDINLINE stdtime stdtime_neg(stdtime t); -STDINLINE stdtime stdtime_add(stdtime ls, stdtime rs); -STDINLINE stdtime stdtime_sub(stdtime ls, stdtime rs); - -STDINLINE stdcode stdtime64_now(stdtime64 *abs_time); -STDINLINE stdtime64 stdtime64_time(stdtime t); /* conversion can silently over/under flow */ - -/* sleep fcns */ - -STDINLINE stdcode stdsleep(stdtime delta, stdtime * rem); -STDINLINE stdcode stdsleep64(stdtime64 delta, stdtime64 * rem); - -#ifdef __cplusplus -} -#endif - -#endif +/* Copyright (c) 2000-2009, The Johns Hopkins University + * All rights reserved. + * + * The contents of this file are subject to a license (the ``License''). + * You may not use this file except in compliance with the License. The + * specific language governing the rights and limitations of the License + * can be found in the file ``STDUTIL_LICENSE'' found in this + * distribution. + * + * Software distributed under the License is distributed on an AS IS + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * The Original Software is: + * The Stdutil Library + * + * Contributors: + * Creator - John Lane Schultz ([email protected]) + * The Center for Networking and Distributed Systems + * (CNDS - http://www.cnds.jhu.edu) + */ + +#ifndef stdtime_h_2003_12_18_18_09_56_jschultz_at_cnds_jhu_edu +#define stdtime_h_2003_12_18_18_09_56_jschultz_at_cnds_jhu_edu + +#include <stdutil/stddefines.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct +{ + stdint64 sec; + stdint32 nano; + +} stdtime; + +typedef stdint64 stdtime64; /* time represented in nanoseconds */ + +STDINLINE stdcode stdtime_now(stdtime *abs_time); +STDINLINE stdtime stdtime_time64(stdtime64 src); + +STDINLINE int stdtime_cmp(stdtime ls, stdtime rs); +STDINLINE int stdtime_sign(stdtime t); + +STDINLINE stdtime stdtime_neg(stdtime t); +STDINLINE stdtime stdtime_add(stdtime ls, stdtime rs); +STDINLINE stdtime stdtime_sub(stdtime ls, stdtime rs); + +STDINLINE stdcode stdtime64_now(stdtime64 *abs_time); +STDINLINE stdtime64 stdtime64_time(stdtime t); /* conversion can silently over/under flow */ + +/* sleep fcns */ + +STDINLINE stdcode stdsleep(stdtime delta, stdtime * rem); +STDINLINE stdcode stdsleep64(stdtime64 delta, stdtime64 * rem); + +#ifdef __cplusplus +} +#endif + +#endif Modified: trunk/stdutil/src/stdutil/stdutil.h =================================================================== --- trunk/stdutil/src/stdutil/stdutil.h 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil/stdutil.h 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). Modified: trunk/stdutil/src/stdutil.c =================================================================== --- trunk/stdutil/src/stdutil.c 2009-06-04 20:39:44 UTC (rev 422) +++ trunk/stdutil/src/stdutil.c 2009-06-04 21:22:26 UTC (rev 423) @@ -1,4 +1,4 @@ -/* Copyright (c) 2000-2006, The Johns Hopkins University +/* Copyright (c) 2000-2009, The Johns Hopkins University * All rights reserved. * * The contents of this file are subject to a license (the ``License''). @@ -219,8 +219,7 @@ defined (__BORLANDC__) || defined (__TURBOC__)) # define stdhcode_sfh_get16bits(d) ( *((const stduint16*)(d)) ) #else -# define stdhcode_sfh_get16bits(d) ( ((stduint32) *((const stduint8 *)(d) + 1) << 8) | \ - (stduint32) *(const stduint8 *)(d) ) +# define stdhcode_sfh_get16bits(d) ( ((stduint32) *((const stduint8 *)(d) + 1) << 8) | (stduint32) *(const stduint8 *)(d) ) #endif STDINLINE stduint32 stdhcode_sfh(const void * buf, stdsize buf_len)