Merge branch 'master' of bitbucket.org:cosmicvoids/void_identification

c_tools/mock/loaders/multidark_loader.cpp

@@ -61,9 +61,6 @@ public:
 
     double tempData;
 
-    simu->new_attribute("uniqueID", uniqueID, delete_adaptor<long>);
-    simu->new_attribute("index", index, delete_adaptor<long>);
-
     cout << "loading multidark particles" << endl;
     long actualNumPart = 0;
 
@@ -96,6 +93,8 @@ public:
     applyTransformations(simu);
     simu->NumPart = actualNumPart;
     simu->TotalNumPart = actualNumPart;
+    simu->new_attribute("uniqueID", uniqueID, delete_adaptor<long>);
+    simu->new_attribute("index", index, delete_adaptor<long>);
     return simu;
   }
 };

external/external_build.cmake

@@ -334,6 +334,11 @@ IF(SDF_SUPPORT)
   )
   SET(LIBSDF_INCLUDE_PATH ${LIBSDF_PATH}/include)
   SET(LIBSDF_LIBRARY ${LIBSDF_PATH}/Objfiles/${LIBSDF_ARCH}/libsw.a)
+
+  find_library(RT_LIBRARY rt)
+  IF (RT_LIBRARY)
+    SET(LIBSDF_LIBRARY ${LIBSDF_LIBRARY} ${RT_LIBRARY})
+  ENDIF (RT_LIBRARY)
 ENDIF(SDF_SUPPORT)
 
 include_directories(${CMAKE_BINARY_DIR}/src 

external/libsdf/GNUmakefile

@@ -20,7 +20,7 @@ all: All
 # spell them a little differently in this file...
 include Make-common/Make.generic
 
-subdirs:= libSDF libmpmy
+subdirs:= libSDF libmpmy libsw
 
 All:
 	for dir in $(subdirs); do (cd $$dir; $(MAKE) ARCH=$(ARCH) all); done

external/libsdf/include/libsdf/abm.h

@@ -0,0 +1,91 @@
+#ifndef ABM_dot_H
+#define ABM_dot_H
+
+#include "chn.h"
+#include "dll.h"
+#include "mpmy.h"
+#include "timers.h"
+
+/* Notice that memcpy is a perfectly good ABMpktz_t.  Overzealous
+ compilers will complain because arg2 isn't const and arg3 is an int
+ rather than a size_t.  AAAARRRRGGGGHHHH....  */
+typedef void (ABMpktz_t)(void *to, void *arg, int sz);
+typedef void (ABMhndlr_t)(int src, int len, void *ptr);
+
+typedef struct {
+    int nfuncs;
+    ABMhndlr_t **hndlarray;
+    Dll undeliveredLL;  /* An LL of all messages that have been ISent, but
+			   not Test'ed affirmative. */
+    int done;			/* I hate these! */
+    int doc;
+    int allbitsdone;
+    int alldone;   
+    Dll *Enqueued;		/* array of DLL's, one for each dest */
+    int *destarr;		/* which of Enqueued are non-empty? */
+    int ndests;			/* how many of Enqueued are non-empty? */
+    int *cntarr;		/* how much data for each dest? */
+    Chn undelChn;		/* chain for undelivereLL */
+    Chn QelmtChn;		/* chain for all of the Enqueued Dll's */
+    MPMY_Comm_request Recv_Hndl;
+    int tag;
+    int pktsize;
+    char *recvbuf1;
+    char *recvbuf2;
+    char *recvbufA;
+    char *recvbufB;
+} ABM ;
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+/* Set the whole thing up.  State goes into abm */
+void ABMSetup(ABM *abm, int pktsize, int tag, int nfuncs, ABMhndlr_t *hndlarray[]);
+
+/* Post a message of given size.  When it's time to deliver it,
+   the packetizing func will be called-back with the given arg.
+   When it arrives, the 'handler' hndlarray[type] on the dest node
+   will be called to process it.  */
+void ABMPost(ABM *abm, int dest, int sz, int type, ABMpktz_t *func, void *arg);
+
+/* Poll for incoming messages.  Handlers get called under here.  */
+int ABMPoll(ABM *abm);
+
+/* Poll for incoming messages.  But wait until something arrives. */
+int ABMPollWait(ABM *abm);
+
+/* Flush any Posted messages to dest.  Packetizers get called under here.  (but
+   this may be called by ABMPost if we run out of space) */
+void ABMFlush(ABM *abm);
+
+/* Assert that we won't be sending out any more 'requests' AND that they,
+   along with any 'cascades' that they may have generated have been received.
+   This is automatic with a request/reply type protocol, but requires some
+   kind of ack if messages do not generate a reply to the originator.
+   See pqsort.c for one way to do the acks. */
+void ABMIamDone(ABM *abm);
+
+/* Return true if everybody has called ABMIamDone */
+int ABMAllDone(ABM *abm);
+
+/* Free all memory.  Etc. */
+void ABMShutdown(ABM *abm);
+
+/* Maintain a bunch of 'informative' Counter_t's.  They record the number
+   of bytes sent in messages of logarithmically binned lenths between
+   lo and hi. */
+void ABMHistEnable(int log2lo, int log2hi);
+
+#define ABMHISTFIRST 3		/* don't bother with the hist below 8 bytes */
+#define ABMHISTLEN 16
+extern Counter_t ABMIsendCnt;	/* How many 'buffers' did we actualy Isend. */
+extern Counter_t ABMPostCnt;	/* How many 'messages' did we Post. */
+extern Counter_t ABMByteCnt;	/* How many bytes were Isent. */
+extern Counter_t ABMHistCnt[ABMHISTLEN];
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

external/libsdf/include/libsdf/dll.h

@@ -0,0 +1,90 @@
+#ifndef _DLLdotH_
+#define _DLLdotH_
+
+#include "chn.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+typedef struct Dll_elmt_s{
+    struct Dll_elmt_s *up, *down;
+    void *stuff[1];		/* Will be alloc'ed to something else! */
+    /* DON'T PUT ANYTHING HERE!!! It will be silently mangleded */
+} Dll_elmt;
+
+typedef struct {
+    Dll_elmt Sup, Inf;
+    Chn *chn;
+    int length;			/* why not? */
+} Dll ;
+
+/* Create a Chain suitable for passing to DllCreate */
+void DllCreateChn(Chn *chn, int sz, int n);
+/* Create a new Dll */
+void DllCreate(Dll *dll, Chn *chn);
+/* Terminate a Dll */
+void DllTerminate(Dll *dll);
+/* Return a new element just above 'DOWN' */
+Dll_elmt *DllInsertAbove(Dll *dll, Dll_elmt *down);
+/* Return a new element just below 'UP' */
+Dll_elmt *DllInsertBelow(Dll *dll, Dll_elmt *up);
+/* Delete OLD.  Return nothing. */
+void DllDelete(Dll *dll, Dll_elmt *old);
+/* Delete OLD.  Return the entry that used to be above it. */
+Dll_elmt *DllDeleteUp(Dll *dll, Dll_elmt *old);
+/* Delete OLD.  Return the entry that used to be below it. */
+Dll_elmt *DllDeleteDown(Dll *dll, Dll_elmt *old);
+/* Extract the 'mover' and place it immediately above 'down'.
+   Like DllDelete, followed by DllInsertAbove, but preserve the
+   data in the object. */
+void DllMoveAbove(Dll *dll, Dll_elmt *mover, Dll_elmt *down);
+/* Extract the 'mover' and place it immediately below 'up'.
+   Like DllDelete, followed by DllInsertBelow, but preserve the
+   data in the object. */
+void DllMoveBelow(Dll *dll, Dll_elmt *mover, Dll_elmt *up);
+
+/* These would require __inline__ to be done properly. */
+/* Insert a new element at the bottom, equivalent to:
+   DllInsertAbove(dll, DllInf(dll)); */
+Dll_elmt *DllInsertAtBottom(Dll *dll);
+/* Insert a new element at the top, equivalent to:
+   DllInsertBelow(dll, DllSup(dll)); */
+Dll_elmt *DllInsertAtTop(Dll *dll);
+/* Move to bottom */
+void DllMoveToBottom(Dll *dll, Dll_elmt *mover);
+/* Move to top */
+void DllMoveToTop(Dll *dll, Dll_elmt *mover);
+
+/* Should we bother with __inline__.  These are simple enough that #define 
+ is sufficient. */
+
+/* How many elements? */
+int DllLength(Dll *dll);
+#define DllLength(dll) ((dll)->length)
+/* One past the topmost 'user' element */
+Dll_elmt *DllSup(Dll *dll);
+#define DllSup(dll) (&((dll)->Sup))
+/* One below the lowest 'user' element */
+Dll_elmt *DllInf(Dll *dll);
+#define DllInf(dll) (&((dll)->Inf))
+/* The highest 'user' element */
+Dll_elmt *DllTop(Dll *dll);
+#define DllTop(dll) ((dll)->Sup.down)
+/* The lowest 'user' element */
+Dll_elmt *DllBottom(Dll *dll);
+#define DllBottom(dll) ((dll)->Inf.up)
+/* The 'user' data */
+void *DllData(Dll_elmt *elmt);
+#define DllData(elmt) ((void *)((elmt)->stuff))
+/* The next elements, both up and down */
+Dll_elmt *DllUp(Dll_elmt *elmt);
+#define DllUp(elmt) ((elmt)->up)
+Dll_elmt *DllDown(Dll_elmt *elmt);
+#define DllDown(elmt) ((elmt)->down)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _DLLdotH_ */

external/libsdf/include/libsdf/files.h

@@ -0,0 +1,19 @@
+#ifndef _FILESdotH
+#define _FILESdotH
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+int fexists(const char *name);
+int fexists_and_unlink(const char *name);
+/* These are advisory routines.  They don't actually do anything */
+/* They just check for files named "_ForceOutput_" and "_ForceStop_" */
+int ForceCheckpoint(void);
+int ForceOutput(void);
+int ForceStop(void);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+

external/libsdf/include/libsdf/gc.h

@@ -0,0 +1,57 @@
+#ifndef _GCdotH
+#define _GCdotH
+
+#include <sys/types.h>
+
+/* little functions for doing gray-code stuff. */
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+
+/* Return the parity of num, i.e., parity(0x22)=0 */
+unsigned int parity(unsigned int num);
+
+/* Return the index of the highest bit in num, i.e., 
+   hibit(3) = 1, hibit(1)=0, hibit(513)=9, hibit(0)=-1 */
+int hibit(unsigned int num);
+
+/* Return the index of the lowest bit in num, i.e., 
+   lobit(3) = 0, lobit(2)=1, lobit(512)=9, lobit(513)=0, lobit(0)=BITSPERWORD
+   */
+int lobit(unsigned int num);
+
+/* Return the integer log2 of the argument.  Round down.  Return -1 for 0. */
+/* Same as hibit! */
+int ilog2(unsigned int num);
+
+/* Return the word-wise xor checksum of n bytes in buf. */
+unsigned int cksum(const void *buf, unsigned int n);
+
+/* Return the number of set bits in num.  Is this sometimes called
+   "popcount"? */
+unsigned int countbits(unsigned int num);
+
+/* Return the 'up' graycode neighbor of proc (out of nproc) */
+int Gcup(unsigned int proc, unsigned int nproc);
+
+/* Return the 'down' graycode neighbor of proc (out of nproc) */
+int Gcdown(unsigned int proc, unsigned int nproc);
+
+/* This isn't really gray-code related, but where else can it go? */
+/* It does the simple-minded "decomposition" of gnobj objects over nproc */
+/* processors.  It returns how many to keep and which one to start with. */
+void NobjInitial(int gnobj, int nproc, int procnum, int *nobj, int *start);
+void NobjInitial64(int64_t gnobj, int nproc, int procnum, int *nobj, int64_t *start);
+
+/* These two came from alt.sources */
+/* Return the 'index' of the given gray code (assuming 32-bit longs!) */
+unsigned long gray2bin(unsigned long b);
+
+/* Return the graycode  of a given index */
+unsigned long bin2gray(unsigned long g);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif

external/libsdf/include/libsdf/heap.h

@@ -0,0 +1,152 @@
+/* Super-fast priority queue. ?  Completely inlined by gcc. */
+/* Assume that each pointer points at */
+/* a key, AND whatever else the caller is interested in keeping. */
+#ifndef HEAPdotH
+#define HEAPdotH
+
+
+typedef struct{
+    const float **arr;
+    unsigned int sz;
+    unsigned int cnt;
+} Heap;
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+extern void HeapInit(Heap *hp, unsigned int initial_nelem);
+extern void HeapTerminate(Heap *hp);
+extern void HeapPush(Heap *hp, const float *ptr);
+extern void HeapPop(Heap *hp, const float **keyp);
+extern const float *HeapPeek(const Heap *hp);
+extern const float **HeapBase(const Heap *hp);
+extern const float **HeapEnd(const Heap *hp);
+extern unsigned int HeapCnt(const Heap *hp);
+extern int HeapIsBad(const Heap *hp);
+extern const float HeapMinf;
+extern const float HeapInf;
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* This is an attempt to get the inline functions into the .h file */
+/* without having to maintain two source files.  */
+#if (defined(__GNUC__) || defined(__ICC__)) || defined(HEAPdotC)
+
+#ifndef assert
+#include "Assert.h"
+#endif
+#include <stddef.h>
+#include <float.h>
+#include "Malloc.h"
+
+#undef INLINE
+#if (defined (__GNUC__) || defined(__ICC__)) && !defined (HEAPdotC)
+#define INLINE extern __inline__
+#else
+#define INLINE
+#endif
+
+#ifndef NULL
+#define NULL (void *)0
+#endif
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS 0
+#endif
+
+#if defined(HeapKey) || defined(HeapParent) || defined(HeapLeft)
+ # error Problems with conflicting definitions in heap.h
+#endif
+#define HeapKey(i) (*arr[i])
+#define HeapParent(i) (i>>1)
+#define HeapLeft(i) (i<<1)
+/* Use left+1 for right */
+
+INLINE void HeapPush(Heap *hp, const float *ptr){
+    const float **arr = hp->arr;
+    const float *tmp;
+    unsigned int i = hp->cnt++;
+    unsigned int pi;
+
+    if( i == hp->sz ){
+	unsigned int newsz = (hp->sz)<<1;
+	arr = hp->arr = Realloc(hp->arr, (newsz+1)*sizeof(*(hp->arr)));
+	assert(hp->arr);
+	hp->sz = newsz;
+    }
+
+    arr[i] = ptr;
+    pi = HeapParent(i);
+    while( HeapKey(pi) <= HeapKey(i) ){
+	tmp = arr[pi];
+	arr[pi] = arr[i];
+	arr[i] = tmp;
+	i = pi;
+	pi = HeapParent(i);
+    }
+}
+
+INLINE void HeapPop(Heap *hp, const float **keyp){
+    const float **arr = hp->arr;
+    const float *save;
+    unsigned int i, li, ri, ix, n;
+    float kl, kr, ksave, kx;
+
+    *keyp = arr[1];
+    n = --hp->cnt;
+    assert( n>0 );
+    i = 1;
+    li = 2;
+    ri = 3;
+    save = arr[n];
+    ksave = *save;
+    arr[n] = &HeapMinf;
+    while( li < n ){
+	kl = HeapKey(li);
+	kr = HeapKey(ri);
+	if( kl >= kr ){
+	    ix = li;
+	    kx = kl;
+	}else{
+	    ix = ri;
+	    kx = kr;
+	}
+	if( ksave >= kx ){
+	    break;
+	}
+
+	/* Move ix up the heap */
+	arr[i] = arr[ix];
+	i = ix;
+	li = HeapLeft(ix);
+	ri = li+1;
+    }
+    arr[i] = save;
+}
+
+INLINE const float *HeapPeek(const Heap *hp){
+    return hp->arr[1];
+}
+
+INLINE const float **HeapBase(const Heap *hp){
+    return &hp->arr[1];
+}
+
+INLINE const float **HeapEnd(const Heap *hp){
+    return &hp->arr[hp->cnt];
+}
+
+INLINE unsigned int HeapCnt(const Heap *hp){
+    return hp->cnt-1;
+}
+
+/* Undefine our private macros */
+#ifndef HEAPdotC
+#undef HeapKey
+#undef HeapParent
+#undef HeapLeft
+#endif /* HEAPdotC */
+#undef INLINE
+
+#endif /* __GNUC__ || HEAPdotC */
+#endif /* already included */

external/libsdf/include/libsdf/hwclock.h

@@ -0,0 +1,3 @@
+double hwclock(void);
+double hwtick(void);
+void zero_hwclock(void);

external/libsdf/include/libsdf/key.h

@@ -0,0 +1,524 @@
+#ifndef _KeyDOTh
+#define _KeyDOTh
+
+#include <limits.h>
+
+/* Should we use long long keys???
+   Compiling tree.c (which does a fair amount of key arith), with 
+   LONG_LONG_KEYS turned on results
+   in 25% shorter sparc code (12k vs. 9k), and 15% shorter i860 code
+   (14k vs 12k).  
+
+   HOWEVER:  in both cases, the LONG_LONG_KEYS code does NOT inline
+   the leftshift and rightshift operators.  They are implemented as
+   calls to ___lshrdi3 and ___lshldi3 in libgcc.a
+
+   The bottom line:  TBD.  I-cache vs. call overhead, vs. do the __lsh calls
+   prevent gcc from doing any optimizations across the call?  I'd guess
+   that the LONG_LONG_KEYS are faster.
+*/
+#if defined(KEY96BITS)
+#define NK 3
+#define _KTYPE unsigned int
+#define KEYBITS 94
+#else
+#if defined(LONG_NK1_KEY)
+#define NK 1
+#define _KTYPE unsigned long int
+#else
+#if defined(LONG_LONG_KEYS)
+#define NK 2
+#define _KTYPE unsigned long long int
+#define KEYBITS 94
+#else
+#define NK 2
+#define _KTYPE unsigned long int
+#define KEYBITS 94
+#endif
+
+#endif /* LONG_LONG */
+#endif /* ONE_LONG */
+
+/* Test for #if FORCE_KEY_ALIGNMENT, not for #ifdef, which gives
+   the Make.$(ARCH) the opportunity to do -DFORCE_KEY_ALIGNMENT=0
+*/
+#if !defined(FORCE_KEY_ALIGNMENT) &&  NK==1
+#define FORCE_KEY_ALIGNMENT 1
+#endif
+
+/* We have to typedef Key_t as a struct, or else we can't return it from */
+/* a function */
+typedef struct {
+    _KTYPE k[NK];
+} Key_t;
+
+/* Be careful! KEYBITS is not necessarily where the "body" bit is located */
+#ifndef KEYBITS
+#define KEYBITS (CHAR_BIT*sizeof(Key_t))
+#endif
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+extern char *PrintKey(Key_t key);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#if (defined(__GNUC__) || defined(__ICC__)) || defined(KEYdotC)
+
+#if (__STDC_VERSION__ >= 199901L) && !defined (KEYdotC)
+#define INLINE inline
+#else
+#if (defined (__GNUC__) || defined(__ICC__)) && !defined (KEYdotC)
+#define INLINE extern __inline__
+#else
+#define INLINE
+#endif
+#endif
+
+#if NK==1
+
+INLINE int
+KeyGT(Key_t key1, Key_t key2)
+{
+    return (key1.k[0] > key2.k[0]);
+}
+
+INLINE int
+KeyLT(Key_t key1, Key_t key2)
+{
+    return (key1.k[0] < key2.k[0]);
+}
+
+INLINE int
+KeyGE(Key_t key1, Key_t key2)
+{
+    return (key1.k[0] >= key2.k[0]);
+}
+
+INLINE int
+KeyLE(Key_t key1, Key_t key2)
+{
+    return (key1.k[0] <= key2.k[0]);
+}
+
+INLINE int
+KeyEQ(Key_t key1, Key_t key2)
+{
+    return (key1.k[0] == key2.k[0]);
+}
+
+INLINE int
+KeyNEQ(Key_t key1, Key_t key2)
+{
+    return (key1.k[0] != key2.k[0]);
+}
+
+INLINE Key_t
+KeyXOR(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    ret.k[0] = key1.k[0] ^ key2.k[0];
+    return(ret);
+}
+
+INLINE Key_t
+KeyAnd(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    ret.k[0] = key1.k[0] & key2.k[0];
+    return(ret);
+}
+
+INLINE Key_t
+KeyOr(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    ret.k[0] = key1.k[0] | key2.k[0];
+    return(ret);
+}
+
+INLINE int
+KeyCmp(Key_t key1, Key_t key2)
+{
+  if(key1.k[0] > key2.k[0] )
+    return 1;
+  else if( key1.k[0] < key2.k[0] )
+    return -1;
+  else
+    return 0;
+}
+
+INLINE Key_t
+KeyNot(Key_t key1)
+{
+    key1.k[0] = ~key1.k[0];
+    return key1;
+}
+
+INLINE Key_t
+KeyRshift(Key_t u, int b)
+{
+    Key_t ret;
+    if (b >= CHAR_BIT*sizeof(u.k[0])) ret.k[0] = 0;
+    else ret.k[0] = u.k[0] >> b;
+    return(ret);
+}
+
+INLINE Key_t
+KeyLshift(Key_t u, int b)
+{
+    Key_t ret;
+    ret.k[0] = u.k[0] << b;
+    return(ret);
+}
+
+/* cast int to Key_t */
+INLINE Key_t
+KeyInt(int i)
+{
+    Key_t ret;
+    ret.k[0] = i;
+    return(ret);
+}
+
+INLINE Key_t
+KeyOrInt(Key_t u, unsigned int i)
+{
+    Key_t ret;
+    ret.k[0] = u.k[0] | i;
+    return(ret);
+}
+
+/* bitwise and key with int */
+/* This is a common operation, and is more efficient than converting the */
+/* int to a key.  It returns an int! */
+
+INLINE unsigned int
+KeyAndInt(Key_t u, unsigned int i)
+{
+    return(u.k[0] & i);
+}
+
+/* bitwise and key with ~int */
+/* This is also  common operation, and is more efficient than converting the */
+/* int to a key.  It returns an Key_t (leaving the top bits alone)! */
+
+INLINE Key_t
+KeyAndNotInt(Key_t u, unsigned int i)
+{
+    u.k[0] &= ~((_KTYPE)i);
+    return u;
+}
+
+INLINE Key_t
+KeyAdd(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    
+    ret.k[0] = key1.k[0] + key2.k[0];
+    return(ret);
+}
+
+INLINE Key_t
+KeySub(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    
+    ret.k[0] = key1.k[0] - key2.k[0];
+    return(ret);
+}
+
+INLINE Key_t
+KeyAddInt(Key_t key1, int i)
+{
+    Key_t ret;
+
+    ret.k[0] = key1.k[0] + i;
+    return(ret);
+}
+
+#else
+#if NK==2
+
+INLINE int
+KeyGT(Key_t key1, Key_t key2)
+{
+    if( key1.k[1] > key2.k[1] )
+      return 1;
+    else if( key1.k[1] < key2.k[1] )
+      return 0;
+    else
+      return (key1.k[0] > key2.k[0]);
+}
+
+INLINE int
+KeyLT(Key_t key1, Key_t key2)
+{
+    if( key1.k[1] < key2.k[1] )
+      return 1;
+    else if( key1.k[1] > key2.k[1] )
+      return 0;
+    else
+      return (key1.k[0] < key2.k[0]);
+}
+
+INLINE int
+KeyGE(Key_t key1, Key_t key2)
+{
+    if( key1.k[1] > key2.k[1] )
+      return 1;
+    else if( key1.k[1] < key2.k[1] )
+      return 0;
+    else
+      return (key1.k[0] >= key2.k[0]);
+}
+
+INLINE int
+KeyLE(Key_t key1, Key_t key2)
+{
+    if( key1.k[1] < key2.k[1] )
+      return 1;
+    else if( key1.k[1] > key2.k[1] )
+      return 0;
+    else
+      return (key1.k[0] <= key2.k[0]);
+}
+
+INLINE int
+KeyEQ(Key_t key1, Key_t key2)
+{
+    return (key1.k[0] == key2.k[0] && key1.k[1] == key2.k[1]);
+}
+
+INLINE int
+KeyNEQ(Key_t key1, Key_t key2)
+{
+    return (key1.k[0] != key2.k[0] || key1.k[1] != key2.k[1]);
+}
+
+INLINE Key_t
+KeyXOR(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    ret.k[0] = key1.k[0] ^ key2.k[0];
+    ret.k[1] = key1.k[1] ^ key2.k[1];
+    return(ret);
+}
+
+INLINE Key_t
+KeyAnd(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    ret.k[0] = key1.k[0] & key2.k[0];
+    ret.k[1] = key1.k[1] & key2.k[1];
+    return(ret);
+}
+
+INLINE Key_t
+KeyOr(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    ret.k[0] = key1.k[0] | key2.k[0];
+    ret.k[1] = key1.k[1] | key2.k[1];
+    return(ret);
+}
+
+INLINE int
+KeyCmp(Key_t key1, Key_t key2)
+{
+  if(key1.k[1] > key2.k[1] )
+    return 1;
+  else if( key1.k[1] < key2.k[1] )
+    return -1;
+
+  if(key1.k[0] > key2.k[0] )
+    return 1;
+  else if( key1.k[0] < key2.k[0] )
+    return -1;
+  return 0;
+}
+
+INLINE Key_t
+KeyNot(Key_t key1)
+{
+    key1.k[0] = ~key1.k[0];
+    key1.k[1] = ~key1.k[1];
+    return key1;
+}
+
+INLINE Key_t
+KeyRshift(Key_t u, int b)
+{
+    Key_t ret;
+    long bm = CHAR_BIT*sizeof(u.k[0])-b;
+    
+    if (b == 0) {
+	ret = u;
+    } else if (bm > 0) {
+	ret.k[0] = (u.k[0] >> b) | (u.k[1] << bm);
+	ret.k[1] = u.k[1] >> b;
+    } else {
+	ret.k[0] = u.k[1] >> -bm;
+	ret.k[1] = 0;
+    }
+    return(ret);
+}
+
+INLINE Key_t
+KeyLshift(Key_t u, int b)
+{
+    Key_t ret;
+    long bm = CHAR_BIT*sizeof(u.k[0])-b;
+    
+    if (b == 0) {
+	ret = u;
+    } else if (bm > 0) {
+	ret.k[1] = (u.k[1] << b) | (u.k[0] >> bm);
+	ret.k[0] = u.k[0] << b;
+    } else {
+	ret.k[1] = u.k[0] << -bm;
+	ret.k[0] = 0;
+    }
+    return(ret);
+}
+
+/* cast int to Key_t */
+INLINE Key_t
+KeyInt(int i)
+{
+    Key_t ret;
+    ret.k[1] = 0;
+    ret.k[0] = i;
+    return(ret);
+}
+
+INLINE Key_t
+KeyOrInt(Key_t u, unsigned int i)
+{
+    Key_t ret;
+    ret.k[0] = u.k[0] | i;
+    ret.k[1] = u.k[1];
+    return(ret);
+}
+
+/* bitwise and key with int */
+/* This is a common operation, and is more efficient than converting the */
+/* int to a key.  It returns an int! */
+
+INLINE unsigned int
+KeyAndInt(Key_t u, unsigned int i)
+{
+    return(u.k[0] & i);
+}
+
+/* bitwise and key with ~int */
+/* This is also  common operation, and is more efficient than converting the */
+/* int to a key.  It returns an Key_t (leaving the top bits alone)! */
+
+INLINE Key_t
+KeyAndNotInt(Key_t u, unsigned int i)
+{
+    u.k[0] &= ~((_KTYPE)i);
+    return u;
+}
+
+INLINE Key_t
+KeyAdd(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    
+    ret.k[0] = key1.k[0] + key2.k[0];
+    ret.k[1] = key1.k[1] + key2.k[1];
+    /* We assume keys are unsigned quantities */
+    if (ret.k[0] < key1.k[0] || ret.k[0] < key2.k[0]) /* carry */
+      ret.k[1]++;
+    return(ret);
+}
+
+INLINE Key_t
+KeySub(Key_t key1, Key_t key2)
+{
+    Key_t ret;
+    
+    ret.k[0] = key1.k[0] - key2.k[0];
+    ret.k[1] = key1.k[1] - key2.k[1];
+    /* We assume keys are unsigned quantities */
+    if (ret.k[0] > key1.k[0] || ret.k[0] > key2.k[0]) /* borrow */
+      ret.k[1]--;
+    return(ret);
+}
+
+INLINE Key_t
+KeyAddInt(Key_t key1, int i)
+{
+    Key_t ret;
+
+    ret.k[0] = key1.k[0] + i;
+    ret.k[1] = key1.k[1];
+    if (i >= 0 && ret.k[0] < key1.k[0])	/* carry */
+      ret.k[1]++;
+    else if (i < 0 && ret.k[0] > key1.k[0]) /* borrow */
+      ret.k[1]--;
+    return(ret);
+}
+
+#else
+ # error NK must be 1 or 2
+#endif /* NK==2 */
+#endif /* NK==1 */
+
+INLINE int
+TreeLevel(Key_t key, int ndim)
+{
+    int level;
+    int chubits = (KEYBITS-1)/ndim;
+    Key_t testkey;
+
+    /* First check whether it's a 'body' (at the deepest level.)  */
+    /* This will save considerable time... */
+    testkey = KeyLshift(KeyInt(1), chubits*ndim);
+    if( KeyEQ( testkey, KeyAnd(testkey, key) ) )
+	return chubits;
+
+    /* Now start looking from low levels */
+    testkey = KeyInt(1);
+    for (level = 0; level<chubits; level++){
+	if( KeyEQ(key, testkey) )
+	    return level;
+	key = KeyRshift(key, ndim);
+    }
+    
+    return -1;
+}
+
+/* Find the common level between two 'body'-keys */
+INLINE int
+CommonLev(Key_t bkey1, Key_t bkey2, int ndim)
+{
+    int level = (KEYBITS-1)/ndim;
+    Key_t key0 = KeyInt(0);
+
+    for (bkey1 = KeyXOR(bkey1, bkey2); KeyNEQ(bkey1, key0); level--)
+      bkey1 = KeyRshift(bkey1, ndim);
+    
+    return(level);
+}
+
+INLINE int
+KeyContained(Key_t outer, Key_t key, int ndim)
+{
+    int ret;
+    int difference;
+    
+    /* What if difference is negative?! */
+    difference = TreeLevel(key, ndim) - TreeLevel(outer, ndim);
+    key = KeyRshift(key, ndim*difference);
+    ret = KeyEQ(key, outer);
+    return(ret);
+}
+
+
+#endif /* __GNUC__ || key.c */
+#endif /* _KeyDOTh */

external/libsdf/include/libsdf/keycvt.h

@@ -0,0 +1,74 @@
+/* Functions defined in keycvt.c.  This will go in the library, eventually */
+
+#ifndef KeyUTiLsDOTh
+#define KeyUTiLsDOTh
+
+#include "key.h"
+#define MAXNDIMKU 5
+
+/* Use these as the 'order' argument in CellBBFromKey and GenerateKeys */
+#define MORTON_ORDER 1
+#define PH_ORDER 2
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+
+typedef struct {
+    int ndim;
+    /* Store rmin and the size.  There are lots of choices.  Some might
+       be better than others.  This is one of them... */
+    float rmin[MAXNDIMKU];
+    float sz[MAXNDIMKU];
+} tbbox;			/* a tree-bbox,  */
+
+/* For now, we will break the OO secrecy rule and just let routines know
+   what's inside the tbbox.  Otherwise I have to write a dozen functions
+   to extract and insert values...Ugh. */
+/* CenterBbox is useful, nevertheless */
+void CenterBbox(tbbox *bb, float *center);
+
+/* This gives a tight bounding box around the list of positions.  Note
+   that the result is rmin <= pos[i] and rmax >= pos[i].  The equality
+   can be a headache for float-to-int conversions!  Consider using
+   InflateBbox and or CubeBbox! */
+void TightBbox(float *pstart, int nobj, int pstride, int ndim, tbbox *bb);
+
+/* Make the bbox a cube by expanding the smaller dimensions. */
+void CubeBbox(tbbox *bb);
+
+/* Increase the linear dimension by 'factor' on all sides */
+void InflateBbox(tbbox *bb, float factor);
+
+/* Return 1 if bb1 completely contains bb2 */
+int ContainsBbox(tbbox *bb1, tbbox *bb2);
+
+/* Construct bbu, the 'union' of bb1 and bb2 */
+void UnionBbox(tbbox *bb1, tbbox *bb2, tbbox *bbu);
+
+/* Generate keys for an array of positions (imagine sizeof(body) as the
+   stride argument!) */
+void GenerateKeys(float *pstart, int nobj, int pstride, tbbox *bb, Key_t *kstart, int kstride, int ordering);
+/* This will be set when GenerateKeys detects that a key is out of
+   bounds.  GenerateKeys will not crash and burn, but prudent callers
+   will check KeyOutOfBounds after calling it.  It is cumulative. */
+extern int KeyOutOfBounds;
+
+/* Replacement for CellCorner:  you supply the bbox that describes the
+   Universe, and we return a bbox that describes the cell */
+void CellBBFromKey(Key_t key, tbbox *bb, tbbox *cellbb, int ordering);
+
+/* Some primitive building blocks.  They can be combined with
+ KeyFromInts and IntsFromKey to do the full conversion... */
+void IntsFromFloats(const float *x, unsigned int *ix, tbbox *bb, int nbits);
+void FloatsFromInts(const int *ix, float *x, tbbox *bb, int nbits);
+
+/* These two names conflict with physics_generic.c.  Good.  It will
+   keep me from using physics_generic.c accidentally. */
+Key_t KeyFromInts(unsigned int *xp, int ndim, int nbits);
+int IntsFromKey(Key_t key, unsigned int *ip, int ndim);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif

external/libsdf/include/libsdf/lsv.h

@@ -0,0 +1,27 @@
+#ifndef _LsvDOTh
+#define _LsvDOTh
+
+#define LSV_ANY (-2)
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+extern int LSV_procnum;
+extern int LSV_nproc;
+
+extern char Smy_name[];		/* my hostname or inet address */
+
+void Ssend(const void *outb, int outcnt, int dest, int type);
+int Srecv_block(void *inb, int size, int type, int *from);
+int Srecv(void *inb, int size, int type, int *from);
+void Sclose(void);
+void Sdiag(int (*)(const char *, ...));
+
+void Sinit_host1(int *portp, char **namep);
+void Sinit_host(int nproc);
+void Sinit_elt(void);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _LsvDOTh */

external/libsdf/include/libsdf/peano.h

@@ -0,0 +1,8 @@
+#ifndef __PeanoDOt_H_
+#define __PeanoDOt_H_
+#include "key.h"
+
+Key_t PHKeyFromInts(unsigned int ikey[], int ndim, int depth);
+unsigned int IntsFromPHKey(Key_t key, unsigned int ikey[], int ndim);
+
+#endif

external/libsdf/include/libsdf/qromo.h

@@ -0,0 +1,8 @@
+float qromo(float (*func)(float), float a, float b,
+	float (*choose)(float (*)(float), float, float, int));
+float midpnt(float (*func)(float), float a, float b, int n);
+
+double qromod(double (*func)(double), double a, double b,
+	double (*choose)(double (*)(double), double, double, int));
+double midpntd(double (*func)(double), double a, double b, int n);
+

external/libsdf/include/libsdf/randoms.h

@@ -0,0 +1,26 @@
+#ifndef Randoms2DOTh
+#define Randoms2DOTh
+
+#define NTAB 32
+
+typedef struct{
+    long idum, idum2;
+    long iy, iv[NTAB];
+    int did_init;
+    int next_norml_ok;
+    float next_norml;
+} ran_state;
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+void ran_init(int seed, ran_state *st);
+float uniform_rand(ran_state *s);
+float normal_rand(ran_state *s);
+float sphere_rand(ran_state *st, int ndim, float *x);
+float cube_rand(ran_state *st, int ndim, float *x);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif

external/libsdf/include/libsdf/ring.h

@@ -0,0 +1,19 @@
+#ifndef _RingDOTh
+#define _RingDOTh
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+void Ring(void *bptr, int bsize, int bnobj,
+     void *optr, int osize, int onobj, int oused, 
+     void initf(void *, void *), void interactf(void *, void *, int, int));
+
+void Ring2(void *bptr, int bsize, int bnobj,
+	   void *optr, int osize, int onobj, int tsize, 
+	   void initf(void *, void *), void interactf(void *, void *, int, int), void finishf(void *, void *));
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _RingDOTh */

external/libsdf/include/libsdf/stk.h

@@ -0,0 +1,192 @@
+#ifndef STKdotH
+#define STKdotH
+
+#include <stddef.h>
+#include <string.h>
+#include "Malloc.h"
+
+/* A quick and dirty stack implementation.  Less functionality than */
+/* the RMS obstack.  Is it faster?  */
+
+/* We could lift the code from obstack to determine proper alignment,
+   but I think it's easier to just -Define it in Make.$ARCH */
+
+/* Use char * so we can do arithmetic without annoying casts. */
+typedef struct stk{
+    char *bottom;
+    char *ptr;
+    char *top;
+    int growby;
+    void *(*realloc_like)(void *, size_t);
+    unsigned int align_mask;
+} Stk;
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+/* StkInitWithData starts with the given DATA ptr */
+void StkInitWithData(struct stk *s, size_t initial_sz,
+		     void *(*realloc_like)(void *, size_t), void *data,
+		     unsigned int alignment);
+
+/* StkCopy makes a completely new stack, initialized with the data in FROM */
+
+void StkCopy(struct stk *to, const struct stk *from);
+/* StkInit initializes a stack. */
+void StkInit(struct stk *s, size_t initial_sz, 
+	     void *(*realloc_like)(void *, size_t), unsigned int alignment);
+
+/* StkGrow adds at least nbytes to the available space in the stack. */
+/* FOR INTERNAL USE ONLY */
+void StkGrow(Stk *s, int nbytes);
+
+/* StkTerminate frees the space and forget about it forever */
+void StkTerminate(struct stk *s);
+
+#if !(__STDC_VERSION__ >= 199901L)
+/* StkInitEz chooses reasonable defaults. */
+extern void StkInitEz(struct stk *s);
+
+/* StkPush returns a pointer to room for nbytes at the top of the */
+/* stack.  It's up to you to put something there. */
+extern void *StkPush(struct stk *s, int nbytes);
+/* The 'Align' version makes sure that the stack remains aligned.
+   Use if WITH AND ONLY WITH StkPopAlign */
+extern void *StkPushAlign(struct stk *s, int nbytes);
+
+/* StkPushData does a push and a memcpy */
+extern void *StkPushData(struct stk *s, void *p, int nbytes);
+
+/* StkPop returns a pointer to the beginning of the nbytes at the */
+/* top of the stack.  The data under those bytes is guaranteed to */
+/* remain intact ONLY UNTIL THE NEXT StkPush, i.e., the data has been */
+/* popped. */
+extern void *StkPop(struct stk *s, int nbytes);
+/* The 'Align' version makes sure that the stack remains aligned.  Use
+   it IF AND ONLY IF with StkPushAlign was used.  NOTE:  you must use
+   the StkPushAlign on the push BEFORE the one that requires alignment! */
+extern void *StkPopAlign(struct stk *s, int nbytes);
+
+/* StkPeek returns the same thing as StkPop, but it doesn't "pop" anything. */
+/* The top of the stack is found by StkPeek(s, 0); */
+extern void *StkPeek(const struct stk *s, int nbytes);
+
+/* StkBase returns the current base of the stack.  Beware, it can move */
+/* around!  It is only guaranteed to stay in place until the next StkPush */
+extern void *StkBase(const struct stk *s);
+
+/* StkSz is the size of the stack. */
+extern size_t StkSz(const struct stk *s);
+
+/* StkTop is easily constructed from the others, but we provide it anyway. */
+/* It returns a pointer just past the end of the current stack. */
+extern void *StkTop(const struct stk *s);
+
+/* StkClear is equivalent to StkPop(s, StkSz(s)), but it returns void */
+extern void StkClear(struct stk *s);
+
+/* StkCrunch realloc's the stack so it doesn't use any more space */
+/* than necessary.  Use it if you know you've reached the high-water-mark */
+extern void *StkCrunch(struct stk *s);
+
+/* Discover the alignment of a given stack.  I.e., how would it  */
+extern int StkAlign(const struct stk *s, unsigned int nbytes);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* Here's a convenient define for popping a known type. */
+#define StkPopType(s, t) (*(t *)StkPop(s, sizeof(t)))
+
+#define StkPushType(s, val, t) (*(t *)StkPush(s, sizeof(t)) = val)
+
+/* StkAlign(n) tells you how many bytes will really be pushed if you */
+/* do a StkPush(n) */
+#ifdef STK_FORCE_ALIGNMENT
+#define _STK_DEFAULT_ALIGNMENT STK_FORCE_ALIGNMENT
+#else
+#define _STK_DEFAULT_ALIGNMENT 1
+#endif
+
+/* Here are all the inlined definitions.  Non-inlined functions */
+/* can go in stk.c */
+
+#if (defined(__GNUC__) || defined(__ICC__)) || defined(STKdotC)
+
+#undef INLINE
+#if (__STDC_VERSION__ >= 199901L) && !defined (STKdotC)
+#define INLINE inline
+#else
+#if (defined (__GNUC__) || defined(__ICC__)) && !defined (STKdotC)
+#define INLINE extern __inline__
+#else
+#define INLINE
+#endif
+#endif
+
+INLINE int StkAlign(const struct stk *s, unsigned int nbytes){
+  return (nbytes + s->align_mask ) & ~s->align_mask;
+}
+
+INLINE void StkInitEz(struct stk *s){
+    StkInit(s, 1024, Realloc_f, _STK_DEFAULT_ALIGNMENT);
+}
+
+INLINE void *StkPush(struct stk *s, int nbytes){
+    char *ret;
+    nbytes = StkAlign(s, nbytes);
+    
+    if( s->ptr + nbytes > s->top ){
+	StkGrow(s, nbytes);
+    }
+    ret = s->ptr;
+    s->ptr += nbytes;
+    return ret;
+}
+
+INLINE void *StkPushData(struct stk *s, void *p, int nbytes){
+    return memcpy(StkPush(s, nbytes), p, nbytes);
+}
+
+INLINE void *StkPop(struct stk *s, int nbytes){
+     nbytes = StkAlign(s, nbytes);
+#ifdef NO_CHECK
+    return s->ptr -= nbytes;
+#else
+    s->ptr -= nbytes;
+    if( s->ptr < s->bottom ){
+	s->ptr += nbytes;	/* undo the damage */
+	return NULL;
+    }else
+	return s->ptr;
+#endif
+}
+
+INLINE void *StkPeek(const struct stk *s, int nbytes){
+    return s->ptr - nbytes;
+}
+
+INLINE void StkClear(struct stk *s){
+    s->ptr = s->bottom;
+}
+
+INLINE void *StkBase(const struct stk *s){
+    return s->bottom;
+}
+
+INLINE size_t StkSz(const struct stk *s){
+    return s->ptr - s->bottom;
+}
+
+INLINE void *StkTop(const struct stk *s){
+    /* NOTE that StkTop is NOT s->top !! */
+    return s->ptr;
+}
+
+#undef INLINE
+#endif /* GNUC || STKdotC */
+
+#endif /* STKdotH */

external/libsdf/include/libsdf/swampi.h

@@ -0,0 +1,144 @@
+#ifndef _MpiDOTh
+#define _MpiDOTh
+
+#define MPI_Init SWAMPI_Init
+#define MPI_Finalize SWAMPI_Finalize
+#define MPI_Abort SWAMPI_Abort
+#define MPI_Comm_rank SWAMPI_Comm_rank
+#define MPI_Comm_size SWAMPI_Comm_size
+#define MPI_Comm_free SWAMPI_Comm_free
+#define MPI_Get_count SWAMPI_Get_count
+#define MPI_Isend SWAMPI_Isend
+#define MPI_Irecv SWAMPI_Irecv
+#define MPI_Issend SWAMPI_Isend	/* can Isend handle Issends? */
+#define MPI_Test SWAMPI_Test
+#define MPI_Wait SWAMPI_Wait
+#define MPI_Waitall SWAMPI_Waitall
+#define MPI_Send SWAMPI_Send
+#define MPI_Recv SWAMPI_Recv
+#define MPI_Sendrecv SWAMPI_Sendrecv
+#define MPI_Bcast SWAMPI_Bcast
+#define MPI_Reduce SWAMPI_Reduce
+#define MPI_Allreduce SWAMPI_Allreduce
+#define MPI_Barrier SWAMPI_Barrier
+#define MPI_Alltoallv SWAMPI_Alltoallv
+#define MPI_Alltoall SWAMPI_Alltoall
+#define MPI_Comm_dup SWAMPI_Comm_dup
+#define MPI_Comm_split SWAMPI_Comm_split
+#define MPI_Type_contiguous SWAMPI_Type_contiguous
+#define MPI_Type_commit SWAMPI_Type_commit
+#define MPI_Wtime SWAMPI_Wtime
+#define MPI_Wtick SWAMPI_Wtick
+
+#ifdef __cplusplus
+extern "C"{
+#endif /* __cplusplus */
+
+typedef struct {
+    int MPI_SOURCE;
+    int MPI_TAG;
+    int MPI_ERROR;
+    int count;
+} MPI_Status;
+
+/* MAXLOC and MINLOC structures */
+typedef struct { float x; int i;} MPI_float_int;
+typedef struct { double x; int i;} MPI_double_int;
+typedef struct { long x; int i;} MPI_long_int;
+typedef struct { int x; int i;} MPI_2int;
+typedef struct { short x; int i;} MPI_short_int;
+typedef struct { long double x; int i;} MPI_long_double_int;
+
+/* Fortran types */
+typedef struct { float real; float imag; } MPI_complex;
+typedef struct { double real; double imag; } MPI_double_complex;
+
+/* must match MPI_Datasize array in swampi.c */
+typedef enum {
+    MPI_FLOAT, MPI_DOUBLE, MPI_LONG_DOUBLE, 
+    MPI_BYTE, MPI_CHAR, MPI_SHORT, MPI_INT, 
+    MPI_LONG, MPI_LONG_LONG,
+    MPI_UNSIGNED, MPI_UNSIGNED_INT, MPI_UNSIGNED_CHAR, 
+    MPI_UNSIGNED_SHORT, MPI_UNSIGNED_LONG, MPI_UNSIGNED_LONG_LONG,
+    MPI_FLOAT_INT, MPI_DOUBLE_INT, MPI_LONG_INT, 
+    MPI_2INT, MPI_SHORT_INT, MPI_LONG_DOUBLE_INT,
+    MPI_COMPLEX, MPI_DOUBLE_COMPLEX, /* for Fortran */
+    MPI_USER_DATA, _MPI_NUMDATATYPES
+} MPI_Datatype;
+
+typedef enum {
+    MPI_SUM, MPI_PROD, MPI_MAX, MPI_MIN, MPI_BAND, MPI_BOR,
+    MPI_BXOR, MPI_LAND, MPI_LOR, MPI_LXOR, MPI_MAXLOC, MPI_MINLOC,
+    _MPI_NUMOPS
+} MPI_Op;
+
+
+typedef void (*MPI_user_comb_func)(void *from1, void *from2, void *to);
+typedef int MPI_Comm;
+typedef void * MPI_Request;
+
+enum MPI_comm { MPI_COMM_WORLD, MPI_COMM_PRIVATE, MPI_COMM_NULL };
+enum MPI_src { MPI_ANY_SOURCE = -1 };
+enum MPI_tag { MPI_ANY_TAG = -1 };
+enum MPI_ret { MPI_ERR_OTHER = -1, MPI_SUCCESS = 0 };
+
+#define MPI_UNDEFINED (-32766)
+#define MPI_REQUEST_NULL ((MPI_Request) 0)
+
+int MPI_Init(int *argcp, char ***argvp);
+int MPI_Finalize(void);
+int MPI_Abort(MPI_Comm comm, int errorcode);
+int MPI_Comm_rank(MPI_Comm comm, int *rank);
+int MPI_Comm_size(MPI_Comm comm, int *size);
+int MPI_Get_count(MPI_Status *status, MPI_Datatype type, int *cnt);
+int MPI_Isend(void *buf, int cnt, MPI_Datatype type, int dest, int tag, 
+	      MPI_Comm comm, MPI_Request *req);
+int MPI_Irecv(void *buf, int cnt, MPI_Datatype type, int src, int tag, 
+	      MPI_Comm comm, MPI_Request *req);
+int MPI_Test(MPI_Request *cptr, int *flag, MPI_Status *stat);
+int MPI_Wait(MPI_Request *cptr, MPI_Status *status);
+int MPI_Waitall(int count, MPI_Request *reqv, MPI_Status *statusv);
+int MPI_Send(void *buf, int cnt, MPI_Datatype type, int dest, int tag, 
+	     MPI_Comm comm);
+int MPI_Recv(void *buf, int cnt, MPI_Datatype type, int src, int tag, 
+	     MPI_Comm comm, MPI_Status *status);
+int MPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+		 int dest, int sendtag, void *recvbuf, int recvcount, 
+		 MPI_Datatype recvtype, int source, int recvtag, 
+		 MPI_Comm comm, MPI_Status *status);
+int MPI_Bcast(void *buf, int cnt, MPI_Datatype type, int src, MPI_Comm comm);
+int MPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, 
+	       MPI_Op op, int root, MPI_Comm comm);
+int MPI_Allreduce(void *sendbuf, void *recvbuf, int count, 
+		  MPI_Datatype datatype, MPI_Op op, MPI_Comm comm);
+int MPI_Barrier(MPI_Comm comm);
+int MPI_Alltoallv(void *sbuf, int *sendcnts, int *sdispls, MPI_Datatype stype, 
+		  void *rbuf, int *recvcnts, int *rdispls, MPI_Datatype rtype, 
+		  MPI_Comm comm);
+int MPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+		 void *recvbuf, int recvcount, MPI_Datatype recvtype, 
+		 MPI_Comm comm);
+int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm);
+int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm);
+int MPI_Comm_free(MPI_Comm *comm);
+int MPI_Type_contiguous(int len, MPI_Datatype type, MPI_Datatype *ptr);
+int MPI_Type_commit(MPI_Datatype *ptr);
+
+double MPI_Wtime(void);
+double MPI_Wtick(void);
+
+/* These convert the enums to a text description */
+char *mpi_op_name[_MPI_NUMOPS], *mpi_datatype_name[_MPI_NUMDATATYPES];
+
+/* These are private for mpi_reduce.c and mpi_bcast.c */
+extern int _MPI_Procnum, _MPI_Nproc;
+extern unsigned int *_MPI_Datasize;
+
+/* These are for mpirun.c */
+void _MPI_init_host1(int *portp, char **namep, int nproc);
+void _MPI_init_host(int nproc);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _MpiDOTh */

external/libsdf/include/libsdf/verify.h

@@ -0,0 +1,44 @@
+/* Defines Verify and VerifyX, which verify the truth of the given 
+   expression.  Unlike assert, they guarantee that the expression be evaluated
+   exactly once.  Thus, you might say:
+
+   Verify(fp=fopen(name, "w"))
+   Verify((nwrit=fwrite(p, sz,ni, fp)) >= 0);
+   VerifyX((nwrit=fwrite(p, sz, ni, fp)) >= 0, Shout("errno=%d, nwrit=%d\n",
+       errno, nwrit));
+   Verify0(stat(path, , &buf));
+   Notice that VerifyX allows you to add "Xtra" information in the event of
+   a failure.
+*/
+#undef Verify
+#undef VerifyX
+/* Is there ever really a good reason to shut this off?? */
+/* You can with -DNVERIFY. */
+# ifndef NVERIFY
+#include "error.h"
+
+#ifndef NO_STRINGIFICATION
+/* One can write a really slick version that uses GNU varargs macros, but */
+/* unfortunately, it would break every other pre-processor.  It isn't even */
+/* possible to #ifdef __GNUC__ it because the pre-processor complains */
+/* about an incorrect arg count.  It might be possible to write it as a */
+/* varargs function, but what's the point? */
+#define VerifyX( expr, xtra) \
+   (expr) ? (void)0 : (xtra, Error("%s failed\n" , #expr))
+#define VerifySX( expr, xtra) \
+   (expr) ? (void)0 : (xtra, SinglError("%s failed\n" , #expr))
+#else
+/* Not only do we not have Stringification, but we assume that we have */
+/* the brain-damaged macro substitution into string constants. */
+#define VerifyX( expr, xtra) \
+   (expr) ? (void)0 : (xtra, Error("%s failed\n" , "expr"))
+#define VerifySX( expr, xtra) \
+   (expr) ? (void)0 : (xtra, SinglError("%s failed\n" , "expr"))
+#endif /* NO_STRINGIFICATION */
+# else
+# define VerifyX( expr, xtra) ((expr),(void)0)
+# endif
+#define Verify( expr ) VerifyX(expr, (void)0)
+#define VerifyS( expr ) VerifySX(expr, (void)0)
+#define Verify0( expr ) Verify(!(expr))
+#define VerifyS0( expr ) VerifyS(!(expr))

external/libsdf/include/libsdf/vop.h

@@ -0,0 +1,328 @@
+/*
+ * Copyright 1991 Michael S. Warren and John K. Salmon.  All Rights Reserved.
+ */
+
+#ifndef NDIM
+ # error NDIM must be defined before reading this file.
+#endif
+
+#if (NDIM!=3) && (NDIM!=2)
+ #error NDIM must be either 2 or 3
+#endif
+
+#ifdef __STDC__
+#define GLUE(a,b) a##b
+#else
+#define GLUE(a,b) a/**/b
+#endif
+
+/* UGLY, but you can use these for parentheses inside the VV macros! */
+#define LPAREN (
+#define RPAREN )
+#define COMMA ,
+#define Dot(a, b) (VVinfix(a, *b, +))
+
+#if (NDIM==3)
+
+#define Sinfix(s, op) s op s op s
+#define Vinfix(a, op) a[0] op a[1] op a[2]
+#define VVinfix(a, b, op) a[0] b[0] op a[1] b[1] op a[2] b[2]
+/* Usage: printf(Sinfix("%g", " "), Vinfix(pos, COMMA)) */
+
+#define VS(a, b) do { \
+	a[0] b; \
+	a[1] b; \
+	a[2] b; \
+      } while(0)
+
+#define VV(a, b) do { \
+        a[0] b[0]; \
+        a[1] b[1]; \
+        a[2] b[2]; \
+      } while(0)
+
+#define VVS(a, b, s) do { \
+        a[0] b[0] s; \
+        a[1] b[1] s; \
+        a[2] b[2] s; \
+      } while(0)
+
+#define VVV(a, b, c) do { \
+        a[0] b[0] c[0]; \
+        a[1] b[1] c[1]; \
+        a[2] b[2] c[2]; \
+      } while(0)
+
+#define VVVV(a, b, c, d) do { \
+        a[0] b[0] c[0] d[0]; \
+        a[1] b[1] c[1] d[1]; \
+        a[2] b[2] c[2] d[2]; \
+      } while(0)
+
+
+#define VVVS(a, b, c, s) do { \
+        a[0] b[0] c[0] s; \
+        a[1] b[1] c[1] s; \
+        a[2] b[2] c[2] s; \
+      } while(0)
+
+#define VVVVS(a, b, c, d, s) do { \
+        a[0] b[0] c[0] d[0] s; \
+        a[1] b[1] c[1] d[1] s; \
+        a[2] b[2] c[2] d[2] s; \
+      } while(0)
+
+
+#define VVVVV(a, b, c, d, e) do { \
+        a[0] b[0] c[0] d[0] e[0]; \
+        a[1] b[1] c[1] d[1] e[1]; \
+        a[2] b[2] c[2] d[2] e[2]; \
+      } while(0)
+
+#define VVVVVS(a, b, c, d, e, s) do { \
+        a[0] b[0] c[0] d[0] e[0] s; \
+        a[1] b[1] c[1] d[1] e[1] s; \
+        a[2] b[2] c[2] d[2] e[2] s; \
+      } while(0)
+
+#define VVVVVV(a, b, c, d, e, f) do { \
+        a[0] b[0] c[0] d[0] e[0] f[0]; \
+        a[1] b[1] c[1] d[1] e[1] f[1]; \
+        a[2] b[2] c[2] d[2] e[2] f[2]; \
+      } while(0)
+
+/* Eleven args! */
+#define Velv(a, b, c, d, e, f, g, h, i, j, k) do { \
+        a[0] b[0] c[0] d[0] e[0] f[0] g[0] h[0] i[0] j[0] k[0]; \
+        a[1] b[1] c[1] d[1] e[1] f[1] g[1] h[1] i[1] j[1] k[1]; \
+        a[2] b[2] c[2] d[2] e[2] f[2] g[2] h[2] i[2] j[2] k[2]; \
+      } while(0)
+
+/* And a couple of matrix operations to support gsw. */
+#define MS(a, b) do { \
+        a[0][0] b; \
+        a[0][1] b; \
+        a[0][2] b; \
+        a[1][0] b; \
+        a[1][1] b; \
+        a[1][2] b; \
+        a[2][0] b; \
+        a[2][1] b; \
+        a[2][2] b; \
+      } while(0)
+
+#define MVV(a, b, c) do { \
+	a[0][0] b[0] c[0]; \
+	a[0][1] b[0] c[1]; \
+	a[0][2] b[0] c[2]; \
+	a[1][0] b[1] c[0]; \
+	a[1][1] b[1] c[1]; \
+	a[1][2] b[1] c[2]; \
+	a[2][0] b[2] c[0]; \
+	a[2][1] b[2] c[1]; \
+	a[2][2] b[2] c[2]; \
+      } while(0)
+
+#define Vdecl(type, v) type v[NDIM]
+
+#define Dotx(a, b) \
+  (GLUE(a,0)*GLUE(b,0) + GLUE(a,1)*GLUE(b,1) + GLUE(a,2)*GLUE(b,2))
+
+/* Use for declarations */
+#define Vxd(a) \
+	GLUE(a,0); \
+	GLUE(a,1); \
+	GLUE(a,2)
+
+/* Use in prototypes */
+#define Vxp(a) \
+	GLUE(a,0), \
+	GLUE(a,1), \
+	GLUE(a,2)
+
+#define VxS(a, b) do { \
+	GLUE(a,0) b; \
+	GLUE(a,1) b; \
+	GLUE(a,2) b; \
+      } while(0)
+
+#define VxV(a, b) do { \
+        GLUE(a,0) b[0]; \
+        GLUE(a,1) b[1]; \
+        GLUE(a,2) b[2]; \
+      } while(0)
+
+#define VxdV(a, b) \
+        GLUE(a,0) b[0]; \
+        GLUE(a,1) b[1]; \
+        GLUE(a,2) b[2]
+
+#define VVx(a, b) do { \
+        a[0] GLUE(b,0); \
+        a[1] GLUE(b,1); \
+        a[2] GLUE(b,2); \
+      } while(0)
+
+#define VxVx(a, b) do { \
+        GLUE(a,0) GLUE(b,0); \
+        GLUE(a,1) GLUE(b,1); \
+        GLUE(a,2) GLUE(b,2); \
+      } while(0)
+
+
+#define VxVV(a, b, c) do { \
+        GLUE(a,0) b[0] c[0]; \
+        GLUE(a,1) b[1] c[1]; \
+        GLUE(a,2) b[2] c[2]; \
+      } while(0)
+
+#define VxVVS(a, b, c, s) do { \
+        GLUE(a,0) b[0] c[0] s; \
+        GLUE(a,1) b[1] c[1] s; \
+        GLUE(a,2) b[2] c[2] s; \
+      } while(0)
+
+#define VxVVx(a, b, c) do { \
+        GLUE(a,0) b[0] GLUE(c,0); \
+        GLUE(a,1) b[1] GLUE(c,1); \
+        GLUE(a,2) b[2] GLUE(c,2); \
+      } while(0)
+
+#define VxVxV(a, b, c) do { \
+        GLUE(a,0) GLUE(b,0) c[0]; \
+        GLUE(a,1) GLUE(b,1) c[1]; \
+        GLUE(a,2) GLUE(b,2) c[2]; \
+      } while(0)
+
+#define VxVxVx(a, b, c) do { \
+        GLUE(a,0) GLUE(b,0) GLUE(c,0); \
+        GLUE(a,1) GLUE(b,1) GLUE(c,1); \
+        GLUE(a,2) GLUE(b,2) GLUE(c,2); \
+      } while(0)
+
+#define VVxVx(a, b, c) do{ \
+	a[0] GLUE(b,0) GLUE(c,0); \
+	a[1] GLUE(b,1) GLUE(c,1); \
+	a[2] GLUE(b,2) GLUE(c,2); \
+      } while(0)
+
+#endif /* NDIM == 3 */
+
+#if (NDIM==2)
+
+#define Sinfix(s, op) s op s
+#define Vinfix(a, op) a[0] op a[1]
+#define VVinfix(a, b, op) a[0] b[0] op a[1] b[1]
+/* Usage: printf(Sinfix("%g", " "), Vinfix(pos, COMMA)) */
+
+#define VS(a, b) do { \
+	a[0] b; \
+	a[1] b; \
+      } while(0)
+
+#define VV(a, b) do { \
+        a[0] b[0]; \
+        a[1] b[1]; \
+      } while(0)
+
+#define VVS(a, b, s) do { \
+        a[0] b[0] s; \
+        a[1] b[1] s; \
+        a[2] b[2] s; \
+      } while(0)
+
+#define VVV(a, b, c) do { \
+        a[0] b[0] c[0]; \
+        a[1] b[1] c[1]; \
+      } while(0)
+
+#define VVVS(a, b, c, s) do { \
+        a[0] b[0] c[0] s; \
+        a[1] b[1] c[1] s; \
+      } while(0)
+
+#define VVVVS(a, b, c, d, s) do { \
+        a[0] b[0] c[0] d[0] s; \
+        a[1] b[1] c[1] d[1] s; \
+      } while(0)
+
+#define VVVV(a, b, c, d) do { \
+        a[0] b[0] c[0] d[0]; \
+        a[1] b[1] c[1] d[1]; \
+      } while(0)
+
+#define VVVVV(a, b, c, d, e) do { \
+        a[0] b[0] c[0] d[0] e[0]; \
+        a[1] b[1] c[1] d[1] e[1]; \
+      } while(0)
+
+#define Vdecl(type, v) type v[NDIM]
+
+#define Dotx(a, b) \
+  (GLUE(a,0)*GLUE(b,0) + GLUE(a,1)*GLUE(b,1))
+
+#define Vxd(a) \
+	GLUE(a,0); \
+	GLUE(a,1)
+
+#define VxS(a, b) do { \
+	GLUE(a,0) b; \
+	GLUE(a,1) b; \
+      } while(0)
+
+#define VxV(a, b) do { \
+        GLUE(a,0) b[0]; \
+        GLUE(a,1) b[1]; \
+      } while(0)
+
+#define VxdV(a, b) \
+        GLUE(a,0) b[0]; \
+        GLUE(a,1) b[1]
+
+#define VVx(a, b) do { \
+        a[0] GLUE(b,0); \
+        a[1] GLUE(b,1); \
+      } while(0)
+
+#define VxVx(a, b) do { \
+        GLUE(a,0) GLUE(b,0); \
+        GLUE(a,1) GLUE(b,1); \
+      } while(0)
+
+
+#define VxVV(a, b, c) do { \
+        GLUE(a,0) b[0] c[0]; \
+        GLUE(a,1) b[1] c[1]; \
+      } while(0)
+
+#define VxVVS(a, b, c, s) do { \
+        GLUE(a,0) b[0] c[0] s; \
+        GLUE(a,1) b[1] c[1] s; \
+      } while(0)
+
+#define VxVVx(a, b, c) do { \
+        GLUE(a,0) b[0] GLUE(c,0); \
+        GLUE(a,1) b[1] GLUE(c,1); \
+      } while(0)
+
+#define VxVVS(a, b, c, s) do { \
+        GLUE(a,0) b[0] c[0] s; \
+        GLUE(a,1) b[1] c[1] s; \
+      } while(0)
+
+#define VVxVx(a, b, c) do{ \
+	a[0] GLUE(b,0) GLUE(c,0); \
+	a[1] GLUE(b,1) GLUE(c,1); \
+      } while(0)
+
+#define VxVxV(a, b, c) do { \
+        GLUE(a,0) GLUE(b,0) c[0]; \
+        GLUE(a,1) GLUE(b,1) c[1]; \
+      } while(0)
+
+#define VxVxVx(a, b, c) do { \
+        GLUE(a,0) GLUE(b,0) GLUE(c,0); \
+        GLUE(a,1) GLUE(b,1) GLUE(c,1); \
+      } while(0)
+
+#endif /* NDIM == 2 */

external/libsdf/libSDF/GNUmakefile

@@ -16,31 +16,56 @@ include $(treedir)/Make-common/Make.$(ARCH)
 include $(treedir)/Make-common/Make.generic
 
 # These rules are slight modifications of the builtin ones
-$(objdir)/%.c : %.y
-	$(YACC.y) $<
-	mv -f y.tab.c $@
+%.c : %.y
+	-($(YACC.y) $<; mv -f y.tab.c $@)
 
-$(objdir)/%.c : %.l
+%.c : %.l
 #  commands to execute (built-in):
-	@$(RM) $@ 
-	$(LEX.l) $< > $@
+	-($(LEX) $(LEX.L) $<; mv -f lex.yy.c $@)
 
 # Makedepends can't pick these up...
-$(objdir)/SDF-parse$(objsuf): SDF-private.h $(objdir)/SDF-lex.c $(objdir)/SDF-parse.c
-	(cd $(objdir); $(CC) $(CFLAGS) -I../../../include -I../.. -c SDF-parse.c)
+$(objdir)/SDF-parse$(objsuf): SDF-private.h SDF-lex.c SDF-parse.c
+	(cd $(objdir); $(CC) $(CFLAGS) -I../../../include/libsdf -I../.. -c ../../SDF-parse.c)
 
 # DO NOT DELETE THIS LINE -- make depend depends on it.
 
 $(objdir)/SDF-parse$(objsuf):
 $(objdir)/SDF-parse$(objsuf):
-$(objdir)/SDF-parse$(objsuf): $(treedir)/include/libsdf/protos.h
-$(objdir)/SDF-parse$(objsuf): $(treedir)/include/libsdf/Msgs.h
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf): $(treedir)/include/libsdf/protos.h $(treedir)/include/libsdf/Msgs.h
 $(objdir)/SDF-parse$(objsuf): $(treedir)/include/libsdf/gccextensions.h SDF-private.h stdio.h
 $(objdir)/SDF-parse$(objsuf): $(treedir)/include/libsdf/mpmy_io.h
 $(objdir)/SDF-parse$(objsuf): $(treedir)/include/libsdf/SDF.h $(treedir)/include/libsdf/Malloc.h
 $(objdir)/SDF-parse$(objsuf): $(treedir)/include/libsdf/error.h SDF-lex.c
 $(objdir)/SDF-parse$(objsuf):
 $(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDF-parse$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
+$(objdir)/SDFfuncs$(objsuf):
 $(objdir)/SDFfuncs$(objsuf):
 $(objdir)/SDFfuncs$(objsuf):
 $(objdir)/SDFfuncs$(objsuf):
@@ -53,12 +78,35 @@ $(objdir)/SDFfuncs$(objsuf): $(treedir)/include/libsdf/error.h $(treedir)/includ
 $(objdir)/SDFfuncs$(objsuf): $(treedir)/include/libsdf/mpmy.h $(treedir)/include/libsdf/timers.h
 $(objdir)/SDFfuncs$(objsuf):
 $(objdir)/SDFget$(objsuf): stdio.h $(treedir)/include/libsdf/mpmy_io.h
-$(objdir)/SDFget$(objsuf): $(treedir)/include/libsdf/error.h $(treedir)/include/libsdf/gccextensions.h
-$(objdir)/SDFget$(objsuf): $(treedir)/include/libsdf/SDF.h
+$(objdir)/SDFget$(objsuf):
+$(objdir)/SDFget$(objsuf):
+$(objdir)/SDFget$(objsuf):
+$(objdir)/SDFget$(objsuf):
+$(objdir)/SDFget$(objsuf):
+$(objdir)/SDFget$(objsuf):
+$(objdir)/SDFget$(objsuf):
+$(objdir)/SDFget$(objsuf):
+$(objdir)/SDFget$(objsuf):
+$(objdir)/SDFget$(objsuf): $(treedir)/include/libsdf/error.h
+$(objdir)/SDFget$(objsuf): $(treedir)/include/libsdf/gccextensions.h $(treedir)/include/libsdf/SDF.h
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
 $(objdir)/SDFhdrio$(objsuf):
 $(objdir)/SDFhdrio$(objsuf): $(treedir)/include/libsdf/Msgs.h $(treedir)/include/libsdf/gccextensions.h
 $(objdir)/SDFhdrio$(objsuf): $(treedir)/include/libsdf/error.h SDF-private.h
-$(objdir)/SDFhdrio$(objsuf): stdio.h
-$(objdir)/SDFhdrio$(objsuf): $(treedir)/include/libsdf/mpmy_io.h
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf):
+$(objdir)/SDFhdrio$(objsuf): stdio.h $(treedir)/include/libsdf/mpmy_io.h
 $(objdir)/SDFhdrio$(objsuf):
 $(objdir)/SDFhdrio$(objsuf): $(treedir)/include/libsdf/SDF.h

external/libsdf/libSDF/SDF-lex.c

@@ -1,5 +1,5 @@
 
-#line 3 "<stdout>"
+#line 3 "lex.yy.c"
 
 #define  YY_INT_ALIGNED short int
 
@@ -53,7 +53,6 @@ typedef int flex_int32_t;
 typedef unsigned char flex_uint8_t; 
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
-#endif /* ! C99 */
 
 /* Limits of integral types. */
 #ifndef INT8_MIN
@@ -84,6 +83,8 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
+#endif /* ! C99 */
+
 #endif /* ! FLEXINT_H */
 
 #ifdef __cplusplus
@@ -140,7 +141,15 @@ typedef unsigned int flex_uint32_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 /* The state buf must be large enough to hold one state per character in the main buffer.
@@ -607,7 +616,7 @@ void SDFlexprepare(void){
 #else /* Not FLEX_SCANNER */
 void SDFlexprepare(void){}
 #endif
-#line 611 "<stdout>"
+#line 620 "lex.yy.c"
 
 #define INITIAL 0
 
@@ -688,7 +697,12 @@ static int input (void );
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
@@ -696,7 +710,7 @@ static int input (void );
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO fwrite( yytext, yyleng, 1, yyout )
+#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
@@ -707,7 +721,7 @@ static int input (void );
 	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 		{ \
 		int c = '*'; \
-		int n; \
+		size_t n; \
 		for ( n = 0; n < max_size && \
 			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 			buf[n] = (char) c; \
@@ -791,7 +805,7 @@ YY_DECL
     
 #line 60 "SDF-lex.l"
 
-#line 795 "<stdout>"
+#line 809 "lex.yy.c"
 
 	if ( !(yy_init) )
 		{
@@ -1054,7 +1068,7 @@ YY_RULE_SETUP
 #line 140 "SDF-lex.l"
 ECHO;
 	YY_BREAK
-#line 1058 "<stdout>"
+#line 1072 "lex.yy.c"
 case YY_STATE_EOF(INITIAL):
 	yyterminate();
 
@@ -1812,8 +1826,8 @@ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
 
 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
  * scan from a @e copy of @a bytes.
- * @param bytes the byte buffer to scan
- * @param len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
  * 
  * @return the newly allocated buffer state object.
  */

external/libsdf/libmpmy/GNUmakefile

@@ -68,39 +68,84 @@ endif
 # DO NOT DELETE THIS LINE -- make depend depends on it.
 
 $(objdir)/mpmy_seq$(objsuf):
-$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/Msgs.h
-$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/gccextensions.h $(treedir)/include/libsdf/mpmy.h
-$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/timers.h
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/Msgs.h $(treedir)/include/libsdf/gccextensions.h
+$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/mpmy.h $(treedir)/include/libsdf/timers.h
+$(objdir)/mpmy_seq$(objsuf):
 $(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/Assert.h $(treedir)/include/libsdf/error.h
-$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/mpmy_io.h $(treedir)/include/libsdf/mpmy_time.h
+$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/mpmy_io.h
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/mpmy_time.h
 $(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/mpmy_abnormal.h timers_hwclock.c
-$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/Malloc.h
-$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/chn.h mpmy_io.c
+$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/Malloc.h $(treedir)/include/libsdf/chn.h
+$(objdir)/mpmy_seq$(objsuf): mpmy_io.c
 $(objdir)/mpmy_seq$(objsuf):
 $(objdir)/mpmy_seq$(objsuf):
 $(objdir)/mpmy_seq$(objsuf):
 $(objdir)/mpmy_seq$(objsuf):
-$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/protos.h iozero.h
-$(objdir)/mpmy_seq$(objsuf): iozero.c io_generic.c mpmy_abnormal.c
 $(objdir)/mpmy_seq$(objsuf):
-$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/singlio.h
-$(objdir)/mpmy_seq$(objsuf): mpmy_generic.c
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/protos.h
+$(objdir)/mpmy_seq$(objsuf): iozero.h iozero.c io_generic.c mpmy_abnormal.c
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf):
+$(objdir)/mpmy_seq$(objsuf): $(treedir)/include/libsdf/singlio.h mpmy_generic.c
 $(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/mpmy_abnormal.h
 $(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/gccextensions.h
 $(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/Malloc.h $(treedir)/include/libsdf/error.h
-$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/chn.h $(treedir)/include/libsdf/Assert.h
-$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/mpmy.h $(treedir)/include/libsdf/timers.h
+$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/chn.h $(treedir)/include/libsdf/mpmy.h
+$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/timers.h
 $(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/Assert.h
 $(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/Msgs.h $(treedir)/include/libsdf/memfile.h
 $(objdir)/mpmy_mpi$(objsuf): timers_hwclock.c
-$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/mpmy_time.h
-$(objdir)/mpmy_mpi$(objsuf): mpmy_mpiio.c
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/mpmy_time.h mpmy_mpiio.c
 $(objdir)/mpmy_mpi$(objsuf):
 $(objdir)/mpmy_mpi$(objsuf):
 $(objdir)/mpmy_mpi$(objsuf):
 $(objdir)/mpmy_mpi$(objsuf):
 $(objdir)/mpmy_mpi$(objsuf):
-$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/protos.h
-$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/mpmy_io.h io_generic.c mpmy_abnormal.c
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/protos.h $(treedir)/include/libsdf/mpmy_io.h
+$(objdir)/mpmy_mpi$(objsuf): io_generic.c mpmy_abnormal.c
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
+$(objdir)/mpmy_mpi$(objsuf):
 $(objdir)/mpmy_mpi$(objsuf): $(treedir)/include/libsdf/singlio.h
 $(objdir)/mpmy_mpi$(objsuf): mpmy_generic.c