seven_zip_ruby_am 1.2.5.1

data/ext/p7zip/CPP/myWindows/StdAfx.h

@@ -0,0 +1,124 @@
+// stdafx.h
+
+#ifndef __STDAFX_H
+#define __STDAFX_H
+
+
+#include "config.h"
+
+
+#define NO_INLINE /* FIXME */
+
+#ifdef ENV_HAVE_PTHREAD
+#include <pthread.h>
+#endif
+
+#include "Common/MyWindows.h"
+#include "Common/Types.h"
+
+#include <windows.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <tchar.h>
+#include <wchar.h>
+#include <stddef.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <errno.h>
+#include <math.h>
+
+#ifdef __NETWARE__
+#include <sys/types.h>
+#endif
+
+#undef CS /* fix for Solaris 10 x86 */
+
+
+/***************************/
+
+#ifndef ENV_HAVE_WCHAR__H
+
+EXTERN_C_BEGIN
+
+size_t	wcslen(const wchar_t *);
+wchar_t *wcscpy(wchar_t * , const wchar_t * );
+wchar_t *wcscat(wchar_t * , const wchar_t * );
+
+EXTERN_C_END
+
+#endif
+
+/***************************/
+
+#define CLASS_E_CLASSNOTAVAILABLE        ((HRESULT)0x80040111L)
+
+/************************* LastError *************************/
+inline DWORD WINAPI GetLastError(void) { return errno; }
+inline void WINAPI SetLastError( DWORD err ) { errno = err; }
+
+#define AreFileApisANSI() (1)
+
+void Sleep(unsigned millisleep);
+
+typedef pid_t t_processID;
+
+t_processID GetCurrentProcess(void);
+
+#define  NORMAL_PRIORITY_CLASS (0)
+#define  IDLE_PRIORITY_CLASS   (10)
+void SetPriorityClass(t_processID , int priority);
+
+#ifdef __cplusplus
+class wxWindow;
+typedef wxWindow *HWND;
+
+#define MB_ICONERROR (0x00000200) // wxICON_ERROR
+#define MB_YESNOCANCEL (0x00000002 | 0x00000008 | 0x00000010) // wxYES | wxNO | wxCANCEL
+#define MB_ICONQUESTION (0x00000400) // wxICON_QUESTION
+#define MB_TASKMODAL  (0) // FIXME
+#define MB_SYSTEMMODAL (0) // FIXME
+
+#define MB_OK (0x00000004) // wxOK
+#define MB_ICONSTOP (0x00000200) // wxICON_STOP
+#define MB_OKCANCEL (0x00000004 | 0x00000010) // wxOK | wxCANCEL
+
+#define MessageBox MessageBoxW
+int MessageBoxW(wxWindow * parent, const TCHAR * mes, const TCHAR * title,int flag);
+
+typedef void *HINSTANCE;
+
+typedef          int   INT_PTR;  // FIXME 64 bits ?
+typedef unsigned int  UINT_PTR;  // FIXME 64 bits ?
+typedef          long LONG_PTR;  // FIXME 64 bits ?
+typedef          long DWORD_PTR; // FIXME 64 bits ?
+typedef UINT_PTR WPARAM;
+
+/* WARNING
+ LPARAM shall be 'long' because of CListView::SortItems and wxListCtrl::SortItems :
+*/
+typedef LONG_PTR LPARAM;
+typedef LONG_PTR LRESULT;
+
+#define CALLBACK /* */
+
+/************ LANG ***********/
+typedef WORD            LANGID;
+
+LANGID GetUserDefaultLangID(void);
+LANGID GetSystemDefaultLangID(void);
+
+#define PRIMARYLANGID(l)        ((WORD)(l) & 0x3ff)
+#define SUBLANGID(l)            ((WORD)(l) >> 10)
+
+#if defined( __x86_64__ )
+
+#define _WIN64 1
+
+#endif
+
+#endif
+
+#endif 
+

data/ext/p7zip/CPP/myWindows/config.h

@@ -0,0 +1,67 @@
+
+#if !defined(__DJGPP__)
+
+#ifndef __CYGWIN__
+  #define FILESYSTEM_IS_CASE_SENSITIVE 1
+#endif
+
+  #if !defined(ENV_MACOSX) && !defined(ENV_BEOS)
+
+    /* <wchar.h> */
+    /* ENV_HAVE_WCHAR__H and not ENV_HAVE_WCHAR_H to avoid warning with wxWidgets */
+    #define ENV_HAVE_WCHAR__H
+
+    /* <wctype.h> */
+    #define ENV_HAVE_WCTYPE_H
+
+    /* mbrtowc */
+/* #ifndef __hpux */
+/*    #define ENV_HAVE_MBRTOWC */
+/* #endif */
+
+    /* towupper */
+    #define ENV_HAVE_TOWUPPER
+
+  #endif /* !ENV_MACOSX && !ENV_BEOS */
+
+  #if !defined(ENV_BEOS)
+    #define ENV_HAVE_GETPASS
+
+    #if !defined(sun)
+      #define ENV_HAVE_TIMEGM
+    #endif
+
+
+  #endif
+
+  /* lstat, readlink and S_ISLNK */
+  #define ENV_HAVE_LSTAT
+
+  /* <locale.h> */
+  #define ENV_HAVE_LOCALE
+
+  /* mbstowcs */
+  #define ENV_HAVE_MBSTOWCS
+
+  /* wcstombs */
+  #define ENV_HAVE_WCSTOMBS
+
+#endif /* !__DJGPP__ */
+
+#ifndef ENV_BEOS
+#define ENV_HAVE_PTHREAD
+#endif
+
+#if defined(ENV_MACOSX)
+#define LOCALE_IS_UTF8
+#endif
+
+#ifdef LOCALE_IS_UTF8
+#undef ENV_HAVE_LOCALE
+#undef ENV_HAVE_MBSTOWCS
+#undef ENV_HAVE_WCSTOMBS
+/* #undef ENV_HAVE_MBRTOWC */
+#endif
+
+#define MAX_PATHNAME_LEN   1024
+

data/ext/p7zip/CPP/myWindows/initguid.h

@@ -0,0 +1,4 @@
+// initguid.h
+
+#include "Common/MyInitGuid.h"
+

data/ext/p7zip/CPP/myWindows/makefile

@@ -0,0 +1,21 @@
+PROG=test_emul
+
+LOCAL_FLAGS=-I. -I.. -I../include_windows -DUNICODE -D_UNICODE
+
+include ../../makefile.crc32
+include ../../makefile.machine
+
+LIBS=$(LOCAL_LIBS)
+
+OBJS=myGetTickCount.o \
+	wine_date_and_time.o \
+	mySplitCommandLine.o \
+	myAddExeFlag.o \
+	wine_GetXXXDefaultLangID.o \
+	test_emul.o \
+	MyVector.o \
+	MyString.o \
+	MyWindows.o
+
+include ../../makefile.glb
+

data/ext/p7zip/CPP/myWindows/makefile.depend

@@ -0,0 +1,32 @@
+myGetTickCount.o: myGetTickCount.cpp StdAfx.h config.h \
+ ../Common/MyWindows.h ../Common/MyGuidDef.h ../Common/Types.h
+mySplitCommandLine.o: mySplitCommandLine.cpp StdAfx.h config.h \
+ ../Common/MyWindows.h ../Common/MyGuidDef.h ../Common/Types.h \
+ ../Common/StringConvert.h ../Common/MyString.h ../Common/MyVector.h \
+ ../Common/Defs.h myPrivate.h
+myAddExeFlag.o: myAddExeFlag.cpp StdAfx.h config.h \
+ ../Common/MyWindows.h ../Common/MyGuidDef.h ../Common/Types.h \
+ myPrivate.h ../Common/StringConvert.h ../Common/MyString.h \
+ ../Common/MyVector.h ../Common/Defs.h
+test_emul.o: test_emul.cpp StdAfx.h config.h ../Common/MyWindows.h \
+ ../Common/MyGuidDef.h ../Common/Types.h ../Common/StringConvert.h \
+ ../Common/MyString.h ../Common/MyVector.h ../Common/Defs.h \
+ ../Common/StdOutStream.h ../Common/StringConvert.cpp \
+ ../Common/UTFConvert.cpp ../Common/UTFConvert.h \
+ ../Common/StdOutStream.cpp ../Common/IntToString.h \
+ ../Common/IntToString.cpp ../Windows/Synchronization.cpp \
+ ../Windows/Synchronization.h ../Windows/Defs.h \
+ ../Windows/../../C/Threads.h ../Windows/../../C/Types.h \
+ ../Windows/FileFind.cpp ../Windows/FileFind.h \
+ ../Windows/../Common/MyString.h ../Windows/FileName.h \
+ ../Windows/../Common/StringConvert.h myPrivate.h
+wine_date_and_time.o: wine_date_and_time.cpp config.h
+MyVector.o: ../Common/MyVector.cpp StdAfx.h config.h \
+ ../Common/MyWindows.h ../Common/MyGuidDef.h ../Common/Types.h \
+ ../Common/MyVector.h ../Common/Defs.h
+MyString.o: ../Common/MyString.cpp StdAfx.h config.h \
+ ../Common/MyWindows.h ../Common/MyGuidDef.h ../Common/Types.h \
+ ../Common/StringConvert.h ../Common/MyString.h ../Common/MyVector.h \
+ ../Common/Defs.h myPrivate.h
+MyWindows.o: ../Common/MyWindows.cpp StdAfx.h config.h \
+ ../Common/MyWindows.h ../Common/MyGuidDef.h ../Common/Types.h

data/ext/p7zip/CPP/myWindows/makefile.list

@@ -0,0 +1,28 @@
+SRCS=myGetTickCount.cpp \
+ mySplitCommandLine.cpp \
+ myAddExeFlag.cpp \
+ test_emul.cpp \
+ wine_date_and_time.cpp \
+ wine_GetXXXDefaultLangID.cpp \
+ ../Common/MyVector.cpp \
+ ../Common/MyString.cpp \
+ ../Common/MyWindows.cpp
+
+mySplitCommandLine.o : mySplitCommandLine.cpp
+	$(CXX) $(CXXFLAGS) mySplitCommandLine.cpp
+myAddExeFlag.o : myAddExeFlag.cpp
+	$(CXX) $(CXXFLAGS) myAddExeFlag.cpp
+myGetTickCount.o : myGetTickCount.cpp
+	$(CXX) $(CXXFLAGS) myGetTickCount.cpp
+test_emul.o : test_emul.cpp
+	$(CXX) $(CXXFLAGS) test_emul.cpp
+wine_date_and_time.o : wine_date_and_time.cpp
+	$(CXX) $(CXXFLAGS) wine_date_and_time.cpp
+wine_GetXXXDefaultLangID.o : wine_GetXXXDefaultLangID.cpp
+	$(CXX) $(CXXFLAGS) wine_GetXXXDefaultLangID.cpp
+MyVector.o : ../Common/MyVector.cpp
+	$(CXX) $(CXXFLAGS) ../Common/MyVector.cpp
+MyString.o : ../Common/MyString.cpp
+	$(CXX) $(CXXFLAGS) ../Common/MyString.cpp
+MyWindows.o : ../Common/MyWindows.cpp
+	$(CXX) $(CXXFLAGS) ../Common/MyWindows.cpp

data/ext/p7zip/CPP/myWindows/myAddExeFlag.cpp

@@ -0,0 +1,20 @@
+#include "StdAfx.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <windows.h>
+
+#define NEED_NAME_WINDOWS_TO_UNIX
+#include "myPrivate.h"
+
+#include "Common/StringConvert.h"
+
+void myAddExeFlag(const UString &u_name)
+{
+	AString filename = UnicodeStringToMultiByte(u_name, CP_ACP); // FIXME
+	const char * name = nameWindowToUnix(filename);
+	// printf("myAddExeFlag(%s)\n",name);
+	chmod(name,0700);
+}
+

data/ext/p7zip/CPP/myWindows/myGetTickCount.cpp

@@ -0,0 +1,8 @@
+#include "StdAfx.h"
+
+#include <time.h>
+
+DWORD WINAPI GetTickCount(VOID) {
+  return (DWORD)time(0); // FIXME : but only for the seed of the random generator
+}
+

data/ext/p7zip/CPP/myWindows/myPrivate.h

@@ -0,0 +1,17 @@
+
+void WINAPI RtlSecondsSince1970ToFileTime( DWORD Seconds, FILETIME * ft );
+
+extern "C" int global_use_utf16_conversion;
+#ifdef ENV_HAVE_LSTAT
+extern "C" int global_use_lstat;
+#endif
+
+const char *my_getlocale(void);
+
+#ifdef NEED_NAME_WINDOWS_TO_UNIX
+static inline const char * nameWindowToUnix(const char * lpFileName) {
+  if ((lpFileName[0] == 'c') && (lpFileName[1] == ':')) return lpFileName+2;
+  return lpFileName;
+}
+#endif
+

data/ext/p7zip/CPP/myWindows/mySplitCommandLine.cpp

@@ -0,0 +1,82 @@
+#include "StdAfx.h"
+
+#include "../Common/StringConvert.h"
+
+#include "myPrivate.h"
+
+#ifdef ENV_HAVE_LOCALE
+#include <locale.h>
+#endif
+
+extern void my_windows_split_path(const AString &p_path, AString &dir , AString &base);
+
+void mySplitCommandLine(int numArguments,const char *arguments[],UStringVector &parts) {
+
+  { // define P7ZIP_HOME_DIR
+    static char p7zip_home_dir[MAX_PATH];
+    AString dir,name;
+    my_windows_split_path(arguments[0],dir,name);
+    snprintf(p7zip_home_dir,sizeof(p7zip_home_dir),"P7ZIP_HOME_DIR=%s/",(const char *)dir);
+    p7zip_home_dir[sizeof(p7zip_home_dir)-1] = 0;
+    putenv(p7zip_home_dir);
+  }
+
+#ifdef ENV_HAVE_LOCALE
+  // set the program's current locale from the user's environment variables
+  setlocale(LC_ALL,"");
+
+
+  // auto-detect which conversion p7zip should use
+  char *locale = setlocale(LC_CTYPE,0);
+  if (locale) {
+    size_t len = strlen(locale);
+    char *locale_upper = (char *)malloc(len+1);
+    if (locale_upper) {
+      strcpy(locale_upper,locale);
+
+      for(size_t i=0;i<len;i++)
+        locale_upper[i] = toupper(locale_upper[i] & 255);
+
+      if (    (strcmp(locale_upper,"") != 0)
+              && (strcmp(locale_upper,"C") != 0)
+              && (strcmp(locale_upper,"POSIX") != 0) ) {
+        global_use_utf16_conversion = 1;
+      }
+      free(locale_upper);
+    }
+  }
+#elif defined(LOCALE_IS_UTF8)
+  global_use_utf16_conversion = 1; // assume LC_CTYPE="utf8"
+#else
+  global_use_utf16_conversion = 0; // assume LC_CTYPE="C"
+#endif
+
+  parts.Clear();
+  for(int ind=0;ind < numArguments; ind++) {
+    if ((ind <= 2) && (strcmp(arguments[ind],"-no-utf16") == 0)) {
+      global_use_utf16_conversion = 0;
+    } else if ((ind <= 2) && (strcmp(arguments[ind],"-utf16") == 0)) {
+      global_use_utf16_conversion = 1;
+    } else {
+      UString tmp = MultiByteToUnicodeString(arguments[ind]);
+      // tmp.Trim(); " " is a valid filename ...
+      if (!tmp.IsEmpty()) {
+        parts.Add(tmp);
+      }
+    }
+  }
+}
+
+const char *my_getlocale(void) {
+#ifdef ENV_HAVE_LOCALE
+  const char* ret = setlocale(LC_CTYPE,0);
+  if (ret == 0)
+    ret ="C";
+  return ret;
+#elif defined(LOCALE_IS_UTF8)
+  return "utf8";
+#else
+  return "C";
+#endif
+}
+

data/ext/p7zip/CPP/myWindows/test_emul.cpp

@@ -0,0 +1,745 @@
+#undef BIG_ENDIAN
+#undef LITTLE_ENDIAN
+
+#include "StdAfx.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <unistd.h>
+
+#ifdef __APPLE_CC__
+#define UInt32  macUIn32
+#include <CoreFoundation/CoreFoundation.h>
+#undef UInt32
+#endif
+
+#ifdef ENV_HAVE_WCHAR__H
+#include <wchar.h>
+#endif
+#ifdef ENV_HAVE_LOCALE
+#include <locale.h>
+#endif
+
+#include <windows.h>
+
+#define NEED_NAME_WINDOWS_TO_UNIX
+// #include "myPrivate.h"
+
+#include "Common/StringConvert.h"
+#include "Common/StdOutStream.h"
+
+#undef NDEBUG
+#include <assert.h>
+
+#include "Common/StringConvert.cpp"
+#include "Common/StdOutStream.cpp"
+#include "Common/IntToString.cpp"
+
+#include "Windows/Synchronization.cpp"
+#include "Windows/FileFind.cpp"
+#include "Windows/Time.cpp"
+#include "../C/Threads.c"
+#include "../../C/Ppmd.h"
+
+using namespace NWindows;
+
+#if  defined(ENV_HAVE_WCHAR__H) && defined(ENV_HAVE_MBSTOWCS) && defined(ENV_HAVE_WCSTOMBS)
+void test_mbs(void) {
+  wchar_t wstr1[256] = {
+                         L'e',
+                         0xE8, // latin small letter e with grave
+                         0xE9, // latin small letter e with acute
+                         L'a',
+                         0xE0, // latin small letter a with grave
+                         0x20AC, // euro sign
+                         L'b',
+                         0 };
+  wchar_t wstr2[256];
+  char    astr[256];
+
+  global_use_utf16_conversion = 1;
+
+  size_t len1 = wcslen(wstr1);
+
+  printf("wstr1 - %d - '%ls'\n",(int)len1,wstr1);
+
+  size_t len0 = wcstombs(astr,wstr1,sizeof(astr));
+  printf("astr - %d - '%s'\n",(int)len0,astr);
+
+  size_t len2 = mbstowcs(wstr2,astr,sizeof(wstr2)/sizeof(*wstr2));
+  printf("wstr - %d - '%ls'\n",(int)len2,wstr2);
+
+  if (wcscmp(wstr1,wstr2) != 0) {
+    printf("ERROR during conversions wcs -> mbs -> wcs\n");
+    exit(EXIT_FAILURE);
+  }
+
+  char *ptr = astr;
+  size_t len = 0;
+  while (*ptr) {
+    ptr = CharNextA(ptr);
+    len += 1;
+  }
+  if ((len != len1) && (len != 12)) { // 12 = when locale is UTF8 instead of ISO8859-15
+    printf("ERROR CharNextA : len=%d, len1=%d\n",(int)len,(int)len1);
+    exit(EXIT_FAILURE);
+  }
+
+  UString ustr(wstr1);
+  assert(ustr.Length() == (int)len1);
+
+  AString  ansistr(astr);
+  assert(ansistr.Length() == (int)len0);
+
+  ansistr = UnicodeStringToMultiByte(ustr);
+  assert(ansistr.Length() == (int)len0);
+
+  assert(strcmp(ansistr,astr) == 0);
+  assert(wcscmp(ustr,wstr1) == 0);
+
+  UString ustr2 = MultiByteToUnicodeString(astr);
+  assert(ustr2.Length() == (int)len1);
+  assert(wcscmp(ustr2,wstr1) == 0);
+}
+#endif
+
+static void test_astring(int num) {
+  AString strResult;
+
+  strResult = "first part : ";
+  char number[256];
+  sprintf(number,"%d",num);
+  strResult += AString(number);
+
+  strResult += " : last part";
+
+  printf("strResult -%s-\n",(const char *)strResult);
+
+}
+
+
+extern void my_windows_split_path(const AString &p_path, AString &dir , AString &base);
+
+static struct {
+  const char *path;
+  const char *dir;
+  const char *base;
+}
+tabSplit[]=
+  {
+    { "",".","." },
+    { "/","/","/" },
+    { ".",".","." },
+    { "//","/","/" },
+    { "///","/","/" },
+    { "dir",".","dir" },
+    { "/dir","/","dir" },
+    { "/dir/","/","dir" },
+    { "/dir/base","/dir","base" },
+    { "/dir//base","/dir","base" },
+    { "/dir///base","/dir","base" },
+    { "//dir/base","//dir","base" },
+    { "///dir/base","///dir","base" },
+    { "/dir/base/","/dir","base" },
+    { 0,0,0 }
+  };
+
+static void test_split_astring() {
+  int ind = 0;
+  while (tabSplit[ind].path) {
+    AString path(tabSplit[ind].path);
+    AString dir;
+    AString base;
+
+    my_windows_split_path(path,dir,base);
+
+    if ((dir != tabSplit[ind].dir) || (base != tabSplit[ind].base)) {
+      printf("ERROR : '%s' '%s' '%s'\n",(const char *)path,(const char *)dir,(const char *)base);
+    }
+    ind++;
+  }
+  printf("test_split_astring : done\n");
+}
+
+ // Number of 100 nanosecond units from 1/1/1601 to 1/1/1970
+#define EPOCH_BIAS  116444736000000000LL
+static LARGE_INTEGER UnixTimeToUL(time_t tps_unx)
+{
+	LARGE_INTEGER ul;
+	ul.QuadPart = tps_unx * 10000000LL + EPOCH_BIAS;
+	return ul;
+}
+
+static LARGE_INTEGER FileTimeToUL(FILETIME fileTime)
+{
+	LARGE_INTEGER lFileTime;
+	lFileTime.QuadPart = fileTime.dwHighDateTime;
+	lFileTime.QuadPart = (lFileTime.QuadPart << 32) | fileTime.dwLowDateTime;
+	return lFileTime;
+}
+
+static void display(const char *txt,SYSTEMTIME systime)
+{
+	FILETIME fileTime;
+	BOOL ret = SystemTimeToFileTime(&systime,&fileTime);
+	assert(ret == TRUE);
+	LARGE_INTEGER ulFileTime = FileTimeToUL(fileTime);
+	
+	const char * day="";
+	switch (systime.wDayOfWeek)
+	{
+        	case 0:day = "Sunday";break;
+        	case 1:day = "Monday";break;
+        	case 2:day = "Tuesday";break;
+        	case 3:day = "Wednesday";break;
+        	case 4:day = "Thursday";break;
+        	case 5:day = "Friday";break;
+        	case 6:day = "Saturday";break;
+	}
+	g_StdOut<< txt << day << " " 
+		<< (int)systime.wYear << "/" <<  (int)systime.wMonth << "/" << (int)systime.wDay << " "
+		<< (int)systime.wHour << ":" << (int)systime.wMinute << ":" <<  (int)systime.wSecond << ":" 
+        	<<     (int)systime.wMilliseconds
+		<< " (" << (UInt64)ulFileTime.QuadPart << ")\n";
+}
+
+static void test_time()
+{
+	time_t tps_unx = time(0);
+
+	printf("Test Time (1):\n");
+	printf("===========\n");
+	SYSTEMTIME systimeGM;
+	GetSystemTime(&systimeGM);
+	
+	LARGE_INTEGER ul = UnixTimeToUL(tps_unx);
+	g_StdOut<<"  unix time = " << (UInt64)tps_unx << " (" << (UInt64)ul.QuadPart << ")\n";
+
+	g_StdOut<<"  gmtime    : " << asctime(gmtime(&tps_unx))<<"\n";
+	g_StdOut<<"  localtime : " << asctime(localtime(&tps_unx))<<"\n";
+
+	display("  GetSystemTime : ", systimeGM);
+}
+
+static void test_time2()
+{
+        UInt32 dosTime = 0x30d0094C;
+        FILETIME utcFileTime;
+        FILETIME localFileTime;
+        FILETIME localFileTime2;
+        UInt32 dosTime2 = 0;
+
+        printf("Test Time (2):\n");
+        printf("===========\n");
+        NTime::DosTimeToFileTime(dosTime, localFileTime);
+        NTime::FileTimeToDosTime(localFileTime, dosTime2);
+        assert(dosTime == dosTime2);
+
+        printf("Test Time (3):\n");
+	printf("===========\n");
+	/* DosTime To utcFileTime */
+
+	if (NTime::DosTimeToFileTime(dosTime, localFileTime)) /* DosDateTimeToFileTime */
+	{
+		if (!LocalFileTimeToFileTime(&localFileTime, &utcFileTime))
+			utcFileTime.dwHighDateTime = utcFileTime.dwLowDateTime = 0;
+	}
+
+	printf("  - 0x%x => 0x%x 0x%x => 0x%x 0x%x\n",(unsigned)dosTime,
+		(unsigned)localFileTime.dwHighDateTime,(unsigned)localFileTime.dwLowDateTime,
+		(unsigned)utcFileTime.dwHighDateTime,(unsigned)utcFileTime.dwLowDateTime);
+
+
+	/* utcFileTime to DosTime */
+
+        FileTimeToLocalFileTime(&utcFileTime, &localFileTime2);
+        NTime::FileTimeToDosTime(localFileTime2, dosTime2);  /* FileTimeToDosDateTime */
+
+	printf("  - 0x%x <= 0x%x 0x%x <= 0x%x 0x%x\n",(unsigned)dosTime2,
+		(unsigned)localFileTime2.dwHighDateTime,(unsigned)localFileTime2.dwLowDateTime,
+		(unsigned)utcFileTime.dwHighDateTime,(unsigned)utcFileTime.dwLowDateTime);
+
+	assert(dosTime == dosTime2);
+	assert(localFileTime.dwHighDateTime == localFileTime2.dwHighDateTime);
+	assert(localFileTime.dwLowDateTime  == localFileTime2.dwLowDateTime);
+}
+
+static void test_semaphore()
+{
+	g_StdOut << "\nTEST SEMAPHORE :\n";
+
+	NWindows::NSynchronization::CSynchro sync;
+	NWindows::NSynchronization::CSemaphoreWFMO sema;
+	bool bres;
+	DWORD waitResult;
+	int i;
+
+	sync.Create();
+	sema.Create(&sync,2,10);
+
+	g_StdOut << "   - Release(1)\n";
+	for(i = 0 ;i < 8;i++)
+	{
+		// g_StdOut << "     - Release(1) : "<< i << "\n";
+		bres = sema.Release(1);
+		assert(bres == S_OK);
+	}
+	// g_StdOut << "     - Release(1) : done\n";
+	bres = sema.Release(1);
+	assert(bres == S_FALSE);
+
+	g_StdOut << "   - WaitForMultipleObjects(INFINITE)\n";
+	HANDLE events[1] = { sema };
+	for(i=0;i<10;i++)
+	{
+		waitResult = ::WaitForMultipleObjects(1, events, FALSE, INFINITE);
+		assert(waitResult == WAIT_OBJECT_0);
+	}
+
+	g_StdOut << "   Done\n";
+}
+
+
+/****************************************************************************************/
+
+
+static int threads_count = 0;
+
+static THREAD_FUNC_RET_TYPE thread_fct(void *  /* param */ ) {
+	threads_count++;
+	return 0;
+}
+
+#define MAX_THREADS 100000
+
+int test_thread(void) {
+	::CThread thread;
+
+	Thread_Construct(&thread);
+
+	threads_count = 0;
+	
+	printf("test_thread : %d threads\n",MAX_THREADS);
+
+	for(int i=0;i<MAX_THREADS;i++) {
+		Thread_Create(&thread, thread_fct, 0); 
+
+		Thread_Wait(&thread);
+
+		Thread_Close(&thread);
+	}
+
+	assert(threads_count == MAX_THREADS);
+
+	return 0;
+}
+
+
+void dumpStr(const char *title,const char *txt)
+{
+  size_t i,len = strlen(txt);
+
+  printf("%s - %d :",title,(int)len);
+
+  for(i  = 0 ; i<len;i++) {
+    printf(" 0x%02x",(unsigned)(txt[i] & 255)); 
+  }
+
+  printf("\n");
+}
+
+
+void dumpWStr(const char *title,const wchar_t *txt)
+{
+  size_t i,len = wcslen(txt);
+
+  printf("%s - %d :",title,(int)len);
+
+  for(i  = 0 ; i<len;i++) {
+    printf(" 0x%02x",(unsigned)(txt[i])); 
+  }
+
+  printf("\n");
+}
+
+#ifdef __APPLE_CC__
+
+void  testMaxOSX_stringConvert()
+{
+/*
+                         0xE8, // latin small letter e with grave
+                         0xE9, // latin small letter e with acute
+                         L'a',
+                         0xE0, // latin small letter a with grave
+                         0x20AC, // euro sign
+*/
+   struct
+   {
+     char astr [256];
+     wchar_t ustr [256];
+   }
+   tab [] =
+   {
+      {
+      //   'a' , 'e with acute'       , 'e with grave'     ,  'a with grave'    ,  'u with grave'    ,  'b' , '.'  ,  't' , 'x'  , 't'  
+         { 0x61,  0x65,  0xcc,  0x81  ,  0x65,  0xcc,  0x80,  0x61,  0xcc,  0x80,  0x75,  0xcc,  0x80,  0x62,  0x2e,  0x74,  0x78, 0x74,  0 },
+         { 0x61,  0xe9,                  0xe8,                0xe0,                0xf9,                0x62,  0x2e,  0x74,  0x78, 0x74, 0 }
+      },
+      {
+      //   'a' , 'euro sign'        ,  'b' , '.'  ,  't' , 'x'  , 't'  , '\n' 
+         { 0x61,  0xe2,  0x82,  0xac,  0x62,  0x2e,  0x74,  0x78,  0x74,  0x0a, 0 },
+         { 0x61,  0x20AC,              0x62,  0x2e,  0x74,  0x78,  0x74,  0x0a, 0 }  
+      },
+      {
+         { 0 },
+         { 0 }
+      }
+   };
+
+   int i;
+
+   printf("testMaxOSX_stringConvert : \n");
+
+   i = 0;
+   while (tab[i].astr[0])
+   {
+     printf("  %s\n",tab[i].astr);
+
+     UString ustr = GetUnicodeString(tab[i].astr);
+
+     // dumpWStr("1",&ustr[0]);
+
+     assert(MyStringCompare(&ustr[0],tab[i].ustr) == 0);
+     assert(ustr.Length() == wcslen(tab[i].ustr) );
+
+
+     AString astr = GetAnsiString(ustr);
+     assert(MyStringCompare(&astr[0],tab[i].astr) == 0);
+     assert(astr.Length() == strlen(tab[i].astr) );
+
+     i++;
+   }
+}
+
+void  testMacOSX()
+{
+//  char texte1[]= { 0xc3 , 0xa9  , 0xc3, 0xa0, 0};
+
+  wchar_t wpath1[4096] = {
+                         0xE9, // latin small letter e with acute
+                         0xE0,
+                         0xc7,
+                         0x25cc,
+                         0x327,
+                         0xe4,
+                         0xe2,
+                         0xc2,
+                         0xc3,
+                         0x2e,
+                         0x74,
+                         0x78,
+                         0x74,
+/*
+                         L'e',
+                         0xE8, // latin small letter e with grave
+                         0xE9, // latin small letter e with acute
+                         L'a',
+                         0xE0, // latin small letter a with grave
+                         0x20AC, // euro sign
+                         L'b',
+*/
+                         0 };
+
+    char utf8[4096];
+    wchar_t wpath2[4096];
+
+
+
+ // dumpStr("UTF8 standart",texte1);
+
+    dumpWStr("UCS32 standard",wpath1);
+
+// Translate into FS pathname
+ {
+    const wchar_t * wcs = wpath1;
+
+    UniChar unipath[4096];
+
+    long n = wcslen(wcs);
+
+    for(long i =   0 ; i<= n ;i++) {
+      unipath[i] = wcs[i];
+    }
+
+    CFStringRef cfpath = CFStringCreateWithCharacters(NULL,unipath,n);
+
+    CFMutableStringRef cfpath2 = CFStringCreateMutableCopy(NULL,0,cfpath);
+    CFRelease(cfpath);
+    CFStringNormalize(cfpath2,kCFStringNormalizationFormD);
+    
+    CFStringGetCString(cfpath2,(char *)utf8,4096,kCFStringEncodingUTF8);
+
+    CFRelease(cfpath2);  
+  }
+
+  dumpStr("UTF8 MacOSX",utf8);
+
+// Translate from FS pathname
+ {
+    const char * path = utf8;
+
+    long n = strlen(path);
+
+    CFStringRef cfpath = CFStringCreateWithCString(NULL,path,kCFStringEncodingUTF8);
+
+    if (cfpath)
+    {
+
+       CFMutableStringRef cfpath2 = CFStringCreateMutableCopy(NULL,0,cfpath);
+       CFRelease(cfpath);
+       CFStringNormalize(cfpath2,kCFStringNormalizationFormC);
+    
+       n = CFStringGetLength(cfpath2);
+       for(long i =   0 ; i<= n ;i++) {
+         wpath2[i] = CFStringGetCharacterAtIndex(cfpath2,i);
+       }
+       wpath2[n] = 0;
+
+       CFRelease(cfpath2);  
+    }
+    else
+    {
+       wpath2[0] = 0;
+    }
+  }
+
+  dumpWStr("UCS32 standard (2)",wpath2);
+
+/*
+ {
+   CFStringRef cfpath;
+
+    cfpath = CFStringCreateWithCString(kCFAllocatorDefault, texte1, kCFStringEncodingUTF8);
+
+    // TODO str = null ?
+
+    CFMutableStringRef cfpath2 = CFStringCreateMutableCopy(NULL,0,cfpaht);
+    CFRealease(cfpath);
+
+    
+
+    
+  }
+*/
+
+
+}
+#endif // __APPLE_CC__
+
+
+static const TCHAR *kMainDll = TEXT("7z.dll");
+
+static CSysString ConvertUInt32ToString(UInt32 value)
+{
+  TCHAR buffer[32];
+  ConvertUInt32ToString(value, buffer);
+  return buffer;
+}
+
+
+void test_csystring(void)
+{
+	{
+		const CSysString baseFolder = TEXT("bin/");
+		const CSysString b2 = baseFolder + kMainDll;
+
+		assert(MyStringCompare(&b2[0],TEXT("bin/7z.dll")) == 0);
+	}
+
+	{
+		LPCTSTR dirPath=TEXT("/tmp/");
+		LPCTSTR prefix=TEXT("foo");
+		CSysString resultPath;
+
+		UINT   number = 12345;
+		UInt32 count  = 6789;
+		
+/*
+		TCHAR * buf = resultPath.GetBuffer(MAX_PATH);
+		::swprintf(buf,MAX_PATH,L"%ls%ls#%d@%d.tmp",dirPath,prefix,(unsigned)number,count);
+		buf[MAX_PATH-1]=0;
+		resultPath.ReleaseBuffer();
+*/
+		resultPath  = dirPath;
+		resultPath += prefix;
+		resultPath += TEXT('#');
+		resultPath += ConvertUInt32ToString(number);
+		resultPath += TEXT('@');
+		resultPath += ConvertUInt32ToString(count);
+		resultPath += TEXT(".tmp");
+
+		// printf("##%ls##\n",&resultPath[0]);
+
+		assert(MyStringCompare(&resultPath[0],TEXT("/tmp/foo#12345@6789.tmp")) == 0);
+	}
+	
+}
+
+static void  test_AString()
+{
+   AString a;
+
+   a = "abc";
+   assert(MyStringCompare(&a[0],"abc") == 0);
+   assert(a.Length() == 3);
+
+   a = GetAnsiString(L"abc");
+   assert(MyStringCompare(&a[0],"abc") == 0);
+   assert(a.Length() == 3);
+}
+
+
+const TCHAR kAnyStringWildcard = '*';
+
+static void test_UString2(const UString &phyPrefix)
+{
+  UString tmp = phyPrefix + wchar_t(kAnyStringWildcard);
+  printf("Enum(%ls-%ls-%lc)\n",&tmp[0],&phyPrefix[0],wchar_t(kAnyStringWildcard));
+}
+
+
+
+static void test_UString()
+{
+  UString us = L"7za433_tar";
+
+   test_UString2(L"7za433_tar");
+
+   UString u1(us);
+   test_UString2(u1);
+   u1 = L"";
+   test_UString2(u1);
+   u1 = us;
+   test_UString2(u1);
+
+   UString u2 = us;
+   test_UString2(u2);
+   u2 = L"";
+   test_UString2(u2);
+   u2 = u1;
+   test_UString2(u2);
+
+   u1 = L"abc";
+   assert(MyStringCompare(&u1[0],L"abc") == 0);
+   assert(u1.Length() == 3);
+
+   u1 = GetUnicodeString("abc");
+   assert(MyStringCompare(&u1[0],L"abc") == 0);
+   assert(u1.Length() == 3);
+}
+
+/****************************************************************************************/
+int main() {
+
+  // return test_thread();
+
+
+#ifdef ENV_HAVE_LOCALE
+  setlocale(LC_ALL,"");
+#endif
+
+#if defined(BIG_ENDIAN)
+  printf("BIG_ENDIAN : %d\n",(int)BIG_ENDIAN);
+#endif
+#if defined(LITTLE_ENDIAN)
+  printf("LITTLE_ENDIAN : %d\n",(int)LITTLE_ENDIAN);
+#endif
+
+  printf("sizeof(Byte)   : %d\n",(int)sizeof(Byte));
+  printf("sizeof(UInt16) : %d\n",(int)sizeof(UInt16));
+  printf("sizeof(UInt32) : %d\n",(int)sizeof(UInt32));
+  printf("sizeof(UINT32) : %d\n",(int)sizeof(UINT32));
+  printf("sizeof(UInt64) : %d\n",(int)sizeof(UInt64));
+  printf("sizeof(UINT64) : %d\n",(int)sizeof(UINT64));
+  printf("sizeof(void *) : %d\n",(int)sizeof(void *));
+  printf("sizeof(size_t) : %d\n",(int)sizeof(size_t));
+  printf("sizeof(ptrdiff_t) : %d\n",(int)sizeof(ptrdiff_t));
+  printf("sizeof(off_t) : %d\n",(int)sizeof(off_t));
+  printf("sizeof(wchar_t) : %d\n",(int)sizeof(wchar_t));
+#ifdef __APPLE_CC__
+  printf("sizeof(UniChar) : %d\n",(int)sizeof(UniChar));
+#endif
+  printf("sizeof(CPpmd_See) : %d\n",(int)sizeof(CPpmd_See));
+  printf("sizeof(CPpmd_State) : %d\n",(int)sizeof(CPpmd_State));
+
+  // size tests
+  assert(sizeof(Byte)==1);
+  assert(sizeof(UInt16)==2);
+  assert(sizeof(UInt32)==4);
+  assert(sizeof(UINT32)==4);
+  assert(sizeof(UInt64)==8);
+  assert(sizeof(UINT64)==8);
+
+  // alignement tests
+  assert(sizeof(CPpmd_See)==4);
+  assert(sizeof(CPpmd_State)==6);
+
+  union {
+	Byte b[2];
+	UInt16 s;
+  } u;
+  u.s = 0x1234;
+
+  if ((u.b[0] == 0x12) && (u.b[1] == 0x34)) {
+    printf("CPU : big endian\n");
+  } else if ((u.b[0] == 0x34) && (u.b[1] == 0x12)) {
+    printf("CPU : little endian\n");
+  } else {
+    printf("CPU : unknown endianess\n");
+  }
+
+#if  defined(ENV_HAVE_WCHAR__H) && defined(ENV_HAVE_MBSTOWCS) && defined(ENV_HAVE_WCSTOMBS)
+  test_mbs();
+#endif
+
+  test_astring(12345);
+  test_split_astring();
+
+  test_csystring();
+  test_AString();
+  test_UString();
+
+  test_time();
+
+  test_time2();
+
+  test_semaphore();
+
+#ifdef __APPLE_CC__
+  testMacOSX();
+  testMaxOSX_stringConvert();
+#endif
+
+
+{
+	LANGID langID;
+	WORD primLang;
+	WORD subLang;
+
+	langID = GetUserDefaultLangID();
+	printf("langID=0x%x\n",langID);
+
+	primLang = (WORD)(PRIMARYLANGID(langID));
+	subLang = (WORD)(SUBLANGID(langID));
+
+	printf("primLang=%d subLang=%d\n",(unsigned)primLang,(unsigned)subLang);  
+}
+
+  printf("\n### All Done ###\n\n");
+
+  return 0;
+}
+