Changeset 3573

Timestamp:

Aug 31, 2007, 6:09:23 AM (18 years ago)

Author:

bird

Message:

kHlp work...

Location:

trunk/kStuff

Files:

• include/k/kErrors.h (modified) (3 diffs)
• include/k/kHlp.h (added)
• include/k/kHlpAlloc.h (modified) (1 diff)
• include/k/kHlpEnv.h (added)
• include/k/kHlpPath.h (added)
• include/k/kHlpProcess.h (added)
• include/k/kHlpSem.h (added)
• include/k/kHlpString.h (modified) (2 diffs)
• include/k/kHlpThread.h (added)
• include/k/kLdr.h (modified) (2 diffs)
• kHlp/Bare (added)
• kHlp/Bare/kHlpBare-gcc.c (moved) (moved from trunk/kStuff/kLdr/kLdrHlp-gcc.c ) (1 diff)
• kHlp/Bare/kHlpBareAssert.c (added)
• kHlp/Bare/kHlpBareEnv.c (added)
• kHlp/Bare/kHlpBareHeap.c (moved) (moved from trunk/kStuff/kLdr/kLdrHlpHeap.c ) (12 diffs)
• kHlp/Bare/kHlpBareMem.c (moved) (moved from trunk/kStuff/kLdr/kLdrHlpMem.c ) (17 diffs)
• kHlp/Bare/kHlpBarePath.c (moved) (moved from trunk/kStuff/kLdr/kLdrHlpPath.c ) (5 diffs)
• kHlp/Bare/kHlpBareProcess.c (added)
• kHlp/Bare/kHlpBareSem.c (moved) (moved from trunk/kStuff/kLdr/kLdrHlpSem.c ) (9 diffs)
• kHlp/Bare/kHlpBareStr.c (moved) (moved from trunk/kStuff/kLdr/kLdrHlpStr.c ) (7 diffs)
• kHlp/Bare/kHlpBareThread.c (added)
• kHlp/Generic (added)
• kHlp/Generic/kHlpInt2Ascii.c (added)
• kHlp/Makefile.kmk (moved) (moved from trunk/kStuff/kHlp/CRT/Makefile.kmk ) (3 diffs)
• kLdr/Makefile.kmk (modified) (3 diffs)
• kLdr/kLdr-os2.c (modified) (1 diff)
• kLdr/kLdr-win.c (modified) (1 diff)
• kLdr/kLdr.c (modified) (5 diffs)
• kLdr/kLdrDyld.c (modified) (16 diffs)
• kLdr/kLdrDyldFind.c (modified) (35 diffs)
• kLdr/kLdrDyldMod.c (modified) (11 diffs)
• kLdr/kLdrDyldOS.c (modified) (3 diffs)
• kLdr/kLdrExeStub-win.c (modified) (2 diffs)
• kLdr/kLdrHlp-os2.c (deleted)
• kLdr/kLdrHlp.c (deleted)
• kLdr/kLdrHlp.h (modified) (1 diff)
• kLdr/kLdrInternal.h (modified) (2 diffs)
• kLdr/kLdrMisc.c (modified) (1 diff)
• kLdr/kLdrMod.c (modified) (5 diffs)
• kLdr/kLdrModLX.c (modified) (30 diffs)
• kLdr/kLdrModMachO.c (modified) (24 diffs)
• kLdr/kLdrModNative.c (modified) (8 diffs)
• kLdr/kLdrModPE.c (modified) (18 diffs)
• kLdr/kLdrRdr.c (modified) (1 diff)
• kLdr/kLdrRdrFile.c (modified) (14 diffs)
• kLdr/tstkLdrHeap.c (modified) (17 diffs)

trunk/kStuff/include/k/kErrors.h

@@ -38 +38 @@
  */
 /** The base of the general status codes. */
-#define KERR_GENERAL_BASE                               (KERR_BASE )
+#define KERR_GENERAL_BASE                               (KERR_BASE)
 /** Generic error. */
 #define KERR_GENERAL_FAILURE                            (KERR_GENERAL_BASE + 1)
@@ -45 +45 @@
 /** Hit some unimplemented functionality - feel free to implement it :-) . */
 #define KERR_NOT_IMPLEMENTED                            (KERR_GENERAL_BASE + 3)
+/** An environment variable wasn't found. */
+#define KERR_ENVVAR_NOT_FOUND                           (KERR_GENERAL_BASE + 4)
+/** Buffer overflow. */
+#define KERR_BUFFER_OVERFLOW                            (KERR_GENERAL_BASE + 5)
 /** @}*/
 
@@ -51 +55 @@
  */
 /** The base of the input validation status codes. */
-#define KERR_INPUT_BASE                                 (KERR_GENERAL_BASE + 4)
+#define KERR_INPUT_BASE                                 (KERR_GENERAL_BASE + 6)
 /** An API was given an invalid parameter. */
 #define KERR_INVALID_PARAMETER                          (KERR_INPUT_BASE + 0)

trunk/kStuff/include/k/kHlpAlloc.h

@@ -61 +61 @@
 KHLP_DECL(int)      kHlpPageFree(void *pv, KSIZE cb);
 
+KHLP_DECL(int)      kHlpHeapInit(void);
+KHLP_DECL(void)     kHlpHeapTerm(void);
+KHLP_DECL(void)     kHlpHeapDonate(void *pv, KSIZE cb);
+
 #ifdef __cplusplus
 }

trunk/kStuff/include/k/kHlpString.h

@@ -28 +28 @@
 #define ___k_kHlpString_h___
 
-#include <k/kDefs.h>
+#include <k/kHlpDefs.h>
 #include <k/kTypes.h>
 
@@ -118 +118 @@
 int     kHlpStrIComp(const char *pv1, const char *pv2);
 
+KHLP_DECL(char *)   kHlpInt2Ascii(char *psz, KSIZE cch, long lVal, unsigned iBase);
+
 #ifdef __cplusplus
 }

trunk/kStuff/include/k/kLdr.h

@@ -1019 +1019 @@
                               const char *pszName, KU32 idLang, PFNKLDRENUMRSRC pfnCallback, void *pvUser);
 
+
 /** @name OS/2 like API
  * @{ */
@@ -1116 +1117 @@
 typedef const KLDREXEARGS *PCKLDREXEARGS;
 
-void kLdrLoadExe(PCKLDREXEARGS pArgs, void *pvOS);
+void kLdrLoadExe(PCKLDREXEARGS pArgs, void *pvOS); /** @todo fix this mess... */
+void kLdrDyldLoadExe(PCKLDREXEARGS pArgs, void *pvOS);
 
 /** @} */

trunk/kStuff/kHlp/Bare/kHlpBare-gcc.c

@@ -26 +26 @@
 
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
+#include "kHlp.h"
 
 

trunk/kStuff/kHlp/Bare/kHlpBareHeap.c

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- *
- * kLdr - The Dynamic Loader, Helper Functions, Heap.
- *
- * Copyright (c) 2006 knut st. osmundsen <bird-kbuild-src@anduin.net>
- *
- *
- * This file is part of kLdr.
- *
- * kLdr is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * kLdr is distributed in the hope that it will be useful,
+ * kHlpBare - Heap.
+ */
+
+/*
+ * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
+ *
+ * This file is part of kStuff.
+ *
+ * kStuff is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * kStuff is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with kLdr; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with kStuff; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
@@ -30 +30 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#ifdef __OS2__
+#include <k/kHlpAlloc.h>
+
+#if K_OS == K_OS_OS2
 # define INCL_BASE
 # define INCL_ERRORS
 # include <os2.h>
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
 # include <Windows.h>
 #else
 # error "port me"
 #endif
-
-#include <k/kLdr.h>
-#include "kLdrHlp.h"
-
 
 
@@ -87 +85 @@
  * Assert that a heap free block is valid. */
 #ifdef KLDRHEAP_STRICT
-# define KLDRHEAP_ASSERT(expr)      kldrHlpAssert(expr)
+# define KLDRHEAP_ASSERT(expr)      kHlpAssert(expr)
 
 # define KLDRHEAP_ASSERT_BLOCK(pHeap, pBlock) \
@@ -193 +191 @@
  * @returns 0 on success, non-zero OS specific status code on failure.
  */
-int kldrHlpHeapInit(void)
+KHLP_DECL(int) kHlpHeapInit(void)
 {
     return kLdrHeapInit(&g_Heap);
@@ -202 +200 @@
  * Terminates the kLdr heap.
  */
-void kldrHlpHeapTerm(void)
+KHLP_DECL(void) kHlpHeapTerm(void)
 {
     kLdrHeapDelete(&g_Heap);
@@ -214 +212 @@
  * @param   cb      The requested heap block size.
  */
-void *kldrHlpAlloc(KSIZE cb)
+KHLP_DECL(void *) kHlpAlloc(KSIZE cb)
 {
     return kLdrHeapAlloc(&g_Heap, cb);
@@ -226 +224 @@
  * @param   cb      The requested heap block size.
  */
-void *kldrHlpAllocZ(KSIZE cb)
+KHLP_DECL(void *) kHlpAllocZ(KSIZE cb)
 {
     void *pv = kLdrHeapAlloc(&g_Heap, cb);
     if (pv)
-        kLdrHlpMemSet(pv, 0, cb);
+        kHlpMemSet(pv, 0, cb);
     return pv;
 }
@@ -238 +236 @@
  * Frees memory allocated off the kLdr heap.
  *
- * @param   pv      Pointer to the heap block returned by kldrHlpAlloc().
- */
-void kldrHlpFree(void *pv)
+ * @param   pv      Pointer to the heap block returned by kHlpAlloc().
+ */
+KHLP_DECL(void) kHlpFree(void *pv)
 {
     kLdrHeapFree(&g_Heap, pv);
@@ -252 +250 @@
  * @param   cb      The amount of memory.
  */
-void kldrHlpHeapDonate(void *pv, KSIZE cb)
+KHLP_DECL(void) kHlpHeapDonate(void *pv, KSIZE cb)
 {
     kLdrHeapDonate(&g_Heap, pv, cb);
@@ -652 +650 @@
 static int kLdrHeapSegAlloc(PKLDRHEAPSEG pSeg, KSIZE cbMin)
 {
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     APIRET rc;
 
@@ -667 +665 @@
     }
 
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
     pSeg->cb = (cbMin + 0xffff) & ~(KSIZE)0xffff;
     pSeg->pvBase = VirtualAlloc(NULL, pSeg->cb, MEM_COMMIT, PAGE_READWRITE);
@@ -691 +689 @@
 static void kLdrHeapSegFree(PKLDRHEAPSEG pSeg)
 {
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     APIRET rc = DosFreeMem(pSeg->pvBase);
     KLDRHEAP_ASSERT(!rc); (void)rc;
 
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
     BOOL fRc = VirtualFree(pSeg->pvBase, 0 /*pSeg->cb*/, MEM_RELEASE);
     KLDRHEAP_ASSERT(fRc); (void)fRc;

trunk/kStuff/kHlp/Bare/kHlpBareMem.c

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- *
- * kLdr - The Dynamic Loader, Memory Helper Functions.
- *
- * Copyright (c) 2006-2007 knut st. osmundsen <bird-kbuild-src@anduin.net>
- *
- *
- * This file is part of kLdr.
- *
- * kLdr is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * kLdr is distributed in the hope that it will be useful,
+ * kHlp - Generic Page Memory Functions.
+ */
+
+/*
+ * Copyright (c) 2007 knut st. osmundsen <bird-src-spam@anduin.net>
+ *
+ * This file is part of kStuff.
+ *
+ * kStuff is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * kStuff is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with kLdr; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
-
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with kStuff; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
 
 /*******************************************************************************
 *   Header Files                                                               *
 *******************************************************************************/
-#ifdef __OS2__
+#include <k/kHlpAlloc.h>
+
+#if K_OS == K_OS_OS2
 # define INCL_BASE
 # define INCL_ERRORS
 # include <os2.h>
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
 # include <Windows.h>
 #else
 # error "port me"
 #endif
-
-#include <k/kLdr.h>
-#include "kLdrHlp.h"
 
 
@@ -46 +44 @@
 *   Global Variables                                                           *
 *******************************************************************************/
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
 /** The base of the stub object.
  * The OS/2 exe stub consists of a single data object. When allocating memory
@@ -54 +52 @@
 static KSIZE            g_cbStub = 0;
 
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
 /** The system info. */
 static SYSTEM_INFO      g_SystemInfo;
@@ -63 +61 @@
 
 
-#ifdef __OS2__
-static ULONG kldrHlpPageProtToNative(KPROT enmProt)
+#if K_OS == K_OS_OS2
+static ULONG kHlpPageProtToNative(KPROT enmProt)
 {
     switch (enmProt)
@@ -75 +73 @@
         case KPROT_EXECUTE_READWRITE:    return PAG_COMMIT | PAG_EXECUTE | PAG_READ | PAG_WRITE;
         default:
-            kldrHlpAssert(0);
+            kHlpAssert(0);
             return ~0U;
     }
 }
-#elif defined(__WIN__)
-static DWORD kldrHlpPageProtToNative(KPROT enmProt)
+#elif  K_OS == K_OS_WINDOWS
+static DWORD kHlpPageProtToNative(KPROT enmProt)
 {
     switch (enmProt)
@@ -91 +89 @@
         case KPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
         default:
-            kldrHlpAssert(0);
+            kHlpAssert(0);
             return ~0U;
     }
@@ -107 +105 @@
  * @param   enmProt     The new protection. Copy-on-write is invalid.
  */
-int     kldrHlpPageAlloc(void **ppv, KSIZE cb, KPROT enmProt, unsigned fFixed)
-{
-#ifdef __OS2__
+KHLP_DECL(int) kHlpPageAlloc(void **ppv, KSIZE cb, KPROT enmProt, KBOOL fFixed)
+{
+#if K_OS == K_OS_OS2
     APIRET  rc;
-    ULONG   fFlags = kldrHlpPageProtToNative(enmProt);;
+    ULONG   fFlags = kHlpPageProtToNative(enmProt);;
 
     if (!fFixed)
@@ -128 +126 @@
     if (!rc)
         return 0;
-    kldrHlpAssert(0);
-    return rc;
-
-#elif defined(__WIN__)
+    kHlpAssert(0);
+    return rc;
+
+#elif  K_OS == K_OS_WINDOWS
     /* (We don't have to care about the stub here, because the stub will be unmapped before we get here.) */
     int     rc;
-    DWORD   fProt = kldrHlpPageProtToNative(enmProt);
+    DWORD   fProt = kHlpPageProtToNative(enmProt);
 
     if (!g_SystemInfo.dwPageSize)
@@ -143 +141 @@
         return 0;
     rc = GetLastError();
-    kldrHlpAssert(0);
+    kHlpAssert(0);
     return rc;
 
@@ -155 +153 @@
  * Change the protection of one or more pages in an allocation.
  *
- * (This will of course only work correctly on memory allocated by kldrHlpPageAlloc().)
+ * (This will of course only work correctly on memory allocated by kHlpPageAlloc().)
  *
  * @returns 0 on success, non-zero OS status code on failure.
@@ -162 +160 @@
  * @param   enmProt     The new protection. Copy-on-write is invalid.
  */
-int     kldrHlpPageProtect(void *pv, KSIZE cb, KPROT enmProt)
-{
-#ifdef __OS2__
+KHLP_DECL(int) kHlpPageProtect(void *pv, KSIZE cb, KPROT enmProt)
+{
+#if K_OS == K_OS_OS2
     APIRET      rc;
-    ULONG       fFlags = kldrHlpPageProtToNative(enmProt);;
+    ULONG       fFlags = kHlpPageProtToNative(enmProt);;
 
     /*
@@ -188 +186 @@
         }
     }
-    kldrHlpAssert(!rc);
-    return rc;
-
-#elif defined(__WIN__)
+    kHlpAssert(!rc);
+    return rc;
+
+#elif  K_OS == K_OS_WINDOWS
     DWORD fOldProt = 0;
-    DWORD fProt = kldrHlpPageProtToNative(enmProt);
+    DWORD fProt = kHlpPageProtToNative(enmProt);
     int rc = 0;
 
@@ -199 +197 @@
     {
         rc = GetLastError();
-        kldrHlpAssert(0);
+        kHlpAssert(0);
     }
     return rc;
@@ -209 +207 @@
 
 /**
- * Free memory allocated by kldrHlpPageAlloc().
+ * Free memory allocated by kHlpPageAlloc().
  *
  * @returns 0 on success, non-zero OS status code on failure.
- * @param   pv          The address returned by kldrHlpPageAlloc().
- * @param   cb          The byte count requested from kldrHlpPageAlloc().
- */
-int     kldrHlpPageFree(void *pv, KSIZE cb)
-{
-#ifdef __OS2__
+ * @param   pv          The address returned by kHlpPageAlloc().
+ * @param   cb          The byte count requested from kHlpPageAlloc().
+ */
+KHLP_DECL(int) skHlpPageFree(void *pv, KSIZE cb)
+{
+#if K_OS == K_OS_OS2
     APIRET rc;
 
@@ -242 +240 @@
             if (rc)
             {
-                kldrHlpAssert(!rc);
+                kHlpAssert(!rc);
                 return rc;
             }
@@ -259 +257 @@
      */
     rc = DosFreeMem(pv);
-    kldrHlpAssert(!rc);
-    return rc;
-
-#elif defined(__WIN__)
+    kHlpAssert(!rc);
+    return rc;
+
+#elif  K_OS == K_OS_WINDOWS
     /*
      * Free the object.
@@ -270 +268 @@
     {
         rc = GetLastError();
-        kldrHlpAssert(0);
-    }
-    return rc;
-
-#else
-# error "port me"
-#endif
-}
-
+        kHlpAssert(0);
+    }
+    return rc;
+
+#else
+# error "port me"
+#endif
+}
+

trunk/kStuff/kHlp/Bare/kHlpBarePath.c

@@ -29 +29 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#include <k/kLdr.h>
-#include "kLdrHlp.h"
+#include <k/kHlpPath.h>
+#include <k/kHlpString.h>
 
 
@@ -40 +40 @@
  * @param   pszFilename     The filename to parse.
  */
-char   *kldrHlpGetFilename(const char *pszFilename)
+char   *kHlpGetFilename(const char *pszFilename)
 {
     const char *pszLast = NULL;
@@ -75 +75 @@
  * @param   pszFilename     The filename to parse.
  */
-char   *kldrHlpGetSuff(const char *pszFilename)
+char   *kHlpGetSuff(const char *pszFilename)
 {
     const char *pszDot = NULL;
-    pszFilename = kldrHlpGetFilename(pszFilename);
+    pszFilename = kHlpGetFilename(pszFilename);
     for (;;)
     {
@@ -103 +103 @@
  * @param   pszFilename     The filename to parse.
  */
-char   *kldrHlpGetExt(const char *pszFilename)
+char   *kHlpGetExt(const char *pszFilename)
 {
-    char *psz = kldrHlpGetSuff(pszFilename);
+    char *psz = kHlpGetSuff(pszFilename);
     return *psz ? psz + 1 : psz;
 }
@@ -118 +118 @@
  * @param   pszFilename     The filename to parse.
  */
-int kldrHlpIsFilenameOnly(const char *pszFilename)
+int kHlpIsFilenameOnly(const char *pszFilename)
 {
     for (;;)

trunk/kStuff/kHlp/Bare/kHlpBareSem.c

@@ -29 +29 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#ifdef __OS2__
+#include <k/kDefs.h>
+#include <k/kHlpSem.h>
+
+#if K_OS == K_OS_OS2
 # define INCL_BASE
 # define INCL_ERRORS
 # include <os2.h>
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
 # include <Windows.h>
 #else
@@ -39 +42 @@
 #endif
 
-#include <k/kLdr.h>
-#include "kLdrHlp.h"
 
 
@@ -46 +47 @@
 *   Global Variables                                                           *
 *******************************************************************************/
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
 /** The loader sempahore. */
 static HMTX             g_hmtx;
 
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
 /** The loader sempahore. */
 static CRITICAL_SECTION g_CritSect;
@@ -63 +64 @@
  * @returns 0 on success, non-zero OS status code on failure.
  */
-int     kldrHlpSemInit(void)
+int     kHlpSemInit(void)
 {
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     APIRET rc;
     g_hmtx = NULLHANDLE;
@@ -72 +73 @@
         return rc;
 
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
     InitializeCriticalSection(&g_CritSect);
 
@@ -85 +86 @@
  * Terminates the loader semaphore.
  */
-void    kldrHlpSemTerm(void)
+void    kHlpSemTerm(void)
 {
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     HMTX hmtx = g_hmtx;
     g_hmtx = NULLHANDLE;
     DosCloseMutexSem(hmtx);
 
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
     DeleteCriticalSection(&g_CritSect);
 
@@ -107 +108 @@
  * @returns 0 on success, non-zero OS status code on failure.
  */
-int     kldrHlpSemRequest(void)
+int     kHlpSemRequest(void)
 {
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     APIRET rc = DosRequestMutexSem(g_hmtx, 5000);
     if (rc == ERROR_TIMEOUT || rc == ERROR_SEM_TIMEOUT || rc == ERROR_INTERRUPT)
@@ -125 +126 @@
     return rc;
 
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
     EnterCriticalSection(&g_CritSect);
     return 0;
@@ -139 +140 @@
  * The caller is responsible for making sure it's the semaphore owner!
  */
-void    kldrHlpSemRelease(void)
+void    kHlpSemRelease(void)
 {
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     APIRET rc = DosReleaseMutexSem(g_hmtx);
-    kldrHlpAssert(!rc); (void)rc;
+    kHlpAssert(!rc); (void)rc;
 
-#elif defined(__WIN__)
+#elif  K_OS == K_OS_WINDOWS
     LeaveCriticalSection(&g_CritSect);
 

trunk/kStuff/kHlp/Bare/kHlpBareStr.c

@@ -1 +1 @@
 /* $Id$ */
 /** @file
+ * kHlpBare - String Manipulation.
+ */
+
+/*
+ * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
  *
- * kLdr - The Dynamic Loader, String Helper Functions.
+ * This file is part of kStuff.
  *
- * Copyright (c) 2006 knut st. osmundsen <bird-kbuild-src@anduin.net>
+ * kStuff is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
  *
+ * kStuff is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
  *
- * This file is part of kLdr.
- *
- * kLdr is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * kLdr is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with kLdr; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with kStuff; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
-
 
 /*******************************************************************************
 *   Header Files                                                               *
 *******************************************************************************/
-#include <k/kLdr.h>
-#include "kLdrHlp.h"
+#include <k/kHlpString.h>
 
 
-/**
- * Converts an signed integer to an ascii string.
- *
- * @returns psz.
- * @param   psz         Pointer to the output buffer.
- * @param   cch         The size of the output buffer.
- * @param   lVal        The value.
- * @param   iBase       The base to format it. (2,8,10 or 16)
- */
-char *kldrHlpInt2Ascii(char *psz, KSIZE cch, long lVal, unsigned iBase)
-{
-    static const char s_szDigits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
-    char *pszRet = psz;
-
-    if (cch >= (lVal < 0 ? 3U : 2U) && psz)
-    {
-        /* prefix */
-        if (lVal < 0)
-        {
-            *psz++ = '-';
-            cch--;
-            lVal = -lVal;
-        }
-
-        /* the digits */
-        do
-        {
-            *psz++ = s_szDigits[lVal % iBase];
-            cch--;
-            lVal /= iBase;
-        } while (lVal && cch > 1);
-
-        /* overflow indicator */
-        if (lVal)
-            psz[-1] = '+';
-    }
-    else if (!pszRet)
-        return pszRet;
-    else if (cch < 1 || !pszRet)
-        return pszRet;
-    else
-        *psz++ = '+';
-    *psz = '\0';
-
-    return pszRet;
-}
-
-
-KSIZE  kLdrHlpStrNLen(const char *psz, KSIZE cchMax)
+KSIZE  kHlpStrNLen(const char *psz, KSIZE cchMax)
 {
     const char * const pszStart = psz;
@@ -90 +40 @@
 
 
-int     kLdrHlpMemIComp(const void *pv1, const void *pv2, KSIZE cb)
+int     kHlpMemIComp(const void *pv1, const void *pv2, KSIZE cb)
 {
     const KU8 *pb1 = (const KU8 *)pv1;
@@ -110 +60 @@
 
 
-int     kLdrHlpStrIComp(const char *pv1, const char *pv2)
+int     kHlpStrIComp(const char *pv1, const char *pv2)
 {
     const KU8 *pb1 = (const KU8 *)pv1;
@@ -132 +82 @@
 
 
-#ifdef kLdrHlpStrChr_needed
-char   *kLdrHlpStrChr(const char *psz, int ch)
+#ifdef kHlpStrChr_needed
+char   *kHlpStrChr(const char *psz, int ch)
 {
     while (*psz)
@@ -146 +96 @@
 
 
-#ifdef kLdrHlpMemChr_needed
-void   *kLdrHlpMemChr(const void *pv, int ch, KSIZE cb)
+#ifdef kHlpMemChr_needed
+void   *kHlpMemChr(const void *pv, int ch, KSIZE cb)
 {
     const KU8 *pb = (const KU8 *)pv;
@@ -162 +112 @@
 
 
-#ifdef kLdrHlpMemMove_needed
-void   *kLdrHlpMemMove(void *pv1, const void *pv2, KSIZE cb)
+#ifdef kHlpMemMove_needed
+void   *kHlpMemMove(void *pv1, const void *pv2, KSIZE cb)
 {
     KU8            *pbDst = (KU8 *)pv1;
@@ -177 +127 @@
 
 
-#ifdef kLdrHlpStrNComp_needed
-int     kLdrHlpStrNComp(const char *psz1, const char *psz2, KSIZE cch)
+#ifdef kHlpStrNComp_needed
+int     kHlpStrNComp(const char *psz1, const char *psz2, KSIZE cch)
 {
     while (cch-- > 0)

trunk/kStuff/kHlp/Makefile.kmk

@@ -1 +1 @@
 # $Id$
 ## @file
-# kHlpCRT - The CRT Based Helper API.
+# kHlp - The Helper API.
 #
 
@@ -25 +25 @@
 #
 
-DEPTH = ../../..
+DEPTH = ../..
 include $(PATH_KBUILD)/header.kmk
+
+#
+# kHlpBaseStatic
+#
+LIBRARIES += kHlpBaseStatic
+kHlpBaseStatic_TEMPLATE = kStuffLIB
+kHlpBaseStatic_SOURCES = \
+        Generic/kHlpInt2Ascii.c \
+        \
+        Bare/kHlpBareAssert.c \
+        Bare/kHlpBareHeap.c \
+        Bare/kHlpBareEnv.c \
+        Bare/kHlpBareMem.c \
+        Bare/kHlpBarePath.c \
+        Bare/kHlpBareProcess.c \
+        Bare/kHlpBareSem.c \
+        Bare/kHlpBareStr.c \
+        Bare/kHlpBareThread.c \
 
 #
@@ -34 +52 @@
 kHlpCRTStatic_TEMPLATE = kStuffLIB
 kHlpCRTStatic_SOURCES = \
-        kHlpCRTAlloc.cpp \
-        kHlpCRTString.cpp \
+        \
+        CRT/kHlpCRTAlloc.cpp \
+        CRT/kHlpCRTString.cpp \
 
 # Generate the rules

trunk/kStuff/kLdr/Makefile.kmk

@@ -120 +120 @@
         kLdrDyldOS.c \
         kLdrErr.c \
-        kLdrHlp.c \
-        kLdrHlpHeap.c \
-        kLdrHlpMem.c \
-        kLdrHlpPath.c \
-        kLdrHlpSem.c \
-        kLdrHlpStr.c \
         kLdrMisc.c \
         kLdrRdr.c \
@@ -137 +131 @@
         kLdr-os2.def \
         kLdr-os2.c \
-        kLdrHlp-gcc.c \
         kLdrA-os2.asm
 kLdr_SOURCES.win = \
         kLdr-win.def \
         kLdr-win.c
+kLdr_LIBS += \
+        $(PATH_LIB)/kHlpBaseStatic$(SUFF_LIB)
 
 kLdrErr.c_DEPS = $(PATH_TARGET)/kldrErrConsts.h
@@ -197 +192 @@
 # Heap testcase.
 #
-PROGRAMS += tstkLdrHeap
+#PROGRAMS += tstkLdrHeap
 tstkLdrHeap_TEMPLATE = TST
 tstkLdrHeap_SOURCES = \
         tstkLdrHeap.c \
-        kLdrHlp.c \
-        kLdrHlpHeap.c \
-        kLdrHlpMem.c \
-        kLdrHlpPath.c \
-        kLdrHlpSem.c \
-        kLdrHlpStr.c \
+        kHlp.c \
+        kHlpHeap.c \
+        kHlpMem.c \
+        kHlpPath.c \
+        kHlpSem.c \
+        kHlpStr.c \
 
 #

trunk/kStuff/kLdr/kLdr-os2.c

@@ -35 +35 @@
 #include <k/kLdr.h>
 #include "kLdrInternal.h"
-#include "kLdrHlp.h"
 
 

trunk/kStuff/kLdr/kLdr-win.c

@@ -34 +34 @@
 #include <k/kLdr.h>
 #include "kLdrInternal.h"
-#include "kLdrHlp.h"
 
 

trunk/kStuff/kLdr/kLdr.c

@@ -52 +52 @@
 *******************************************************************************/
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
 
@@ -95 +94 @@
             break;
         }
-        kldrHlpSleep(1);
+        kHlpSleep(1);
     }
 
@@ -101 +100 @@
      * Do the initialization.
      */
-    rc = kldrHlpHeapInit();
+    rc = kHlpHeapInit();
     if (!rc)
     {
-        rc = kldrHlpSemInit();
+        rc = kHlpSemInit();
         if (!rc)
         {
@@ -113 +112 @@
                 return 0;
             }
-            kldrHlpSemTerm();
+            kHlpSemTerm();
         }
-        kldrHlpHeapTerm();
+        kHlpHeapTerm();
     }
     g_fInitialized = -2;
@@ -135 +134 @@
      * Do the termination.
      */
-    kldrHlpSemTerm();
-    kldrHlpHeapTerm();
+    kHlpSemTerm();
+    kHlpHeapTerm();
 
     /* done */

trunk/kStuff/kLdr/kLdrDyld.c

@@ -30 +30 @@
 *******************************************************************************/
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
 
@@ -45 +44 @@
  */
 #ifdef KLDRDYLD_STRICT
-# define KLDRDYLD_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRDYLD_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRDYLD_ASSERT(expr)  do {} while (0)
@@ -267 +266 @@
     /** @todo make sense of this default prefix/suffix stuff. */
     if (pArgs->szDefPrefix[0] != '\0')
-        kLdrHlpMemCopy(kLdrDyldDefPrefix, pArgs->szDefPrefix, K_MIN(sizeof(pArgs->szDefPrefix), sizeof(kLdrDyldDefPrefix)));
+        kHlpMemCopy(kLdrDyldDefPrefix, pArgs->szDefPrefix, K_MIN(sizeof(pArgs->szDefPrefix), sizeof(kLdrDyldDefPrefix)));
     if (pArgs->szDefSuffix[0] != '\0')
-        kLdrHlpMemCopy(kLdrDyldDefSuffix, pArgs->szDefSuffix, K_MIN(sizeof(pArgs->szDefSuffix), sizeof(kLdrDyldDefSuffix)));
+        kHlpMemCopy(kLdrDyldDefSuffix, pArgs->szDefSuffix, K_MIN(sizeof(pArgs->szDefSuffix), sizeof(kLdrDyldDefSuffix)));
 
     /** @todo append that path to the one for the specified search method. */
     /** @todo create a function for doing this, an exposed api preferably. */
     /* append path */
-    cbStack = sizeof(kLdrDyldLibraryPath) - kLdrHlpStrLen(kLdrDyldLibraryPath); /* borrow cbStack for a itty bit. */
-    kLdrHlpMemCopy(kLdrDyldLibraryPath, pArgs->szLibPath, K_MIN(sizeof(pArgs->szLibPath), cbStack));
+    cbStack = sizeof(kLdrDyldLibraryPath) - kHlpStrLen(kLdrDyldLibraryPath); /* borrow cbStack for a itty bit. */
+    kHlpMemCopy(kLdrDyldLibraryPath, pArgs->szLibPath, K_MIN(sizeof(pArgs->szLibPath), cbStack));
     kLdrDyldLibraryPath[sizeof(kLdrDyldLibraryPath) - 1] = '\0';
 
@@ -281 +280 @@
      * Make sure we own the loader semaphore (necessary for init).
      */
-    rc = kldrHlpSemRequest();
+    rc = kHlpSemRequest();
     if (rc)
         kldrDyldFailure(rc, "Sem req. failure, rc=%d", rc);
@@ -333 +332 @@
         *pszErr = '\0';
     *phMod = NIL_HKLDRMOD;
-    KLDRHLP_VALIDATE_STRING(pszDll);
-    KLDRHLP_VALIDATE_OPTIONAL_STRING(pszPrefix);
-    KLDRHLP_VALIDATE_OPTIONAL_STRING(pszSuffix);
-    KLDRHLP_VALIDATE_ENUM(enmSearch, KLDRDYLD_SEARCH);
-    KLDRHLP_VALIDATE_OPTIONAL_BUFFER(pszErr, cchErr);
+    K_VALIDATE_STRING(pszDll);
+    K_VALIDATE_OPTIONAL_STRING(pszPrefix);
+    K_VALIDATE_OPTIONAL_STRING(pszSuffix);
+    K_VALIDATE_ENUM(enmSearch, KLDRDYLD_SEARCH);
+    K_VALIDATE_OPTIONAL_BUFFER(pszErr, cchErr);
 
     /* get the semaphore and do the job. */
-    rc = kldrHlpSemRequest();
+    rc = kHlpSemRequest();
     if (!rc)
     {
@@ -349 +348 @@
         g_cActiveLoadCalls--;
         kldrDyldDoModuleTerminationAndGarabageCollection();
-        kldrHlpSemRelease();
+        kHlpSemRelease();
         *phMod = pMod ? pMod->hMod : NIL_HKLDRMOD;
     }
@@ -370 +369 @@
 
     /* get sem & do work */
-    rc = kldrHlpSemRequest();
+    rc = kHlpSemRequest();
     if (!rc)
     {
@@ -378 +377 @@
         g_cActiveUnloadCalls--;
         kldrDyldDoModuleTerminationAndGarabageCollection();
-        kldrHlpSemRelease();
+        kHlpSemRelease();
     }
     return rc;
@@ -406 +405 @@
     /* validate & initialize */
     *phMod = NIL_HKLDRMOD;
-    KLDRHLP_VALIDATE_STRING(pszDll);
+    K_VALIDATE_STRING(pszDll);
 
     /* get sem & do work */
-    rc = kldrHlpSemRequest();
+    rc = kHlpSemRequest();
     if (!rc)
     {
         PKLDRDYLDMOD pMod = NULL;
         rc = kldrDyldDoFindByName(pszDll, pszPrefix, pszSuffix, enmSearch, fFlags, &pMod);
-        kldrHlpSemRelease();
+        kHlpSemRelease();
         *phMod = pMod ? pMod->hMod : NIL_HKLDRMOD;
     }
@@ -446 +445 @@
 
     /* get sem & do work */
-    rc = kldrHlpSemRequest();
+    rc = kHlpSemRequest();
     if (!rc)
     {
         PKLDRDYLDMOD pMod = NULL;
         rc = kldrDyldDoFindByAddress(Address, &pMod, piSegment, poffSegment);
-        kldrHlpSemRelease();
+        kHlpSemRelease();
         *phMod = pMod ? pMod->hMod : NIL_HKLDRMOD;
     }
@@ -476 +475 @@
         *pszName = '\0';
     KLDRDYLD_VALIDATE_HKLDRMOD(hMod);
-    KLDRHLP_VALIDATE_BUFFER(pszName, cchName);
+    K_VALIDATE_BUFFER(pszName, cchName);
 
     /* get sem & do work */
-    rc = kldrHlpSemRequest();
+    rc = kHlpSemRequest();
     if (!rc)
     {
         rc = kldrDyldDoGetName(hMod, pszName, cchName);
-        kldrHlpSemRelease();
+        kHlpSemRelease();
     }
     return rc;
@@ -507 +506 @@
         *pszFilename = '\0';
     KLDRDYLD_VALIDATE_HKLDRMOD(hMod);
-    KLDRHLP_VALIDATE_BUFFER(pszFilename, cchFilename);
+    K_VALIDATE_BUFFER(pszFilename, cchFilename);
 
     /* get sem & do work */
-    rc = kldrHlpSemRequest();
+    rc = kHlpSemRequest();
     if (!rc)
     {
         rc = kldrDyldDoGetFilename(hMod, pszFilename, cchFilename);
-        kldrHlpSemRelease();
+        kHlpSemRelease();
     }
     return rc;
@@ -545 +544 @@
         return KLDR_ERR_INVALID_PARAMETER;
     KLDRDYLD_VALIDATE_HKLDRMOD(hMod);
-    KLDRHLP_VALIDATE_OPTIONAL_STRING(pszSymbolName);
+    K_VALIDATE_OPTIONAL_STRING(pszSymbolName);
 
     /* get sem & do work */
-    rc = kldrHlpSemRequest();
+    rc = kHlpSemRequest();
     if (!rc)
     {
         rc = kldrDyldDoQuerySymbol(hMod, uSymbolOrdinal, pszSymbolName, pValue, pfKind);
-        kldrHlpSemRelease();
+        kHlpSemRelease();
     }
     return rc;
@@ -1086 +1085 @@
         KU32 cNew = g_cStackModsAllocated ? g_cStackModsAllocated * 2 : 128;
         void *pvOld = g_papStackMods;
-        void *pvNew = kldrHlpAlloc(cNew * sizeof(g_papStackMods[0]));
+        void *pvNew = kHlpAlloc(cNew * sizeof(g_papStackMods[0]));
         if (!pvNew)
             return KLDR_ERR_NO_MEMORY;
-        kLdrHlpMemCopy(pvNew, pvOld, g_cStackMods * sizeof(g_papStackMods[0]));
+        kHlpMemCopy(pvNew, pvOld, g_cStackMods * sizeof(g_papStackMods[0]));
         g_papStackMods = (PPKLDRDYLDMOD)pvNew;
-        kldrHlpFree(pvOld);
+        kHlpFree(pvOld);
     }
 
@@ -1472 +1471 @@
     /** @todo print it. */
     if (g_fBootstrapping);
-        kldrHlpExit(1);
+        kHlpExit(1);
     return rc;
 }
@@ -1491 +1490 @@
     /* if no error string, format the rc into a string. */
     if (!g_szkLdrDyldError[0] && rc)
-        kldrHlpInt2Ascii(g_szkLdrDyldError, sizeof(g_szkLdrDyldError), rc, 10);
+        kHlpInt2Ascii(g_szkLdrDyldError, sizeof(g_szkLdrDyldError), rc, 10);
 
     /* copy it if we got something. */
     if (cchErr && pszErr && g_szkLdrDyldError[0])
     {
-        cchToCopy = kLdrHlpStrLen(g_szkLdrDyldError);
+        cchToCopy = kHlpStrLen(g_szkLdrDyldError);
         if (cchToCopy >= cchErr)
             cchToCopy = cchErr - 1;
-        kLdrHlpMemCopy(pszErr, g_szkLdrDyldError, cchToCopy);
+        kHlpMemCopy(pszErr, g_szkLdrDyldError, cchToCopy);
         pszErr[cchToCopy] = '\0';
     }

trunk/kStuff/kLdr/kLdrDyldFind.c

@@ -52 +52 @@
 
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
+
 
 /*******************************************************************************
@@ -66 +66 @@
  */
 #ifdef KLDRDYLDFIND_STRICT
-# define KLDRDYLDFIND_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRDYLDFIND_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRDYLDFIND_ASSERT(expr)  do {} while (0)
@@ -225 +225 @@
      * The kLdr search parameters.
      */
-    rc = kldrHlpGetEnv("KLDR_LIBRARY_PATH", kLdrDyldLibraryPath, sizeof(kLdrDyldLibraryPath));
-    rc = kldrHlpGetEnv("KLDR_DEF_PREFIX", szTmp, sizeof(szTmp));
+    rc = kHlpGetEnv("KLDR_LIBRARY_PATH", kLdrDyldLibraryPath, sizeof(kLdrDyldLibraryPath));
+    rc = kHlpGetEnv("KLDR_DEF_PREFIX", szTmp, sizeof(szTmp));
     if (!rc)
-        kLdrHlpMemCopy(kLdrDyldDefPrefix, szTmp, sizeof(szTmp));
-    rc = kldrHlpGetEnv("KLDR_DEF_SUFFIX", szTmp, sizeof(szTmp));
+        kHlpMemCopy(kLdrDyldDefPrefix, szTmp, sizeof(szTmp));
+    rc = kHlpGetEnv("KLDR_DEF_SUFFIX", szTmp, sizeof(szTmp));
     if (!rc)
-        kLdrHlpMemCopy(kLdrDyldDefSuffix, szTmp, sizeof(szTmp));
+        kHlpMemCopy(kLdrDyldDefSuffix, szTmp, sizeof(szTmp));
 
     /*
@@ -251 +251 @@
 
 #else
-    kldrHlpGetEnv("KLDR_OS2_LIBPATH", kLdrDyldOS2Libpath, sizeof(kLdrDyldOS2Libpath));
-    kldrHlpGetEnv("KLDR_OS2_LIBPATHSTRICT", kLdrDyldOS2LibpathStrict, sizeof(kLdrDyldOS2LibpathStrict));
+    kHlpGetEnv("KLDR_OS2_LIBPATH", kLdrDyldOS2Libpath, sizeof(kLdrDyldOS2Libpath));
+    kHlpGetEnv("KLDR_OS2_LIBPATHSTRICT", kLdrDyldOS2LibpathStrict, sizeof(kLdrDyldOS2LibpathStrict));
     if (    kLdrDyldOS2LibpathStrict[0] == 'T'
         ||  kLdrDyldOS2LibpathStrict[0] == 't')
@@ -259 +259 @@
         kLdrDyldOS2LibpathStrict[0] = '\0';
     kLdrDyldOS2LibpathStrict[1] = '\0';
-    kldrHlpGetEnv("KLDR_OS2_BEGINLIBPATH", kLdrDyldOS2BeginLibpath, sizeof(kLdrDyldOS2BeginLibpath));
-    kldrHlpGetEnv("KLDR_OS2_ENDLIBPATH", kLdrDyldOS2EndLibpath, sizeof(kLdrDyldOS2EndLibpath));
+    kHlpGetEnv("KLDR_OS2_BEGINLIBPATH", kLdrDyldOS2BeginLibpath, sizeof(kLdrDyldOS2BeginLibpath));
+    kHlpGetEnv("KLDR_OS2_ENDLIBPATH", kLdrDyldOS2EndLibpath, sizeof(kLdrDyldOS2EndLibpath));
 #endif
 
@@ -273 +273 @@
     if (cch >= sizeof(kLdrDyldWindowsDir))
         return (rc = GetLastError()) ? rc : -1;
-    kldrHlpGetEnv("PATH", kLdrDyldWindowsPath, sizeof(kLdrDyldWindowsPath));
+    kHlpGetEnv("PATH", kLdrDyldWindowsPath, sizeof(kLdrDyldWindowsPath));
 #else
-    kldrHlpGetEnv("KLDR_WINDOWS_SYSTEM_DIR", kLdrDyldWindowsSystemDir, sizeof(kLdrDyldWindowsSystemDir));
-    kldrHlpGetEnv("KLDR_WINDOWS_DIR", kLdrDyldWindowsDir, sizeof(kLdrDyldWindowsDir));
-    rc = kldrHlpGetEnv("KLDR_WINDOWS_PATH", kLdrDyldWindowsPath, sizeof(kLdrDyldWindowsPath));
+    kHlpGetEnv("KLDR_WINDOWS_SYSTEM_DIR", kLdrDyldWindowsSystemDir, sizeof(kLdrDyldWindowsSystemDir));
+    kHlpGetEnv("KLDR_WINDOWS_DIR", kLdrDyldWindowsDir, sizeof(kLdrDyldWindowsDir));
+    rc = kHlpGetEnv("KLDR_WINDOWS_PATH", kLdrDyldWindowsPath, sizeof(kLdrDyldWindowsPath));
     if (rc)
-        kldrHlpGetEnv("PATH", kLdrDyldWindowsPath, sizeof(kLdrDyldWindowsPath));
+        kHlpGetEnv("PATH", kLdrDyldWindowsPath, sizeof(kLdrDyldWindowsPath));
 #endif
 
@@ -285 +285 @@
      * The Unix search parameters.
      */
-    rc = kldrHlpGetEnv("KLDR_UNIX_LIBRARY_PATH", kLdrDyldUnixLibraryPath, sizeof(kLdrDyldUnixLibraryPath));
+    rc = kHlpGetEnv("KLDR_UNIX_LIBRARY_PATH", kLdrDyldUnixLibraryPath, sizeof(kLdrDyldUnixLibraryPath));
     if (rc)
-        kldrHlpGetEnv("LD_LIBRARY_PATH", kLdrDyldUnixLibraryPath, sizeof(kLdrDyldUnixLibraryPath));
+        kHlpGetEnv("LD_LIBRARY_PATH", kLdrDyldUnixLibraryPath, sizeof(kLdrDyldUnixLibraryPath));
 
     (void)cch;
@@ -310 +310 @@
         if (!rc)
         {
-            *kldrHlpGetFilename(kLdrDyldAppDir) = '\0';
-             kLdrHlpMemCopy(kLdrDyldWindowsAppDir, kLdrDyldAppDir, sizeof(kLdrDyldAppDir));
+            *kHlpGetFilename(kLdrDyldAppDir) = '\0';
+             kHlpMemCopy(kLdrDyldWindowsAppDir, kLdrDyldAppDir, sizeof(kLdrDyldAppDir));
         }
         else
@@ -324 +324 @@
         if (dwSize > 0)
         {
-            *kldrHlpGetFilename(kLdrDyldAppDir) = '\0';
-            kLdrHlpMemCopy(kLdrDyldWindowsAppDir, kLdrDyldAppDir, sizeof(kLdrDyldAppDir));
+            *kHlpGetFilename(kLdrDyldAppDir) = '\0';
+            kHlpMemCopy(kLdrDyldWindowsAppDir, kLdrDyldAppDir, sizeof(kLdrDyldAppDir));
         }
         else
@@ -364 +364 @@
      * that should be opened directly and not a module name to be searched for.
      */
-    if (!kldrHlpIsFilenameOnly(pszName))
+    if (!kHlpIsFilenameOnly(pszName))
         rc = kldrDyldFindTryOpen(pszName, &pRdr);
     else if (!(fFlags & KLDRDYLD_LOAD_FLAGS_EXECUTABLE))
@@ -377 +377 @@
         {
             const char     *pszFilename = kLdrRdrName(pRdr);
-            const KSIZE     cchFilename = kLdrHlpStrLen(pszFilename);
+            const KSIZE     cchFilename = kHlpStrLen(pszFilename);
             PKLDRDYLDMOD    pCur;
             for (pCur = kLdrDyldHead; pCur; pCur = pCur->Load.pNext)
                 KLDRDYLDFIND_ASSERT(    pCur->pMod->cchFilename != cchFilename
-                                    ||  kLdrHlpMemComp(pCur->pMod->pszFilename, pszFilename, cchFilename));
+                                    ||  kHlpMemComp(pCur->pMod->pszFilename, pszFilename, cchFilename));
         }
 #endif
@@ -391 +391 @@
         {
             const char     *pszFilename = kLdrRdrName(pRdr);
-            const KSIZE     cchFilename = kLdrHlpStrLen(pszFilename);
+            const KSIZE     cchFilename = kHlpStrLen(pszFilename);
             PKLDRDYLDMOD    pCur;
             for (pCur = kLdrDyldHead; pCur; pCur = pCur->Load.pNext)
@@ -397 +397 @@
                 if (    !pCur->fGlobalOrSpecific
                     &&  pCur->pMod->cchFilename == cchFilename
-                    &&  !kLdrHlpMemComp(pCur->pMod->pszFilename, pszFilename, cchFilename))
+                    &&  !kHlpMemComp(pCur->pMod->pszFilename, pszFilename, cchFilename))
                 {
                     kLdrRdrClose(pRdr);
@@ -405 +405 @@
                 }
                 KLDRDYLDFIND_ASSERT(    pCur->pMod->cchFilename != cchFilename
-                                    ||  kLdrHlpMemComp(pCur->pMod->pszFilename, pszFilename, cchFilename));
+                                    ||  kHlpMemComp(pCur->pMod->pszFilename, pszFilename, cchFilename));
             }
         }
@@ -449 +449 @@
         return rc;
     Args.pszName = pszName;
-    Args.cchName = kLdrHlpStrLen(pszName);
-    Args.cchPrefix = Args.pszPrefix ? kLdrHlpStrLen(Args.pszPrefix) : 0;
-    Args.cchSuffix = Args.pszSuffix ? kLdrHlpStrLen(Args.pszSuffix) : 0;
+    Args.cchName = kHlpStrLen(pszName);
+    Args.cchPrefix = Args.pszPrefix ? kHlpStrLen(Args.pszPrefix) : 0;
+    Args.cchSuffix = Args.pszSuffix ? kHlpStrLen(Args.pszSuffix) : 0;
     Args.cchMaxLength = Args.cchName + Args.cchSuffix + Args.cchPrefix;
     Args.fFlags = fFlags;
@@ -467 +467 @@
             if (kLdrDyldAppDir[0] != '\0')
             {
-                rc = kldrDyldFindTryOpenPath(kLdrDyldAppDir, kLdrHlpStrLen(kLdrDyldAppDir), &Args);
+                rc = kldrDyldFindTryOpenPath(kLdrDyldAppDir, kHlpStrLen(kLdrDyldAppDir), &Args);
                 if (rc != KLDR_ERR_MODULE_NOT_FOUND)
                     break;
@@ -494 +494 @@
         {
             kldrDyldFindLazyInitAppDir();
-            rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsAppDir, kLdrHlpStrLen(kLdrDyldWindowsAppDir), &Args);
+            rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsAppDir, kHlpStrLen(kLdrDyldWindowsAppDir), &Args);
             if (rc != KLDR_ERR_MODULE_NOT_FOUND)
                 break;
@@ -503 +503 @@
                     break;
             }
-            rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsSystemDir, kLdrHlpStrLen(kLdrDyldWindowsSystemDir), &Args);
+            rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsSystemDir, kHlpStrLen(kLdrDyldWindowsSystemDir), &Args);
             if (rc != KLDR_ERR_MODULE_NOT_FOUND)
                 break;
-            rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsDir, kLdrHlpStrLen(kLdrDyldWindowsDir), &Args);
+            rc = kldrDyldFindTryOpenPath(kLdrDyldWindowsDir, kHlpStrLen(kLdrDyldWindowsDir), &Args);
             if (rc != KLDR_ERR_MODULE_NOT_FOUND)
                 break;
@@ -528 +528 @@
         }
 
-        default: kldrHlpAssert(!"internal error"); return -1;
+        default: kHlpAssert(!"internal error"); return -1;
     }
     return rc;
@@ -563 +563 @@
         return rc;
     Args.pszName = pszName;
-    Args.cchName = kLdrHlpStrLen(pszName);
-    Args.cchPrefix = Args.pszPrefix ? kLdrHlpStrLen(Args.pszPrefix) : 0;
-    Args.cchSuffix = Args.pszSuffix ? kLdrHlpStrLen(Args.pszSuffix) : 0;
+    Args.cchName = kHlpStrLen(pszName);
+    Args.cchPrefix = Args.pszPrefix ? kHlpStrLen(Args.pszPrefix) : 0;
+    Args.cchSuffix = Args.pszSuffix ? kHlpStrLen(Args.pszSuffix) : 0;
     Args.cchMaxLength = Args.cchName + Args.cchSuffix + Args.cchPrefix;
     Args.fFlags = fFlags;
@@ -579 +579 @@
         if (kLdrDyldAppDir[0] != '\0')
         {
-            rc = kldrDyldFindTryOpenPath(kLdrDyldAppDir, kLdrHlpStrLen(kLdrDyldAppDir), &Args);
+            rc = kldrDyldFindTryOpenPath(kLdrDyldAppDir, kHlpStrLen(kLdrDyldAppDir), &Args);
             if (rc != KLDR_ERR_MODULE_NOT_FOUND)
                 return rc;
@@ -591 +591 @@
     {
         KSIZE cch;
-        kldrHlpGetEnv("KLDR_EXE_PATH", kLdrDyldExePath, sizeof(kLdrDyldExePath) - 10);
-        cch = kLdrHlpStrLen(kLdrDyldExePath);
+        kHlpGetEnv("KLDR_EXE_PATH", kLdrDyldExePath, sizeof(kLdrDyldExePath) - 10);
+        cch = kHlpStrLen(kLdrDyldExePath);
         kLdrDyldExePath[cch++] = ';';
-        kldrHlpGetEnv("PATH", &kLdrDyldExePath[cch], sizeof(kLdrDyldExePath) - cch);
+        kHlpGetEnv("PATH", &kLdrDyldExePath[cch], sizeof(kLdrDyldExePath) - cch);
     }
     return kldrDyldFindEnumeratePath(kLdrDyldExePath, &Args);
@@ -662 +662 @@
      * The directory path.
      */
-    kLdrHlpMemCopy(s_szFilename, pchPath, cchPath);
+    kHlpMemCopy(s_szFilename, pchPath, cchPath);
     psz = &s_szFilename[cchPath];
     if (psz[-1] != '/'
@@ -677 +677 @@
     if (pArgs->cchPrefix)
     {
-        kLdrHlpMemCopy(psz, pArgs->pszPrefix, pArgs->cchPrefix);
+        kHlpMemCopy(psz, pArgs->pszPrefix, pArgs->cchPrefix);
         psz += pArgs->cchPrefix;
     }
-    kLdrHlpMemCopy(psz, pArgs->pszName, pArgs->cchName);
+    kHlpMemCopy(psz, pArgs->pszName, pArgs->cchName);
     psz += pArgs->cchName;
     if (pArgs->cchSuffix)
     {
-        kLdrHlpMemCopy(psz, pArgs->pszSuffix, pArgs->cchSuffix);
+        kHlpMemCopy(psz, pArgs->pszSuffix, pArgs->cchSuffix);
         psz += pArgs->cchSuffix;
     }
@@ -836 +836 @@
     if (*ppszSuffix)
     {
-        const KSIZE cchName = kLdrHlpStrLen(pszName);
-        const KSIZE cchSuffix = kLdrHlpStrLen(*ppszSuffix);
+        const KSIZE cchName = kHlpStrLen(pszName);
+        const KSIZE cchSuffix = kHlpStrLen(*ppszSuffix);
         if (    cchName > cchSuffix
             &&  (   fCaseSensitive
-                 ?  !kLdrHlpMemComp(pszName + cchName - cchSuffix, *ppszSuffix, cchSuffix)
-                 :  !kLdrHlpMemIComp(pszName + cchName - cchSuffix, *ppszSuffix, cchSuffix))
+                 ?  !kHlpMemComp(pszName + cchName - cchSuffix, *ppszSuffix, cchSuffix)
+                 :  !kHlpMemIComp(pszName + cchName - cchSuffix, *ppszSuffix, cchSuffix))
            )
             *ppszSuffix = NULL;
@@ -893 +893 @@
      */
     fOS2LibpathStrict = 0;
-    if (    !kldrHlpIsFilenameOnly(pszName)
+    if (    !kHlpIsFilenameOnly(pszName)
         ||  (fOS2LibpathStrict = (   enmSearch == KLDRDYLD_SEARCH_OS2
                                   && kLdrDyldOS2LibpathStrict[0] == 'T')
@@ -908 +908 @@
             /* do a filename based search. */
             const char     *pszFilename = kLdrRdrName(pRdr);
-            const KSIZE     cchFilename = kLdrHlpStrLen(pszFilename);
+            const KSIZE     cchFilename = kHlpStrLen(pszFilename);
             PKLDRDYLDMOD    pCur;
             rc = KLDR_ERR_MODULE_NOT_FOUND;
@@ -914 +914 @@
             {
                 if (    pCur->pMod->cchFilename == cchFilename
-                    &&  !kLdrHlpMemComp(pCur->pMod->pszFilename, pszFilename, cchFilename))
+                    &&  !kHlpMemComp(pCur->pMod->pszFilename, pszFilename, cchFilename))
                 {
                     *ppMod = pCur;
@@ -926 +926 @@
     else
     {
-        const KSIZE     cchName = kLdrHlpStrLen(pszName);
-        const KSIZE     cchPrefix = pszPrefix ? kLdrHlpStrLen(pszPrefix) : 0;
-        const KSIZE     cchSuffix = pszSuffix ? kLdrHlpStrLen(pszSuffix) : 0;
-        const char     *pszNameSuffix = kldrHlpGetSuff(pszName);
+        const KSIZE     cchName = kHlpStrLen(pszName);
+        const KSIZE     cchPrefix = pszPrefix ? kHlpStrLen(pszPrefix) : 0;
+        const KSIZE     cchSuffix = pszSuffix ? kHlpStrLen(pszSuffix) : 0;
+        const char     *pszNameSuffix = kHlpGetSuff(pszName);
         PKLDRDYLDMOD    pCur = kLdrDyldHead;
 
@@ -942 +942 @@
         {
             const unsigned fNameHasSuffix = pszNameSuffix
-                                         && kLdrHlpStrLen(pszNameSuffix) == cchSuffix
-                                         && !kLdrHlpMemIComp(pszNameSuffix, pszName + cchName - cchSuffix, cchSuffix);
+                                         && kHlpStrLen(pszNameSuffix) == cchSuffix
+                                         && !kHlpMemIComp(pszNameSuffix, pszName + cchName - cchSuffix, cchSuffix);
             for (; pCur; pCur = pCur->Load.pNext)
             {
@@ -953 +953 @@
                 /* match name */
                 if (    pCur->pMod->cchName == cchName
-                    &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszName, cchName))
+                    &&  !kHlpMemIComp(pCur->pMod->pszName, pszName, cchName))
                     break;
                 if (cchPrefix)
                 {
                     if (    pCur->pMod->cchName == cchName + cchPrefix
-                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
-                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName))
+                        &&  !kHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
+                        &&  !kHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName))
                     break;
                 }
@@ -965 +965 @@
                 {
                     if (    pCur->pMod->cchName == cchName + cchSuffix
-                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchName, pszSuffix, cchSuffix)
-                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszName, cchName))
+                        &&  !kHlpMemIComp(pCur->pMod->pszName + cchName, pszSuffix, cchSuffix)
+                        &&  !kHlpMemIComp(pCur->pMod->pszName, pszName, cchName))
                     break;
                     if (    fNameHasSuffix
                         &&  pCur->pMod->cchName == cchName - cchSuffix
-                        &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszName, cchName - cchSuffix))
+                        &&  !kHlpMemIComp(pCur->pMod->pszName, pszName, cchName - cchSuffix))
                     break;
                     if (cchPrefix)
                     {
                         if (    pCur->pMod->cchName == cchName + cchPrefix + cchSuffix
-                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
-                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName)
-                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix + cchName, pszSuffix, cchSuffix))
+                            &&  !kHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
+                            &&  !kHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName)
+                            &&  !kHlpMemIComp(pCur->pMod->pszName + cchPrefix + cchName, pszSuffix, cchSuffix))
                         break;
                         if (    fNameHasSuffix
                             &&  pCur->pMod->cchName == cchName + cchPrefix - cchSuffix
-                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
-                            &&  !kLdrHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName - cchSuffix))
+                            &&  !kHlpMemIComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
+                            &&  !kHlpMemIComp(pCur->pMod->pszName + cchPrefix, pszName, cchName - cchSuffix))
                         break;
                     }
@@ -991 +991 @@
         {
             const unsigned fNameHasSuffix = pszNameSuffix
-                                         && kLdrHlpStrLen(pszNameSuffix) == cchSuffix
-                                         && kLdrHlpMemComp(pszNameSuffix, pszName + cchName - cchSuffix, cchSuffix);
+                                         && kHlpStrLen(pszNameSuffix) == cchSuffix
+                                         && kHlpMemComp(pszNameSuffix, pszName + cchName - cchSuffix, cchSuffix);
             for (; pCur; pCur = pCur->Load.pNext)
             {
@@ -1002 +1002 @@
                 /* match name */
                 if (    pCur->pMod->cchName == cchName
-                    &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszName, cchName))
+                    &&  !kHlpMemComp(pCur->pMod->pszName, pszName, cchName))
                     break;
                 if (cchPrefix)
                 {
                     if (    pCur->pMod->cchName == cchName + cchPrefix
-                        &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
-                        &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName))
+                        &&  !kHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
+                        &&  !kHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName))
                     break;
                 }
@@ -1014 +1014 @@
                 {
                     if (    pCur->pMod->cchName == cchName + cchSuffix
-                        &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchName, pszSuffix, cchSuffix)
-                        &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszName, cchName))
+                        &&  !kHlpMemComp(pCur->pMod->pszName + cchName, pszSuffix, cchSuffix)
+                        &&  !kHlpMemComp(pCur->pMod->pszName, pszName, cchName))
                     break;
                     if (    fNameHasSuffix
                         &&  pCur->pMod->cchName == cchName - cchSuffix
-                        &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszName, cchName - cchSuffix))
+                        &&  !kHlpMemComp(pCur->pMod->pszName, pszName, cchName - cchSuffix))
                     break;
                     if (cchPrefix)
                     {
                         if (    pCur->pMod->cchName == cchName + cchPrefix + cchSuffix
-                            &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
-                            &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName)
-                            &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix + cchName, pszSuffix, cchSuffix))
+                            &&  !kHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
+                            &&  !kHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName)
+                            &&  !kHlpMemComp(pCur->pMod->pszName + cchPrefix + cchName, pszSuffix, cchSuffix))
                         break;
                         if (    pCur->pMod->cchName == cchName + cchPrefix - cchSuffix
-                            &&  !kLdrHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
-                            &&  !kLdrHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName - cchSuffix))
+                            &&  !kHlpMemComp(pCur->pMod->pszName, pszPrefix, cchPrefix)
+                            &&  !kHlpMemComp(pCur->pMod->pszName + cchPrefix, pszName, cchName - cchSuffix))
                         break;
                     }

trunk/kStuff/kLdr/kLdrDyldMod.c

@@ -32 +32 @@
 #include <k/kLdr.h>
 #include "kLdrInternal.h"
-#include "kLdrHlp.h"
 
 
@@ -46 +45 @@
  */
 #ifdef KLDRDYLDMOD_STRICT
-# define KLDRDYLDMOD_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRDYLDMOD_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRDYLDMOD_ASSERT(expr)  do {} while (0)
@@ -120 +119 @@
      * Allocate a new dyld module.
      */
-    pMod = (PKLDRDYLDMOD)kldrHlpAlloc(sizeof(*pMod));
+    pMod = (PKLDRDYLDMOD)kHlpAlloc(sizeof(*pMod));
     if (pMod)
     {
@@ -282 +281 @@
         }
 
-        kldrHlpFree(pMod->papPrereqs);
+        kHlpFree(pMod->papPrereqs);
         pMod->papPrereqs = NULL;
         pMod->cPrereqs = 0;
@@ -305 +304 @@
         pMod->u32MagicHead = 1;
         pMod->u32MagicTail = 2;
-        kldrHlpFree(pMod);
+        kHlpFree(pMod);
     }
 }
@@ -490 +489 @@
         pMod->u32MagicHead = 1;
         pMod->u32MagicTail = 2;
-        kldrHlpFree(pMod);
+        kHlpFree(pMod);
     }
 }
@@ -757 +756 @@
      */
     cPrereqs = kLdrModNumberOfImports(pMod->pMod, NULL);
-    kldrHlpAssert(cPrereqs >= 0);
+    kHlpAssert(cPrereqs >= 0);
     if (pMod->cPrereqs != cPrereqs)
     {
         KLDRDYLDMOD_ASSERT(!pMod->papPrereqs);
-        pMod->papPrereqs = (PPKLDRDYLDMOD)kldrHlpAllocZ(sizeof(pMod->papPrereqs[0]) * cPrereqs);
+        pMod->papPrereqs = (PPKLDRDYLDMOD)kHlpAllocZ(sizeof(pMod->papPrereqs[0]) * cPrereqs);
         if (!pMod->papPrereqs)
             return KLDR_ERR_NO_MEMORY;
@@ -1149 +1148 @@
             /* check if there is a stack size override/default. */
             KSIZE cbDefOverride;
-            if (kldrHlpGetEnvUZ("KLDR_MAIN_STACK_SIZE", &cbDefOverride))
+            if (kHlpGetEnvUZ("KLDR_MAIN_STACK_SIZE", &cbDefOverride))
                 cbDefOverride = 0;
 
@@ -1235 +1234 @@
     if (cch)
     {
-        kLdrHlpMemCopy(pszName, pMod->pMod->pszName, cch - 1);
+        kHlpMemCopy(pszName, pMod->pMod->pszName, cch - 1);
         pszName[cch - 1] = '\0';
     }
@@ -1255 +1254 @@
     if (cch)
     {
-        kLdrHlpMemCopy(pszFilename, pMod->pMod->pszFilename, cch - 1);
+        kHlpMemCopy(pszFilename, pMod->pMod->pszFilename, cch - 1);
         pszFilename[cch - 1] = '\0';
     }
@@ -1280 +1279 @@
 
     rc = kLdrModQuerySymbol(pMod->pMod, NULL, KLDRMOD_BASEADDRESS_MAP,
-                            uSymbolOrdinal, pszSymbolName, kLdrHlpStrLen(pszSymbolName), NULL,
+                            uSymbolOrdinal, pszSymbolName, kHlpStrLen(pszSymbolName), NULL,
                             kldrDyldModFixupGetImportCallback, pMod,
                             &uValue, &fKind);

trunk/kStuff/kLdr/kLdrDyldOS.c

@@ -40 +40 @@
 
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
 
@@ -103 +102 @@
 
     TerminateProcess(GetCurrentProcess(), rc);
-    kldrHlpAssert(!"TerminateProcess failed");
+    kHlpAssert(!"TerminateProcess failed");
     for (;;)
         TerminateProcess(GetCurrentProcess(), rc);
@@ -118 +117 @@
 void kldrDyldDoLoadExeStackSwitch(PKLDRDYLDMOD pExe, void *pvStack, KSIZE cbStack)
 {
-    /*kldrHlpAssert(!"not implemented");*/
+    /*kHlpAssert(!"not implemented");*/
 
     /** @todo implement this properly! */

trunk/kStuff/kLdr/kLdrExeStub-win.c

@@ -31 +31 @@
 #include <k/kLdr.h>
 #include <Windows.h>
+#include "kLdrInternal.h"
 
 
@@ -52 +53 @@
 int WindowsMain(void)
 {
-    return kLdrDyldLoadExe(&g_Args, NULL);
+    kLdrDyldLoadExe(&g_Args, NULL);
+    /* won't happen */
+    return 0;
 }
 

trunk/kStuff/kLdr/kLdrHlp.h

@@ -1 @@
-/* $Id$ */
-/** @file
- *
- * kLdr - The Dynamic Loader, Helper Functions.
- *
- * Copyright (c) 2006 knut st. osmundsen <bird@anduin.net>
- *
- *
- * This file is part of kLdr.
- *
- * kLdr is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * kLdr is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with kLdr; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
-
-
-#ifndef __kLdrHlp_h__
-#define __kLdrHlp_h__
-
-/** @defgroup grp_kLdrHlp  kLdrHlp - Helper Functions
- * @internal
- * @{ */
-
-/*
- * Compiler specific helpers / CRT.
- * (I.e. operations that tend to have compiler intrinsic implementations).
- */
-#ifndef KLDR_USE_CRT
-
-# ifdef __GNUC__
-/** memchr */
-#  define kLdrHlpMemChr(a,b,c)  __builtin_memchr(a,b,c)
-/** memcmp */
-#  define kLdrHlpMemComp(a,b,c) __builtin_memcmp(a,b,c)
-/** memcpy */
-#  define kLdrHlpMemCopy(a,b,c) __builtin_memcpy(a,b,c)
-/** memmove */
-/*# define kLdrHlpMemMove(a,b,c) __builtin_memmove(a,b,c)*/
-#  define kLdrHlpMemMove_needed
-/** memset */
-#  define kLdrHlpMemSet(a,b,c)  __builtin_memset(a,b,c)
-/** strchr */
-#  define kLdrHlpStrChr(a, b)   __builtin_strchr(a, b)
-/** strcmp */
-#  define kLdrHlpStrComp(a, b)  __builtin_strcmp(a, b)
-/** strncmp */
-#  define kLdrHlpStrNComp(a,b,c) __builtin_strncmp(a, b, c)
-/** strlen */
-#  define kLdrHlpStrLen(a)      __builtin_strlen(a)
-/** alloca */
-#  define kLdrHlpAllocA(a)      __builtin_alloca(a)
-/** int3 */
-#  define kldrHlpBreakpoint() do { __asm__ __volatile__ ("int3\n\tnop"); } while (0)
-/** NULL */
-#  ifndef NULL
-#   define NULL 0
-#  endif
-# endif
-
-# ifdef _MSC_VER
-#  include <string.h>
-#  include <malloc.h>
-#  pragma intrinsic(memcmp, memcpy, memset, strcmp, strlen, __debugbreak)
-/** memchr */
-#  define kLdrHlpMemChr_needed
-/** memcmp */
-#  define kLdrHlpMemComp(a,b,c) memcmp(a,b,c)
-/** memcpy */
-#  define kLdrHlpMemCopy(a,b,c) memcpy(a,b,c)
-/** memmove */
-#  define kLdrHlpMemMove_needed
-/** memset */
-#  define kLdrHlpMemSet(a,b,c)  memset(a,b,c)
-/** strcmp */
-#  define kLdrHlpStrComp(a, b)  strcmp(a, b)
-/** strncmp */
-#  define kLdrHlpStrNComp_needed
-/** strlen */
-#  define kLdrHlpStrLen(a)      strlen(a)
-/** strchr */
-#  define kLdrHlpStrChr_needed
-/** alloca */
-#  define kLdrHlpAllocA(a)      alloca(a)
-/** int3 */
-#  define kldrHlpBreakpoint() __debugbreak()
-/** NULL */
-#  ifndef NULL
-#   define NULL 0
-#  endif
-# endif
-
-# ifdef kLdrHlpStrChr_needed
-char   *kLdrHlpStrChr(const char *psz, int ch);
-# endif
-# ifdef kLdrHlpStrChr_needed
-int     kLdrHlpStrNComp(const char *psz1, const char *psz2, KSIZE cch);
-# endif
-# ifdef kLdrHlpMemChr_needed
-void   *kLdrHlpMemChr(const void *pv, int ch, KSIZE cb);
-# endif
-# ifdef kLdrHlpMemMove_needed
-void   *kLdrHlpMemMove(void *pv1, const void *pv2, KSIZE cb);
-# endif
-
-
-#else /* KLDR_USE_CRT */
-
-#  include <string.h>
-#  include <stdlib.h>
-#  ifdef _MSC_VER
-#   include <malloc.h>
-#  endif
-
-#  define kLdrHlpMemChr(a,b,c)  memchr(a,b,c)
-/** memcmp */
-#  define kLdrHlpMemComp(a,b,c) memcmp(a,b,c)
-/** memcpy */
-#  define kLdrHlpMemCopy(a,b,c) memcpy(a,b,c)
-/** memmove */
-#  define kLdrHlpMemMove(a,b,c) memmove(a,b,c)
-/** memset */
-#  define kLdrHlpMemSet(a,b,c)  memset(a,b,c)
-/** strchr */
-#  define kLdrHlpStrChr(a, b)   strchr(a, b)
-/** strcmp */
-#  define kLdrHlpStrComp(a, b)  strcmp(a, b)
-/** strncmp */
-#  define kLdrHlpStrNComp(a,b,c) strncmp(a, b, c)
-/** strlen */
-#  define kLdrHlpStrLen(a)      strlen(a)
-/** alloca */
-#  define kLdrHlpAllocA(a)      alloca(a)
-/** int3 */
-#  ifdef __GNUC__
-#   define kldrHlpBreakpoint() do { __asm__ __volatile__ ("int3\n\tnop"); } while (0)
-#  endif
-#  ifdef _MSC_VER
-#   define kldrHlpBreakpoint() __debugbreak()
-#  endif
-
-#endif
-
-#if (!defined(kLdrHlpMemChr) && !defined(kLdrHlpStrChr_needed))\
- || !defined(kLdrHlpMemComp) \
- || !defined(kLdrHlpMemCopy) \
- || !defined(kLdrHlpMemSet) \
- || (!defined(kLdrHlpStrChr) && !defined(kLdrHlpStrChr_needed)) \
- || !defined(kLdrHlpStrComp) \
- || (!defined(kLdrHlpStrNComp) && !defined(kLdrHlpStrNComp_needed)) \
- || !defined(kLdrHlpStrLen) \
- || !defined(kLdrHlpAllocA) \
- || !defined(kldrHlpBreakpoint)
-# error "Needs porting to your compiler."
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-KSIZE   kLdrHlpStrNLen(const char *psz, KSIZE cchMax);
-int     kLdrHlpMemIComp(const void *pv1, const void *pv2, KSIZE cb);
-int     kLdrHlpStrIComp(const char *pv1, const char *pv2);
-
-int     kldrHlpSemInit(void);
-void    kldrHlpSemTerm(void);
-int     kldrHlpSemRequest(void);
-void    kldrHlpSemRelease(void);
-
-int     kldrHlpPageAlloc(void **ppv, KSIZE cb, KPROT enmProt, unsigned fFixed);
-int     kldrHlpPageProtect(void *pv, KSIZE cb, KPROT enmProt);
-int     kldrHlpPageFree(void *pv, KSIZE cb);
-
-int     kldrHlpHeapInit(void);
-void    kldrHlpHeapTerm(void);
-void    kldrHlpHeapDonate(void *pv, KSIZE cb);
-void *  kldrHlpAlloc(KSIZE cb);
-void *  kldrHlpAllocZ(KSIZE cb);
-void    kldrHlpFree(void *pv);
 
 int     kldrHlpGetEnv(const char *pszVar, char *pszVal, KSIZE cchVal);
 int     kldrHlpGetEnvUZ(const char *pszVar, KSIZE *pcb);
-char   *kldrHlpGetFilename(const char *pszFilename);
-char   *kldrHlpGetSuff(const char *pszFilename);
-char   *kldrHlpGetExt(const char *pszFilename);
-int     kldrHlpIsFilenameOnly(const char *pszFilename);
+
 void    kldrHlpExit(int rc);
 void    kldrHlpSleep(unsigned cMillies);
+
 char   *kldrHlpInt2Ascii(char *psz, KSIZE cch, long lVal, unsigned iBase);
-void    kldrHlpAssertMsg(const char *pszExpr, const char *pszFile, unsigned iLine, const char *pszFunction);
 
-#ifdef __cplusplus
-}
-#endif
-
-
-/** Assertion macro.
- * Users should wrap it since this is ALWAYS compiled in. */
-#define kldrHlpAssert(expr) \
-    do { \
-        if (!(expr)) \
-        { \
-            kldrHlpAssertMsg(#expr, __FILE__, __LINE__, __FUNCTION__); \
-            kldrHlpBreakpoint(); \
-        } \
-    } while (0)
-
-
-/** @name Parameter validation macros
- * @{ */
-
-/** Crash validation of a string argument. */
-#define KLDRHLP_VALIDATE_STRING(str) \
-    do { kLdrHlpStrLen(str); } while (0)
-
-/** Crash validation of an optional string argument. */
-#define KLDRHLP_VALIDATE_OPTIONAL_STRING(str) \
-    do { if (str) { KLDRHLP_VALIDATE_STRING(str); } } while (0)
-
-/** Return/Crash validation of an output buffer. */
-#define KLDRHLP_VALIDATE_BUFFER(buf, cb) \
-    do { \
-        if ((cb)) \
-        { \
-            KU8             __b; \
-            KU8 volatile *  __pb = (KU8 volatile *)(buf); \
-            KSIZE           __cbPage1 = 0x1000 - ((KUPTR)(__pb) & 0xfff); /* ASSUMES page size! */ \
-            __b = *__pb; *__pb = 0xff; *__pb = __b; \
-            if ((cb) > __cbPage1) \
-            { \
-                KSIZE   __cb = (cb) - __cbPage1; \
-                __pb -= __cbPage1; \
-                for (;;) \
-                { \
-                    __b = *__pb; *__pb = 0xff; *__pb = __b; \
-                    if (__cb < 0x1000) \
-                        break; \
-                    __pb += 0x1000; \
-                    __cb -= 0x1000; \
-                } \
-            } \
-        } \
-        else \
-            return KLDR_ERR_INVALID_PARAMETER; \
-    } while (0)
-
-/** Crash validation of an optional output buffer. */
-#define KLDRHLP_VALIDATE_OPTIONAL_BUFFER(buf, cb) \
-    do { \
-        if ((buf) != NULL && (cb) != 0) \
-        { \
-            KLDRHLP_VALIDATE_BUFFER(buf, cb); \
-        } \
-    } while (0)
-
-/** Return validation of an enum argument. */
-#define KLDRHLP_VALIDATE_ENUM(arg, enumname) \
-    do { \
-        if ((arg) <= enumname##_INVALID || (arg) >= enumname##_END) \
-        {  \
-            return KLDR_ERR_INVALID_PARAMETER; \
-        } \
-    } while (0)
-
-/** Return validation of a flags argument. */
-#define KLDRHLP_VALIDATE_FLAGS(arg, AllowedMask) \
-    do { \
-        if ((arg) & ~(AllowedMask)) \
-        {  \
-            return KLDR_ERR_INVALID_PARAMETER; \
-        } \
-    } while (0)
-
-/** @} */
-
-
-/** @} */
-
-#endif /* __kLdrHlp_h__ */
-

trunk/kStuff/kLdr/kLdrInternal.h

@@ -26 +26 @@
 
 
-#ifndef __kLdrInternal_h__
-#define __kLdrInternal_h__
+#ifndef ___kLdrInternal_h___
+#define ___kLdrInternal_h___
+
+#include <k/kHlp.h>
 
 #ifdef __cplusplus
@@ -442 +444 @@
 /** @} */
 
+
 /** @} */
 #ifdef __cplusplus

trunk/kStuff/kLdr/kLdrMisc.c

@@ -30 +30 @@
 *******************************************************************************/
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
 

trunk/kStuff/kLdr/kLdrMod.c

@@ -30 +30 @@
 *******************************************************************************/
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
 #include <k/kLdrFmts/mz.h>
@@ -53 +52 @@
  */
 #ifdef KLDRMOD_STRICT
-# define KLDRMOD_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRMOD_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRMOD_ASSERT(expr)  do {} while (0)
@@ -268 +267 @@
         *puValue = 0;
     if (pfKind)
-        KLDRHLP_VALIDATE_FLAGS(*pfKind, KLDRSYMKIND_REQ_SEGMENTED);
+        K_VALIDATE_FLAGS(*pfKind, KLDRSYMKIND_REQ_SEGMENTED);
     return pMod->pOps->pfnQuerySymbol(pMod, pvBits, BaseAddress, iSymbol, pchSymbol, cchSymbol, pszVersion,
                                       pfnGetForwarder, pvUser, puValue, pfKind);
@@ -292 +291 @@
 {
     KLDRMOD_VALIDATE(pMod);
-    KLDRHLP_VALIDATE_FLAGS(fFlags, KLDRMOD_ENUM_SYMS_FLAGS_ALL);
+    K_VALIDATE_FLAGS(fFlags, KLDRMOD_ENUM_SYMS_FLAGS_ALL);
     return pMod->pOps->pfnEnumSymbols(pMod, pvBits, BaseAddress, fFlags, pfnCallback, pvUser);
 }
@@ -653 +652 @@
 {
     KLDRMOD_VALIDATE(pMod);
-    KLDRHLP_VALIDATE_FLAGS(fAttachingOrDetaching, 1);
+    K_VALIDATE_FLAGS(fAttachingOrDetaching, 1);
     return pMod->pOps->pfnCallThread(pMod, uHandle, fAttachingOrDetaching);
 }

trunk/kStuff/kLdr/kLdrModLX.c

@@ -30 +30 @@
 *******************************************************************************/
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
 #include <k/kLdrFmts/lx.h>
@@ -46 +45 @@
  */
 #ifdef KLDRMODLX_STRICT
-# define KLDRMODLX_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRMODLX_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRMODLX_ASSERT(expr)  do {} while (0)
@@ -162 +161 @@
         return 0;
     }
-    kldrHlpFree(pModLX);
+    kHlpFree(pModLX);
     return rc;
 }
@@ -267 +266 @@
      * Calc the instance size, allocate and initialize it.
      */
-    cchFilename = kLdrHlpStrLen(kLdrRdrName(pRdr));
+    cchFilename = kHlpStrLen(kLdrRdrName(pRdr));
     cb = K_ALIGN_Z(sizeof(KLDRMODLX), 8)
        + K_ALIGN_Z(K_OFFSETOF(KLDRMOD, aSegments[Hdr.e32_objcnt + 1]), 8)
        + K_ALIGN_Z(cchFilename + 1, 8)
        + Hdr.e32_ldrsize + 2; /* +2 for two extra zeros. */
-    pModLX = (PKLDRMODLX)kldrHlpAlloc(cb);
+    pModLX = (PKLDRMODLX)kHlpAlloc(cb);
     if (!pModLX)
         return KLDR_ERR_NO_MEMORY;
@@ -285 +284 @@
     pMod->cchFilename = cchFilename;
     pMod->pszFilename = (char *)K_ALIGN_P(&pMod->aSegments[pMod->cSegments], 8);
-    kLdrHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
+    kHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
     pMod->pszName = NULL; /* finalized further down */
     pMod->cchName = 0;
@@ -387 +386 @@
         return KLDR_ERR_LX_NO_SONAME;
     pMod->cchName = *(const KU8 *)pMod->pszName++;
-    if (pMod->cchName != kLdrHlpStrLen(pMod->pszName))
+    if (pMod->cchName != kHlpStrLen(pMod->pszName))
         return KLDR_ERR_LX_BAD_SONAME;
 
@@ -533 +532 @@
     if (pModLX->pbNonResNameTab)
     {
-        kldrHlpFree(pModLX->pbNonResNameTab);
+        kHlpFree(pModLX->pbNonResNameTab);
         pModLX->pbNonResNameTab = NULL;
     }
     if (pModLX->pbFixupSection)
     {
-        kldrHlpFree(pModLX->pbFixupSection);
+        kHlpFree(pModLX->pbFixupSection);
         pModLX->pbFixupSection = NULL;
     }
     pMod->u32Magic = 0;
     pMod->pOps = NULL;
-    kldrHlpFree(pModLX);
+    kHlpFree(pModLX);
     return rc;
 }
@@ -789 +788 @@
 
         if (    cbName == cbSymbol8Bit
-            &&  !kLdrHlpMemComp(pbNameTable + 1, pchSymbol, cbName))
+            &&  !kHlpMemComp(pbNameTable + 1, pchSymbol, cbName))
             return pbNameTable;
 
@@ -937 +936 @@
     void *pv;
 
-    pv = kldrHlpAlloc(pModLX->Hdr.e32_fixupsize);
+    pv = kHlpAlloc(pModLX->Hdr.e32_fixupsize);
     if (!pv)
         return KLDR_ERR_NO_MEMORY;
@@ -962 +961 @@
     }
     else
-        kldrHlpFree(pv);
+        kHlpFree(pv);
     return rc;
 }
@@ -1208 +1207 @@
     if (*pb < cchName)
     {
-        kLdrHlpMemCopy(pszName, pb + 1, *pb);
+        kHlpMemCopy(pszName, pb + 1, *pb);
         pszName[*pb] = '\0';
         rc = 0;
@@ -1214 +1213 @@
     else
     {
-        kLdrHlpMemCopy(pszName, pb + 1, cchName);
+        kHlpMemCopy(pszName, pb + 1, cchName);
         if (cchName)
             pszName[cchName - 1] = '\0';
@@ -1345 +1344 @@
             return KLDR_ERR_ADDRESS_OVERFLOW;
     }
-    rc = kldrHlpPageAlloc(&pvBase, pModLX->cbMapped, KPROT_EXECUTE_READWRITE, fFixed);
+    rc = kHlpPageAlloc(&pvBase, pModLX->cbMapped, KPROT_EXECUTE_READWRITE, fFixed);
     if (rc)
         return rc;
@@ -1366 +1365 @@
     }
     else
-        kldrHlpPageFree(pvBase, pModLX->cbMapped);
+        kHlpPageFree(pvBase, pModLX->cbMapped);
     return rc;
 }
@@ -1413 +1412 @@
                         rc = kLdrRdrRead(pRdr, pbPage, pMap->o32_pagesize,
                                          pModLX->Hdr.e32_datapage + (pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift));
-                        kLdrHlpMemSet(pbPage + pMap->o32_pagesize, 0, OBJPAGELEN - pMap->o32_pagesize);
+                        kHlpMemSet(pbPage + pMap->o32_pagesize, 0, OBJPAGELEN - pMap->o32_pagesize);
                     }
                     else
@@ -1424 +1423 @@
                     if (!pbTmpPage)
                     {
-                        pbTmpPage = kldrHlpAlloc(OBJPAGELEN + 256);
+                        pbTmpPage = kHlpAlloc(OBJPAGELEN + 256);
                         if (!pbTmpPage)
                             break;
@@ -1440 +1439 @@
                     if (rc)
                         break;
-                    kLdrHlpMemSet(pbTmpPage + pMap->o32_pagesize, 0, 4);
+                    kHlpMemSet(pbTmpPage + pMap->o32_pagesize, 0, 4);
 
                     /* unpack it into the image page. */
@@ -1451 +1450 @@
                 case INVALID: /* we're probably not dealing correctly with INVALID pages... */
                 case ZEROED:
-                    kLdrHlpMemSet(pbPage, 0, OBJPAGELEN);
+                    kHlpMemSet(pbPage, 0, OBJPAGELEN);
                     break;
 
@@ -1468 +1467 @@
          */
         if (iPage < cPages)
-            kLdrHlpMemSet(pbPage, 0, (cPages - iPage) * OBJPAGELEN);
+            kHlpMemSet(pbPage, 0, (cPages - iPage) * OBJPAGELEN);
     }
 
     if (pbTmpPage)
-        kldrHlpFree(pbTmpPage);
+        kHlpFree(pbTmpPage);
     return rc;
 }
@@ -1513 +1512 @@
                 return KLDR_ERR_LX_BAD_ITERDATA;
 
-            kLdrHlpMemSet(pbDst, pIter->LX_Iterdata, pIter->LX_nIter);
+            kHlpMemSet(pbDst, pIter->LX_Iterdata, pIter->LX_nIter);
             pbDst += pIter->LX_nIter;
             pIter++;
@@ -1533 +1532 @@
 
             for (i = pIter->LX_nIter; i > 0; i--, pbDst += pIter->LX_nBytes)
-                kLdrHlpMemCopy(pbDst, &pIter->LX_Iterdata, pIter->LX_nBytes);
+                kHlpMemCopy(pbDst, &pIter->LX_Iterdata, pIter->LX_nBytes);
             pIter   = (struct LX_Iter *)((char*)pIter + 4 + pIter->LX_nBytes);
         }
@@ -1542 +1541 @@
      */
     if (cbDst > 0)
-        kLdrHlpMemSet(pbDst, 0, cbDst);
+        kHlpMemSet(pbDst, 0, cbDst);
 
     return 0;
@@ -1599 +1598 @@
                     if (cbSrc < 0)
                         return KLDR_ERR_LX_BAD_ITERDATA2;
-                    kLdrHlpMemCopy(pbDst, ++pbSrc, cb);
+                    kHlpMemCopy(pbDst, ++pbSrc, cb);
                     pbDst += cb;
                     pbSrc += cb;
@@ -1616 +1615 @@
                     if (cbSrc < 0)
                         return KLDR_ERR_LX_BAD_ITERDATA2;
-                    kLdrHlpMemSet(pbDst, pbSrc[2], cb);
+                    kHlpMemSet(pbDst, pbSrc[2], cb);
                     pbDst += cb;
                     pbSrc += 3;
@@ -1652 +1651 @@
                     if (cbDst < 0)
                         return KLDR_ERR_LX_BAD_ITERDATA2;
-                    kLdrHlpMemCopy(pbDst, pbSrc, cb1);
+                    kHlpMemCopy(pbDst, pbSrc, cb1);
                     pbDst += cb1;
                     pbSrc += cb1;
@@ -1661 +1660 @@
                     if (cbDst < 0)
                         return KLDR_ERR_LX_BAD_ITERDATA2;
-                    kLdrHlpMemMove(pbDst, pbDst - off, cb2);
+                    kHlpMemMove(pbDst, pbDst - off, cb2);
                     pbDst += cb2;
                 }
@@ -1733 +1732 @@
                     if (cbDst < 0)
                         return KLDR_ERR_LX_BAD_ITERDATA2;
-                    kLdrHlpMemCopy(pbDst, pbSrc, cb1);
+                    kHlpMemCopy(pbDst, pbSrc, cb1);
                     pbDst += cb1;
                     pbSrc += cb1;
@@ -1757 +1756 @@
      */
     if (cbDst > 0)
-        kLdrHlpMemSet(pbDst, 0, cbDst);
+        kHlpMemSet(pbDst, 0, cbDst);
 
     return 0;
@@ -1867 +1866 @@
         pv = (KU8 *)pvBits + pMod->aSegments[i].RVA;
 
-        rc = kldrHlpPageProtect(pv, pMod->aSegments[i].cbMapped, enmProt);
+        rc = kHlpPageProtect(pv, pMod->aSegments[i].cbMapped, enmProt);
         if (rc)
             break;
@@ -1894 +1893 @@
      * Free the mapping and update the segments.
      */
-    rc = kldrHlpPageFree((void *)pModLX->pvMapping, pModLX->cbMapped);
+    rc = kHlpPageFree((void *)pModLX->pvMapping, pModLX->cbMapped);
     KLDRMODLX_ASSERT(!rc);
     pModLX->pvMapping = NULL;

trunk/kStuff/kLdr/kLdrModMachO.c

@@ -30 +30 @@
 *******************************************************************************/
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
 #include <k/kLdrFmts/mach-o.h>
@@ -46 +45 @@
  */
 #ifdef KLDRMODMACHO_STRICT
-# define KLDRMODMACHO_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRMODMACHO_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRMODMACHO_ASSERT(expr)  do {} while (0)
@@ -215 +214 @@
     if (pModMachO)
     {
-        kldrHlpFree(pModMachO->pbLoadCommands);
-        kldrHlpFree(pModMachO);
+        kHlpFree(pModMachO->pbLoadCommands);
+        kHlpFree(pModMachO);
     }
     return rc;
@@ -279 +278 @@
      * Read and pre-parse the load commands to figure out how many segments we'll be needing.
      */
-    pbLoadCommands = kldrHlpAlloc(s.Hdr32.sizeofcmds);
+    pbLoadCommands = kHlpAlloc(s.Hdr32.sizeofcmds);
     if (!pbLoadCommands)
         return KLDR_ERR_NO_MEMORY;
@@ -290 +289 @@
     if (rc)
     {
-        kldrHlpFree(pbLoadCommands);
+        kHlpFree(pbLoadCommands);
         return rc;
     }
@@ -298 +297 @@
      * Calc the instance size, allocate and initialize it.
      */
-    cchFilename = kLdrHlpStrLen(kLdrRdrName(pRdr));
+    cchFilename = kHlpStrLen(kLdrRdrName(pRdr));
     cb = K_ALIGN_Z(  K_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
                       + sizeof(KLDRMODMACHOSECT) * cSections, 16)
@@ -304 +303 @@
        + cchFilename + 1
        + cbStringPool;
-    pModMachO = (PKLDRMODMACHO)kldrHlpAlloc(cb);
+    pModMachO = (PKLDRMODMACHO)kHlpAlloc(cb);
     if (!pModMachO)
         return KLDR_ERR_NO_MEMORY;
@@ -319 +318 @@
     pMod->cchFilename = cchFilename;
     pMod->pszFilename = (char *)&pMod->aSegments[pMod->cSegments];
-    kLdrHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
-    pMod->pszName = kldrHlpGetFilename(pMod->pszFilename);
+    kHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
+    pMod->pszName = kHlpGetFilename(pMod->pszFilename);
     pMod->cchName = cchFilename - (pMod->pszName - pMod->pszFilename);
     switch (s.Hdr32.cputype)
@@ -619 +618 @@
                             /* a new segment? */
                             if (    !cSegments
-                                ||  kLdrHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
+                                ||  kHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
                             {
 #if 0 /** @todo This  doesn't work because of BSS. */
@@ -626 +625 @@
                                 while ((KUPTR)pCur >= (KUPTR)pFirstSect)
                                 {
-                                    if (!kLdrHlpStrNComp(pCur->segname, pSect->segname, sizeof(pSect->segname)))
+                                    if (!kHlpStrNComp(pCur->segname, pSect->segname, sizeof(pSect->segname)))
                                         return KLDR_ERR_MACHO_BAD_SECTION_ORDER;
                                     pCur--;
@@ -634 +633 @@
                                 /* ok. count it and the string. */
                                 cSegments++;
-                                cbStringPool += kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->segname)) + 1;
+                                cbStringPool += kHlpStrNLen(&pSect->segname[0], sizeof(pSect->segname)) + 1;
                             }
                             break;
@@ -858 +857 @@
 
                             if (    fFirstSegment
-                                ||  kLdrHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
+                                ||  kHlpStrNComp(pSect->segname, (pSect - 1)->segname, sizeof(pSect->segname)))
                             {
                                 /* close the previous segment */
@@ -867 +866 @@
                                 pSeg->pvUser = NULL;
                                 pSeg->pchName = pbStringPool;
-                                pSeg->cchName = (KU32)kLdrHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
-                                kLdrHlpMemCopy(pbStringPool, &pSect->segname[0], pSeg->cchName);
+                                pSeg->cchName = (KU32)kHlpStrNLen(&pSect->segname[0], sizeof(pSect->sectname));
+                                kHlpMemCopy(pbStringPool, &pSect->segname[0], pSeg->cchName);
                                 pbStringPool += pSeg->cchName;
                                 *pbStringPool++ = '\0';
@@ -1002 +1001 @@
         while (j-- > 0)
         {
-            kldrHlpFree(pModMachO->aSegments[i].paSections[j].paFixups);
+            kHlpFree(pModMachO->aSegments[i].paSections[j].paFixups);
             pModMachO->aSegments[i].paSections[j].paFixups = NULL;
         }
@@ -1014 +1013 @@
     pMod->u32Magic = 0;
     pMod->pOps = NULL;
-    kldrHlpFree(pModMachO->pbLoadCommands);
+    kHlpFree(pModMachO->pbLoadCommands);
     pModMachO->pbLoadCommands = NULL;
-    kldrHlpFree(pModMachO->pchStrings);
+    kHlpFree(pModMachO->pchStrings);
     pModMachO->pchStrings = NULL;
-    kldrHlpFree(pModMachO->pvaSymbols);
+    kHlpFree(pModMachO->pvaSymbols);
     pModMachO->pvaSymbols = NULL;
-    kldrHlpFree(pModMachO);
+    kHlpFree(pModMachO);
     return rc;
 }
@@ -1152 +1151 @@
             if (psz[cchSymbol])
                 continue;
-            if (kLdrHlpMemComp(psz, pchSymbol, cchSymbol))
+            if (kHlpMemComp(psz, pchSymbol, cchSymbol))
                 continue;
 
@@ -1325 +1324 @@
             return KLDR_ERR_MACHO_BAD_SYMBOL;
         psz = &pchStrings[paSyms[iSym].n_un.n_strx];
-        cch = kLdrHlpStrLen(psz);
+        cch = kHlpStrLen(psz);
         if (!cch)
             psz = NULL;
@@ -1757 +1756 @@
                     return KLDR_ERR_MACHO_BAD_SYMBOL;
                 pszSymbol = &pModMachO->pchStrings[paSyms[iSym].n_un.n_strx];
-                cchSymbol = kLdrHlpStrLen(pszSymbol);
+                cchSymbol = kHlpStrLen(pszSymbol);
                 rc = pfnGetImport(pModMachO->pMod, NIL_KLDRMOD_IMPORT, iSym, pszSymbol, cchSymbol, NULL,
                                   &Value, &fKind, pvUser);
@@ -1808 +1807 @@
                     return KLDR_ERR_MACHO_BAD_SYMBOL;
                 pszSymbol = &pModMachO->pchStrings[paSyms[iSym].n_un.n_strx];
-                cchSymbol = kLdrHlpStrLen(pszSymbol);
+                cchSymbol = kHlpStrLen(pszSymbol);
                 rc = pfnGetImport(pModMachO->pMod, NIL_KLDRMOD_IMPORT, iSym, pszSymbol, cchSymbol, NULL,
                                   &Value, &fKind, pvUser);
@@ -2142 +2141 @@
             return KLDR_ERR_SIZE_OVERFLOW;
         rc = KLDR_ERR_NO_MEMORY;
-        pvSyms = kldrHlpAlloc(cbSyms);
+        pvSyms = kHlpAlloc(cbSyms);
         if (pvSyms)
         {
             if (pModMachO->cchStrings)
-                pvStrings = kldrHlpAlloc(pModMachO->cchStrings);
+                pvStrings = kHlpAlloc(pModMachO->cchStrings);
             else
-                pvStrings = kldrHlpAllocZ(4);
+                pvStrings = kHlpAllocZ(4);
             if (pvStrings)
             {
@@ -2188 +2187 @@
                     return 0;
                 }
-                kldrHlpFree(pvStrings);
+                kHlpFree(pvStrings);
             }
-            kldrHlpFree(pvSyms);
+            kHlpFree(pvSyms);
         }
     }
@@ -2220 +2219 @@
     if (cbFixups / sizeof(*paFixups) != cFixups)
         return KLDR_ERR_SIZE_OVERFLOW;
-    paFixups = (macho_relocation_info_t *)kldrHlpAlloc(cbFixups);
+    paFixups = (macho_relocation_info_t *)kHlpAlloc(cbFixups);
     if (!paFixups)
         return KLDR_ERR_NO_MEMORY;
@@ -2244 +2243 @@
     }
     else
-        kldrHlpFree(paFixups);
+        kHlpFree(paFixups);
     return rc;
 }
@@ -2306 +2305 @@
      * Zero the entire buffer first to simplify things.
      */
-    kLdrHlpMemSet(pvBits, 0, (KSIZE)pModMachO->cbImage);
+    kHlpMemSet(pvBits, 0, (KSIZE)pModMachO->cbImage);
 
     /*

trunk/kStuff/kLdr/kLdrModNative.c

@@ -30 +30 @@
 *******************************************************************************/
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
 #ifdef __OS2__
@@ -81 +80 @@
  */
 #ifdef KLDRMODNATIVE_STRICT
-# define KLDRMODNATIVE_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRMODNATIVE_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRMODNATIVE_ASSERT(expr)  do {} while (0)
@@ -300 +299 @@
      * Calc the instance size, allocate and initialize it.
      */
-    cchFilename = kLdrHlpStrLen(szFilename);
+    cchFilename = kHlpStrLen(szFilename);
     cb = K_ALIGN_Z(sizeof(KLDRMODNATIVE), 16)
        + K_OFFSETOF(KLDRMOD, aSegments[cSegments])
        + cchFilename + 1;
-    pModNative = (PKLDRMODNATIVE)kldrHlpAlloc(cb);
+    pModNative = (PKLDRMODNATIVE)kHlpAlloc(cb);
     if (!pModNative)
         return KLDR_ERR_NO_MEMORY;
@@ -316 +315 @@
     pMod->cchFilename = cchFilename;
     pMod->pszFilename = (char *)&pMod->aSegments[pMod->cSegments];
-    kLdrHlpMemCopy((char *)pMod->pszFilename, szFilename, cchFilename + 1);
-    pMod->pszName = kldrHlpGetFilename(pMod->pszFilename); /** @todo get soname */
+    kHlpMemCopy((char *)pMod->pszFilename, szFilename, cchFilename + 1);
+    pMod->pszName = kHlpGetFilename(pMod->pszFilename); /** @todo get soname */
     pMod->cchName = cchFilename - (pMod->pszName - pMod->pszFilename);
 #if defined(__i386__) || defined(__X86__) || defined(_M_IX86)
@@ -492 +491 @@
             case IMAGE_SCN_ALIGN_4096BYTES:     pMod->aSegments[i + 1].Alignment = 4096; break;
             case IMAGE_SCN_ALIGN_8192BYTES:     pMod->aSegments[i + 1].Alignment = 8192; break;
-            default: kldrHlpAssert(0);          pMod->aSegments[i + 1].Alignment = 0; break;
+            default: kHlpAssert(0);          pMod->aSegments[i + 1].Alignment = 0; break;
         }
     }
@@ -535 +534 @@
     pMod->u32Magic = 0;
     pMod->pOps = NULL;
-    kldrHlpFree(pModNative);
+    kHlpFree(pModNative);
     return rc;
 }
@@ -561 +560 @@
     if (pszSymbol && pszSymbol[cchSymbol])
     {
-        char *pszCopy = kLdrHlpAllocA(cchSymbol + 1);
-        kLdrHlpMemCopy(pszCopy, pchSymbol, cchSymbol);
+        char *pszCopy = kHlpAllocA(cchSymbol + 1);
+        kHlpMemCopy(pszCopy, pchSymbol, cchSymbol);
         pszCopy[cchSymbol] = '\0';
         pszSymbol = pszCopy;
@@ -756 +755 @@
                                       const IMAGE_IMPORT_DESCRIPTOR *);
     pszImportName = KLDRMODNATIVE_RVA2TYPE(pModNative->hmod, pImpDesc->Name, const char *);
-    cchImportName = kLdrHlpStrLen(pszImportName);
+    cchImportName = kHlpStrLen(pszImportName);
     if (cchImportName < cchName)
     {
-        kLdrHlpMemCopy(pszName, pszImportName, cchImportName + 1);
+        kHlpMemCopy(pszName, pszImportName, cchImportName + 1);
         rc = 0;
     }
     else
     {
-        kLdrHlpMemCopy(pszName, pszImportName, cchName);
+        kHlpMemCopy(pszName, pszImportName, cchName);
         if (cchName)
             pszName[cchName - 1] = '\0';

trunk/kStuff/kLdr/kLdrModPE.c

@@ -30 +30 @@
 *******************************************************************************/
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 #include "kLdrInternal.h"
 #include <k/kLdrFmts/pe.h>
@@ -46 +45 @@
  */
 #ifdef KLDRMODPE_STRICT
-# define KLDRMODPE_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRMODPE_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRMODPE_ASSERT(expr)  do {} while (0)
@@ -151 +150 @@
         return 0;
     }
-    kldrHlpFree(pModPE);
+    kHlpFree(pModPE);
     return rc;
 }
@@ -200 +199 @@
      * Calc the instance size, allocate and initialize it.
      */
-    cchFilename = kLdrHlpStrLen(kLdrRdrName(pRdr));
+    cchFilename = kHlpStrLen(kLdrRdrName(pRdr));
     cb = K_ALIGN_Z(K_OFFSETOF(KLDRMODPE, aShdrs[s.FileHdr.NumberOfSections]), 16)
        + K_OFFSETOF(KLDRMOD, aSegments[s.FileHdr.NumberOfSections + 1])
        + cchFilename + 1;
-    pModPE = (PKLDRMODPE)kldrHlpAlloc(cb);
+    pModPE = (PKLDRMODPE)kHlpAlloc(cb);
     if (!pModPE)
         return KLDR_ERR_NO_MEMORY;
@@ -217 +216 @@
     pMod->cchFilename = cchFilename;
     pMod->pszFilename = (char *)&pMod->aSegments[pMod->cSegments];
-    kLdrHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
-    pMod->pszName = kldrHlpGetFilename(pMod->pszFilename);
+    kHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
+    pMod->pszName = kHlpGetFilename(pMod->pszFilename);
     pMod->cchName = cchFilename - (pMod->pszName - pMod->pszFilename);
     switch (s.FileHdr.Machine)
@@ -234 +233 @@
             break;
         default:
-            kldrHlpAssert(0);
+            kHlpAssert(0);
             break;
     }
@@ -410 +409 @@
             case IMAGE_SCN_ALIGN_4096BYTES:     pMod->aSegments[i + 1].Alignment = 4096; break;
             case IMAGE_SCN_ALIGN_8192BYTES:     pMod->aSegments[i + 1].Alignment = 8192; break;
-            default: kldrHlpAssert(0);          pMod->aSegments[i + 1].Alignment = 0; break;
+            default: kHlpAssert(0);          pMod->aSegments[i + 1].Alignment = 0; break;
         }
     }
@@ -536 +535 @@
     pMod->u32Magic = 0;
     pMod->pOps = NULL;
-    kldrHlpFree(pModPE);
+    kHlpFree(pModPE);
     return rc;
 }
@@ -751 +750 @@
                 {
                     pszName = KLDRMODPE_RVA2TYPE(pvBits, paRVANames[i], const char *);
-                    KLDRMODPE_ASSERT(kLdrHlpStrNComp(pszName, pchSymbol, cchSymbol) || pszName[cchSymbol]);
-                    KLDRMODPE_ASSERT(i == 0 || kLdrHlpStrComp(pszName, KLDRMODPE_RVA2TYPE(pvBits, paRVANames[i - 1], const char *)));
+                    KLDRMODPE_ASSERT(kHlpStrNComp(pszName, pchSymbol, cchSymbol) || pszName[cchSymbol]);
+                    KLDRMODPE_ASSERT(i == 0 || kHlpStrComp(pszName, KLDRMODPE_RVA2TYPE(pvBits, paRVANames[i - 1], const char *)));
                 }
 #endif
@@ -760 +759 @@
             i = (iEnd - iStart) / 2 + iStart;
             pszName = KLDRMODPE_RVA2TYPE(pvBits, paRVANames[i - 1], const char *);
-            diff = kLdrHlpStrNComp(pszName, pchSymbol, cchSymbol);
+            diff = kHlpStrNComp(pszName, pchSymbol, cchSymbol);
             if (!diff)
                 diff = pszName[cchSymbol] - 0;
@@ -903 +902 @@
     {
         const char *pszName = KLDRMODPE_RVA2TYPE(pvBits, paImpDir[iImpModule].Name, const char *);
-        KSIZE       cchName = kLdrHlpStrLen(pszName);
+        KSIZE       cchName = kHlpStrLen(pszName);
         if (    (   cchName == cchImpModule
                  || (   cchName > cchImpModule
@@ -911 +910 @@
                      && (pszName[cchImpModule + 3] == 'l' || pszName[cchImpModule + 3] == 'L'))
                 )
-            &&  kLdrHlpMemIComp(pszName, pszForwarder, cchImpModule)
+            &&  kHlpMemIComp(pszName, pszForwarder, cchImpModule)
            )
         {
@@ -918 +917 @@
              */
             rc = pfnGetForwarder(pModPE->pMod, iImpModule, iSymbol, pszSymbol,
-                                 pszSymbol ? kLdrHlpStrLen(pszSymbol) : 0, NULL, puValue, pfKind, pvUser);
+                                 pszSymbol ? kHlpStrLen(pszSymbol) : 0, NULL, puValue, pfKind, pvUser);
             if (!rc && pfKind)
                 *pfKind |= KLDRSYMKIND_FORWARDER;
@@ -989 +988 @@
             fFoundName = 1;
             pszName = KLDRMODPE_RVA2TYPE(pvBits, paRVANames[iName], const char *);
-            rc = pfnCallback(pMod, iFunction + pExpDir->Base, pszName, kLdrHlpStrLen(pszName), NULL,
+            rc = pfnCallback(pMod, iFunction + pExpDir->Base, pszName, kHlpStrLen(pszName), NULL,
                              uValue, fKind, pvUser);
             if (rc)
@@ -1040 +1039 @@
                                   const IMAGE_IMPORT_DESCRIPTOR *);
     pszImportName = KLDRMODPE_RVA2TYPE(pvBits, pImpDesc->Name, const char *);
-    cchImportName = kLdrHlpStrLen(pszImportName);
+    cchImportName = kHlpStrLen(pszImportName);
     if (cchImportName < cchName)
     {
-        kLdrHlpMemCopy(pszName, pszImportName, cchImportName + 1);
+        kHlpMemCopy(pszName, pszImportName, cchImportName + 1);
         rc = 0;
     }
     else
     {
-        kLdrHlpMemCopy(pszName, pszImportName, cchName);
+        kHlpMemCopy(pszName, pszImportName, cchName);
         if (cchName)
             pszName[cchName - 1] = '\0';
@@ -1594 +1593 @@
                 const IMAGE_IMPORT_BY_NAME *pName = KLDRMODPE_RVA2TYPE(pvMapping, pThunk->u1.Ordinal, const IMAGE_IMPORT_BY_NAME *);
                 rc = pfnGetImport(pMod, iImp, NIL_KLDRMOD_SYM_ORDINAL, (const char *)pName->Name,
-                                  kLdrHlpStrLen((const char *)pName->Name), NULL, &Value, &fKind, pvUser);
+                                  kHlpStrLen((const char *)pName->Name), NULL, &Value, &fKind, pvUser);
             }
             else
@@ -1662 +1661 @@
                 const IMAGE_IMPORT_BY_NAME *pName = KLDRMODPE_RVA2TYPE(pvMapping, pThunk->u1.Ordinal, const IMAGE_IMPORT_BY_NAME *);
                 rc = pfnGetImport(pMod, iImp, NIL_KLDRMOD_SYM_ORDINAL, (const char *)pName->Name,
-                                  kLdrHlpStrLen((const char *)pName->Name), NULL, &Value, &fKind, pvUser);
+                                  kHlpStrLen((const char *)pName->Name), NULL, &Value, &fKind, pvUser);
             }
             else
@@ -1902 +1901 @@
      * Zero the entire buffer first to simplify things.
      */
-    kLdrHlpMemSet(pvBits, 0, pModPE->Hdrs.OptionalHeader.SizeOfImage);
+    kHlpMemSet(pvBits, 0, pModPE->Hdrs.OptionalHeader.SizeOfImage);
 
     /*

trunk/kStuff/kLdr/kLdrRdr.c

@@ -44 +44 @@
  */
 #ifdef KLDRRDR_STRICT
-# define KLDRRDR_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRRDR_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRRDR_ASSERT(expr)  do {} while (0)

trunk/kStuff/kLdr/kLdrRdrFile.c

@@ -153 +153 @@
 
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
 
 
@@ -167 +166 @@
  */
 #ifdef KLDRRDRFILE_STRICT
-# define KLDRRDRFILE_ASSERT(expr)  kldrHlpAssert(expr)
+# define KLDRRDRFILE_ASSERT(expr)  kHlpAssert(expr)
 #else
 # define KLDRRDRFILE_ASSERT(expr)  do {} while (0)
@@ -377 +376 @@
 {
     kldrRdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 1 /* unprotect */);
-    return kldrHlpPageFree(pPrep->pv, pPrep->cb);
+    return kHlpPageFree(pPrep->pv, pPrep->cb);
 }
 
@@ -452 +451 @@
         pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
 
-        rc = kldrHlpPageProtect(pv, paSegments[i].cbMapped, enmProt);
+        rc = kHlpPageProtect(pv, paSegments[i].cbMapped, enmProt);
         if (rc)
             break;
@@ -502 +501 @@
      */
     /** @todo only zero the areas not covered by raw file bits. */
-    kLdrHlpMemSet(pPrep->pv, 0, pPrep->cb);
+    kHlpMemSet(pPrep->pv, 0, pPrep->cb);
 
     /*
@@ -769 +768 @@
 
     /*
-     * Generic mapping code using kldrHlpPageAlloc(), kldrHlpPageFree() and kldrHlpPageProtect().
-     */
-    rc = kldrHlpPageAlloc(&pPrep->pv, pPrep->cb, KPROT_EXECUTE_READWRITE, fFixed);
+     * Generic mapping code using kHlpPageAlloc(), kHlpPageFree() and kHlpPageProtect().
+     */
+    rc = kHlpPageAlloc(&pPrep->pv, pPrep->cb, KPROT_EXECUTE_READWRITE, fFixed);
     if (rc)
         return rc;
@@ -804 +803 @@
 
     /* bailout */
-    kldrHlpPageFree(pPrep->pv, pPrep->cb);
+    kHlpPageFree(pPrep->pv, pPrep->cb);
     return rc;
 }
@@ -896 +895 @@
     if (!--pRdrFile->cMappings)
     {
-        kldrHlpFree(pRdrFile->pvMapping);
+        kHlpFree(pRdrFile->pvMapping);
         pRdrFile->pvMapping = NULL;
     }
@@ -917 +916 @@
         KLDRFOFF cb = pRdrFile->Core.pOps->pfnSize(pRdr);
 
-        pRdrFile->pvMapping = kldrHlpAlloc(cb);
+        pRdrFile->pvMapping = kHlpAlloc(cb);
         if (!pRdrFile->pvMapping)
 #if defined(__OS2__) || defined(__WIN__)
@@ -927 +926 @@
         if (rc)
         {
-            kldrHlpFree(pRdrFile->pvMapping);
+            kHlpFree(pRdrFile->pvMapping);
             pRdrFile->pvMapping = NULL;
             return rc;
@@ -1047 +1046 @@
     if (pRdrFile->pvMapping)
     {
-        kldrHlpFree(pRdrFile->pvMapping);
+        kHlpFree(pRdrFile->pvMapping);
         pRdrFile->pvMapping = NULL;
     }
 
-    kldrHlpFree(pRdr);
+    kHlpFree(pRdr);
     return rc;
 }
@@ -1076 +1075 @@
     {
         char *psz;
-        cchFilename = kLdrHlpStrLen(szFilename);
-        psz = (char *)kLdrHlpAllocA(cchFilename + 1);
-        kLdrHlpMemCopy(psz, pszFilename, cchFilename + 1);
+        cchFilename = kHlpStrLen(szFilename);
+        psz = (char *)kHlpAllocA(cchFilename + 1);
+        kHlpMemCopy(psz, pszFilename, cchFilename + 1);
         pszFilename = psz;
     }
@@ -1147 +1146 @@
      * Allocate the reader instance.
      */
-    cchFilename = kLdrHlpStrLen(szFilename);
-    pRdrFile = (PKLDRRDRFILE)kldrHlpAlloc(sizeof(*pRdrFile) + cchFilename);
+    cchFilename = kHlpStrLen(szFilename);
+    pRdrFile = (PKLDRRDRFILE)kHlpAlloc(sizeof(*pRdrFile) + cchFilename);
     if (!pRdrFile)
 #if defined(__OS2__)
@@ -1174 +1173 @@
     pRdrFile->cMappings = 0;
     pRdrFile->cPreps = 0;
-    kLdrHlpMemCopy(&pRdrFile->szFilename[0], szFilename, cchFilename + 1);
+    kHlpMemCopy(&pRdrFile->szFilename[0], szFilename, cchFilename + 1);
 
     *ppRdr = &pRdrFile->Core;

trunk/kStuff/kLdr/tstkLdrHeap.c

@@ -30 +30 @@
 *******************************************************************************/
 #include <k/kLdr.h>
-#include "kLdrHlp.h"
+#include <k/kHlp.h>
 
 #include <stdio.h>
@@ -44 +44 @@
 
 #define CHECK(expr) \
-    do { if (!(expr)) { printf("tstkLdrHeap(%d): ERROR - %s\n", __LINE__, #expr); cErrors++; kldrHlpBreakpoint();} \
+    do { if (!(expr)) { printf("tstkLdrHeap(%d): ERROR - %s\n", __LINE__, #expr); cErrors++; kHlpAssertBreakpoint();} \
     } while (0)
 
@@ -72 +72 @@
 
 #if 0
-# define kldrHlpAlloc(a) malloc(a)
-# define kldrHlpFree(a) free(a)
+# define kHlpAlloc(a) malloc(a)
+# define kHlpFree(a) free(a)
 #endif
 
@@ -93 +93 @@
      * Some simple init / term.
      */
-    rc = kldrHlpHeapInit();
-    CHECK_FATAL(!rc);
-    kldrHlpHeapTerm();
-
-    rc = kldrHlpHeapInit();
-    CHECK_FATAL(!rc);
-    kldrHlpHeapTerm();
+    rc = kHlpHeapInit();
+    CHECK_FATAL(!rc);
+    kHlpHeapTerm();
+
+    rc = kHlpHeapInit();
+    CHECK_FATAL(!rc);
+    kHlpHeapTerm();
 
 
@@ -105 +105 @@
      * Simple alloc all, free all in FIFO order.
      */
-    rc = kldrHlpHeapInit();
+    rc = kHlpHeapInit();
     CHECK_FATAL(!rc);
 
@@ -112 +112 @@
     {
         s_aAllocs[i].cb = RandSize();
-        s_aAllocs[i].pv = kldrHlpAlloc(s_aAllocs[i].cb);
+        s_aAllocs[i].pv = kHlpAlloc(s_aAllocs[i].cb);
         CHECK(s_aAllocs[i].pv);
     }
@@ -118 +118 @@
     /* 2. free all slots. */
     for (i = 0; i < MAX_ALLOCS; i++)
-        kldrHlpFree(s_aAllocs[i].pv);
+        kHlpFree(s_aAllocs[i].pv);
 
     /* terminate */
-    kldrHlpHeapTerm();
+    kHlpHeapTerm();
 
 
@@ -127 +127 @@
      * Simple alloc all, free all in LIFO order.
      */
-    rc = kldrHlpHeapInit();
+    rc = kHlpHeapInit();
     CHECK_FATAL(!rc);
 
@@ -134 +134 @@
     {
         s_aAllocs[i].cb = RandSize();
-        s_aAllocs[i].pv = kldrHlpAlloc(s_aAllocs[i].cb);
+        s_aAllocs[i].pv = kHlpAlloc(s_aAllocs[i].cb);
         CHECK(s_aAllocs[i].pv);
     }
@@ -141 +141 @@
     i = MAX_ALLOCS;
     while (i-- > 0)
-        kldrHlpFree(s_aAllocs[i].pv);
+        kHlpFree(s_aAllocs[i].pv);
 
     /* terminate */
-    kldrHlpHeapTerm();
+    kHlpHeapTerm();
 
 
@@ -150 +150 @@
      * Bunch of allocations, free half, allocate and free in pairs, free all.
      */
-    rc = kldrHlpHeapInit();
+    rc = kHlpHeapInit();
     CHECK_FATAL(!rc);
 
@@ -157 +157 @@
     {
         s_aAllocs[i].cb = RandSize();
-        s_aAllocs[i].pv = kldrHlpAlloc(s_aAllocs[i].cb);
+        s_aAllocs[i].pv = kHlpAlloc(s_aAllocs[i].cb);
         CHECK(s_aAllocs[i].pv);
     }
@@ -166 +166 @@
     {
         i = RandIdx(cAllocs);
-        kldrHlpFree(s_aAllocs[i].pv);
+        kHlpFree(s_aAllocs[i].pv);
         cAllocs--;
         if (i != cAllocs)
@@ -181 +181 @@
             i = cAllocs;
             s_aAllocs[i].cb = RandSize();
-            s_aAllocs[i].pv = kldrHlpAlloc(s_aAllocs[i].cb);
+            s_aAllocs[i].pv = kHlpAlloc(s_aAllocs[i].cb);
             CHECK(s_aAllocs[i].pv);
             cAllocs++;
@@ -191 +191 @@
         {
             i = RandIdx(cAllocs);
-            kldrHlpFree(s_aAllocs[i].pv);
+            kHlpFree(s_aAllocs[i].pv);
             cAllocs--;
             if (i != cAllocs)
@@ -202 +202 @@
     {
         i = RandIdx(cAllocs);
-        kldrHlpFree(s_aAllocs[i].pv);
+        kHlpFree(s_aAllocs[i].pv);
         cAllocs--;
         if (i != cAllocs)
@@ -209 +209 @@
 
     /* terminate */
-    kldrHlpHeapTerm();
+    kHlpHeapTerm();