-=> Quoting Darin McBride to Phil Crown <=-

 PC>   return rc;  // A calling thread is pre-empted here before returning rc.
 
 PC>               // A second threads comes along and completes the
 PC>               // function before the first thread has finished,
 PC>               // thus causing rc to contain invalid data.
 PC>               // Is this possible?

 DM> No.

 DM> You only require semaphores to protect global and static data, not
 DM> local data.  Since RC is a ULONG allocated on the stack, it will be
 DM> only on the thread's local stack.  So when thread A calls someFn(), a
 DM> ULONG will be placed on thread A's stack.  OS/2 pre-empts thread A,
 DM> and thread B continues, calling someFn().  This time the arguments say
 DM> not to call DosSleep(), so it gets all the way through - but this time
 DM> the ULONG is on thread B's stack - seperate from thread A's stack. 
 DM> However, global and static data are stored in another place entirely,
 DM> with one instance being visible to both (all) threads.  If there is
 DM> any danger of global data being written to by one thread while another
 DM> is trying to read it (or write), then you need a semaphore to protect
 DM> it.  (If everyone just reads it, then no semaphore is required,
 DM> obviously.) 
 DM> If str is a global pointer, then yes, you need to protect it.

str is defined in a class.  The mutex semaphore seems to have fixed my
traps.

Thanks for your help!

Phil Crown
pcrown{at}airmail.net
http://web2.airmail.net/pcrown/

--- Blue Wave/OS2 v2.30