1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/.brch__VMS__malloc_brch	Sat Feb 11 17:46:39 2012 -0800
     1.3 @@ -0,0 +1,4 @@
     1.4 +This branch is for the project structure defined Jan 2012..  the #includes reflect this directory structure.
     1.5 +
     1.6 +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.
     1.7 +

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/.hgeol	Sat Feb 11 17:46:39 2012 -0800
     2.3 @@ -0,0 +1,14 @@
     2.4 +
     2.5 +[patterns]
     2.6 +**.py = native
     2.7 +**.txt = native
     2.8 +**.c = native
     2.9 +**.h = native
    2.10 +**.cpp = native
    2.11 +**.java = native
    2.12 +**.class = bin
    2.13 +**.jar = bin
    2.14 +**.sh = native
    2.15 +**.pl = native
    2.16 +**.jpg = bin
    2.17 +**.gif = bin

     3.1 --- a/DynArray.c	Thu Feb 09 15:47:41 2012 +0100
     3.2 +++ b/DynArray.c	Sat Feb 11 17:46:39 2012 -0800
     3.3 @@ -1,214 +1,213 @@
     3.4 -/*
     3.5 - * Copyright 2010  OpenSourceCodeStewardshipFoundation
     3.6 - *
     3.7 - * Licensed under BSD
     3.8 - */
     3.9 -
    3.10 -
    3.11 -
    3.12 -#include <stdio.h>
    3.13 -
    3.14 -#include "DynArray.h"
    3.15 -#include "../vmalloc.h"
    3.16 -
    3.17 -//== declarations
    3.18 -void
    3.19 -increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize );
    3.20 -//==
    3.21 -
    3.22 -PrivDynArrayInfo *
    3.23 -makePrivDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
    3.24 - { PrivDynArrayInfo *info;
    3.25 -
    3.26 -   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
    3.27 -
    3.28 -   info->addrOfPtrToArray = addrOfPtrToArray;
    3.29 -   info->sizeOfArray      = sizeOfArray;
    3.30 -   info->numInArray       = 0;
    3.31 -   return info;
    3.32 - }
    3.33 -
    3.34 -PrivDynArrayInfo *
    3.35 -makePrivDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
    3.36 - { PrivDynArrayInfo *info;
    3.37 -
    3.38 -   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
    3.39 -
    3.40 -   info->addrOfPtrToArray = addrOfPtrToArray;
    3.41 -
    3.42 -   *(addrOfPtrToArray)    = VMS__malloc( sizeOfArray * sizeof(void *) );
    3.43 -   info->sizeOfArray      = sizeOfArray;
    3.44 -   info->numInArray       = 0;
    3.45 -   return info;
    3.46 - }
    3.47 -
    3.48 -PrivDynArrayInfo *
    3.49 -makePrivDynArrayOfSize_Ext( void ***addrOfPtrToArray, int32 sizeOfArray )
    3.50 - { PrivDynArrayInfo *info;
    3.51 -
    3.52 -   info = malloc( sizeof(PrivDynArrayInfo) );
    3.53 -
    3.54 -   info->addrOfPtrToArray = addrOfPtrToArray;
    3.55 -
    3.56 -   *(addrOfPtrToArray)    = malloc( sizeOfArray * sizeof(void *) );
    3.57 -   info->sizeOfArray      = sizeOfArray;
    3.58 -   info->numInArray       = 0;
    3.59 - }
    3.60 -
    3.61 -
    3.62 -/*A dynamic array is same as any other array, but add a DynArrayInfo next
    3.63 - * to it.  Accesses and updates of array indexes are done normally, it's
    3.64 - * only when add a new element into array that use the extra info.
    3.65 - * An add can cause the pointer to the normal array to change..  so must
    3.66 - * be protected to single VP at a time.
    3.67 - *
    3.68 - *Only need to use this Fn when need a new index, higher than any previous
    3.69 - */
    3.70 -int32
    3.71 -addToDynArray( void *value, PrivDynArrayInfo *info )
    3.72 - { int32 numInArray, sizeOfArray;
    3.73 -   void **array;
    3.74 -
    3.75 -   numInArray = info->numInArray;
    3.76 -   sizeOfArray    = info->sizeOfArray;
    3.77 -
    3.78 -   if( numInArray >= sizeOfArray )
    3.79 -    {
    3.80 -      increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
    3.81 -    }
    3.82 -
    3.83 -   array = *(info->addrOfPtrToArray);
    3.84 -   array[ numInArray ] = value;
    3.85 -   info->numInArray++;
    3.86 -
    3.87 -   return numInArray; //pre-incr value is the index put value into
    3.88 - }
    3.89 -int32
    3.90 -addToDynArray_Ext( void *value, PrivDynArrayInfo *info )
    3.91 - { int32 numInArray, sizeOfArray;
    3.92 -   void **array;
    3.93 -
    3.94 -   numInArray = info->numInArray;
    3.95 -   sizeOfArray    = info->sizeOfArray;
    3.96 -
    3.97 -   if( numInArray >= sizeOfArray )
    3.98 -    {
    3.99 -      increaseSizeOfDynArrayTo_Ext( info, sizeOfArray * 2 );
   3.100 -    }
   3.101 -
   3.102 -   array = *(info->addrOfPtrToArray);
   3.103 -   array[ numInArray ] = value;
   3.104 -   info->numInArray++;
   3.105 -
   3.106 -   return numInArray; //pre-incr value is the index put value into
   3.107 - }
   3.108 -
   3.109 -
   3.110 -/*Use this when know how many things going to add in -- then can do this
   3.111 - * once and use as normal array afterwards.  If later add another chunk,
   3.112 - * do this again.  Note, this makes new size be just big enough to hold
   3.113 - * highest index, so will do a linear number of copies if use only this.
   3.114 - *To cut down on number of copies, can use the increaseSizeTo Fn to
   3.115 - * exponentially increase size..
   3.116 - */
   3.117 -void
   3.118 -makeHighestDynArrayIndexBe( PrivDynArrayInfo *info, int32 highestIndex )
   3.119 - {
   3.120 -   if( info->sizeOfArray <= highestIndex )
   3.121 -    {
   3.122 -      increaseSizeOfDynArrayTo( info, highestIndex + 1 );
   3.123 -    }
   3.124 -   info->numInArray = highestIndex + 1;
   3.125 - }
   3.126 -
   3.127 -void
   3.128 -makeHighestDynArrayIndexBeAtLeast(PrivDynArrayInfo *info, int32 index)
   3.129 - {
   3.130 -   if( index < info->numInArray ) return;
   3.131 -   else makeHighestDynArrayIndexBe( info, index );
   3.132 - }
   3.133 -
   3.134 -
   3.135 -/*Only use this if certain new size is bigger than current size
   3.136 - */
   3.137 -void
   3.138 -increaseSizeOfDynArrayTo( PrivDynArrayInfo *info, int32 newSize )
   3.139 - { int32 oldSizeOfArray, i;
   3.140 -   void **newArray, **oldArray;
   3.141 -
   3.142 -   oldSizeOfArray   = info->sizeOfArray;
   3.143 -   if( newSize <= oldSizeOfArray ) return;
   3.144 -
   3.145 -   oldArray         = *(info->addrOfPtrToArray);
   3.146 -   newArray         = VMS__malloc( newSize * sizeof(void *) );
   3.147 -
   3.148 -   for( i = 0; i < oldSizeOfArray; i++ )
   3.149 -    {
   3.150 -      newArray[i] = oldArray[i];
   3.151 -    }
   3.152 -   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   3.153 -   info->sizeOfArray = newSize;
   3.154 -
   3.155 -   VMS__free( oldArray );
   3.156 - }
   3.157 -
   3.158 -/*Can't mix VMS__malloc locations with external malloc locations -- so use
   3.159 - * this version inside VMS, which will perform normal malloc in the core
   3.160 - * loop -- hopefully avoiding the annoying system-stack bugs..
   3.161 - */
   3.162 -void
   3.163 -increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize )
   3.164 - { int32 oldSizeOfArray, i;
   3.165 -   void **newArray, **oldArray;
   3.166 -
   3.167 -   oldSizeOfArray   = info->sizeOfArray;
   3.168 -   if( newSize <= oldSizeOfArray ) return;
   3.169 -
   3.170 -   oldArray         = *(info->addrOfPtrToArray);
   3.171 -   newArray         = malloc( newSize * sizeof(void *) );
   3.172 -
   3.173 -   for( i = 0; i < oldSizeOfArray; i++ )
   3.174 -    {
   3.175 -      newArray[i] = oldArray[i];
   3.176 -    }
   3.177 -   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   3.178 -   info->sizeOfArray = newSize;
   3.179 -
   3.180 -   free( oldArray );
   3.181 - }
   3.182 -
   3.183 -
   3.184 -/* Frees the array, plus the info
   3.185 - */
   3.186 -void
   3.187 -freeDynArrayDeep( PrivDynArrayInfo *info, FreeFnPtr freeFnPtr )
   3.188 - {
   3.189 -   forAllInDynArrayDo( info, freeFnPtr );
   3.190 -   VMS__free( *(info->addrOfPtrToArray) );
   3.191 -   VMS__free( info );
   3.192 - }
   3.193 -
   3.194 -/* Only frees the info
   3.195 - */
   3.196 -void
   3.197 -freeDynArrayFlat( PrivDynArrayInfo *info )
   3.198 - {
   3.199 -   VMS__free( info );
   3.200 - }
   3.201 -
   3.202 -
   3.203 -/*The function has a fixed prototype: takes a void * returns void
   3.204 - * So, the function has to internally cast void * to whatever data struc..
   3.205 - */
   3.206 -void
   3.207 -forAllInDynArrayDo( PrivDynArrayInfo *info, DynArrayFnPtr fnPtr )
   3.208 - { int32 idx;
   3.209 -   void **array;
   3.210 -
   3.211 -   array = *(info->addrOfPtrToArray);
   3.212 -   for( idx = 0; idx < info->numInArray; idx++ )
   3.213 -    {
   3.214 -      (*fnPtr)(array[idx]);
   3.215 -    }
   3.216 - }
   3.217 -
   3.218 +/*
   3.219 + * Copyright 2010  OpenSourceCodeStewardshipFoundation
   3.220 + *
   3.221 + * Licensed under BSD
   3.222 + */
   3.223 +
   3.224 +
   3.225 +
   3.226 +#include <stdio.h>
   3.227 +
   3.228 +#include "DynArray.h"
   3.229 +
   3.230 +//== declarations
   3.231 +void
   3.232 +increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize );
   3.233 +//==
   3.234 +
   3.235 +PrivDynArrayInfo *
   3.236 +makePrivDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
   3.237 + { PrivDynArrayInfo *info;
   3.238 +
   3.239 +   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
   3.240 +
   3.241 +   info->addrOfPtrToArray = addrOfPtrToArray;
   3.242 +   info->sizeOfArray      = sizeOfArray;
   3.243 +   info->numInArray       = 0;
   3.244 +   return info;
   3.245 + }
   3.246 +
   3.247 +PrivDynArrayInfo *
   3.248 +makePrivDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
   3.249 + { PrivDynArrayInfo *info;
   3.250 +
   3.251 +   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
   3.252 +
   3.253 +   info->addrOfPtrToArray = addrOfPtrToArray;
   3.254 +
   3.255 +   *(addrOfPtrToArray)    = VMS__malloc( sizeOfArray * sizeof(void *) );
   3.256 +   info->sizeOfArray      = sizeOfArray;
   3.257 +   info->numInArray       = 0;
   3.258 +   return info;
   3.259 + }
   3.260 +
   3.261 +PrivDynArrayInfo *
   3.262 +makePrivDynArrayOfSize_Ext( void ***addrOfPtrToArray, int32 sizeOfArray )
   3.263 + { PrivDynArrayInfo *info;
   3.264 +
   3.265 +   info = malloc( sizeof(PrivDynArrayInfo) );
   3.266 +
   3.267 +   info->addrOfPtrToArray = addrOfPtrToArray;
   3.268 +
   3.269 +   *(addrOfPtrToArray)    = malloc( sizeOfArray * sizeof(void *) );
   3.270 +   info->sizeOfArray      = sizeOfArray;
   3.271 +   info->numInArray       = 0;
   3.272 + }
   3.273 +
   3.274 +
   3.275 +/*A dynamic array is same as any other array, but add a DynArrayInfo next
   3.276 + * to it.  Accesses and updates of array indexes are done normally, it's
   3.277 + * only when add a new element into array that use the extra info.
   3.278 + * An add can cause the pointer to the normal array to change..  so must
   3.279 + * be protected to single VP at a time.
   3.280 + *
   3.281 + *Only need to use this Fn when need a new index, higher than any previous
   3.282 + */
   3.283 +int32
   3.284 +addToDynArray( void *value, PrivDynArrayInfo *info )
   3.285 + { int32 numInArray, sizeOfArray;
   3.286 +   void **array;
   3.287 +
   3.288 +   numInArray = info->numInArray;
   3.289 +   sizeOfArray    = info->sizeOfArray;
   3.290 +
   3.291 +   if( numInArray >= sizeOfArray )
   3.292 +    {
   3.293 +      increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
   3.294 +    }
   3.295 +
   3.296 +   array = *(info->addrOfPtrToArray);
   3.297 +   array[ numInArray ] = value;
   3.298 +   info->numInArray++;
   3.299 +
   3.300 +   return numInArray; //pre-incr value is the index put value into
   3.301 + }
   3.302 +int32
   3.303 +addToDynArray_Ext( void *value, PrivDynArrayInfo *info )
   3.304 + { int32 numInArray, sizeOfArray;
   3.305 +   void **array;
   3.306 +
   3.307 +   numInArray = info->numInArray;
   3.308 +   sizeOfArray    = info->sizeOfArray;
   3.309 +
   3.310 +   if( numInArray >= sizeOfArray )
   3.311 +    {
   3.312 +      increaseSizeOfDynArrayTo_Ext( info, sizeOfArray * 2 );
   3.313 +    }
   3.314 +
   3.315 +   array = *(info->addrOfPtrToArray);
   3.316 +   array[ numInArray ] = value;
   3.317 +   info->numInArray++;
   3.318 +
   3.319 +   return numInArray; //pre-incr value is the index put value into
   3.320 + }
   3.321 +
   3.322 +
   3.323 +/*Use this when know how many things going to add in -- then can do this
   3.324 + * once and use as normal array afterwards.  If later add another chunk,
   3.325 + * do this again.  Note, this makes new size be just big enough to hold
   3.326 + * highest index, so will do a linear number of copies if use only this.
   3.327 + *To cut down on number of copies, can use the increaseSizeTo Fn to
   3.328 + * exponentially increase size..
   3.329 + */
   3.330 +void
   3.331 +makeHighestDynArrayIndexBe( PrivDynArrayInfo *info, int32 highestIndex )
   3.332 + {
   3.333 +   if( info->sizeOfArray <= highestIndex )
   3.334 +    {
   3.335 +      increaseSizeOfDynArrayTo( info, highestIndex + 1 );
   3.336 +    }
   3.337 +   info->numInArray = highestIndex + 1;
   3.338 + }
   3.339 +
   3.340 +void
   3.341 +makeHighestDynArrayIndexBeAtLeast(PrivDynArrayInfo *info, int32 index)
   3.342 + {
   3.343 +   if( index < info->numInArray ) return;
   3.344 +   else makeHighestDynArrayIndexBe( info, index );
   3.345 + }
   3.346 +
   3.347 +
   3.348 +/*Only use this if certain new size is bigger than current size
   3.349 + */
   3.350 +void
   3.351 +increaseSizeOfDynArrayTo( PrivDynArrayInfo *info, int32 newSize )
   3.352 + { int32 oldSizeOfArray, i;
   3.353 +   void **newArray, **oldArray;
   3.354 +
   3.355 +   oldSizeOfArray   = info->sizeOfArray;
   3.356 +   if( newSize <= oldSizeOfArray ) return;
   3.357 +
   3.358 +   oldArray         = *(info->addrOfPtrToArray);
   3.359 +   newArray         = VMS__malloc( newSize * sizeof(void *) );
   3.360 +
   3.361 +   for( i = 0; i < oldSizeOfArray; i++ )
   3.362 +    {
   3.363 +      newArray[i] = oldArray[i];
   3.364 +    }
   3.365 +   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   3.366 +   info->sizeOfArray = newSize;
   3.367 +
   3.368 +   VMS__free( oldArray );
   3.369 + }
   3.370 +
   3.371 +/*Can't mix VMS__malloc locations with external malloc locations -- so use
   3.372 + * this version inside VMS, which will perform normal malloc in the core
   3.373 + * loop -- hopefully avoiding the annoying system-stack bugs..
   3.374 + */
   3.375 +void
   3.376 +increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize )
   3.377 + { int32 oldSizeOfArray, i;
   3.378 +   void **newArray, **oldArray;
   3.379 +
   3.380 +   oldSizeOfArray   = info->sizeOfArray;
   3.381 +   if( newSize <= oldSizeOfArray ) return;
   3.382 +
   3.383 +   oldArray         = *(info->addrOfPtrToArray);
   3.384 +   newArray         = malloc( newSize * sizeof(void *) );
   3.385 +
   3.386 +   for( i = 0; i < oldSizeOfArray; i++ )
   3.387 +    {
   3.388 +      newArray[i] = oldArray[i];
   3.389 +    }
   3.390 +   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   3.391 +   info->sizeOfArray = newSize;
   3.392 +
   3.393 +   free( oldArray );
   3.394 + }
   3.395 +
   3.396 +
   3.397 +/* Frees the array, plus the info
   3.398 + */
   3.399 +void
   3.400 +freeDynArrayDeep( PrivDynArrayInfo *info, FreeFnPtr freeFnPtr )
   3.401 + {
   3.402 +   forAllInDynArrayDo( info, freeFnPtr );
   3.403 +   VMS__free( *(info->addrOfPtrToArray) );
   3.404 +   VMS__free( info );
   3.405 + }
   3.406 +
   3.407 +/* Only frees the info
   3.408 + */
   3.409 +void
   3.410 +freeDynArrayFlat( PrivDynArrayInfo *info )
   3.411 + {
   3.412 +   VMS__free( info );
   3.413 + }
   3.414 +
   3.415 +
   3.416 +/*The function has a fixed prototype: takes a void * returns void
   3.417 + * So, the function has to internally cast void * to whatever data struc..
   3.418 + */
   3.419 +void
   3.420 +forAllInDynArrayDo( PrivDynArrayInfo *info, DynArrayFnPtr fnPtr )
   3.421 + { int32 idx;
   3.422 +   void **array;
   3.423 +
   3.424 +   array = *(info->addrOfPtrToArray);
   3.425 +   for( idx = 0; idx < info->numInArray; idx++ )
   3.426 +    {
   3.427 +      (*fnPtr)(array[idx]);
   3.428 +    }
   3.429 + }
   3.430 +

     4.1 --- a/DynArray.h	Thu Feb 09 15:47:41 2012 +0100
     4.2 +++ b/DynArray.h	Sat Feb 11 17:46:39 2012 -0800
     4.3 @@ -9,6 +9,7 @@
     4.4  #define	_DYNARRAY_H
     4.5  
     4.6  #include "../../VMS_Implementations/VMS_impl/VMS_primitive_data_types.h"
     4.7 +#include "../../VMS_Implementations/VMS_impl/vmalloc.h"
     4.8  
     4.9  
    4.10     //A dynamic array is same as any other array, but add a DynArrayInfo next