- Prepar using indexes in MAP mode (not used yet)

modified:
  storage/connect/tabdos.cpp
  storage/connect/xindex.cpp
  storage/connect/xindex.h

3 files changed, 56 insertions, 315 deletions

diff --git a/storage/connect/tabdos.cpp b/storage/connect/tabdos.cpp
index dee4a9025c2..54e10574b7d 100644
--- a/storage/connect/tabdos.cpp
+++ b/storage/connect/tabdos.cpp
@@ -554,9 +554,7 @@ int TDBDOS::MakeIndex(PGLOBAL g, PIXDEF pxdf, bool add)
       if (!x->Make(g, sxp)) {
         // Retreive define values from the index
         xdp->SetMaxSame(x->GetMaxSame());
-//      xdp->SetOffset(x->GetDefoff());
-//      xdp->SetOffhigh(x->GetDefhigh());
-        xdp->SetSize(x->GetSize());
+//      xdp->SetSize(x->GetSize());
 
         // store KXYCOL Mxs in KPARTDEF Mxsame
         xdp->SetMxsame(x);
@@ -565,7 +563,7 @@ int TDBDOS::MakeIndex(PGLOBAL g, PIXDEF pxdf, bool add)
         printf("Make done...\n");
 #endif   // TRACE
 
-        if (x->GetSize() > 0)
+//      if (x->GetSize() > 0)
           sxp = xdp;
 
         xdp->SetInvalid(false);
diff --git a/storage/connect/xindex.cpp b/storage/connect/xindex.cpp
index 78c8e6115ef..68a6bba47ec 100755
--- a/storage/connect/xindex.cpp
+++ b/storage/connect/xindex.cpp
@@ -1,7 +1,7 @@
 /***************** Xindex C++ Class Xindex Code (.CPP) *****************/
-/*  Name: XINDEX.CPP  Version 2.7                                      */
+/*  Name: XINDEX.CPP  Version 2.8                                      */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2004-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          2004-2013    */
 /*                                                                     */
 /*  This file contains the class XINDEX implementation code.           */
 /***********************************************************************/
@@ -112,7 +112,7 @@ INDEXDEF::INDEXDEF(char *name, bool uniq, int n)
   ID = n;
 //Offset = 0;
 //Offhigh = 0;
-  Size = 0;
+//Size = 0;
   MaxSame = 1;
   } // end of INDEXDEF constructor
 
@@ -212,7 +212,7 @@ XINDEX::XINDEX(PTDBDOS tdbp, PIXDEF xdp, PXLOAD pxp, PCOL *cp, PXOB *xp, int k)
   Incr = 0;
 //Defoff = xdp->GetOffset();
 //Defhigh = xdp->GetOffhigh();
-  Size = xdp->GetSize();
+//Size = xdp->GetSize();
   MaxSame = xdp->GetMaxSame();
   } // end of XINDEX constructor
 
@@ -283,16 +283,13 @@ bool XINDEX::Make(PGLOBAL g, PIXDEF sxp)
   /*  Table can be accessed through an index.                          */
   /*********************************************************************/
   int     k, rc = RC_OK;
-  int   *bof, i, j, n, ndf, nkey;
+  int    *bof, i, j, n, ndf, nkey;
   PKPDEF  kdfp = Xdp->GetToKeyParts();
   bool    brc = true;
   PCOL    colp;
   PXCOL   kp, prev = NULL, kcp = NULL;
   PDBUSER dup = (PDBUSER)g->Activityp->Aptr;
 
-  Defoff = 0;
-  Size = 0;                     // Void index
-
   /*********************************************************************/
   /*  Allocate the storage that will contain the keys and the file     */
   /*  positions corresponding to them.                                 */
@@ -704,7 +701,7 @@ bool XINDEX::SaveIndex(PGLOBAL g, PIXDEF sxp)
   char   *ftype;
   char    fn[_MAX_PATH];
   int     n[NZ], nof = (Mul) ? (Ndif + 1) : 0;
-  int     id = -1;
+  int     id = -1, size = 0;
   bool    sep, rc = false;
   PXCOL   kcp = To_KeyCol;
   PDOSDEF defp = (PDOSDEF)Tdbp->To_Def;
@@ -754,13 +751,6 @@ bool XINDEX::SaveIndex(PGLOBAL g, PIXDEF sxp)
   if (!Ndif)
     goto end;                // Void index
 
-  // Defoff is the start of the definition in the index file
-//X->GetOff(Defoff, Defhigh, sxp);
-
-#if defined(TRACE)
-  printf("Defoff=%d Defhigh=%d\n", Defoff, Defhigh);
-#endif   // TRACE
-
   /*********************************************************************/
   /*  Write the index values on the index file.                        */
   /*********************************************************************/
@@ -777,16 +767,16 @@ bool XINDEX::SaveIndex(PGLOBAL g, PIXDEF sxp)
     ID, Nk, nof, Num_K, Incr, Nblk, Sblk);
 #endif   // TRACE
 
-  Size = X->Write(g, n, NZ, sizeof(int), rc);
+  size = X->Write(g, n, NZ, sizeof(int), rc);
   dup->ProgCur = 1;
 
   if (Mul)             // Write the offset array
-    Size += X->Write(g, Pof, nof, sizeof(int), rc);
+    size += X->Write(g, Pof, nof, sizeof(int), rc);
 
   dup->ProgCur = 5;
 
   if (!Incr)           // Write the record position array(s)
-    Size += X->Write(g, To_Rec, Num_K, sizeof(int), rc);
+    size += X->Write(g, To_Rec, Num_K, sizeof(int), rc);
 
   dup->ProgCur = 15;
 
@@ -797,19 +787,19 @@ bool XINDEX::SaveIndex(PGLOBAL g, PIXDEF sxp)
     n[3] = kcp->Klen;                // To be checked later
     n[4] = kcp->Type;                // To be checked later
 
-    Size += X->Write(g, n, NW, sizeof(int), rc);
+    size += X->Write(g, n, NW, sizeof(int), rc);
     dup->ProgCur += 1;
 
     if (n[2])
-      Size += X->Write(g, kcp->To_Bkeys, Nblk, kcp->Klen, rc);
+      size += X->Write(g, kcp->To_Bkeys, Nblk, kcp->Klen, rc);
 
     dup->ProgCur += 5;
 
-    Size += X->Write(g, kcp->To_Keys, n[0], kcp->Klen, rc);
+    size += X->Write(g, kcp->To_Keys, n[0], kcp->Klen, rc);
     dup->ProgCur += 5;
 
     if (n[1])
-      Size += X->Write(g, kcp->Kof, n[1], sizeof(int), rc);
+      size += X->Write(g, kcp->Kof, n[1], sizeof(int), rc);
 
     dup->ProgCur += 5;
     } // endfor kcp
@@ -1078,7 +1068,7 @@ bool XINDEX::Init(PGLOBAL g)
   const char *ftype;
   BYTE   *mbase;
   char    fn[_MAX_PATH];
-  int   *nv, k, n;
+  int    *nv, k, n, id = -1;
   bool    estim;
   PCOL    colp;
   PXCOL   prev = NULL, kcp = NULL;
@@ -1138,8 +1128,10 @@ bool XINDEX::Init(PGLOBAL g)
     _splitpath(defp->GetOfn(), drive, direc, fname, NULL);
     strcat(strcat(fname, "_"), Xdp->GetName());
     _makepath(fn, drive, direc, fname, ftype);
-  } else
+  } else {
+    id = ID;
     strcat(PlugRemoveType(fn, strcpy(fn, defp->GetOfn())), ftype);
+  } // endif SepIndex
 
   PlugSetPath(fn, fn, Tdbp->GetPath());
 
@@ -1150,9 +1142,17 @@ bool XINDEX::Init(PGLOBAL g)
   /*********************************************************************/
   /*  Get a view on the part of the index file containing this index.  */
   /*********************************************************************/
-  if (!(mbase = (BYTE*)X->FileView(g, fn, Defoff, Defhigh, Size)))
+  if (!(mbase = (BYTE*)X->FileView(g, fn)))
     goto err;
 
+  if (id >= 0) {
+    // Get offset from the header
+    IOFF *noff = (IOFF*)mbase;
+
+    // Position the memory base at the offset of this index
+    mbase += noff[id].Low;
+    } // endif id
+    
   //  Now start the mapping process.
   nv = (int*)mbase;
   mbase += NZ * sizeof(int);
@@ -2152,24 +2152,8 @@ bool XFILE::Open(PGLOBAL g, char *filename, int id, MODE mode)
   return false;
   } // end of Open
 
-#if 0
 /***********************************************************************/
-/*  Tell were we are in the index file.                                */
-/***********************************************************************/
-bool XFILE::GetOff(int& low, int& high, PIXDEF sxp)
-  {
-  if (sxp) {
-    low  = sxp->GetOffset() + sxp->GetSize();
-    high = 0;
-  } else
-    low = high = 0;
-
-  return false;
-  } // end of GetOff
-#endif // 0
-
-/***********************************************************************/
-/*  Tell were we are in a huge file.                                   */
+/*  Move into an index file.                                           */
 /***********************************************************************/
 bool XFILE::Seek(PGLOBAL g, int low, int high, int origin)
   {
@@ -2252,121 +2236,15 @@ void XFILE::Close(void)
   } // end of Close
 
 #if defined(XMAP)
-#if defined(WIN32)
-/***********************************************************************/
-/*  Return a pointer to the segment at the given offset and size.      */
-/***********************************************************************/
-void *XFILE::FileView(PGLOBAL g, char *fn, int loff, int hoff, int size)
-  {
-  SYSTEM_INFO SysInfo;  // system information; used to get the granularity
-  char   *pData;        // pointer to the data
-  int     iViewDelta;   // the offset into the view where the data shows up
-  HANDLE  hMapFile;     // handle for the file's memory-mapped region
-  DWORD   offset;       // Where to start in the index file
-  DWORD   FileMapSize;  // size of the file mapping
-  DWORD   FileMapStart; // where in the file to start the file map view
-  DWORD   Granularity;  // system allocation granularity
-  DWORD   MapViewSize;  // the size of the view
-
-  if (hoff) {
-    strcpy(g->Message, MSG(HI_OFFSET_ERR));
-    return NULL;
-    } // endf hoff
-
-  // Open the file in mode read only
-  Hfile = CreateFile(fn, GENERIC_READ, FILE_SHARE_READ, NULL,
-                     OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-
-  if (Hfile == INVALID_HANDLE_VALUE) {
-    char  buf[512];
-    DWORD rc = GetLastError();
-
-    sprintf(g->Message, MSG(OPEN_ERROR), rc, MODE_READ, fn);
-    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
-                  FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0,
-                  (LPTSTR)buf, sizeof(buf), NULL);
-    strcat(g->Message, buf);
-    return NULL;
-    } // endif Hfile
-
-  // Get the system allocation granularity.
-  GetSystemInfo(&SysInfo);
-  Granularity = SysInfo.dwAllocationGranularity;
-
-  // The offset is a 64 byte integer low part
-  offset = loff;
-
-  // To calculate where to start the file mapping, round down the
-  // offset of the data into the file to the nearest multiple of the
-  // system allocation granularity.
-  FileMapStart = (offset / Granularity) * Granularity;
-
-  // Calculate the size of the file mapping view.
-  MapViewSize = offset % Granularity + (DWORD)size;
-
-  // How large will the file-mapping object be?
-  FileMapSize = offset + (DWORD)size;
-
-  // The data of interest isn't at the beginning of the
-  // view, so determine how far into the view to set the pointer.
-  iViewDelta = (int)(offset - FileMapStart);
-
-  // Check that the index file is more than large enough
-  if (GetFileSize(Hfile, NULL) < FileMapSize) {
-    strcpy(g->Message, MSG(XFILE_TOO_SMALL));
-    return NULL;
-    } // endif FileSize
-
-  // Create a file-mapping object for the file.
-  hMapFile = CreateFileMapping( Hfile,         // current file handle
-                                NULL,          // default security
-                                PAGE_READONLY, // permission
-                                0,             // size, high
-                                FileMapSize,   // size, low
-                                NULL);         // name
-
-  if (hMapFile == NULL) {
-    sprintf(g->Message, MSG(HANDLE_IS_NULL), "hMapFile", GetLastError() );
-    return NULL;
-    } // endif hMapFile
-
-  // Map the view.
-  ViewBase = MapViewOfFile(hMapFile,      // handle to mapping object
-                           FILE_MAP_READ, // access mode
-                           0,             // high-order 32 bits of file offset
-                           FileMapStart,  // low-order 32 bits of file offset
-                           MapViewSize);  // number of bytes to map
-
-  if (!ViewBase) {
-    sprintf(g->Message, MSG(HANDLE_IS_NULL), "ViewBase", GetLastError());
-    return NULL;
-    } // endif ViewBase
-
-  // Calculate the pointer to the data.
-  pData = (char *)ViewBase + iViewDelta;
-
-  // close the file-mapping object
-  if (!CloseHandle(hMapFile))
-    sprintf(g->Message, MSG(MAP_OBJ_ERR), GetLastError());
-
-  // close the file itself
-  if (!CloseHandle(Hfile))
-    sprintf(g->Message, MSG(FILE_CLOSE_ERR), GetLastError());
-  else
-    Hfile = INVALID_HANDLE_VALUE;
-
-  return pData;
-  } // end of FileView
-#else  // not WIN32
   /*********************************************************************/
-  /*  Map the entire index.                                            */
+  /*  Map the entire index file.                                       */
   /*********************************************************************/
-void *XFILE::FileView(PGLOBAL g, char *fn, int loff, int hoff, int size)
+void *XFILE::FileView(PGLOBAL g, char *fn)
   {
   HANDLE  h;
 
   Mmp = (MMP)PlugSubAlloc(g, NULL, sizeof(MEMMAP));
-  h = CreateFileMap(g, filename, Mmp, MODE_READ, false);
+  h = CreateFileMap(g, fn, Mmp, MODE_READ, false);
 
   if (h == INVALID_HANDLE_VALUE || (!Mmp->lenH && !Mmp->lenL)) {
     if (!(*g->Message))
@@ -2379,7 +2257,6 @@ void *XFILE::FileView(PGLOBAL g, char *fn, int loff, int hoff, int size)
   CloseFileHandle(h);                    // Not used anymore
   return Mmp->memory;
   } // end of FileView
-#endif // not WIN32
 #endif // XMAP
 
 /* -------------------------- XHUGE Class --------------------------- */
@@ -2564,42 +2441,6 @@ bool XHUGE::Open(PGLOBAL g, char *filename, int id, MODE mode)
   return false;
   } // end of Open
 
-#if 0
-/***********************************************************************/
-/*  Get the offset of this index in the index file.                    */
-/***********************************************************************/
-bool XHUGE::GetOff(int& low, int& high, PIXDEF sxp)
-  {
-  if (!sxp) {
-    low = 0;
-    high = 0;
-    return false;
-    } // endif sxp
-
-#if defined(WIN32)
-  LARGE_INTEGER ln;
-
-  ln.LowPart = sxp->GetOffset();
-  ln.HighPart = sxp->GetOffhigh();
-  ln.QuadPart += (LONGLONG)sxp->GetSize();
-  low = ln.LowPart;
-  high = (int)ln.HighPart;
-#else  // UNIX
-#define G4   ((off64_t)0x100 * (off64_t)0x1000000)
-#if defined(TRACE)
-  printf("in GetOff...\n");
-#endif   // TRACE
-  off64_t pos;
-
-  pos  = (off64_t)sxp->GetOffset() + (off64_t)sxp->GetOffhigh() * G4;
-  pos += (off64_t)sxp->GetSize();
-  low  = (int)(pos % G4);
-  high = (int)(pos / G4);
-#endif // UNIX
-  return false;
-  } // end of GetOff
-#endif // 0
-
 /***********************************************************************/
 /*  Go to position in a huge file.                                     */
 /***********************************************************************/
@@ -2755,111 +2596,14 @@ void XHUGE::Close(char *fn, int id)
   } // end of Close
 
 #if defined(XMAP)
-#if defined(WIN32)
-/***********************************************************************/
-/*  Return a pointer to the segment at the given offset and size.      */
-/***********************************************************************/
-void *XHUGE::FileView(PGLOBAL g, char *fn, int loff, int hoff, int size)
-  {
-  SYSTEM_INFO SysInfo;  // system information; used to get the granularity
-  char   *pData;        // pointer to the data
-  int     iViewDelta;   // the offset into the view where the data shows up
-  HANDLE hMapFile;      // handle for the file's memory-mapped region
-  LARGE_INTEGER lint;   // a utility holder
-  __int64 offset;       // Where to start in the index file
-  __int64 FileMapSize;  // size of the file mapping
-  __int64 FileMapStart; // where in the file to start the file map view
-  __int64 Granularity;  // system allocation granularity
-  DWORD   MapViewSize;  // the size of the view
-
-  // Open the file in mode read only
-  if (Open(g, fn, MODE_READ))
-    return NULL;
-
-  // Get the system allocation granularity.
-  GetSystemInfo(&SysInfo);
-  Granularity = (__int64)SysInfo.dwAllocationGranularity;
-
-  // Calculate the offset as a 64 byte integer
-  lint.LowPart = loff;
-  lint.HighPart = hoff;
-  offset = lint.QuadPart;
-
-  // To calculate where to start the file mapping, round down the
-  // offset of the data into the file to the nearest multiple of the
-  // system allocation granularity.
-  FileMapStart = (offset / Granularity) * Granularity;
-
-  // Calculate the size of the file mapping view.
-  MapViewSize = (DWORD)(offset % Granularity) + (DWORD)size;
-
-  // How large will the file-mapping object be?
-  FileMapSize = offset + (__int64)size;
-
-  // The data of interest isn't at the beginning of the
-  // view, so determine how far into the view to set the pointer.
-  iViewDelta = (int)(offset - FileMapStart);
-
-  // Let the user know that the index file is more than large enough
-  lint.LowPart = GetFileSize(Hfile,  (LPDWORD)&lint.HighPart);
-
-  // Prepare the low and high parts of the size.
-  lint.QuadPart = FileMapSize;
-
-  // Create a file-mapping object for the file.
-  hMapFile = CreateFileMapping( Hfile,            // current file handle
-                                NULL,             // default security
-                                PAGE_READONLY,    // permission
-                                lint.HighPart,    // size, high
-                                lint.LowPart,     // size, low
-                                NULL);            // name
-
-  if (hMapFile == NULL) {
-    sprintf(g->Message, MSG(HANDLE_IS_NULL), "hMapFile",  GetLastError());
-    return NULL;
-    } // endif hMapFile
-
-  // Prepare the low and high parts of the starting file offset.
-  lint.QuadPart = FileMapStart;
-
-  // Map the view.
-  ViewBase = MapViewOfFile(hMapFile,      // handle to mapping object
-                           FILE_MAP_READ, // access mode
-                           lint.HighPart, // high-order 32 bits of file offset
-                           lint.LowPart,  // low-order 32 bits of file offset
-                           MapViewSize);  // number of bytes to map
-
-  if (!ViewBase) {
-    sprintf(g->Message, MSG(HANDLE_IS_NULL), "ViewBase", GetLastError());
-    return NULL;
-    } // endif ViewBase
-
-  // Calculate the pointer to the data.
-  pData = (char *)ViewBase + iViewDelta;
-
-  // close the file-mapping object
-  if (!CloseHandle(hMapFile))
-    sprintf(g->Message, MSG(MAP_OBJ_ERR), GetLastError());
-
-  // close the file itself
-  if (!CloseHandle(Hfile))
-    sprintf(g->Message, MSG(FILE_CLOSE_ERR), GetLastError());
-  else
-    Hfile = INVALID_HANDLE_VALUE;
-
-  return pData;
-  } // end of FileView
-#else  // not WIN32
 /***********************************************************************/
-/*  Don't know whether this is possible for non Windows OS.            */
+/*  Don't know whether this is possible for huge files.                */
 /***********************************************************************/
-void *XHUGE::FileView(PGLOBAL g, char *fn,
-                         int loff, int hoff, int size)
+void *XHUGE::FileView(PGLOBAL g, char *fn)
   {
   strcpy(g->Message, MSG(NO_PART_MAP));
   return NULL;
   } // end of FileView
-#endif   // not WIN32
 #endif   // XMAP
 
 /* -------------------------- XXROW Class --------------------------- */
diff --git a/storage/connect/xindex.h b/storage/connect/xindex.h
index 17ff53888d9..f2da7a23a02 100644
--- a/storage/connect/xindex.h
+++ b/storage/connect/xindex.h
@@ -1,7 +1,7 @@
 /*************** Xindex H Declares Source Code File (.H) ***************/
-/*  Name: XINDEX.H    Version 3.4                                      */
+/*  Name: XINDEX.H    Version 3.5                                      */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2004 - 2012  */
+/*  (C) Copyright to the author Olivier BERTRAND          2004 - 2013  */
 /*                                                                     */
 /*  This file contains the XINDEX class declares.                      */
 /***********************************************************************/
@@ -11,12 +11,17 @@
 #include "csort.h"            /* Base class declares                   */
 #include "xtable.h"
 #include "valblk.h"
+#if defined(XMAP)
+#include "maputil.h"
+#endif   // XMAP
 
 enum IDT {TYPE_IDX_ERROR = 0,         /* Type not defined              */
           TYPE_IDX_INDX  = 4,         /* Permanent standard index      */
           TYPE_IDX_XROW  = 5};        /* Permanent row index           */
 
-typedef struct mem_map  *MMP;
+#if defined(XMAP)
+typedef        MEMMAP   *MMP;
+#endif   // XMAP
 typedef class  INDEXDEF *PIXDEF;
 typedef class  KPARTDEF *PKPDEF;
 typedef class  XINDEX   *PXINDEX;
@@ -96,8 +101,8 @@ class DllExport INDEXDEF : public BLOCK { /* Index description block   */
 //void    SetOffset(int off) {Offset = off;}
 //int     GetOffhigh(void) {return Offhigh;}
 //void    SetOffhigh(int hof) {Offhigh = hof;}
-  int     GetSize(void) {return Size;}
-  void    SetSize(int size) {Size = size;}
+//int     GetSize(void) {return Size;}
+//void    SetSize(int size) {Size = size;}
   int     GetMaxSame(void) {return MaxSame;}
   bool    Define(PGLOBAL g, void *memp, PTABDEF dfp, LPCSTR p);
   PIXDEF  GetIndexOf(PCOL colp, bool hd = false);
@@ -119,7 +124,7 @@ class DllExport INDEXDEF : public BLOCK { /* Index description block   */
   int     ID;                 /* Index ID number                       */
 //int     Offset;             /* Offset in index file                  */
 //int     Offhigh;            /* Offset high in big index file         */
-  int     Size;               /* Size of index file                    */
+//int     Size;               /* Size of index file                    */
   int     MaxSame;            /* Max number of same values             */
   }; // end of INDEXDEF
 
@@ -246,9 +251,9 @@ class DllExport XINDEX : public XXBASE {
   virtual int  GetCurPos(void) {return (Pex) ? Pex[Cur_K] : Cur_K;}
   virtual void SetNval(int n) {Nval = n;}
           int  GetMaxSame(void) {return MaxSame;}
-          int  GetDefoff(void) {return Defoff;}
-          int  GetDefhigh(void) {return Defhigh;}
-          int  GetSize(void) {return Size;}
+//        int  GetDefoff(void) {return Defoff;}
+//        int  GetDefhigh(void) {return Defhigh;}
+//        int  GetSize(void) {return Size;}
 
   // Methods
   virtual void Reset(void);
@@ -281,9 +286,9 @@ class DllExport XINDEX : public XXBASE {
   int     Nk;               // The number of indexed columns
   int     Nval;             // The number of used columns
   int     Incr;             // Increment of record position
-  int     Defoff;           // Offset of definition in index file
-  int     Defhigh;          // High order of offset big value
-  int     Size;             // Size of definition in index file
+//int     Defoff;           // Offset of definition in index file
+//int     Defhigh;          // High order of offset big value
+//int     Size;             // Size of definition in index file
   int     MaxSame;          // Max number of same values
   }; // end of class XINDEX
 
@@ -324,7 +329,6 @@ class DllExport XLOAD : public BLOCK {
 
   // Methods
   virtual bool  Open(PGLOBAL g, char *filename, int id, MODE mode) = 0;
-//virtual bool  GetOff(int& low, int& high, PIXDEF sxp) = 0;
   virtual bool  Seek(PGLOBAL g, int low, int high, int origin) = 0;
   virtual bool  Read(PGLOBAL g, void *buf, int n, int size) = 0;
   virtual int   Write(PGLOBAL g, void *buf, int n,
@@ -332,8 +336,7 @@ class DllExport XLOAD : public BLOCK {
   virtual void  Close(char *fn, int id) = 0;
   virtual void  Close(void);
 #if defined(XMAP)
-  virtual void *FileView(PGLOBAL g, char *fn, int loff,
-                                              int hoff, int size) = 0;
+  virtual void *FileView(PGLOBAL g, char *fn) = 0;
 #endif   // XMAP
 
  protected:
@@ -359,22 +362,20 @@ class DllExport XFILE : public XLOAD {
 
   // Methods
   virtual bool  Open(PGLOBAL g, char *filename, int id, MODE mode);
-//virtual bool  GetOff(int& low, int& high, PIXDEF sxp);
   virtual bool  Seek(PGLOBAL g, int low, int high, int origin);
   virtual bool  Read(PGLOBAL g, void *buf, int n, int size);
   virtual int   Write(PGLOBAL g, void *buf, int n, int size, bool& rc);
   virtual void  Close(char *fn, int id);
   virtual void  Close(void);
 #if defined(XMAP)
-  virtual void *FileView(PGLOBAL g, char *fn, int loff,
-                                              int hoff, int size);
+  virtual void *FileView(PGLOBAL g, char *fn);
 #endif   // XMAP
 
  protected:
   // Members
   FILE   *Xfile;            // Index stream file
-#if defined(XMAP) && !defined(WIN32)
-  MMP     Mmp;              // To UNIX mapped index file
+#if defined(XMAP)
+  MMP     Mmp;              // To mapped index file
 #endif   // XMAP
   }; // end of class XFILE
 
@@ -388,14 +389,12 @@ class DllExport XHUGE : public XLOAD {
 
   // Methods
   virtual bool  Open(PGLOBAL g, char *filename, int id, MODE mode);
-//virtual bool  GetOff(int& low, int& high, PIXDEF sxp);
   virtual bool  Seek(PGLOBAL g, int low, int high, int origin);
   virtual bool  Read(PGLOBAL g, void *buf, int n, int size);
   virtual int   Write(PGLOBAL g, void *buf, int n, int size, bool& rc);
   virtual void  Close(char *fn, int id);
 #if defined(XMAP)
-  virtual void *FileView(PGLOBAL g, char *fn, int loff,
-                                              int hoff, int size);
+  virtual void *FileView(PGLOBAL g, char *fn);
 #endif   // XMAP
 
  protected: