seven_zip_ruby_am 1.2.5.1

data/ext/p7zip/C/RotateDefs.h

@@ -0,0 +1,20 @@
+/* RotateDefs.h -- Rotate functions
+2009-02-07 : Igor Pavlov : Public domain */
+
+#ifndef __ROTATE_DEFS_H
+#define __ROTATE_DEFS_H
+
+#ifdef _MSC_VER
+
+#include <stdlib.h>
+#define rotlFixed(x, n) _rotl((x), (n))
+#define rotrFixed(x, n) _rotr((x), (n))
+
+#else
+
+#define rotlFixed(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+#define rotrFixed(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
+
+#endif
+
+#endif

data/ext/p7zip/C/Sha256.c

@@ -0,0 +1,204 @@
+/* Crypto/Sha256.c -- SHA-256 Hash
+2010-06-11 : Igor Pavlov : Public domain
+This code is based on public domain code from Wei Dai's Crypto++ library. */
+
+#include "RotateDefs.h"
+#include "Sha256.h"
+
+/* define it for speed optimization */
+/* #define _SHA256_UNROLL */
+/* #define _SHA256_UNROLL2 */
+
+void Sha256_Init(CSha256 *p)
+{
+  p->state[0] = 0x6a09e667;
+  p->state[1] = 0xbb67ae85;
+  p->state[2] = 0x3c6ef372;
+  p->state[3] = 0xa54ff53a;
+  p->state[4] = 0x510e527f;
+  p->state[5] = 0x9b05688c;
+  p->state[6] = 0x1f83d9ab;
+  p->state[7] = 0x5be0cd19;
+  p->count = 0;
+}
+
+#define S0(x) (rotrFixed(x, 2) ^ rotrFixed(x,13) ^ rotrFixed(x, 22))
+#define S1(x) (rotrFixed(x, 6) ^ rotrFixed(x,11) ^ rotrFixed(x, 25))
+#define s0(x) (rotrFixed(x, 7) ^ rotrFixed(x,18) ^ (x >> 3))
+#define s1(x) (rotrFixed(x,17) ^ rotrFixed(x,19) ^ (x >> 10))
+
+#define blk0(i) (W[i] = data[i])
+#define blk2(i) (W[i&15] += s1(W[(i-2)&15]) + W[(i-7)&15] + s0(W[(i-15)&15]))
+
+#define Ch(x,y,z) (z^(x&(y^z)))
+#define Maj(x,y,z) ((x&y)|(z&(x|y)))
+
+#define a(i) T[(0-(i))&7]
+#define b(i) T[(1-(i))&7]
+#define c(i) T[(2-(i))&7]
+#define d(i) T[(3-(i))&7]
+#define e(i) T[(4-(i))&7]
+#define f(i) T[(5-(i))&7]
+#define g(i) T[(6-(i))&7]
+#define h(i) T[(7-(i))&7]
+
+
+#ifdef _SHA256_UNROLL2
+
+#define R(a,b,c,d,e,f,g,h, i) h += S1(e) + Ch(e,f,g) + K[i+j] + (j?blk2(i):blk0(i));\
+  d += h; h += S0(a) + Maj(a, b, c)
+
+#define RX_8(i) \
+  R(a,b,c,d,e,f,g,h, i); \
+  R(h,a,b,c,d,e,f,g, i+1); \
+  R(g,h,a,b,c,d,e,f, i+2); \
+  R(f,g,h,a,b,c,d,e, i+3); \
+  R(e,f,g,h,a,b,c,d, i+4); \
+  R(d,e,f,g,h,a,b,c, i+5); \
+  R(c,d,e,f,g,h,a,b, i+6); \
+  R(b,c,d,e,f,g,h,a, i+7)
+
+#else
+
+#define R(i) h(i) += S1(e(i)) + Ch(e(i),f(i),g(i)) + K[i+j] + (j?blk2(i):blk0(i));\
+  d(i) += h(i); h(i) += S0(a(i)) + Maj(a(i), b(i), c(i))
+
+#ifdef _SHA256_UNROLL
+
+#define RX_8(i) R(i+0); R(i+1); R(i+2); R(i+3); R(i+4); R(i+5); R(i+6); R(i+7);
+
+#endif
+
+#endif
+
+static const UInt32 K[64] = {
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+};
+
+static void Sha256_Transform(UInt32 *state, const UInt32 *data)
+{
+  UInt32 W[16];
+  unsigned j;
+  #ifdef _SHA256_UNROLL2
+  UInt32 a,b,c,d,e,f,g,h;
+  a = state[0];
+  b = state[1];
+  c = state[2];
+  d = state[3];
+  e = state[4];
+  f = state[5];
+  g = state[6];
+  h = state[7];
+  #else
+  UInt32 T[8];
+  for (j = 0; j < 8; j++)
+    T[j] = state[j];
+  #endif
+
+  for (j = 0; j < 64; j += 16)
+  {
+    #if defined(_SHA256_UNROLL) || defined(_SHA256_UNROLL2)
+    RX_8(0); RX_8(8);
+    #else
+    unsigned i;
+    for (i = 0; i < 16; i++) { R(i); }
+    #endif
+  }
+
+  #ifdef _SHA256_UNROLL2
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+  state[4] += e;
+  state[5] += f;
+  state[6] += g;
+  state[7] += h;
+  #else
+  for (j = 0; j < 8; j++)
+    state[j] += T[j];
+  #endif
+  
+  /* Wipe variables */
+  /* memset(W, 0, sizeof(W)); */
+  /* memset(T, 0, sizeof(T)); */
+}
+
+#undef S0
+#undef S1
+#undef s0
+#undef s1
+
+static void Sha256_WriteByteBlock(CSha256 *p)
+{
+  UInt32 data32[16];
+  unsigned i;
+  for (i = 0; i < 16; i++)
+    data32[i] =
+      ((UInt32)(p->buffer[i * 4    ]) << 24) +
+      ((UInt32)(p->buffer[i * 4 + 1]) << 16) +
+      ((UInt32)(p->buffer[i * 4 + 2]) <<  8) +
+      ((UInt32)(p->buffer[i * 4 + 3]));
+  Sha256_Transform(p->state, data32);
+}
+
+void Sha256_Update(CSha256 *p, const Byte *data, size_t size)
+{
+  UInt32 curBufferPos = (UInt32)p->count & 0x3F;
+  while (size > 0)
+  {
+    p->buffer[curBufferPos++] = *data++;
+    p->count++;
+    size--;
+    if (curBufferPos == 64)
+    {
+      curBufferPos = 0;
+      Sha256_WriteByteBlock(p);
+    }
+  }
+}
+
+void Sha256_Final(CSha256 *p, Byte *digest)
+{
+  UInt64 lenInBits = (p->count << 3);
+  UInt32 curBufferPos = (UInt32)p->count & 0x3F;
+  unsigned i;
+  p->buffer[curBufferPos++] = 0x80;
+  while (curBufferPos != (64 - 8))
+  {
+    curBufferPos &= 0x3F;
+    if (curBufferPos == 0)
+      Sha256_WriteByteBlock(p);
+    p->buffer[curBufferPos++] = 0;
+  }
+  for (i = 0; i < 8; i++)
+  {
+    p->buffer[curBufferPos++] = (Byte)(lenInBits >> 56);
+    lenInBits <<= 8;
+  }
+  Sha256_WriteByteBlock(p);
+
+  for (i = 0; i < 8; i++)
+  {
+    *digest++ = (Byte)(p->state[i] >> 24);
+    *digest++ = (Byte)(p->state[i] >> 16);
+    *digest++ = (Byte)(p->state[i] >> 8);
+    *digest++ = (Byte)(p->state[i]);
+  }
+  Sha256_Init(p);
+}

data/ext/p7zip/C/Sha256.h

@@ -0,0 +1,26 @@
+/* Sha256.h -- SHA-256 Hash
+2010-06-11 : Igor Pavlov : Public domain */
+
+#ifndef __CRYPTO_SHA256_H
+#define __CRYPTO_SHA256_H
+
+#include "Types.h"
+
+EXTERN_C_BEGIN
+
+#define SHA256_DIGEST_SIZE 32
+
+typedef struct
+{
+  UInt32 state[8];
+  UInt64 count;
+  Byte buffer[64];
+} CSha256;
+
+void Sha256_Init(CSha256 *p);
+void Sha256_Update(CSha256 *p, const Byte *data, size_t size);
+void Sha256_Final(CSha256 *p, Byte *digest);
+
+EXTERN_C_END
+
+#endif

data/ext/p7zip/C/Sort.c

@@ -0,0 +1,93 @@
+/* Sort.c -- Sort functions
+2010-09-17 : Igor Pavlov : Public domain */
+
+#include "Sort.h"
+
+#define HeapSortDown(p, k, size, temp) \
+  { for (;;) { \
+    UInt32 s = (k << 1); \
+    if (s > size) break; \
+    if (s < size && p[s + 1] > p[s]) s++; \
+    if (temp >= p[s]) break; \
+    p[k] = p[s]; k = s; \
+  } p[k] = temp; }
+
+void HeapSort(UInt32 *p, UInt32 size)
+{
+  if (size <= 1)
+    return;
+  p--;
+  {
+    UInt32 i = size / 2;
+    do
+    {
+      UInt32 temp = p[i];
+      UInt32 k = i;
+      HeapSortDown(p, k, size, temp)
+    }
+    while (--i != 0);
+  }
+  /*
+  do
+  {
+    UInt32 k = 1;
+    UInt32 temp = p[size];
+    p[size--] = p[1];
+    HeapSortDown(p, k, size, temp)
+  }
+  while (size > 1);
+  */
+  while (size > 3)
+  {
+    UInt32 temp = p[size];
+    UInt32 k = (p[3] > p[2]) ? 3 : 2;
+    p[size--] = p[1];
+    p[1] = p[k];
+    HeapSortDown(p, k, size, temp)
+  }
+  {
+    UInt32 temp = p[size];
+    p[size] = p[1];
+    if (size > 2 && p[2] < temp)
+    {
+      p[1] = p[2];
+      p[2] = temp;
+    }
+    else
+      p[1] = temp;
+  }
+}
+
+/*
+#define HeapSortRefDown(p, vals, n, size, temp) \
+  { UInt32 k = n; UInt32 val = vals[temp]; for (;;) { \
+    UInt32 s = (k << 1); \
+    if (s > size) break; \
+    if (s < size && vals[p[s + 1]] > vals[p[s]]) s++; \
+    if (val >= vals[p[s]]) break; \
+    p[k] = p[s]; k = s; \
+  } p[k] = temp; }
+
+void HeapSortRef(UInt32 *p, UInt32 *vals, UInt32 size)
+{
+  if (size <= 1)
+    return;
+  p--;
+  {
+    UInt32 i = size / 2;
+    do
+    {
+      UInt32 temp = p[i];
+      HeapSortRefDown(p, vals, i, size, temp);
+    }
+    while (--i != 0);
+  }
+  do
+  {
+    UInt32 temp = p[size];
+    p[size--] = p[1];
+    HeapSortRefDown(p, vals, 1, size, temp);
+  }
+  while (size > 1);
+}
+*/

data/ext/p7zip/C/Sort.h

@@ -0,0 +1,20 @@
+/* Sort.h -- Sort functions
+2009-02-07 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_SORT_H
+#define __7Z_SORT_H
+
+#include "Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void HeapSort(UInt32 *p, UInt32 size);
+/* void HeapSortRef(UInt32 *p, UInt32 *vals, UInt32 size); */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/p7zip/C/Threads.c

@@ -0,0 +1,582 @@
+/* Threads.c */
+
+#include "Threads.h"
+
+#ifdef ENV_BEOS
+#include <kernel/OS.h>
+#else
+#include <pthread.h>
+#include <stdlib.h>
+#endif
+
+#include <errno.h>
+
+#if defined(__linux__) 
+#define PTHREAD_MUTEX_ERRORCHECK PTHREAD_MUTEX_ERRORCHECK_NP
+#endif
+
+#ifdef ENV_BEOS
+
+/* TODO : optimize the code and verify the returned values */ 
+
+WRes Thread_Create(CThread *thread, THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
+{ 
+	thread->_tid = spawn_thread((int32 (*)(void *))startAddress, "CThread", B_LOW_PRIORITY, parameter);
+	if (thread->_tid >= B_OK) {
+		resume_thread(thread->_tid);
+	} else {
+		thread->_tid = B_BAD_THREAD_ID;
+	}
+	thread->_created = 1;
+	return 0; // SZ_OK;
+}
+
+WRes Thread_Wait(CThread *thread)
+{
+  int ret;
+
+  if (thread->_created == 0)
+    return EINVAL;
+
+  if (thread->_tid >= B_OK) 
+  {
+    status_t exit_value;
+    wait_for_thread(thread->_tid, &exit_value);
+    thread->_tid = B_BAD_THREAD_ID;
+  } else {
+    return EINVAL;
+  }
+  
+  thread->_created = 0;
+  
+  return 0;
+}
+
+WRes Thread_Close(CThread *thread)
+{
+    if (!thread->_created) return SZ_OK;
+    
+    thread->_tid = B_BAD_THREAD_ID;
+    thread->_created = 0;
+    return SZ_OK;
+}
+
+
+WRes Event_Create(CEvent *p, BOOL manualReset, int initialSignaled)
+{
+  p->_index_waiting = 0;
+  p->_manual_reset  = manualReset;
+  p->_state         = (initialSignaled ? TRUE : FALSE);
+  p->_created       = 1;
+  p->_sem           = create_sem(1,"event");
+  return 0;
+}
+
+WRes Event_Set(CEvent *p) {
+  int index;
+  acquire_sem(p->_sem);
+  p->_state = TRUE;
+  for(index = 0 ; index < p->_index_waiting ; index++)
+  {
+     send_data(p->_waiting[index], '7zCN', NULL, 0);
+  }
+  p->_index_waiting = 0;
+  release_sem(p->_sem);
+  return 0;
+}
+
+WRes Event_Reset(CEvent *p) {
+  acquire_sem(p->_sem);
+  p->_state = FALSE;
+  release_sem(p->_sem);
+  return 0;
+}
+ 
+WRes Event_Wait(CEvent *p) {
+  acquire_sem(p->_sem);
+  while (p->_state == FALSE)
+  {
+    thread_id sender; 
+    p->_waiting[p->_index_waiting++] = find_thread(NULL);
+    release_sem(p->_sem);
+    /* int msg = */ receive_data(&sender, NULL, 0);
+    acquire_sem(p->_sem);
+  }
+  if (p->_manual_reset == FALSE)
+  {
+     p->_state = FALSE;
+  }
+  release_sem(p->_sem);
+  return 0;
+}
+
+WRes Event_Close(CEvent *p) { 
+  if (p->_created)
+  {
+    p->_created = 0;
+    delete_sem(p->_sem);
+  }
+  return 0;
+}
+
+WRes Semaphore_Create(CSemaphore *p, UInt32 initiallyCount, UInt32 maxCount)
+{
+  p->_index_waiting = 0;
+  p->_count         = initiallyCount;
+  p->_maxCount      = maxCount;
+  p->_created       = 1;
+  p->_sem           = create_sem(1,"sem");
+  return 0;
+}
+
+WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 releaseCount)
+{
+  UInt32 newCount;
+  int index;
+  
+  if (releaseCount < 1) return EINVAL;
+
+  acquire_sem(p->_sem);
+  newCount = p->_count + releaseCount;
+  if (newCount > p->_maxCount)
+  {
+    release_sem(p->_sem);
+    return EINVAL;
+  }
+  p->_count = newCount;
+  for(index = 0 ; index < p->_index_waiting ; index++)
+  {
+     send_data(p->_waiting[index], '7zCN', NULL, 0);
+  }
+  p->_index_waiting = 0;
+  release_sem(p->_sem);
+  return 0;
+}
+
+WRes Semaphore_Wait(CSemaphore *p) {
+  acquire_sem(p->_sem);
+  while (p->_count < 1)
+  {
+    thread_id sender;  
+    p->_waiting[p->_index_waiting++] = find_thread(NULL);
+    release_sem(p->_sem);
+    /* int msg = */ receive_data(&sender, NULL, 0);
+    acquire_sem(p->_sem);
+  }
+  p->_count--;
+  release_sem(p->_sem); 
+  return 0;
+}
+
+WRes Semaphore_Close(CSemaphore *p) {
+  if (p->_created)
+  {
+    p->_created = 0;
+    delete_sem(p->_sem);
+  }
+  return 0;
+}
+
+WRes CriticalSection_Init(CCriticalSection * lpCriticalSection)
+{
+  lpCriticalSection->_sem = create_sem(1,"cc");
+  return 0;
+}
+
+#else /* !ENV_BEOS */
+
+WRes Thread_Create(CThread *thread, THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
+{ 
+	pthread_attr_t attr;
+	int ret;
+
+	thread->_created = 0;
+
+	ret = pthread_attr_init(&attr);
+	if (ret) return ret;
+
+	ret = pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE);
+	if (ret) return ret;
+
+	ret = pthread_create(&thread->_tid, &attr, (void * (*)(void *))startAddress, parameter);
+
+	/* ret2 = */ pthread_attr_destroy(&attr);
+
+	if (ret) return ret;
+	
+	thread->_created = 1;
+
+	return 0; // SZ_OK;
+}
+
+WRes Thread_Wait(CThread *thread)
+{
+  void *thread_return;
+  int ret;
+
+  if (thread->_created == 0)
+    return EINVAL;
+
+  ret = pthread_join(thread->_tid,&thread_return);
+  thread->_created = 0;
+  
+  return ret;
+}
+
+WRes Thread_Close(CThread *thread)
+{
+    if (!thread->_created) return SZ_OK;
+    
+    pthread_detach(thread->_tid);
+    thread->_tid = 0;
+    thread->_created = 0;
+    return SZ_OK;
+}
+
+#ifdef DEBUG_SYNCHRO
+
+#include <stdio.h>
+
+static void dump_error(int ligne,int ret,const char *text,void *param)
+{
+  printf("\n##T%d#ERROR2 (l=%d) %s : param=%p ret = %d (%s)##\n",(int)pthread_self(),ligne,text,param,ret,strerror(ret));
+    // abort();
+}
+
+WRes Event_Create(CEvent *p, BOOL manualReset, int initialSignaled)
+{
+  int ret;
+  pthread_mutexattr_t mutexattr;
+  memset(&mutexattr,0,sizeof(mutexattr));
+  ret = pthread_mutexattr_init(&mutexattr);
+  if (ret != 0) dump_error(__LINE__,ret,"Event_Create::pthread_mutexattr_init",&mutexattr);
+  ret = pthread_mutexattr_settype(&mutexattr,PTHREAD_MUTEX_ERRORCHECK);
+  if (ret != 0) dump_error(__LINE__,ret,"Event_Create::pthread_mutexattr_settype",&mutexattr);
+  ret = pthread_mutex_init(&p->_mutex,&mutexattr);
+  if (ret != 0) dump_error(__LINE__,ret,"Event_Create::pthread_mutexattr_init",&p->_mutex);
+  if (ret == 0)
+  {
+    ret = pthread_cond_init(&p->_cond,0);
+    if (ret != 0) dump_error(__LINE__,ret,"Event_Create::pthread_cond_init",&p->_cond);
+    p->_manual_reset = manualReset;
+    p->_state        = (initialSignaled ? TRUE : FALSE);
+    p->_created = 1;
+  }
+  return ret;
+}
+
+WRes Event_Set(CEvent *p) {
+  int ret = pthread_mutex_lock(&p->_mutex);
+  if (ret != 0) dump_error(__LINE__,ret,"ES::pthread_mutex_lock",&p->_mutex);
+  if (ret == 0)
+  {
+    p->_state = TRUE;
+    ret = pthread_cond_broadcast(&p->_cond);
+    if (ret != 0) dump_error(__LINE__,ret,"ES::pthread_cond_broadcast",&p->_cond);
+    if (ret == 0)
+    {
+       ret = pthread_mutex_unlock(&p->_mutex);
+       if (ret != 0) dump_error(__LINE__,ret,"ES::pthread_mutex_unlock",&p->_mutex);
+    }
+  }
+  return ret;
+}
+
+WRes Event_Reset(CEvent *p) {
+  int ret = pthread_mutex_lock(&p->_mutex);
+  if (ret != 0) dump_error(__LINE__,ret,"ER::pthread_mutex_lock",&p->_mutex);
+  if (ret == 0)
+  {
+    p->_state = FALSE;
+    ret = pthread_mutex_unlock(&p->_mutex);
+    if (ret != 0) dump_error(__LINE__,ret,"ER::pthread_mutex_unlock",&p->_mutex);
+  }
+  return ret;
+}
+ 
+WRes Event_Wait(CEvent *p) {
+  int ret = pthread_mutex_lock(&p->_mutex);
+  if (ret != 0) dump_error(__LINE__,ret,"EW::pthread_mutex_lock",&p->_mutex);
+  if (ret == 0)
+  {
+    while ((p->_state == FALSE) && (ret == 0))
+    {
+       ret = pthread_cond_wait(&p->_cond, &p->_mutex);
+       if (ret != 0) dump_error(__LINE__,ret,"EW::pthread_cond_wait",&p->_mutex);
+    }
+    if (ret == 0)
+    {
+       if (p->_manual_reset == FALSE)
+       {
+         p->_state = FALSE;
+       }
+       ret = pthread_mutex_unlock(&p->_mutex);
+       if (ret != 0) dump_error(__LINE__,ret,"EW::pthread_mutex_unlock",&p->_mutex);
+    }
+  }
+  return ret;
+}
+
+WRes Event_Close(CEvent *p) { 
+  if (p->_created)
+  {
+    int ret;
+    p->_created = 0;
+    ret = pthread_mutex_destroy(&p->_mutex);
+    if (ret != 0) dump_error(__LINE__,ret,"EC::pthread_mutex_destroy",&p->_mutex);
+    ret = pthread_cond_destroy(&p->_cond);
+    if (ret != 0) dump_error(__LINE__,ret,"EC::pthread_cond_destroy",&p->_cond);
+  }
+  return 0;
+}
+
+WRes Semaphore_Create(CSemaphore *p, UInt32 initiallyCount, UInt32 maxCount)
+{
+  int ret;
+  pthread_mutexattr_t mutexattr;
+  memset(&mutexattr,0,sizeof(mutexattr));
+  ret = pthread_mutexattr_init(&mutexattr);
+  if (ret != 0) dump_error(__LINE__,ret,"SemC::pthread_mutexattr_init",&mutexattr);
+  ret = pthread_mutexattr_settype(&mutexattr,PTHREAD_MUTEX_ERRORCHECK);
+  if (ret != 0) dump_error(__LINE__,ret,"SemC::pthread_mutexattr_settype",&mutexattr);
+  ret = pthread_mutex_init(&p->_mutex,&mutexattr);
+  if (ret != 0) dump_error(__LINE__,ret,"SemC::pthread_mutexattr_init",&p->_mutex);
+  if (ret == 0)
+  {
+    ret = pthread_cond_init(&p->_cond,0);
+    if (ret != 0) dump_error(__LINE__,ret,"SemC::pthread_cond_init",&p->_mutex);
+    p->_count    = initiallyCount;
+    p->_maxCount = maxCount;
+    p->_created = 1;
+  }
+  return ret;
+}
+
+WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 releaseCount)
+{
+  int ret;
+  if (releaseCount < 1) return EINVAL;
+
+  ret = pthread_mutex_lock(&p->_mutex);
+  if (ret != 0) dump_error(__LINE__,ret,"SemR::pthread_mutex_lock",&p->_mutex);
+  if (ret == 0)
+  {
+    UInt32 newCount = p->_count + releaseCount;
+    if (newCount > p->_maxCount)
+    {
+      ret = pthread_mutex_unlock(&p->_mutex);
+      if (ret != 0) dump_error(__LINE__,ret,"SemR::pthread_mutex_unlock",&p->_mutex);
+      return EINVAL;
+    }
+    p->_count = newCount;
+    ret = pthread_cond_broadcast(&p->_cond);
+    if (ret != 0) dump_error(__LINE__,ret,"SemR::pthread_cond_broadcast",&p->_cond);
+    if (ret == 0)
+    {
+       ret = pthread_mutex_unlock(&p->_mutex);
+       if (ret != 0) dump_error(__LINE__,ret,"SemR::pthread_mutex_unlock",&p->_mutex);
+    }
+  }
+  return ret;
+}
+
+WRes Semaphore_Wait(CSemaphore *p) {
+  int ret = pthread_mutex_lock(&p->_mutex);
+  if (ret != 0) dump_error(__LINE__,ret,"SemW::pthread_mutex_lock",&p->_mutex);
+  if (ret == 0)
+  {
+    while ((p->_count < 1) && (ret == 0))
+    {
+       ret = pthread_cond_wait(&p->_cond, &p->_mutex);
+       if (ret != 0) dump_error(__LINE__,ret,"SemW::pthread_cond_wait",&p->_mutex);
+    }
+    if (ret == 0)
+    {
+      p->_count--;
+      ret = pthread_mutex_unlock(&p->_mutex);
+      if (ret != 0) dump_error(__LINE__,ret,"SemW::pthread_mutex_unlock",&p->_mutex);
+    }
+  }
+  return ret;
+}
+
+WRes Semaphore_Close(CSemaphore *p) {
+  if (p->_created)
+  {
+    int ret;
+    p->_created = 0;
+    ret = pthread_mutex_destroy(&p->_mutex);
+    if (ret != 0) dump_error(__LINE__,ret,"Semc::pthread_mutex_destroy",&p->_mutex);
+    ret = pthread_cond_destroy(&p->_cond);
+    if (ret != 0) dump_error(__LINE__,ret,"Semc::pthread_cond_destroy",&p->_cond);
+  }
+  return 0;
+}
+
+WRes CriticalSection_Init(CCriticalSection * lpCriticalSection)
+{
+	if (lpCriticalSection)
+	{
+		int ret;
+		pthread_mutexattr_t mutexattr;
+		memset(&mutexattr,0,sizeof(mutexattr));
+		ret = pthread_mutexattr_init(&mutexattr);
+		if (ret != 0) dump_error(__LINE__,ret,"CS I::pthread_mutexattr_init",&mutexattr);
+		ret = pthread_mutexattr_settype(&mutexattr,PTHREAD_MUTEX_ERRORCHECK);
+		if (ret != 0) dump_error(__LINE__,ret,"CS I::pthread_mutexattr_settype",&mutexattr);
+		ret = pthread_mutex_init(&lpCriticalSection->_mutex,&mutexattr);
+		if (ret != 0) dump_error(__LINE__,ret,"CS I::pthread_mutexattr_init",&lpCriticalSection->_mutex);
+		return ret;
+	}
+	return EINTR;
+}
+
+void CriticalSection_Enter(CCriticalSection * lpCriticalSection)
+{
+	if (lpCriticalSection)
+	{
+		int ret = pthread_mutex_lock(&(lpCriticalSection->_mutex));
+                if (ret != 0) dump_error(__LINE__,ret,"CS::pthread_mutex_lock",&(lpCriticalSection->_mutex));
+	}
+}
+
+void CriticalSection_Leave(CCriticalSection * lpCriticalSection)
+{
+	if (lpCriticalSection)
+	{
+		int ret = pthread_mutex_unlock(&(lpCriticalSection->_mutex));
+                if (ret != 0) dump_error(__LINE__,ret,"CS::pthread_mutex_unlock",&(lpCriticalSection->_mutex));
+	}
+}
+
+void CriticalSection_Delete(CCriticalSection * lpCriticalSection)
+{
+	if (lpCriticalSection)
+	{
+		int ret = pthread_mutex_destroy(&(lpCriticalSection->_mutex));
+                if (ret != 0) dump_error(__LINE__,ret,"CS::pthread_mutex_destroy",&(lpCriticalSection->_mutex));
+	}
+}
+
+#else
+
+WRes Event_Create(CEvent *p, BOOL manualReset, int initialSignaled)
+{
+  pthread_mutex_init(&p->_mutex,0);
+  pthread_cond_init(&p->_cond,0);
+  p->_manual_reset = manualReset;
+  p->_state        = (initialSignaled ? TRUE : FALSE);
+  p->_created = 1;
+  return 0;
+}
+
+WRes Event_Set(CEvent *p) {
+  pthread_mutex_lock(&p->_mutex);
+  p->_state = TRUE;
+  pthread_cond_broadcast(&p->_cond);
+  pthread_mutex_unlock(&p->_mutex);
+  return 0;
+}
+
+WRes Event_Reset(CEvent *p) {
+  pthread_mutex_lock(&p->_mutex);
+  p->_state = FALSE;
+  pthread_mutex_unlock(&p->_mutex);
+  return 0;
+}
+ 
+WRes Event_Wait(CEvent *p) {
+  pthread_mutex_lock(&p->_mutex);
+  while (p->_state == FALSE)
+  {
+     pthread_cond_wait(&p->_cond, &p->_mutex);
+  }
+  if (p->_manual_reset == FALSE)
+  {
+     p->_state = FALSE;
+  }
+  pthread_mutex_unlock(&p->_mutex);
+  return 0;
+}
+
+WRes Event_Close(CEvent *p) { 
+  if (p->_created)
+  {
+    p->_created = 0;
+    pthread_mutex_destroy(&p->_mutex);
+    pthread_cond_destroy(&p->_cond);
+  }
+  return 0;
+}
+
+WRes Semaphore_Create(CSemaphore *p, UInt32 initiallyCount, UInt32 maxCount)
+{
+  pthread_mutex_init(&p->_mutex,0);
+  pthread_cond_init(&p->_cond,0);
+  p->_count    = initiallyCount;
+  p->_maxCount = maxCount;
+  p->_created  = 1;
+  return 0;
+}
+
+WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 releaseCount)
+{
+  UInt32 newCount;
+
+  if (releaseCount < 1) return EINVAL;
+
+  pthread_mutex_lock(&p->_mutex);
+
+  newCount = p->_count + releaseCount;
+  if (newCount > p->_maxCount)
+  {
+    pthread_mutex_unlock(&p->_mutex);
+    return EINVAL;
+  }
+  p->_count = newCount;
+  pthread_cond_broadcast(&p->_cond);
+  pthread_mutex_unlock(&p->_mutex);
+  return 0;
+}
+
+WRes Semaphore_Wait(CSemaphore *p) {
+  pthread_mutex_lock(&p->_mutex);
+  while (p->_count < 1)
+  {
+     pthread_cond_wait(&p->_cond, &p->_mutex);
+  }
+  p->_count--;
+  pthread_mutex_unlock(&p->_mutex);
+  return 0;
+}
+
+WRes Semaphore_Close(CSemaphore *p) {
+  if (p->_created)
+  {
+    p->_created = 0;
+    pthread_mutex_destroy(&p->_mutex);
+    pthread_cond_destroy(&p->_cond);
+  }
+  return 0;
+}
+
+WRes CriticalSection_Init(CCriticalSection * lpCriticalSection)
+{
+	return pthread_mutex_init(&(lpCriticalSection->_mutex),0);
+}
+
+#endif /* DEBUG_SYNCHRO */
+
+#endif /* ENV_BEOS */
+
+WRes ManualResetEvent_Create(CManualResetEvent *p, int initialSignaled)
+  { return Event_Create(p, TRUE, initialSignaled); }
+
+WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p) 
+  { return ManualResetEvent_Create(p, 0); }
+
+WRes AutoResetEvent_Create(CAutoResetEvent *p, int initialSignaled)
+  { return Event_Create(p, FALSE, initialSignaled); }
+WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p) 
+  { return AutoResetEvent_Create(p, 0); }
+