Changeset 3544 for trunk

Timestamp:

Aug 25, 2007, 8:48:53 AM (18 years ago)

Author:

bird

Message:

More kRdr stuff refactored.

Location:

trunk/kStuff

Files:

• include/k/kErrors.h (modified) (1 diff)
• kRdr/kRdrFile.c (modified) (49 diffs)
• kRdr/kRdrInternal.h (modified) (1 diff)

trunk/kStuff/include/k/kErrors.h

@@ -91 +91 @@
 /** @} */
 
+/** @name   kRdr Specific
+ * @{ */
+/** the base of the kRdr specific status codes. */
+#define KRDR_ERR_BASE                                   (KDBG_ERR_BASE + 4)
+/** The file reader can't take more concurrent mappings. */
+#define KRDR_ERR_TOO_MANY_MAPPINGS                      (KRDR_ERR_BASE + 59)
+/** @} */
+
 /** @}*/
 

trunk/kStuff/kRdr/kRdrFile.c

@@ -1 +1 @@
 /* $Id$ */
 /** @file
+ * kRdrFile - The Native File Provider
+ */
+
+/*
+ * Copyright (c) 2007 knut st. osmundsen <bird-src-spam@anduin.net>
  *
- * kLdr - The Dynamic Loader, file abstraction.
+ * This file is part of kStuff.
  *
- * 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
+ * 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 of the License, or
  * (at your option) any later version.
  *
- * kLdr is distributed in the hope that it will be useful,
+ * 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.
+ * GNU Lesser 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
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
@@ -29 +29 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#ifdef __OS2__
+#include <k/kDefs.h>
+
+#if K_OS == K_OS_OS2
 # define INCL_ERRORS
 # define INCL_BASE
 # include <os2.h>
 
-#elif defined(__WIN32__) || defined(__WIN64__) || defined(__WIN__)
+#elif K_OS == K_OS_WINDOWS
 # define WIN32_NO_STATUS
 # include <Windows.h>
@@ -152 +154 @@
 #endif
 
-#include <kLdr.h>
-#include "kLdrHlp.h"
-
-
-/*******************************************************************************
-*   Defined Constants And Macros                                               *
-*******************************************************************************/
-/** @def KLDRRDRFILE_STRICT
- * Define KLDRRDRFILE_STRICT to enabled strict checks in KLDRRDRFILE. */
-#define KLDRRDRFILE_STRICT 1
-
-/** @def KLDRRDRFILE_ASSERT
- * Assert that an expression is true when KLDRRDRFILE_STRICT is defined.
- */
-#ifdef KLDRRDRFILE_STRICT
-# define KLDRRDRFILE_ASSERT(expr)  kldrHlpAssert(expr)
-#else
-# define KLDRRDRFILE_ASSERT(expr)  do {} while (0)
-#endif
+#include "kRdrInternal.h"
+#include <k/kHlpAlloc.h>
+#include <k/kHlpString.h>
 
 
@@ -179 +165 @@
  * Prepared stuff.
  */
-typedef struct KLDRRDRFILEPREP
+typedef struct KRDRFILEPREP
 {
     /** The address of the prepared region. */
     void           *pv;
     /** The size of the prepared region. */
-    size_t          cb;
-#if defined(__WIN__) || defined(__NT__)
+    KSIZE           cb;
+#if K_OS == K_OS_WINDOWS
     /** Handle to the section created to map the file. */
     HANDLE          hSection;
 #endif
-} KLDRRDRFILEPREP, *PKLDRRDRFILEPREP;
+} KRDRFILEPREP, *PKRDRFILEPREP;
 
 /**
  * The file provier instance for native files.
  */
-typedef struct KLDRRDRFILE
+typedef struct KRDRFILE
 {
     /** The file reader vtable. */
-    KLDRRDR             Core;
+    KRDR                Core;
     /** The file handle. */
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     HFILE               File;
-#elif defined(__WIN__) || defined(__NT__)
+#elif K_OS == K_OS_WINDOWS
     HANDLE              File;
 #else
@@ -207 +193 @@
 #endif
     /** The current file offset. */
-    KLDRFOFF            off;
+    KFOFF               off;
     /** The file size. */
-    KLDRFOFF            cb;
+    KFOFF               cb;
     /** Array where we stuff the mapping area data. */
-    KLDRRDRFILEPREP     aPreps[4];
+    KRDRFILEPREP        aPreps[4];
     /** The number of current preps. */
-    uint32_t            cPreps;
+    KU32                cPreps;
     /** Number of mapping references. */
-    int32_t             cMappings;
+    KI32                cMappings;
     /** The memory mapping. */
     void               *pvMapping;
     /** The filename. */
     char                szFilename[1];
-} KLDRRDRFILE, *PKLDRRDRFILE;
+} KRDRFILE, *PKRDRFILE;
 
 
@@ -226 +212 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-static void     kldrRdrFileDone(PKLDRRDR pRdr);
-static int      kldrRdrFileUnmap(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
-static int      kldrRdrFileGenericUnmap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments);
-static int      kldrRdrFileProtect(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
-static int      kldrRdrFileGenericProtect(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
-static int      kldrRdrFileRefresh(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments);
-static int      kldrRdrFileGenericRefresh(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments);
-static int      kldrRdrFileMap(PKLDRRDR pRdr, void **ppvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed);
-static int      kldrRdrFileGenericMap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed);
-static size_t   kldrRdrFilePageSize(PKLDRRDR pRdr);
-static const char *kldrRdrFileName(PKLDRRDR pRdr);
-static KLDRFOFF kldrRdrFileTell(PKLDRRDR pRdr);
-static KLDRFOFF kldrRdrFileSize(PKLDRRDR pRdr);
-static int      kldrRdrFileAllUnmap(PKLDRRDR pRdr, const void *pvBits);
-static int      kldrRdrFileAllMap(PKLDRRDR pRdr, const void **ppvBits);
-static int      kldrRdrFileRead(PKLDRRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off);
-static int      kldrRdrFileDestroy(PKLDRRDR pRdr);
-static int      kldrRdrFileCreate(PPKLDRRDR ppRdr, const char *pszFilename);
+static void     krdrFileDone(PKRDR pRdr);
+static int      krdrFileUnmap(PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
+static int      krdrFileGenericUnmap(PKRDR pRdr, PKRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments);
+static int      krdrFileProtect(PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
+static int      krdrFileGenericProtect(PKRDR pRdr, PKRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect);
+static int      krdrFileRefresh(PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments);
+static int      krdrFileGenericRefresh(PKRDR pRdr, PKRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments);
+static int      krdrFileMap(PKRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed);
+static int      krdrFileGenericMap(PKRDR pRdr, PKRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed);
+static KSIZE   krdrFilePageSize(PKRDR pRdr);
+static const char *krdrFileName(PKRDR pRdr);
+static KIPTR    krdrFileNativeFH(PKRDR pRdr);
+static KFOFF    krdrFileTell(PKRDR pRdr);
+static KFOFF    krdrFileSize(PKRDR pRdr);
+static int      krdrFileAllUnmap(PKRDR pRdr, const void *pvBits);
+static int      krdrFileAllMap(PKRDR pRdr, const void **ppvBits);
+static int      krdrFileRead(PKRDR pRdr, void *pvBuf, KSIZE cb, KFOFF off);
+static int      krdrFileDestroy(PKRDR pRdr);
+static int      krdrFileCreate(PPKRDR ppRdr, const char *pszFilename);
 
 
@@ -250 +237 @@
 *******************************************************************************/
 /** Native file provider operations. */
-const KLDRRDROPS g_kLdrRdrFileOps =
+const KRDROPS g_kRdrFileOps =
 {
     "native file",
     NULL,
-    kldrRdrFileCreate,
-    kldrRdrFileDestroy,
-    kldrRdrFileRead,
-    kldrRdrFileAllMap,
-    kldrRdrFileAllUnmap,
-    kldrRdrFileSize,
-    kldrRdrFileTell,
-    kldrRdrFileName,
-    kldrRdrFilePageSize,
-    kldrRdrFileMap,
-    kldrRdrFileRefresh,
-    kldrRdrFileProtect,
-    kldrRdrFileUnmap,
-    kldrRdrFileDone,
+    krdrFileCreate,
+    krdrFileDestroy,
+    krdrFileRead,
+    krdrFileAllMap,
+    krdrFileAllUnmap,
+    krdrFileSize,
+    krdrFileTell,
+    krdrFileName,
+    krdrFileNativeFH,
+    krdrFilePageSize,
+    krdrFileMap,
+    krdrFileRefresh,
+    krdrFileProtect,
+    krdrFileUnmap,
+    krdrFileDone,
     42
 };
 
 
-#if defined(__WIN__) || defined(__NT__)
+#if K_OS == K_OS_WINDOWS
 /**
  * Converts a kLdr segment protection to NT protection for a mapping.
@@ -279 +267 @@
  * @param   enmProt     kLdr protection.
  */
-static ULONG kldrRdrFileGetNtMapProt(KLDRPROT enmProt)
+static ULONG krdrFileGetNtMapProt(KLDRPROT enmProt)
 {
     switch (enmProt)
@@ -302 +290 @@
  * @param   enmProt     kLdr protection.
  */
-static ULONG kldrRdrFileGetNtAllocProt(KLDRPROT enmProt)
+static ULONG krdrFileGetNtAllocProt(KLDRPROT enmProt)
 {
     switch (enmProt)
@@ -320 +308 @@
 
 
-/** @copydoc KLDRRDR::pfnDone */
-static void     kldrRdrFileDone(PKLDRRDR pRdr)
+/** @copydoc KRDROPS::pfnDone */
+static void     krdrFileDone(PKRDR pRdr)
 {
 }
@@ -333 +321 @@
  * @param   pv      The base of the region.
  */
-static PKLDRRDRFILEPREP kldrRdrFileFindPrepExact(PKLDRRDRFILE pFile, void *pv)
-{
-    int32_t i = pFile->cPreps;
+static PKRDRFILEPREP krdrFileFindPrepExact(PKRDRFILE pFile, void *pv)
+{
+    KI32 i = pFile->cPreps;
     while (i-- > 0)
         if (pFile->aPreps[i].pv == pv)
@@ -343 +331 @@
 
 
-/** @copydoc KLDRRDR::pfnUnmap */
-static int      kldrRdrFileUnmap(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments)
-{
-    PKLDRRDRFILE        pRdrFile = (PKLDRRDRFILE)pRdr;
-    PKLDRRDRFILEPREP    pPrep = kldrRdrFileFindPrepExact(pRdrFile, pvBase);
+/** @copydoc KRDROPS::pfnUnmap */
+static int      krdrFileUnmap(PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments)
+{
+    PKRDRFILE        pRdrFile = (PKRDRFILE)pRdr;
+    PKRDRFILEPREP       pPrep = krdrFileFindPrepExact(pRdrFile, pvBase);
     int                 rc;
     if (!pPrep)
-        return KLDR_ERR_INVALID_PARAMETER;
-
-#if defined(__WIN__) || defined(__NT__)
+        return KERR_INVALID_PARAMETER;
+
+#if K_OS == K_OS_WINDOWS
     if (pPrep->hSection != NULL)
     {
@@ -360 +348 @@
 #endif
 
-    rc = kldrRdrFileGenericUnmap(pRdr, pPrep, cSegments, paSegments);
+    rc = krdrFileGenericUnmap(pRdr, pPrep, cSegments, paSegments);
 
     /* remove the mapping data on success. */
@@ -373 +361 @@
 
 
-/** Generic implementation of kldrRdrFileUnmap. */
-static int kldrRdrFileGenericUnmap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments)
-{
-    kldrRdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 1 /* unprotect */);
-    return kldrHlpPageFree(pPrep->pv, pPrep->cb);
-}
-
-
-/** @copydoc KLDRRDR::pfnProtect */
-static int      kldrRdrFileProtect(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
-{
-    PKLDRRDRFILE        pRdrFile = (PKLDRRDRFILE)pRdr;
-    PKLDRRDRFILEPREP    pPrep = kldrRdrFileFindPrepExact(pRdrFile, pvBase);
+/** Generic implementation of krdrFileUnmap. */
+static int krdrFileGenericUnmap(PKRDR pRdr, PKRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments)
+{
+    krdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 1 /* unprotect */);
+    return kHlpPageFree(pPrep->pv, pPrep->cb);
+}
+
+
+/** @copydoc KRDROPS::pfnProtect */
+static int      krdrFileProtect(PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
+{
+    PKRDRFILE        pRdrFile = (PKRDRFILE)pRdr;
+    PKRDRFILEPREP    pPrep = krdrFileFindPrepExact(pRdrFile, pvBase);
     if (!pPrep)
-        return KLDR_ERR_INVALID_PARAMETER;
-
-#if defined(__WIN__) || defined(__NT__)
+        return KERR_INVALID_PARAMETER;
+
+#if K_OS == K_OS_WINDOWS
     if (pPrep->hSection != NULL)
     {
@@ -397 +385 @@
 #endif
 
-    return kldrRdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, fUnprotectOrProtect);
-}
-
-
-/** Generic implementation of kldrRdrFileProtect. */
-static int kldrRdrFileGenericProtect(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
-{
-    uint32_t i;
+    return krdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, fUnprotectOrProtect);
+}
+
+
+/** Generic implementation of krdrFileProtect. */
+static int krdrFileGenericProtect(PKRDR pRdr, PKRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments, unsigned fUnprotectOrProtect)
+{
+    KU32 i;
 
     /*
@@ -437 +425 @@
                     break;
                 default:
-                    KLDRRDRFILE_ASSERT(!"bad enmProt");
+                    kRdrAssert(!"bad enmProt");
                     return -1;
             }
@@ -452 +440 @@
         pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
 
-        rc = kldrHlpPageProtect(pv, paSegments[i].cbMapped, enmProt);
+        rc = kHlpPageProtect(pv, paSegments[i].cbMapped, enmProt);
         if (rc)
             break;
@@ -461 +449 @@
 
 
-/** @copydoc KLDRRDR::pfnRefresh */
-static int      kldrRdrFileRefresh(PKLDRRDR pRdr, void *pvBase, uint32_t cSegments, PCKLDRSEG paSegments)
-{
-    PKLDRRDRFILE        pRdrFile = (PKLDRRDRFILE)pRdr;
-    PKLDRRDRFILEPREP    pPrep = kldrRdrFileFindPrepExact(pRdrFile, pvBase);
+/** @copydoc KRDROPS::pfnRefresh */
+static int      krdrFileRefresh(PKRDR pRdr, void *pvBase, KU32 cSegments, PCKLDRSEG paSegments)
+{
+    PKRDRFILE        pRdrFile = (PKRDRFILE)pRdr;
+    PKRDRFILEPREP    pPrep = krdrFileFindPrepExact(pRdrFile, pvBase);
     if (!pPrep)
-        return KLDR_ERR_INVALID_PARAMETER;
-
-#if defined(__WIN__) || defined(__NT__)
+        return KERR_INVALID_PARAMETER;
+
+#if K_OS == K_OS_WINDOWS
     if (pPrep->hSection != NULL)
     {
@@ -477 +465 @@
 #endif
 
-    return kldrRdrFileGenericRefresh(pRdr, pPrep, cSegments, paSegments);
-}
-
-
-/** Generic implementation of kldrRdrFileRefresh. */
-static int      kldrRdrFileGenericRefresh(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments)
+    return krdrFileGenericRefresh(pRdr, pPrep, cSegments, paSegments);
+}
+
+
+/** Generic implementation of krdrFileRefresh. */
+static int      krdrFileGenericRefresh(PKRDR pRdr, PKRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments)
 {
     int rc;
     int rc2;
-    uint32_t i;
+    KU32 i;
 
     /*
      * Make everything writable again.
      */
-    rc = kldrRdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 1 /* unprotect */);
+    rc = krdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 1 /* unprotect */);
     if (rc)
     {
-        kldrRdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 0 /* protect */);
+        krdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 0 /* protect */);
         return rc;
     }
@@ -502 +490 @@
      */
     /** @todo only zero the areas not covered by raw file bits. */
-    kLdrHlpMemSet(pPrep->pv, 0, pPrep->cb);
+    kHlpMemSet(pPrep->pv, 0, pPrep->cb);
 
     /*
@@ -526 +514 @@
      * Protect the bits again.
      */
-    rc2 = kldrRdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 0 /* protect */);
+    rc2 = krdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 0 /* protect */);
     if (rc2 && rc)
         rc = rc2;
@@ -534 +522 @@
 
 
-/** @copydoc KLDRRDR::pfnMap */
-static int      kldrRdrFileMap(PKLDRRDR pRdr, void **ppvBase, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed)
-{
-    PKLDRRDRFILE        pRdrFile = (PKLDRRDRFILE)pRdr;
-    PKLDRRDRFILEPREP    pPrep = &pRdrFile->aPreps[pRdrFile->cPreps];
-    KLDRSIZE            cbTotal;
-    const size_t        cbPage = pRdr->pOps->pfnPageSize(pRdr);
-    int                 rc;
-    uint32_t            i;
-
-    if (pRdrFile->cPreps >= KLDR_ELEMENTS(pRdrFile->aPreps))
-        return KLDR_ERR_TOO_MANY_MAPPINGS;
+/** @copydoc KRDROPS::pfnMap */
+static int      krdrFileMap(PKRDR pRdr, void **ppvBase, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed)
+{
+    PKRDRFILE       pRdrFile = (PKRDRFILE)pRdr;
+    PKRDRFILEPREP   pPrep = &pRdrFile->aPreps[pRdrFile->cPreps];
+    KLDRSIZE        cbTotal;
+    const KSIZE     cbPage = pRdr->pOps->pfnPageSize(pRdr);
+    int             rc;
+    KU32            i;
+
+    if (pRdrFile->cPreps >= K_ELEMENTS(pRdrFile->aPreps))
+        return KRDR_ERR_TOO_MANY_MAPPINGS;
 
     /*
@@ -560 +548 @@
             cbTotal = uRVASegmentEnd;
     }
-    pPrep->cb = (size_t)cbTotal;
+    pPrep->cb = (KSIZE)cbTotal;
     if (pPrep->cb != cbTotal)
         return KLDR_ERR_ADDRESS_OVERFLOW;
     pPrep->cb = (pPrep->cb + (cbPage - 1)) & ~(cbPage- 1);
 
-#if defined(__WIN__) || defined(__NT__)
+#if K_OS == K_OS_WINDOWS
     /*
      * The NT memory mapped file API sucks in a lot of ways. Unless you're actually
@@ -646 +634 @@
         {
             pv = NULL;
-            ViewSize = (size_t)cbTotal;
+            ViewSize = (KSIZE)cbTotal;
 
             Status = NtAllocateVirtualMemory(NtCurrentProcess(),
@@ -682 +670 @@
                 SectionOffset.QuadPart = paSegments[i].offFile;
                 ViewSize = paSegments[i].cbFile;
-                fPageProt = kldrRdrFileGetNtMapProt(paSegments[i].enmProt);
+                fPageProt = krdrFileGetNtMapProt(paSegments[i].enmProt);
                 /* STATUS_MAPPED_ALIGNMENT
                    STATUS_CONFLICTING_ADDRESSES
@@ -706 +694 @@
             {
                 ViewSize = paSegments[i].cbMapped;
-                fPageProt = kldrRdrFileGetNtAllocProt(paSegments[i].enmProt);
+                fPageProt = krdrFileGetNtAllocProt(paSegments[i].enmProt);
                 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
                                                  &pv,
@@ -751 +739 @@
      */
     pPrep->pv = fFixed ? *ppvBase : NULL;
-    rc = kldrRdrFileGenericMap(pRdr, pPrep, cSegments, paSegments, fFixed);
+    rc = krdrFileGenericMap(pRdr, pPrep, cSegments, paSegments, fFixed);
     if (!rc)
     {
@@ -762 +750 @@
 
 
-/** Generic implementation of kldrRdrFileMap. */
-static int  kldrRdrFileGenericMap(PKLDRRDR pRdr, PKLDRRDRFILEPREP pPrep, uint32_t cSegments, PCKLDRSEG paSegments, unsigned fFixed)
+/** Generic implementation of krdrFileMap. */
+static int  krdrFileGenericMap(PKRDR pRdr, PKRDRFILEPREP pPrep, KU32 cSegments, PCKLDRSEG paSegments, unsigned fFixed)
 {
     int rc;
-    uint32_t i;
-
-    /*
-     * Generic mapping code using kldrHlpPageAlloc(), kldrHlpPageFree() and kldrHlpPageProtect().
-     */
-    rc = kldrHlpPageAlloc(&pPrep->pv, pPrep->cb, KLDRPROT_EXECUTE_READWRITE, fFixed);
+    KU32 i;
+
+    /*
+     * Generic mapping code using kHlpPageAlloc(), kHlpPageFree() and kHlpPageProtect().
+     */
+    rc = kHlpPageAlloc(&pPrep->pv, pPrep->cb, KLDRPROT_EXECUTE_READWRITE, fFixed);
     if (rc)
         return rc;
@@ -797 +785 @@
     if (!rc)
     {
-        rc = kldrRdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 0 /* protect */);
+        rc = krdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 0 /* protect */);
         if (!rc)
             return 0;
-        kldrRdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 1 /* unprotect */);
+        krdrFileGenericProtect(pRdr, pPrep, cSegments, paSegments, 1 /* unprotect */);
     }
 
     /* bailout */
-    kldrHlpPageFree(pPrep->pv, pPrep->cb);
+    kHlpPageFree(pPrep->pv, pPrep->cb);
     return rc;
 }
 
 
-/** @copydoc KLDRRDR::pfnPageSize */
-static size_t   kldrRdrFilePageSize(PKLDRRDR pRdr)
-{
-#ifdef __OS2__
+/** @copydoc KRDROPS::pfnPageSize */
+static KSIZE   krdrFilePageSize(PKRDR pRdr)
+{
+#if K_OS == K_OS_OS2
     /* The page size on OS/2 wont change anytime soon. :-) */
     return 0x1000;
@@ -827 +815 @@
 
 
-/** @copydoc KLDRRDR::pfnName */
-static const char *kldrRdrFileName(PKLDRRDR pRdr)
-{
-    PKLDRRDRFILE pRdrFile = (PKLDRRDRFILE)pRdr;
+/** @copydoc KRDROPS::pfnName */
+static const char *krdrFileName(PKRDR pRdr)
+{
+    PKRDRFILE pRdrFile = (PKRDRFILE)pRdr;
     return &pRdrFile->szFilename[0];
 }
 
 
-/** @copydoc KLDRRDR::pfnTell */
-static KLDRFOFF kldrRdrFileTell(PKLDRRDR pRdr)
-{
-    PKLDRRDRFILE pRdrFile = (PKLDRRDRFILE)pRdr;
+static KIPTR krdrFileNativeFH(PKRDR pRdr)
+{
+    PKRDRFILE pRdrFile = (PKRDRFILE)pRdr;
+#if K_OS == K_OS_OS2 || K_OS == K_OS_WINDOWS
+    return (KIPTR)pRdrFile->File;
+#else
+# error "port me"
+#endif
+}
+
+
+/** @copydoc KRDROPS::pfnTell */
+static KFOFF krdrFileTell(PKRDR pRdr)
+{
+    PKRDRFILE pRdrFile = (PKRDRFILE)pRdr;
 
     /*
@@ -845 +844 @@
     if (pRdrFile->off == -1)
     {
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
         ULONG ulNew;
         APIRET rc = DosSetFilePtr(pRdrFile->File, 0, FILE_CURRENT, &ulNew);
@@ -862 +861 @@
         if (rc)
             return -1;
-        pRdrFile->off = ((KLDRFOFF)offHigh << 32) | offLow;
+        pRdrFile->off = ((KFOFF)offHigh << 32) | offLow;
 
 #else
@@ -872 +871 @@
 
 
-/** @copydoc KLDRRDR::pfnSize */
-static KLDRFOFF kldrRdrFileSize(PKLDRRDR pRdr)
-{
-    PKLDRRDRFILE pRdrFile = (PKLDRRDRFILE)pRdr;
+/** @copydoc KRDROPS::pfnSize */
+static KFOFF krdrFileSize(PKRDR pRdr)
+{
+    PKRDRFILE pRdrFile = (PKRDRFILE)pRdr;
     return pRdrFile->cb;
 }
 
 
-/** @copydoc KLDRRDR::pfnAllUnmap */
-static int kldrRdrFileAllUnmap(PKLDRRDR pRdr, const void *pvBits)
-{
-    PKLDRRDRFILE pRdrFile = (PKLDRRDRFILE)pRdr;
+/** @copydoc KRDROPS::pfnAllUnmap */
+static int krdrFileAllUnmap(PKRDR pRdr, const void *pvBits)
+{
+    PKRDRFILE pRdrFile = (PKRDRFILE)pRdr;
 
     /* check for underflow */
@@ -896 +895 @@
     if (!--pRdrFile->cMappings)
     {
-        kldrHlpFree(pRdrFile->pvMapping);
+        kHlpFree(pRdrFile->pvMapping);
         pRdrFile->pvMapping = NULL;
     }
@@ -904 +903 @@
 
 
-/** @copydoc KLDRRDR::pfnAllMap */
-static int kldrRdrFileAllMap(PKLDRRDR pRdr, const void **ppvBits)
-{
-    PKLDRRDRFILE pRdrFile = (PKLDRRDRFILE)pRdr;
+/** @copydoc KRDROPS::pfnAllMap */
+static int krdrFileAllMap(PKRDR pRdr, const void **ppvBits)
+{
+    PKRDRFILE pRdrFile = (PKRDRFILE)pRdr;
 
     /*
@@ -915 +914 @@
     {
         int rc;
-        KLDRFOFF cb = pRdrFile->Core.pOps->pfnSize(pRdr);
-
-        pRdrFile->pvMapping = kldrHlpAlloc(cb);
+        KFOFF cb = pRdrFile->Core.pOps->pfnSize(pRdr);
+
+        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;
@@ -940 +939 @@
 
 
-/** @copydoc KLDRRDR::pfnRead */
-static int kldrRdrFileRead(PKLDRRDR pRdr, void *pvBuf, size_t cb, KLDRFOFF off)
-{
-    PKLDRRDRFILE pRdrFile = (PKLDRRDRFILE)pRdr;
+/** @copydoc KRDROPS::pfnRead */
+static int krdrFileRead(PKRDR pRdr, void *pvBuf, KSIZE cb, KFOFF off)
+{
+    PKRDRFILE pRdrFile = (PKRDRFILE)pRdr;
 
     /*
@@ -950 +949 @@
     if (pRdrFile->off != off)
     {
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
         ULONG ulNew;
         APIRET rc;
@@ -965 +964 @@
         LONG offLow;
 
-        offHigh = sizeof(KLDRFOFF) == 4 ? 0 : (off >> 32);
+        offHigh = sizeof(KFOFF) == 4 ? 0 : (off >> 32);
         offLow = SetFilePointer(pRdrFile->File, (LONG)off, &offHigh, FILE_BEGIN);
         if (    offLow != (LONG)off
-            ||  offHigh != (LONG)(sizeof(KLDRFOFF) == 4 ? 0 : (off >> 32)))
+            ||  offHigh != (LONG)(sizeof(KFOFF) == 4 ? 0 : (off >> 32)))
         {
             int rc = GetLastError();
@@ -985 +984 @@
      * Do the read.
      */
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     {
     ULONG cbRead = 0;
@@ -1028 +1027 @@
 
 
-/** @copydoc KLDRRDR::pfnDestroy */
-static int kldrRdrFileDestroy(PKLDRRDR pRdr)
-{
-    PKLDRRDRFILE    pRdrFile = (PKLDRRDRFILE)pRdr;
+/** @copydoc KRDROPS::pfnDestroy */
+static int krdrFileDestroy(PKRDR pRdr)
+{
+    PKRDRFILE    pRdrFile = (PKRDRFILE)pRdr;
     int             rc;
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     rc = DosClose(pRdrFile->File);
 
@@ -1047 +1046 @@
     if (pRdrFile->pvMapping)
     {
-        kldrHlpFree(pRdrFile->pvMapping);
+        kHlpFree(pRdrFile->pvMapping);
         pRdrFile->pvMapping = NULL;
     }
 
-    kldrHlpFree(pRdr);
+    kHlpFree(pRdr);
     return rc;
 }
 
 
-/** @copydoc KLDRRDROPS::pfnCreate */
-static int kldrRdrFileCreate(PPKLDRRDR ppRdr, const char *pszFilename)
-{
-    size_t          cchFilename;
-    PKLDRRDRFILE    pRdrFile;
+/** @copydoc KRDROPS::pfnCreate */
+static int krdrFileCreate(PPKRDR ppRdr, const char *pszFilename)
+{
+    KSIZE       cchFilename;
+    PKRDRFILE   pRdrFile;
 
     /*
      * Open the file and determin its size.
      */
-#ifdef __OS2__
+#if K_OS == K_OS_OS2
     ULONG           ulAction = 0;
     FILESTATUS3     Info;
     APIRET          rc;
     HFILE           File = 0;
-    KLDRFOFF        cb;
+    KFOFF           cb;
     char            szFilename[CCHMAXPATH];
 
@@ -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;
     }
@@ -1109 +1108 @@
     int                 rc;
     HANDLE              File;
-    KLDRFOFF            cb;
+    KFOFF            cb;
     char                szFilename[MAX_PATH];
 
@@ -1134 +1133 @@
         return rc;
     }
-    if (sizeof(KLDRFOFF) == 4)
+    if (sizeof(KFOFF) == 4)
         cb = High ? 0x7fffffff : Low;
     else
-        cb = ((KLDRFOFF)High << 32) | Low;
+        cb = ((KFOFF)High << 32) | Low;
 
 #else
@@ -1147 +1146 @@
      * Allocate the reader instance.
      */
-    cchFilename = kLdrHlpStrLen(szFilename);
-    pRdrFile = (PKLDRRDRFILE)kldrHlpAlloc(sizeof(*pRdrFile) + cchFilename);
+    cchFilename = kHlpStrLen(szFilename);
+    pRdrFile = (PKRDRFILE)kHlpAlloc(sizeof(*pRdrFile) + cchFilename);
     if (!pRdrFile)
 #if defined(__OS2__)
@@ -1168 +1167 @@
      */
     pRdrFile->Core.u32Magic = KLDRRDR_MAGIC;
-    pRdrFile->Core.pOps = &g_kLdrRdrFileOps;
+    pRdrFile->Core.pOps = &g_kRdrFileOps;
     pRdrFile->File = File;
     pRdrFile->cb = cb;
@@ -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/kRdr/kRdrInternal.h

@@ -30 +30 @@
 #include <k/kHlpAssert.h>
 #include <k/kMagics.h>
+#include <k/kRdrAll.h>
+#include <k/kErrors.h>
 
 #ifdef __cplusplus