chore: initial commit (extracted from Launchers monorepo)

Plugin: ns7zip v2.0.0 Architectures: x86-ansi, x86-unicode, amd64-unicode License: LGPL-2.1-or-later
2026-04-29 14:07:51 +02:00
commit d074cc7c07
3848 changed files with 1076682 additions and 0 deletions
@@ -0,0 +1,340 @@
+// NewHandler.cpp
+ 
+#include "StdAfx.h"
+
+#include <stdlib.h>
+
+#include "NewHandler.h"
+
+// #define DEBUG_MEMORY_LEAK
+
+#ifndef DEBUG_MEMORY_LEAK
+
+#ifdef Z7_REDEFINE_OPERATOR_NEW
+
+/*
+void * my_new(size_t size)
+{
+  // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
+  if (size == 0)
+    size = 1;
+  void *p = ::malloc(size);
+  if (!p)
+    throw CNewException();
+  return p;
+}
+
+void my_delete(void *p) throw()
+{
+  // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
+  ::free(p);
+}
+
+void * my_Realloc(void *p, size_t newSize, size_t oldSize)
+{
+  void *newBuf = my_new(newSize);
+  if (oldSize != 0)
+    memcpy(newBuf, p, oldSize);
+  my_delete(p);
+  return newBuf;
+}
+*/
+
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new(size_t size)
+{
+  /* by C++ specification:
+       if (size == 0), operator new(size) returns non_NULL pointer.
+     If (operator new(0) returns NULL), it's out of specification.
+       but some calling code can work correctly even in this case too. */
+  // if (size == 0) return NULL; // for debug only. don't use it
+
+  /* malloc(0) returns non_NULL in main compilers, as we need here.
+     But specification also allows malloc(0) to return NULL.
+     So we change (size=0) to (size=1) here to get real non_NULL pointer */
+  if (size == 0)
+    size = 1;
+  // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
+  // void *p = ::MyAlloc(size);  // note: MyAlloc(0) returns NULL
+  void *p = ::malloc(size);
+  if (!p)
+    throw CNewException();
+  return p;
+}
+
+
+#if defined(_MSC_VER) && _MSC_VER == 1600
+// vs2010 has no throw() by default ?
+#pragma warning(push)
+#pragma warning(disable : 4986) // 'operator delete': exception specification does not match previous declaration
+#endif
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p) throw()
+{
+  // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
+  // MyFree(p);
+  ::free(p);
+}
+
+/* we define operator delete(void *p, size_t n) because
+   vs2022 compiler uses delete(void *p, size_t n), and
+   we want to mix files from different compilers:
+     - old vc6 linker
+     - old vc6 complier
+     - new vs2022 complier
+*/
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t n) throw()
+{
+  UNUSED_VAR(n)
+  ::free(p);
+}
+
+#if defined(_MSC_VER) && _MSC_VER == 1600
+#pragma warning(pop)
+#endif
+
+/*
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new[](size_t size)
+{
+  // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
+  if (size == 0)
+    size = 1;
+  void *p = ::malloc(size);
+  if (!p)
+    throw CNewException();
+  return p;
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p) throw()
+{
+  // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
+  ::free(p);
+}
+*/
+
+#endif
+
+#else
+
+#include <stdio.h>
+
+// #pragma init_seg(lib)
+/*
+const int kDebugSize = 1000000;
+static void *a[kDebugSize];
+static int g_index = 0;
+
+class CC
+{
+public:
+  CC()
+  {
+    for (int i = 0; i < kDebugSize; i++)
+      a[i] = 0;
+  }
+  ~CC()
+  {
+    printf("\nDestructor: %d\n", numAllocs);
+    for (int i = 0; i < kDebugSize; i++)
+      if (a[i] != 0)
+        return;
+  }
+} g_CC;
+*/
+
+#ifdef _WIN32
+static bool wasInit = false;
+static CRITICAL_SECTION cs;
+#endif
+
+static int numAllocs = 0;
+
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new(size_t size)
+{
+ #ifdef _WIN32
+  if (!wasInit)
+  {
+    InitializeCriticalSection(&cs);
+    wasInit = true;
+  }
+  EnterCriticalSection(&cs);
+
+  numAllocs++;
+  int loc = numAllocs;
+  void *p = HeapAlloc(GetProcessHeap(), 0, size);
+  /*
+  if (g_index < kDebugSize)
+  {
+    a[g_index] = p;
+    g_index++;
+  }
+  */
+  printf("Alloc %6d, size = %8u\n", loc, (unsigned)size);
+  LeaveCriticalSection(&cs);
+  if (!p)
+    throw CNewException();
+  return p;
+ #else
+  numAllocs++;
+  int loc = numAllocs;
+  if (size == 0)
+    size = 1;
+  void *p = malloc(size);
+  /*
+  if (g_index < kDebugSize)
+  {
+    a[g_index] = p;
+    g_index++;
+  }
+  */
+  printf("Alloc %6d, size = %8u\n", loc, (unsigned)size);
+  if (!p)
+    throw CNewException();
+  return p;
+ #endif
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p) throw()
+{
+  if (!p)
+    return;
+ #ifdef _WIN32
+  EnterCriticalSection(&cs);
+  /*
+  for (int i = 0; i < g_index; i++)
+    if (a[i] == p)
+      a[i] = 0;
+  */
+  HeapFree(GetProcessHeap(), 0, p);
+  // if (numAllocs == 0) numAllocs = numAllocs; // ERROR
+  numAllocs--;
+  // if (numAllocs == 0) numAllocs = numAllocs; // OK: all objects were deleted
+  printf("Free %d\n", numAllocs);
+  LeaveCriticalSection(&cs);
+ #else
+  free(p);
+  numAllocs--;
+  printf("Free %d\n", numAllocs);
+ #endif
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t n) throw();
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t n) throw()
+{
+  UNUSED_VAR(n)
+  printf("delete_WITH_SIZE=%u, ptr = %p\n", (unsigned)n, p);
+  operator delete(p);
+}
+
+/*
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new[](size_t size)
+{
+  printf("operator_new[] : ");
+  return operator new(size);
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t sz) throw();
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t sz) throw()
+{
+  if (!p)
+    return;
+  printf("operator_delete_size : size=%d  : ", (unsigned)sz);
+  operator delete(p);
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p) throw()
+{
+  if (!p)
+    return;
+  printf("operator_delete[] : ");
+  operator delete(p);
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p, size_t sz) throw();
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p, size_t sz) throw()
+{
+  if (!p)
+    return;
+  printf("operator_delete_size[] : size=%d  : ", (unsigned)sz);
+  operator delete(p);
+}
+*/
+
+#endif
+
+/*
+int MemErrorVC(size_t)
+{
+  throw CNewException();
+  // return 1;
+}
+CNewHandlerSetter::CNewHandlerSetter()
+{
+  // MemErrorOldVCFunction = _set_new_handler(MemErrorVC);
+}
+CNewHandlerSetter::~CNewHandlerSetter()
+{
+  // _set_new_handler(MemErrorOldVCFunction);
+}
+*/