1.1 --- a/BlockingQueue.c	Wed Jun 22 18:49:17 2011 +0200
     1.2 +++ b/BlockingQueue.c	Mon Feb 13 19:32:12 2012 +0100
     1.3 @@ -13,7 +13,7 @@
     1.4  #include <sched.h>
     1.5  
     1.6  #include "BlockingQueue.h"
     1.7 -#include "../vmalloc.h"
     1.8 +#include "VMS_Implementations/VMS_impl/vmalloc.h"
     1.9  
    1.10  #define INC(x) (++x == 1024) ? (x) = 0 : (x)
    1.11  
    1.12 @@ -26,7 +26,7 @@
    1.13   {
    1.14     PThdQueueStruc* retQ;
    1.15     int retCode;
    1.16 -   retQ = (PThdQueueStruc *) VMS__malloc( sizeof( PThdQueueStruc ) );
    1.17 +   retQ = (PThdQueueStruc *) VMS_int__malloc( sizeof( PThdQueueStruc ) );
    1.18  
    1.19  
    1.20     retCode =
    1.21 @@ -118,7 +118,7 @@
    1.22  CASQueueStruc* makeCASQ()
    1.23   {
    1.24     CASQueueStruc* retQ;
    1.25 -   retQ = (CASQueueStruc *) VMS__malloc( sizeof( CASQueueStruc ) );
    1.26 +   retQ = (CASQueueStruc *) VMS_int__malloc( sizeof( CASQueueStruc ) );
    1.27  
    1.28     retQ->insertLock = UNLOCKED;
    1.29     retQ->extractLock= UNLOCKED;
    1.30 @@ -243,7 +243,7 @@
    1.31  SRSWQueueStruc* makeSRSWQ()
    1.32   {
    1.33     SRSWQueueStruc* retQ;
    1.34 -   retQ = (SRSWQueueStruc *) VMS__malloc( sizeof( SRSWQueueStruc ) );
    1.35 +   retQ = (SRSWQueueStruc *) VMS_int__malloc( sizeof( SRSWQueueStruc ) );
    1.36     
    1.37     retQ->extractPos = &(retQ->startOfData[0]); //side by side == empty
    1.38     retQ->insertPos  = &(retQ->startOfData[1]); // so start pos's have to be
    1.39 @@ -255,7 +255,7 @@
    1.40  void
    1.41  freeSRSWQ( SRSWQueueStruc* Q )
    1.42   {
    1.43 -   VMS__free( Q );
    1.44 +   VMS_int__free( Q );
    1.45   }
    1.46  
    1.47  void* readSRSWQ( SRSWQueueStruc* Q )
    1.48 @@ -380,11 +380,11 @@
    1.49  SRMWQueueStruc* makeSRMWQ()
    1.50   { SRMWQueueStruc* retQ;
    1.51     
    1.52 -   retQ = (SRMWQueueStruc *) VMS__malloc( sizeof( SRMWQueueStruc ) );
    1.53 +   retQ = (SRMWQueueStruc *) VMS_int__malloc( sizeof( SRMWQueueStruc ) );
    1.54     
    1.55     retQ->numInternalQs = 0;
    1.56     retQ->internalQsSz  = 10;
    1.57 -   retQ->internalQs = VMS__malloc( retQ->internalQsSz *
    1.58 +   retQ->internalQs = VMS_int__malloc( retQ->internalQsSz *
    1.59                                     sizeof(SRSWQueueStruc *) );
    1.60     
    1.61     retQ->lastQReadFrom = 0;
    1.62 @@ -411,11 +411,11 @@
    1.63        oldSz            = Q->internalQsSz;
    1.64        oldArray         = Q->internalQs;
    1.65        Q->internalQsSz *= 2;
    1.66 -      Q->internalQs    = VMS__malloc( Q->internalQsSz * sizeof(SRSWQueueStruc *));
    1.67 +      Q->internalQs    = VMS_int__malloc( Q->internalQsSz * sizeof(SRSWQueueStruc *));
    1.68        for( i = 0; i < oldSz; i++ )
    1.69         { Q->internalQs[i] = oldArray[i];
    1.70         }
    1.71 -      VMS__free( oldArray );
    1.72 +      VMS_int__free( oldArray );
    1.73      }
    1.74     Q->internalQs[ Q->numInternalQs - 1 ] = makeSRSWQ();
    1.75     return Q->numInternalQs - 1;

     2.1 --- a/PrivateQueue.c	Wed Jun 22 18:49:17 2011 +0200
     2.2 +++ b/PrivateQueue.c	Mon Feb 13 19:32:12 2012 +0100
     2.3 @@ -1,203 +1,203 @@
     2.4 -/*
     2.5 - *  Copyright 2009 OpenSourceStewardshipFoundation.org
     2.6 - *  Licensed under GNU General Public License version 2
     2.7 - *
     2.8 - * Author: seanhalle@yahoo.com
     2.9 - */
    2.10 -
    2.11 -
    2.12 -#include <stdio.h>
    2.13 -#include <string.h>
    2.14 -#include <errno.h>
    2.15 -#include <stdlib.h>
    2.16 -
    2.17 -#include "PrivateQueue.h"
    2.18 -#include "../vmalloc.h"
    2.19 -
    2.20 -
    2.21 -
    2.22 -//===========================================================================
    2.23 -
    2.24 -/*This kind of queue is private to a single core at a time -- has no
    2.25 - * synchronizations 
    2.26 - */
    2.27 -
    2.28 -PrivQueueStruc* makeVMSPrivQ()
    2.29 - {
    2.30 -   PrivQueueStruc *retQ;
    2.31 -   retQ = VMS__malloc( sizeof( PrivQueueStruc ) );
    2.32 -   retQ->startOfData = (void*)VMS__malloc( 1024 * sizeof(void *) );
    2.33 -   memset( retQ->startOfData, 0, 1024 );
    2.34 -
    2.35 -   retQ->extractPos = &(retQ->startOfData[0]); //side by side == empty
    2.36 -   retQ->insertPos  = &(retQ->startOfData[1]); // so start pos's have to be
    2.37 -   retQ->endOfData  = &(retQ->startOfData[1023]);
    2.38 -
    2.39 -   return retQ;
    2.40 - }
    2.41 -
    2.42 -
    2.43 -void
    2.44 -enlargePrivQ( PrivQueueStruc *Q )
    2.45 - { size_t    oldSize, newSize;
    2.46 -   void **oldStartOfData;
    2.47 -
    2.48 -   oldSize           = Q->endOfData - Q->startOfData + 1;
    2.49 -   newSize           = 2 * oldSize;
    2.50 -   oldStartOfData = Q->startOfData;
    2.51 -   Q->startOfData = VMS__malloc( newSize * sizeof(void*));
    2.52 -   //copy second half
    2.53 -   size_t secondHalfSize = Q->endOfData - Q->extractPos + 1;
    2.54 -   memcpy(Q->startOfData,Q->extractPos, secondHalfSize * sizeof(void*));
    2.55 -   //copy first half
    2.56 -   memcpy(Q->startOfData + secondHalfSize, oldStartOfData, 
    2.57 -                        (oldSize-secondHalfSize) * sizeof(void*));
    2.58 -   VMS__free(oldStartOfData);
    2.59 -   
    2.60 -   Q->extractPos  = Q->startOfData;
    2.61 -   Q->insertPos   = Q->startOfData + oldSize - 1;
    2.62 -   Q->endOfData   = &(Q->startOfData[newSize - 1]);
    2.63 - }
    2.64 -
    2.65 -
    2.66 -/*Returns NULL when queue is empty
    2.67 - */
    2.68 -void* readPrivQ( PrivQueueStruc* Q )
    2.69 - { void *out    = 0;
    2.70 -   void **startOfData = Q->startOfData;
    2.71 -   void **endOfData   = Q->endOfData;
    2.72 -
    2.73 -   void **insertPos  = Q->insertPos;
    2.74 -   void **extractPos = Q->extractPos;
    2.75 -
    2.76 -      //if not empty -- (extract is just below insert when empty)
    2.77 -   if( insertPos - extractPos != 1 &&
    2.78 -       !(extractPos == endOfData && insertPos == startOfData))
    2.79 -    {    //move before read
    2.80 -      if( extractPos == endOfData ) //write new pos exactly once, correctly
    2.81 -       { Q->extractPos = startOfData; //can't overrun then fix it 'cause
    2.82 -       }                              // other thread might read bad pos
    2.83 -      else
    2.84 -       { Q->extractPos++;
    2.85 -       }
    2.86 -      out = *(Q->extractPos);
    2.87 -      return out;
    2.88 -    }
    2.89 -      //Q is empty
    2.90 -   return NULL;
    2.91 - }
    2.92 -
    2.93 -int32
    2.94 -numInPrivQ( PrivQueueStruc *Q )
    2.95 - { int32 size, numIn;
    2.96 - 
    2.97 -   if( Q->insertPos < Q->extractPos )
    2.98 -    {    //insert has wrapped around so numIn is:
    2.99 -         // insertPos + size - extractPos -- Consider, is empty when
   2.100 -         // extractPos = endOfData and insert = start -- correctly get zero
   2.101 -      size  = Q->endOfData - Q->startOfData;
   2.102 -      numIn = Q->insertPos + size - Q->extractPos;
   2.103 -    }
   2.104 -   else
   2.105 -    {
   2.106 -      numIn =  Q->insertPos -  Q->extractPos -1;//-1 bec empty @ side-by-side
   2.107 -    }
   2.108 -   return numIn;
   2.109 - }
   2.110 -
   2.111 -
   2.112 -/*Expands the queue size automatically when it's full
   2.113 - */
   2.114 -void
   2.115 -writePrivQ( void * in, PrivQueueStruc* Q )
   2.116 - {
   2.117 -   while(1){
   2.118 -       void **startOfData = Q->startOfData;
   2.119 -       void **endOfData   = Q->endOfData;
   2.120 -
   2.121 -       void **insertPos  = Q->insertPos;
   2.122 -       void **extractPos = Q->extractPos;
   2.123 -
   2.124 -          //Full? (insert is just below extract when full)
   2.125 -       if( extractPos - insertPos != 1 &&
   2.126 -           !(insertPos == endOfData && extractPos == startOfData))
   2.127 -        { *(Q->insertPos) = in;   //insert before move
   2.128 -          if( insertPos == endOfData ) //write new pos exactly once, correctly
   2.129 -           { Q->insertPos = startOfData;
   2.130 -           }
   2.131 -          else
   2.132 -           { Q->insertPos++;
   2.133 -           }
   2.134 -          return;
   2.135 -        }
   2.136 -          //Q is full
   2.137 -       enlargePrivQ( Q );
   2.138 -   }
   2.139 - }
   2.140 -
   2.141 -
   2.142 -/*Returns false when the queue was full.
   2.143 - * have option of calling make_larger_PrivQ to make more room, then try again
   2.144 - */
   2.145 -int writeIfSpacePrivQ( void * in, PrivQueueStruc* Q )
   2.146 - {
   2.147 -   void **startOfData = Q->startOfData;
   2.148 -   void **endOfData   = Q->endOfData;
   2.149 -
   2.150 -   void **insertPos  = Q->insertPos;
   2.151 -   void **extractPos = Q->extractPos;
   2.152 -
   2.153 -   if( extractPos - insertPos != 1 &&
   2.154 -       !(insertPos == endOfData && extractPos == startOfData))
   2.155 -    { *(Q->insertPos) = in;   //insert before move
   2.156 -      if( insertPos == endOfData ) //write new pos exactly once, correctly
   2.157 -       { Q->insertPos = startOfData;
   2.158 -       }
   2.159 -      else
   2.160 -       { Q->insertPos++;
   2.161 -       }
   2.162 -      return TRUE;
   2.163 -    }
   2.164 -      //Q is full
   2.165 -   return FALSE;
   2.166 - }
   2.167 -
   2.168 -/*Treats queue as a stack -- no matter contents, if read done right after
   2.169 - * a push, then the pushed item is what comes out.
   2.170 - * Expands the queue size automatically when it's full.
   2.171 - */
   2.172 -void
   2.173 -pushPrivQ( void * in, PrivQueueStruc* Q )
   2.174 - {
   2.175 -   while(1){
   2.176 -       void **startOfData = Q->startOfData;
   2.177 -       void **endOfData   = Q->endOfData;
   2.178 -
   2.179 -       void **insertPos  = Q->insertPos;
   2.180 -       void **extractPos = Q->extractPos;
   2.181 -
   2.182 -          //Full? (insert is just below extract when full)
   2.183 -       if( extractPos - insertPos != 1 &&
   2.184 -           !(insertPos == endOfData && extractPos == startOfData))
   2.185 -        {    //insert -- but go backwards, inserting at read position then
   2.186 -             // move read pos backwards
   2.187 -          *(Q->extractPos) = in;
   2.188 -          if( extractPos == startOfData ) //write new pos exactly once, correctly
   2.189 -           { Q->extractPos = endOfData;   //can't overrun then fix it 'cause
   2.190 -           }                              // other thread might read bad pos
   2.191 -          else
   2.192 -           { Q->extractPos--;
   2.193 -           }
   2.194 -          return;
   2.195 -        }
   2.196 -          //Q is full
   2.197 -       enlargePrivQ( Q );
   2.198 -   }
   2.199 - }
   2.200 -
   2.201 -void
   2.202 -freePrivQ( PrivQueueStruc *Q )
   2.203 - {
   2.204 -   VMS__free( Q->startOfData );
   2.205 -   VMS__free( Q );
   2.206 +/*
   2.207 + *  Copyright 2009 OpenSourceStewardshipFoundation.org
   2.208 + *  Licensed under GNU General Public License version 2
   2.209 + *
   2.210 + * Author: seanhalle@yahoo.com
   2.211 + */
   2.212 +
   2.213 +
   2.214 +#include <stdio.h>
   2.215 +#include <string.h>
   2.216 +#include <errno.h>
   2.217 +#include <stdlib.h>
   2.218 +
   2.219 +#include "PrivateQueue.h"
   2.220 +#include "VMS_Implementations/VMS_impl/vmalloc.h"
   2.221 +
   2.222 +
   2.223 +
   2.224 +//===========================================================================
   2.225 +
   2.226 +/*This kind of queue is private to a single core at a time -- has no
   2.227 + * synchronizations 
   2.228 + */
   2.229 +
   2.230 +PrivQueueStruc* makePrivQ()
   2.231 + {
   2.232 +   PrivQueueStruc *retQ;
   2.233 +   retQ = VMS_int__malloc( sizeof( PrivQueueStruc ) );
   2.234 +   retQ->startOfData = (void*)VMS_int__malloc( 1024 * sizeof(void *) );
   2.235 +   memset( retQ->startOfData, 0, 1024 );
   2.236 +
   2.237 +   retQ->extractPos = &(retQ->startOfData[0]); //side by side == empty
   2.238 +   retQ->insertPos  = &(retQ->startOfData[1]); // so start pos's have to be
   2.239 +   retQ->endOfData  = &(retQ->startOfData[1023]);
   2.240 +
   2.241 +   return retQ;
   2.242 + }
   2.243 +
   2.244 +
   2.245 +void
   2.246 +enlargePrivQ( PrivQueueStruc *Q )
   2.247 + { size_t    oldSize, newSize;
   2.248 +   void **oldStartOfData;
   2.249 +
   2.250 +   oldSize           = Q->endOfData - Q->startOfData + 1;
   2.251 +   newSize           = 2 * oldSize;
   2.252 +   oldStartOfData = Q->startOfData;
   2.253 +   Q->startOfData = VMS_int__malloc( newSize * sizeof(void*));
   2.254 +   //copy second half
   2.255 +   size_t secondHalfSize = Q->endOfData - Q->extractPos + 1;
   2.256 +   memcpy(Q->startOfData,Q->extractPos, secondHalfSize * sizeof(void*));
   2.257 +   //copy first half
   2.258 +   memcpy(Q->startOfData + secondHalfSize, oldStartOfData, 
   2.259 +                        (oldSize-secondHalfSize) * sizeof(void*));
   2.260 +   VMS_int__free(oldStartOfData);
   2.261 +   
   2.262 +   Q->extractPos  = Q->startOfData;
   2.263 +   Q->insertPos   = Q->startOfData + oldSize - 1;
   2.264 +   Q->endOfData   = &(Q->startOfData[newSize - 1]);
   2.265 + }
   2.266 +
   2.267 +
   2.268 +/*Returns NULL when queue is empty
   2.269 + */
   2.270 +void* readPrivQ( PrivQueueStruc* Q )
   2.271 + { void *out    = 0;
   2.272 +   void **startOfData = Q->startOfData;
   2.273 +   void **endOfData   = Q->endOfData;
   2.274 +
   2.275 +   void **insertPos  = Q->insertPos;
   2.276 +   void **extractPos = Q->extractPos;
   2.277 +
   2.278 +      //if not empty -- (extract is just below insert when empty)
   2.279 +   if( insertPos - extractPos != 1 &&
   2.280 +       !(extractPos == endOfData && insertPos == startOfData))
   2.281 +    {    //move before read
   2.282 +      if( extractPos == endOfData ) //write new pos exactly once, correctly
   2.283 +       { Q->extractPos = startOfData; //can't overrun then fix it 'cause
   2.284 +       }                              // other thread might read bad pos
   2.285 +      else
   2.286 +       { Q->extractPos++;
   2.287 +       }
   2.288 +      out = *(Q->extractPos);
   2.289 +      return out;
   2.290 +    }
   2.291 +      //Q is empty
   2.292 +   return NULL;
   2.293 + }
   2.294 +
   2.295 +int32
   2.296 +numInPrivQ( PrivQueueStruc *Q )
   2.297 + { int32 size, numIn;
   2.298 + 
   2.299 +   if( Q->insertPos < Q->extractPos )
   2.300 +    {    //insert has wrapped around so numIn is:
   2.301 +         // insertPos + size - extractPos -- Consider, is empty when
   2.302 +         // extractPos = endOfData and insert = start -- correctly get zero
   2.303 +      size  = Q->endOfData - Q->startOfData;
   2.304 +      numIn = Q->insertPos + size - Q->extractPos;
   2.305 +    }
   2.306 +   else
   2.307 +    {
   2.308 +      numIn =  Q->insertPos -  Q->extractPos -1;//-1 bec empty @ side-by-side
   2.309 +    }
   2.310 +   return numIn;
   2.311 + }
   2.312 +
   2.313 +
   2.314 +/*Expands the queue size automatically when it's full
   2.315 + */
   2.316 +void
   2.317 +writePrivQ( void * in, PrivQueueStruc* Q )
   2.318 + {
   2.319 +   while(1){
   2.320 +       void **startOfData = Q->startOfData;
   2.321 +       void **endOfData   = Q->endOfData;
   2.322 +
   2.323 +       void **insertPos  = Q->insertPos;
   2.324 +       void **extractPos = Q->extractPos;
   2.325 +
   2.326 +          //Full? (insert is just below extract when full)
   2.327 +       if( extractPos - insertPos != 1 &&
   2.328 +           !(insertPos == endOfData && extractPos == startOfData))
   2.329 +        { *(Q->insertPos) = in;   //insert before move
   2.330 +          if( insertPos == endOfData ) //write new pos exactly once, correctly
   2.331 +           { Q->insertPos = startOfData;
   2.332 +           }
   2.333 +          else
   2.334 +           { Q->insertPos++;
   2.335 +           }
   2.336 +          return;
   2.337 +        }
   2.338 +          //Q is full
   2.339 +       enlargePrivQ( Q );
   2.340 +   }
   2.341 + }
   2.342 +
   2.343 +
   2.344 +/*Returns false when the queue was full.
   2.345 + * have option of calling make_larger_PrivQ to make more room, then try again
   2.346 + */
   2.347 +int writeIfSpacePrivQ( void * in, PrivQueueStruc* Q )
   2.348 + {
   2.349 +   void **startOfData = Q->startOfData;
   2.350 +   void **endOfData   = Q->endOfData;
   2.351 +
   2.352 +   void **insertPos  = Q->insertPos;
   2.353 +   void **extractPos = Q->extractPos;
   2.354 +
   2.355 +   if( extractPos - insertPos != 1 &&
   2.356 +       !(insertPos == endOfData && extractPos == startOfData))
   2.357 +    { *(Q->insertPos) = in;   //insert before move
   2.358 +      if( insertPos == endOfData ) //write new pos exactly once, correctly
   2.359 +       { Q->insertPos = startOfData;
   2.360 +       }
   2.361 +      else
   2.362 +       { Q->insertPos++;
   2.363 +       }
   2.364 +      return TRUE;
   2.365 +    }
   2.366 +      //Q is full
   2.367 +   return FALSE;
   2.368 + }
   2.369 +
   2.370 +/*Treats queue as a stack -- no matter contents, if read done right after
   2.371 + * a push, then the pushed item is what comes out.
   2.372 + * Expands the queue size automatically when it's full.
   2.373 + */
   2.374 +void
   2.375 +pushPrivQ( void * in, PrivQueueStruc* Q )
   2.376 + {
   2.377 +   while(1){
   2.378 +       void **startOfData = Q->startOfData;
   2.379 +       void **endOfData   = Q->endOfData;
   2.380 +
   2.381 +       void **insertPos  = Q->insertPos;
   2.382 +       void **extractPos = Q->extractPos;
   2.383 +
   2.384 +          //Full? (insert is just below extract when full)
   2.385 +       if( extractPos - insertPos != 1 &&
   2.386 +           !(insertPos == endOfData && extractPos == startOfData))
   2.387 +        {    //insert -- but go backwards, inserting at read position then
   2.388 +             // move read pos backwards
   2.389 +          *(Q->extractPos) = in;
   2.390 +          if( extractPos == startOfData ) //write new pos exactly once, correctly
   2.391 +           { Q->extractPos = endOfData;   //can't overrun then fix it 'cause
   2.392 +           }                              // other thread might read bad pos
   2.393 +          else
   2.394 +           { Q->extractPos--;
   2.395 +           }
   2.396 +          return;
   2.397 +        }
   2.398 +          //Q is full
   2.399 +       enlargePrivQ( Q );
   2.400 +   }
   2.401 + }
   2.402 +
   2.403 +void
   2.404 +freePrivQ( PrivQueueStruc *Q )
   2.405 + {
   2.406 +   VMS_int__free( Q->startOfData );
   2.407 +   VMS_int__free( Q );
   2.408   }
   2.409 \ No newline at end of file

     3.1 --- a/PrivateQueue.h	Wed Jun 22 18:49:17 2011 +0200
     3.2 +++ b/PrivateQueue.h	Mon Feb 13 19:32:12 2012 +0100
     3.3 @@ -1,38 +1,38 @@
     3.4 -/*
     3.5 - *  Copyright 2009 OpenSourceStewardshipFoundation.org
     3.6 - *  Licensed under GNU General Public License version 2
     3.7 - *
     3.8 - * Author: seanhalle@yahoo.com
     3.9 - */
    3.10 -
    3.11 -#ifndef _PRIVATE_QUEUE_H
    3.12 -#define	_PRIVATE_QUEUE_H
    3.13 -
    3.14 -#include "../VMS_primitive_data_types.h"
    3.15 -
    3.16 -#define TRUE     1
    3.17 -#define FALSE    0
    3.18 -
    3.19 -#define LOCKED   1
    3.20 -#define UNLOCKED 0
    3.21 -
    3.22 -
    3.23 -typedef struct
    3.24 - { void      **insertPos;
    3.25 -   void      **extractPos;
    3.26 -   void      **startOfData;  //data is pointers
    3.27 -   void      **endOfData;    //set when alloc data
    3.28 - }
    3.29 -PrivQueueStruc;
    3.30 -
    3.31 -
    3.32 -PrivQueueStruc*  makeVMSPrivQ ( );
    3.33 -void*            readPrivQ ( PrivQueueStruc *Q );
    3.34 -void             writePrivQ( void *in, PrivQueueStruc *Q );
    3.35 -int32            writeIfSpacePrivQ( void * in, PrivQueueStruc* Q ); //return
    3.36 -                    // false when full
    3.37 -int32            numInPrivQ( PrivQueueStruc *Q );
    3.38 -void             pushPrivQ( void * in, PrivQueueStruc* Q );
    3.39 -
    3.40 -#endif	/* _PRIVATE_QUEUE_H */
    3.41 -
    3.42 +/*
    3.43 + *  Copyright 2009 OpenSourceStewardshipFoundation.org
    3.44 + *  Licensed under GNU General Public License version 2
    3.45 + *
    3.46 + * Author: seanhalle@yahoo.com
    3.47 + */
    3.48 +
    3.49 +#ifndef _PRIVATE_QUEUE_H
    3.50 +#define	_PRIVATE_QUEUE_H
    3.51 +
    3.52 +#include "VMS_Implementations/VMS_impl/VMS_primitive_data_types.h"
    3.53 +
    3.54 +#define TRUE     1
    3.55 +#define FALSE    0
    3.56 +
    3.57 +#define LOCKED   1
    3.58 +#define UNLOCKED 0
    3.59 +
    3.60 +
    3.61 +typedef struct
    3.62 + { void      **insertPos;
    3.63 +   void      **extractPos;
    3.64 +   void      **startOfData;  //data is pointers
    3.65 +   void      **endOfData;    //set when alloc data
    3.66 + }
    3.67 +PrivQueueStruc;
    3.68 +
    3.69 +
    3.70 +PrivQueueStruc*  makePrivQ ( );
    3.71 +void*            readPrivQ ( PrivQueueStruc *Q );
    3.72 +void             writePrivQ( void *in, PrivQueueStruc *Q );
    3.73 +int32            writeIfSpacePrivQ( void * in, PrivQueueStruc* Q ); //return
    3.74 +                    // false when full
    3.75 +int32            numInPrivQ( PrivQueueStruc *Q );
    3.76 +void             pushPrivQ( void * in, PrivQueueStruc* Q );
    3.77 +
    3.78 +#endif	/* _PRIVATE_QUEUE_H */
    3.79 +