# HG changeset patch
# User Me@portablequad
# Date 1329011199 28800
# Node ID 53c5d022dd453c7e4c22732a66cdd92ce0403bce
# Parent  1cffeb8705640155d8127fd09795e05cbea40b80
added eol handling and .brch__VMS_malloc_brch to indicate brch (and reason for it)

diff -r 1cffeb870564 -r 53c5d022dd45 .brch__VMS__malloc_brch
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.brch__VMS__malloc_brch	Sat Feb 11 17:46:39 2012 -0800
@@ -0,0 +1,4 @@
+This branch is for the project structure defined Jan 2012..  the #includes reflect this directory structure.
+
+More importantly, the MC_shared  version of VMS requires a separat malloc impl by VMS code..  so this branch has modified the library to use the VMS-specific malloc.
+
diff -r 1cffeb870564 -r 53c5d022dd45 .hgeol
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgeol	Sat Feb 11 17:46:39 2012 -0800
@@ -0,0 +1,14 @@
+
+[patterns]
+**.py = native
+**.txt = native
+**.c = native
+**.h = native
+**.cpp = native
+**.java = native
+**.class = bin
+**.jar = bin
+**.sh = native
+**.pl = native
+**.jpg = bin
+**.gif = bin
diff -r 1cffeb870564 -r 53c5d022dd45 DynArray.c
--- a/DynArray.c	Thu Feb 09 15:47:41 2012 +0100
+++ b/DynArray.c	Sat Feb 11 17:46:39 2012 -0800
@@ -1,214 +1,213 @@
-/*
- * Copyright 2010  OpenSourceCodeStewardshipFoundation
- *
- * Licensed under BSD
- */
-
-
-
-#include <stdio.h>
-
-#include "DynArray.h"
-#include "../vmalloc.h"
-
-//== declarations
-void
-increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize );
-//==
-
-PrivDynArrayInfo *
-makePrivDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
- { PrivDynArrayInfo *info;
-
-   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
-
-   info->addrOfPtrToArray = addrOfPtrToArray;
-   info->sizeOfArray      = sizeOfArray;
-   info->numInArray       = 0;
-   return info;
- }
-
-PrivDynArrayInfo *
-makePrivDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
- { PrivDynArrayInfo *info;
-
-   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
-
-   info->addrOfPtrToArray = addrOfPtrToArray;
-
-   *(addrOfPtrToArray)    = VMS__malloc( sizeOfArray * sizeof(void *) );
-   info->sizeOfArray      = sizeOfArray;
-   info->numInArray       = 0;
-   return info;
- }
-
-PrivDynArrayInfo *
-makePrivDynArrayOfSize_Ext( void ***addrOfPtrToArray, int32 sizeOfArray )
- { PrivDynArrayInfo *info;
-
-   info = malloc( sizeof(PrivDynArrayInfo) );
-
-   info->addrOfPtrToArray = addrOfPtrToArray;
-
-   *(addrOfPtrToArray)    = malloc( sizeOfArray * sizeof(void *) );
-   info->sizeOfArray      = sizeOfArray;
-   info->numInArray       = 0;
- }
-
-
-/*A dynamic array is same as any other array, but add a DynArrayInfo next
- * to it.  Accesses and updates of array indexes are done normally, it's
- * only when add a new element into array that use the extra info.
- * An add can cause the pointer to the normal array to change..  so must
- * be protected to single VP at a time.
- *
- *Only need to use this Fn when need a new index, higher than any previous
- */
-int32
-addToDynArray( void *value, PrivDynArrayInfo *info )
- { int32 numInArray, sizeOfArray;
-   void **array;
-
-   numInArray = info->numInArray;
-   sizeOfArray    = info->sizeOfArray;
-
-   if( numInArray >= sizeOfArray )
-    {
-      increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
-    }
-
-   array = *(info->addrOfPtrToArray);
-   array[ numInArray ] = value;
-   info->numInArray++;
-
-   return numInArray; //pre-incr value is the index put value into
- }
-int32
-addToDynArray_Ext( void *value, PrivDynArrayInfo *info )
- { int32 numInArray, sizeOfArray;
-   void **array;
-
-   numInArray = info->numInArray;
-   sizeOfArray    = info->sizeOfArray;
-
-   if( numInArray >= sizeOfArray )
-    {
-      increaseSizeOfDynArrayTo_Ext( info, sizeOfArray * 2 );
-    }
-
-   array = *(info->addrOfPtrToArray);
-   array[ numInArray ] = value;
-   info->numInArray++;
-
-   return numInArray; //pre-incr value is the index put value into
- }
-
-
-/*Use this when know how many things going to add in -- then can do this
- * once and use as normal array afterwards.  If later add another chunk,
- * do this again.  Note, this makes new size be just big enough to hold
- * highest index, so will do a linear number of copies if use only this.
- *To cut down on number of copies, can use the increaseSizeTo Fn to
- * exponentially increase size..
- */
-void
-makeHighestDynArrayIndexBe( PrivDynArrayInfo *info, int32 highestIndex )
- {
-   if( info->sizeOfArray <= highestIndex )
-    {
-      increaseSizeOfDynArrayTo( info, highestIndex + 1 );
-    }
-   info->numInArray = highestIndex + 1;
- }
-
-void
-makeHighestDynArrayIndexBeAtLeast(PrivDynArrayInfo *info, int32 index)
- {
-   if( index < info->numInArray ) return;
-   else makeHighestDynArrayIndexBe( info, index );
- }
-
-
-/*Only use this if certain new size is bigger than current size
- */
-void
-increaseSizeOfDynArrayTo( PrivDynArrayInfo *info, int32 newSize )
- { int32 oldSizeOfArray, i;
-   void **newArray, **oldArray;
-
-   oldSizeOfArray   = info->sizeOfArray;
-   if( newSize <= oldSizeOfArray ) return;
-
-   oldArray         = *(info->addrOfPtrToArray);
-   newArray         = VMS__malloc( newSize * sizeof(void *) );
-
-   for( i = 0; i < oldSizeOfArray; i++ )
-    {
-      newArray[i] = oldArray[i];
-    }
-   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
-   info->sizeOfArray = newSize;
-
-   VMS__free( oldArray );
- }
-
-/*Can't mix VMS__malloc locations with external malloc locations -- so use
- * this version inside VMS, which will perform normal malloc in the core
- * loop -- hopefully avoiding the annoying system-stack bugs..
- */
-void
-increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize )
- { int32 oldSizeOfArray, i;
-   void **newArray, **oldArray;
-
-   oldSizeOfArray   = info->sizeOfArray;
-   if( newSize <= oldSizeOfArray ) return;
-
-   oldArray         = *(info->addrOfPtrToArray);
-   newArray         = malloc( newSize * sizeof(void *) );
-
-   for( i = 0; i < oldSizeOfArray; i++ )
-    {
-      newArray[i] = oldArray[i];
-    }
-   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
-   info->sizeOfArray = newSize;
-
-   free( oldArray );
- }
-
-
-/* Frees the array, plus the info
- */
-void
-freeDynArrayDeep( PrivDynArrayInfo *info, FreeFnPtr freeFnPtr )
- {
-   forAllInDynArrayDo( info, freeFnPtr );
-   VMS__free( *(info->addrOfPtrToArray) );
-   VMS__free( info );
- }
-
-/* Only frees the info
- */
-void
-freeDynArrayFlat( PrivDynArrayInfo *info )
- {
-   VMS__free( info );
- }
-
-
-/*The function has a fixed prototype: takes a void * returns void
- * So, the function has to internally cast void * to whatever data struc..
- */
-void
-forAllInDynArrayDo( PrivDynArrayInfo *info, DynArrayFnPtr fnPtr )
- { int32 idx;
-   void **array;
-
-   array = *(info->addrOfPtrToArray);
-   for( idx = 0; idx < info->numInArray; idx++ )
-    {
-      (*fnPtr)(array[idx]);
-    }
- }
-
+/*
+ * Copyright 2010  OpenSourceCodeStewardshipFoundation
+ *
+ * Licensed under BSD
+ */
+
+
+
+#include <stdio.h>
+
+#include "DynArray.h"
+
+//== declarations
+void
+increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize );
+//==
+
+PrivDynArrayInfo *
+makePrivDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
+ { PrivDynArrayInfo *info;
+
+   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
+
+   info->addrOfPtrToArray = addrOfPtrToArray;
+   info->sizeOfArray      = sizeOfArray;
+   info->numInArray       = 0;
+   return info;
+ }
+
+PrivDynArrayInfo *
+makePrivDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
+ { PrivDynArrayInfo *info;
+
+   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
+
+   info->addrOfPtrToArray = addrOfPtrToArray;
+
+   *(addrOfPtrToArray)    = VMS__malloc( sizeOfArray * sizeof(void *) );
+   info->sizeOfArray      = sizeOfArray;
+   info->numInArray       = 0;
+   return info;
+ }
+
+PrivDynArrayInfo *
+makePrivDynArrayOfSize_Ext( void ***addrOfPtrToArray, int32 sizeOfArray )
+ { PrivDynArrayInfo *info;
+
+   info = malloc( sizeof(PrivDynArrayInfo) );
+
+   info->addrOfPtrToArray = addrOfPtrToArray;
+
+   *(addrOfPtrToArray)    = malloc( sizeOfArray * sizeof(void *) );
+   info->sizeOfArray      = sizeOfArray;
+   info->numInArray       = 0;
+ }
+
+
+/*A dynamic array is same as any other array, but add a DynArrayInfo next
+ * to it.  Accesses and updates of array indexes are done normally, it's
+ * only when add a new element into array that use the extra info.
+ * An add can cause the pointer to the normal array to change..  so must
+ * be protected to single VP at a time.
+ *
+ *Only need to use this Fn when need a new index, higher than any previous
+ */
+int32
+addToDynArray( void *value, PrivDynArrayInfo *info )
+ { int32 numInArray, sizeOfArray;
+   void **array;
+
+   numInArray = info->numInArray;
+   sizeOfArray    = info->sizeOfArray;
+
+   if( numInArray >= sizeOfArray )
+    {
+      increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
+    }
+
+   array = *(info->addrOfPtrToArray);
+   array[ numInArray ] = value;
+   info->numInArray++;
+
+   return numInArray; //pre-incr value is the index put value into
+ }
+int32
+addToDynArray_Ext( void *value, PrivDynArrayInfo *info )
+ { int32 numInArray, sizeOfArray;
+   void **array;
+
+   numInArray = info->numInArray;
+   sizeOfArray    = info->sizeOfArray;
+
+   if( numInArray >= sizeOfArray )
+    {
+      increaseSizeOfDynArrayTo_Ext( info, sizeOfArray * 2 );
+    }
+
+   array = *(info->addrOfPtrToArray);
+   array[ numInArray ] = value;
+   info->numInArray++;
+
+   return numInArray; //pre-incr value is the index put value into
+ }
+
+
+/*Use this when know how many things going to add in -- then can do this
+ * once and use as normal array afterwards.  If later add another chunk,
+ * do this again.  Note, this makes new size be just big enough to hold
+ * highest index, so will do a linear number of copies if use only this.
+ *To cut down on number of copies, can use the increaseSizeTo Fn to
+ * exponentially increase size..
+ */
+void
+makeHighestDynArrayIndexBe( PrivDynArrayInfo *info, int32 highestIndex )
+ {
+   if( info->sizeOfArray <= highestIndex )
+    {
+      increaseSizeOfDynArrayTo( info, highestIndex + 1 );
+    }
+   info->numInArray = highestIndex + 1;
+ }
+
+void
+makeHighestDynArrayIndexBeAtLeast(PrivDynArrayInfo *info, int32 index)
+ {
+   if( index < info->numInArray ) return;
+   else makeHighestDynArrayIndexBe( info, index );
+ }
+
+
+/*Only use this if certain new size is bigger than current size
+ */
+void
+increaseSizeOfDynArrayTo( PrivDynArrayInfo *info, int32 newSize )
+ { int32 oldSizeOfArray, i;
+   void **newArray, **oldArray;
+
+   oldSizeOfArray   = info->sizeOfArray;
+   if( newSize <= oldSizeOfArray ) return;
+
+   oldArray         = *(info->addrOfPtrToArray);
+   newArray         = VMS__malloc( newSize * sizeof(void *) );
+
+   for( i = 0; i < oldSizeOfArray; i++ )
+    {
+      newArray[i] = oldArray[i];
+    }
+   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
+   info->sizeOfArray = newSize;
+
+   VMS__free( oldArray );
+ }
+
+/*Can't mix VMS__malloc locations with external malloc locations -- so use
+ * this version inside VMS, which will perform normal malloc in the core
+ * loop -- hopefully avoiding the annoying system-stack bugs..
+ */
+void
+increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize )
+ { int32 oldSizeOfArray, i;
+   void **newArray, **oldArray;
+
+   oldSizeOfArray   = info->sizeOfArray;
+   if( newSize <= oldSizeOfArray ) return;
+
+   oldArray         = *(info->addrOfPtrToArray);
+   newArray         = malloc( newSize * sizeof(void *) );
+
+   for( i = 0; i < oldSizeOfArray; i++ )
+    {
+      newArray[i] = oldArray[i];
+    }
+   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
+   info->sizeOfArray = newSize;
+
+   free( oldArray );
+ }
+
+
+/* Frees the array, plus the info
+ */
+void
+freeDynArrayDeep( PrivDynArrayInfo *info, FreeFnPtr freeFnPtr )
+ {
+   forAllInDynArrayDo( info, freeFnPtr );
+   VMS__free( *(info->addrOfPtrToArray) );
+   VMS__free( info );
+ }
+
+/* Only frees the info
+ */
+void
+freeDynArrayFlat( PrivDynArrayInfo *info )
+ {
+   VMS__free( info );
+ }
+
+
+/*The function has a fixed prototype: takes a void * returns void
+ * So, the function has to internally cast void * to whatever data struc..
+ */
+void
+forAllInDynArrayDo( PrivDynArrayInfo *info, DynArrayFnPtr fnPtr )
+ { int32 idx;
+   void **array;
+
+   array = *(info->addrOfPtrToArray);
+   for( idx = 0; idx < info->numInArray; idx++ )
+    {
+      (*fnPtr)(array[idx]);
+    }
+ }
+
diff -r 1cffeb870564 -r 53c5d022dd45 DynArray.h
--- a/DynArray.h	Thu Feb 09 15:47:41 2012 +0100
+++ b/DynArray.h	Sat Feb 11 17:46:39 2012 -0800
@@ -9,6 +9,7 @@
 #define	_DYNARRAY_H
 
 #include "../../VMS_Implementations/VMS_impl/VMS_primitive_data_types.h"
+#include "../../VMS_Implementations/VMS_impl/vmalloc.h"
 
 
    //A dynamic array is same as any other array, but add a DynArrayInfo next