Adding upstream version 1:10.11.6.upstream/1%10.11.6upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1614 insertions, 0 deletions

diff --git a/storage/connect/plgdbutl.cpp b/storage/connect/plgdbutl.cpp
new file mode 100644
index 00000000..68641129
--- /dev/null
+++ b/storage/connect/plgdbutl.cpp
@@ -0,0 +1,1614 @@
+/********** PlgDBUtl Fpe C++ Program Source Code File (.CPP) ***********/
+/* PROGRAM NAME: PLGDBUTL                                              */
+/* -------------                                                       */
+/*  Version 4.1                                                        */
+/*                                                                     */
+/* COPYRIGHT:                                                          */
+/* ----------                                                          */
+/*  (C) Copyright to the author Olivier BERTRAND          1998-2020    */
+/*                                                                     */
+/* WHAT THIS PROGRAM DOES:                                             */
+/* -----------------------                                             */
+/*  Utility functions used by DB semantic routines.                    */
+/*                                                                     */
+/* WHAT YOU NEED TO COMPILE THIS PROGRAM:                              */
+/* --------------------------------------                              */
+/*                                                                     */
+/*  REQUIRED FILES:                                                    */
+/*  ---------------                                                    */
+/*  See Readme.C for a list and description of required SYSTEM files.  */
+/*                                                                     */
+/*    PLGDBUTL.C     - Source code                                     */
+/*    GLOBAL.H       - Global declaration file                         */
+/*    PLGDBSEM.H     - DB application declaration file                 */
+/*                                                                     */
+/*  REQUIRED LIBRARIES:                                                */
+/*  -------------------                                                */
+/*    OS2.LIB        - OS2 libray                                      */
+/*    LLIBCE.LIB     - Protect mode/standard combined large model C    */
+/*                     library                                         */
+/*                                                                     */
+/*  REQUIRED PROGRAMS:                                                 */
+/*  ------------------                                                 */
+/*    IBM, MS, Borland or GNU C++ Compiler                             */
+/*    IBM, MS, Borland or GNU Linker                                   */
+/***********************************************************************/
+
+/***********************************************************************/
+/*  Include relevant MariaDB header file.                              */
+/***********************************************************************/
+#include "my_global.h"
+#include "my_pthread.h"
+#if defined(_WIN32)
+#include <io.h>
+#include <fcntl.h>
+#include <errno.h>
+#define BIGMEM         1048576            // 1 Megabyte
+#else     // !_WIN32
+#include <unistd.h>
+#include <fcntl.h>
+//#if defined(THREAD)
+#include <pthread.h>
+//#endif   // THREAD
+#include <stdarg.h>
+#define BIGMEM      2147483647            // Max int value
+#endif    // !_WIN32
+#include <locale.h>
+
+/***********************************************************************/
+/*  Include application header files                                   */
+/***********************************************************************/
+#include "global.h"    // header containing all global declarations.
+#include "plgdbsem.h"  // header containing the DB applic. declarations.
+#include "preparse.h"  // For DATPAR
+#include "osutil.h"
+#include "maputil.h"
+#include "catalog.h"
+#include "colblk.h"
+#include "xtable.h"    // header of TBX, TDB and TDBASE classes
+#include "tabcol.h"    // header of XTAB and COLUMN classes
+#include "valblk.h"
+#include "rcmsg.h"
+#ifdef ZIP_SUPPORT
+#include "filamzip.h"
+#endif // ZIP_SUPPORT
+#ifdef JAVA_SUPPORT
+#include "javaconn.h"
+#endif // JAVA_SUPPORT
+#ifdef CMGO_SUPPORT
+#include "cmgoconn.h"
+#endif // JAVA_SUPPORT
+
+/***********************************************************************/
+/*  DB static variables.                                               */
+/***********************************************************************/
+bool  Initdone = false;
+bool  plugin = false;  // True when called by the XDB plugin handler 
+
+extern "C" {
+extern char version[];
+} // extern "C"
+
+//#if defined(_WIN32)
+//extern CRITICAL_SECTION parsec;      // Used calling the Flex parser
+//#else   // !_WIN32
+extern pthread_mutex_t parmut;
+//#endif  // !_WIN32
+
+// The debug trace used by the main thread
+FILE *pfile = NULL;
+
+MBLOCK Nmblk = {NULL, false, 0, false, NULL};   // Used to init MBLOCK's
+
+/***********************************************************************/
+/*  Routines called externally and internally by utility routines.     */
+/***********************************************************************/
+bool PlugEvalLike(PGLOBAL, LPCSTR, LPCSTR, bool);
+bool EvalLikePattern(LPCSTR, LPCSTR);
+void PlugConvertConstant(PGLOBAL, void* &, short&);
+
+#ifdef DOMDOC_SUPPORT
+void CloseXMLFile(PGLOBAL, PFBLOCK, bool);
+#endif   // DOMDOC_SUPPORT
+
+#ifdef LIBXML2_SUPPORT
+#include "libdoc.h"
+#endif   // LIBXML2_SUPPORT
+
+#ifdef ODBC_SUPPORT
+void OdbcClose(PGLOBAL g, PFBLOCK fp);
+#endif   // ODBC_SUPPORT
+
+/***********************************************************************/
+/* Routines for file IO with error reporting to g->Message             */
+/* Note: errno and strerror must be called before the message file     */
+/* is read in the case of XMSG compile.                                */
+/***********************************************************************/
+static void global_open_error_msg(GLOBAL *g, int msgid, const char *path, 
+                                                        const char *mode)
+{
+  int  len, rno= (int)errno;
+  char errmsg[256]= "";
+
+  strncat(errmsg, strerror(errno), 255);
+
+  switch (msgid)
+  {
+    case MSGID_CANNOT_OPEN:
+      len= snprintf(g->Message, sizeof(g->Message) - 1,
+                    MSG(CANNOT_OPEN), // Cannot open %s
+                    path);
+      break;
+
+    case MSGID_OPEN_MODE_ERROR:
+      len= snprintf(g->Message, sizeof(g->Message) - 1,
+                    MSG(OPEN_MODE_ERROR), // "Open(%s) error %d on %s"
+                    mode, rno, path);
+      break;
+
+    case MSGID_OPEN_MODE_STRERROR:
+      {char fmt[256];
+      strcat(strcpy(fmt, MSG(OPEN_MODE_ERROR)), ": %s");
+      len= snprintf(g->Message, sizeof(g->Message) - 1,
+                    fmt, // Open(%s) error %d on %s: %s
+                    mode, rno, path, errmsg);
+      }break;
+
+    case MSGID_OPEN_STRERROR:
+      len= snprintf(g->Message, sizeof(g->Message) - 1,
+                    MSG(OPEN_STRERROR), // "open error: %s"
+                    errmsg);
+      break;
+
+    case MSGID_OPEN_ERROR_AND_STRERROR:
+      len= snprintf(g->Message, sizeof(g->Message) - 1,
+                    //OPEN_ERROR does not work, as it wants mode %d (not %s)
+                    //MSG(OPEN_ERROR) "%s",// "Open error %d in mode %d on %s: %s"
+                    "Open error %d in mode %s on %s: %s",
+                    rno, mode, path, errmsg);
+      break;
+
+    case MSGID_OPEN_EMPTY_FILE:
+      len= snprintf(g->Message, sizeof(g->Message) - 1,
+                    MSG(OPEN_EMPTY_FILE), // "Opening empty file %s: %s"
+                    path, errmsg);
+      break;
+
+    default:
+      DBUG_ASSERT(0);
+      /* Fall through*/
+    case 0:
+      len= 0;
+  }
+  g->Message[len]= '\0';
+}
+
+
+FILE *global_fopen(GLOBAL *g, int msgid, const char *path, const char *mode)
+{
+  FILE *f;
+  if (!(f= fopen(path, mode)))
+    global_open_error_msg(g, msgid, path, mode);
+  return f;
+}
+
+
+int global_open(GLOBAL *g, int msgid, const char *path, int flags)
+{
+  int h;
+  if ((h= open(path, flags)) <= 0)
+    global_open_error_msg(g, msgid, path, "");
+  return h;
+}
+
+
+int global_open(GLOBAL *g, int msgid, const char *path, int flags, int mode)
+{
+  int h;
+  if ((h= open(path, flags, mode)) <= 0)
+  {
+    char modestr[64];
+    snprintf(modestr, sizeof(modestr), "%d", mode);
+    global_open_error_msg(g, msgid, path, modestr);
+  }
+  return h;
+}
+
+DllExport void SetTrc(void)
+{
+  // If tracing is on, debug must be initialized.
+  debug = pfile;
+} // end of SetTrc
+
+/**************************************************************************/
+/*  SubAllocate the result structure that will contain result data.       */
+/**************************************************************************/
+PQRYRES PlgAllocResult(PGLOBAL g, int ncol, int maxres, int ids,
+                       int *buftyp, XFLD *fldtyp, 
+                       unsigned int *length, bool blank, bool nonull)
+{
+  char     cname[NAM_LEN+1];
+  int      i;
+  PCOLRES *pcrp, crp;
+  PQRYRES  qrp;
+
+	try {
+		/**********************************************************************/
+		/*  Allocate the structure used to contain the result set.            */
+		/**********************************************************************/
+		qrp = (PQRYRES)PlugSubAlloc(g, NULL, sizeof(QRYRES));
+		pcrp = &qrp->Colresp;
+		qrp->Continued = false;
+		qrp->Truncated = false;
+		qrp->Info = false;
+		qrp->Suball = true;
+		qrp->Maxres = maxres;
+		qrp->Maxsize = 0;
+		qrp->Nblin = 0;
+		qrp->Nbcol = 0;                                     // will be ncol
+		qrp->Cursor = 0;
+		qrp->BadLines = 0;
+
+		for (i = 0; i < ncol; i++) {
+			*pcrp = (PCOLRES)PlugSubAlloc(g, NULL, sizeof(COLRES));
+			crp = *pcrp;
+			pcrp = &crp->Next;
+			memset(crp, 0, sizeof(COLRES));
+			crp->Colp = NULL;
+			crp->Ncol = ++qrp->Nbcol;
+			crp->Type = buftyp[i];
+			crp->Length = length[i];
+			crp->Clen = GetTypeSize(crp->Type, length[i]);
+			crp->Prec = 0;
+
+			if (ids > 0) {
+#if defined(XMSG)
+				// Get header from message file
+				strncpy(cname, PlugReadMessage(g, ids + crp->Ncol, NULL), NAM_LEN);
+				cname[NAM_LEN] = 0;					// for truncated long names
+#else   // !XMSG
+				GetRcString(ids + crp->Ncol, cname, sizeof(cname));
+#endif  // !XMSG
+				crp->Name = (PSZ)PlugDup(g, cname);
+			} else
+				crp->Name = NULL;           // Will be set by caller
+
+			if (fldtyp)
+				crp->Fld = fldtyp[i];
+			else
+				crp->Fld = FLD_NO;
+
+			// Allocate the Value Block that will contain data
+			if (crp->Length || nonull)
+				crp->Kdata = AllocValBlock(g, NULL, crp->Type, maxres,
+					crp->Length, 0, true, blank, false);
+			else
+				crp->Kdata = NULL;
+
+			if (trace(1))
+				htrc("Column(%d) %s type=%d len=%d value=%p\n",
+					crp->Ncol, crp->Name, crp->Type, crp->Length, crp->Kdata);
+
+		} // endfor i
+
+		*pcrp = NULL;
+
+	} catch (int n) {
+  	htrc("Exception %d: %s\n", n, g->Message);
+	  qrp = NULL;
+  } catch (const char *msg) {
+  	strcpy(g->Message, msg);
+	  htrc("%s\n", g->Message);
+	  qrp = NULL;
+  } // end catch
+
+	return qrp;
+} // end of PlgAllocResult
+
+/***********************************************************************/
+/*  Allocate and initialize the new DB User Block.                     */
+/***********************************************************************/
+PDBUSER PlgMakeUser(PGLOBAL g)
+  {
+  PDBUSER dbuserp;
+
+  if (!(dbuserp = (PDBUSER)malloc(sizeof(DBUSERBLK)))) {
+    snprintf(g->Message, sizeof(g->Message), MSG(MALLOC_ERROR), "PlgMakeUser");
+    return NULL;
+    } // endif dbuserp
+
+  memset(dbuserp, 0, sizeof(DBUSERBLK));
+  dbuserp->Maxbmp = MAXBMP;
+//dbuserp->UseTemp = TMP_AUTO;
+  dbuserp->Check = CHK_ALL;
+  strcpy(dbuserp->Server, "CONNECT");
+  return dbuserp;
+  } // end of PlgMakeUser
+
+/***********************************************************************/
+/*  PlgGetUser: returns DBUSER block pointer.                          */
+/***********************************************************************/
+PDBUSER PlgGetUser(PGLOBAL g)
+  {
+  PDBUSER dup = (PDBUSER)((g->Activityp) ? g->Activityp->Aptr : NULL);
+
+  if (!dup)
+    strcpy(g->Message, MSG(APPL_NOT_INIT));
+
+  return dup;
+  } // end of PlgGetUser
+
+/***********************************************************************/
+/*  PlgGetCatalog: returns CATALOG class pointer.                      */
+/***********************************************************************/
+PCATLG PlgGetCatalog(PGLOBAL g, bool jump)
+  {
+  PDBUSER dbuserp = PlgGetUser(g);
+  PCATLG  cat = (dbuserp) ? dbuserp->Catalog : NULL;
+
+  if (!cat && jump) {
+    // Raise exception so caller doesn't have to check return value
+    strcpy(g->Message, MSG(NO_ACTIVE_DB));
+		throw 1;
+	} // endif cat
+
+  return cat;
+  } // end of PlgGetCatalog
+
+#if 0
+/***********************************************************************/
+/*  PlgGetDataPath: returns the default data path.                     */
+/***********************************************************************/
+char *PlgGetDataPath(PGLOBAL g)
+  {
+  PCATLG cat = PlgGetCatalog(g, false);
+
+  return (cat) ? cat->GetDataPath() : NULL;
+  } // end of PlgGetDataPath
+#endif // 0
+
+/***********************************************************************/
+/*  This function returns a database path.                             */
+/***********************************************************************/
+char *SetPath(PGLOBAL g, const char *path)
+{
+  char *buf= NULL;
+
+	if (path) {
+		size_t len = strlen(path) + (*path != '.' ? 4 : 1);
+
+		if (!(buf = (char*)PlgDBSubAlloc(g, NULL, len)))
+			return NULL;
+
+		if (PlugIsAbsolutePath(path)) {
+			snprintf(buf, len, "%s", path);
+			return buf;
+		} // endif path
+
+		if (*path != '.') {
+#if defined(_WIN32)
+			const char *s = "\\";
+#else   // !_WIN32
+			const char *s = "/";
+#endif  // !_WIN32
+			snprintf(buf, len, ".%s%s%s", s, path, s);
+		} else
+			snprintf(buf, len, "%s", path);
+
+	} // endif path
+
+  return buf;
+} // end of SetPath
+
+/***********************************************************************/
+/*  Extract from a path name the required component.                   */
+/*  This function assumes there is enough space in the buffer.         */
+/***********************************************************************/
+char *ExtractFromPath(PGLOBAL g, char *pBuff, char *FileName, OPVAL op)
+  {
+  char *drive = NULL, *direc = NULL, *fname = NULL, *ftype = NULL;
+
+  switch (op) {           // Determine which part to extract
+#if defined(_WIN32)
+    case OP_FDISK: drive = pBuff; break;
+#endif   // !UNIX
+    case OP_FPATH: direc = pBuff; break;
+    case OP_FNAME: fname = pBuff; break;
+    case OP_FTYPE: ftype = pBuff; break;
+    default:
+      snprintf(g->Message, sizeof(g->Message), MSG(INVALID_OPER), op, "ExtractFromPath");
+      return NULL;
+    } // endswitch op
+
+  // Now do the extraction
+  _splitpath(FileName, drive, direc, fname, ftype);
+  return pBuff;
+  } // end of PlgExtractFromPath
+
+
+#ifdef NOT_USED
+/***********************************************************************/
+/*  Check the occurrence and matching of a pattern against a string.    */
+/*  Because this function is only used for catalog name checking,      */
+/*  it must be case insensitive.                                       */
+/***********************************************************************/
+static bool PlugCheckPattern(PGLOBAL g, LPCSTR string, LPCSTR pat)
+  {
+  if (pat && strlen(pat)) {
+    // This leaves 2048 bytes (MAX_STR / 2) for each components
+    LPSTR name = g->Message + MAX_STR / 2;
+
+    strlwr(strcpy(name, string));
+    strlwr(strcpy(g->Message, pat));         // Can be modified by Eval
+    return EvalLikePattern(name, g->Message);
+  } else
+    return true;
+
+  } // end of PlugCheckPattern
+#endif /* NOT_USED */
+
+/***********************************************************************/
+/*  PlugEvalLike: evaluates a LIKE clause.                             */
+/*  Syntaxe: M like P escape C. strg->M, pat->P, C not implemented yet */
+/***********************************************************************/
+bool PlugEvalLike(PGLOBAL g, LPCSTR strg, LPCSTR pat, bool ci)
+  {
+  char *tp, *sp;
+  bool  b;
+
+  if (trace(2))
+    htrc("LIKE: strg='%s' pattern='%s'\n", strg, pat);
+
+  if (ci) {                        /* Case insensitive test             */
+    if (strlen(pat) + strlen(strg) + 1 < MAX_STR)
+      tp = g->Message;
+    else if (!(tp = new char[strlen(pat) + strlen(strg) + 2])) {
+      strcpy(g->Message, MSG(NEW_RETURN_NULL));
+			throw (int)OP_LIKE;
+		} /* endif tp */
+    
+    sp = tp + strlen(pat) + 1;
+    strlwr(strcpy(tp, pat));      /* Make a lower case copy of pat     */
+    strlwr(strcpy(sp, strg));     /* Make a lower case copy of strg    */
+  } else {                        /* Case sensitive test               */
+    if (strlen(pat) < MAX_STR)    /* In most of the case for small pat */
+      tp = g->Message;            /* Use this as temporary work space. */
+    else if (!(tp = new char[strlen(pat) + 1])) {
+      strcpy(g->Message, MSG(NEW_RETURN_NULL));
+			throw (int)OP_LIKE;
+		} /* endif tp */
+    
+    strcpy(tp, pat);                  /* Make a copy to be worked into */
+    sp = (char*)strg;
+  } /* endif ci */
+
+  b = EvalLikePattern(sp, tp);
+
+  if (tp != g->Message)               /* If working space was obtained */
+    delete [] tp;                     /* by the use of new, delete it. */
+
+  return (b);
+  } /* end of PlugEvalLike */
+
+/***********************************************************************/
+/*  M and P are variable length character string. If M and P are zero  */
+/*  length strings then the Like predicate is true.                    */
+/*                                                                     */
+/*  The Like predicate is true if:                                     */
+/*                                                                     */
+/*  1- A subtring of M is a sequence of 0 or more contiguous <CR> of M */
+/*     and each <CR> of M is part of exactly one substring.            */
+/*                                                                     */
+/*  2- If the i-th <subtring-specifyer> of P is an <arbitrary-char-    */
+/*     specifier>, the i-th subtring of M is any single <CR>.          */
+/*                                                                     */
+/*  3- If the i-th <subtring-specifyer> of P is an <arbitrary-string-  */
+/*     specifier>, then the i-th subtring of M is any sequence of zero */
+/*     or more <CR>.                                                   */
+/*                                                                     */
+/*  4- If the i-th <subtring-specifyer> of P is neither an <arbitrary- */
+/*     character-specifier> nor an <arbitrary-string-specifier>, then  */
+/*     the i-th substring of M is equal to that <substring-specifier>  */
+/*     according to the collating sequence of the <like-predicate>,    */
+/*     without the appending of <space-character>, and has the same    */
+/*     length as that <substring-specifier>.                           */
+/*                                                                     */
+/*  5- The number of substrings of M is equal to the number of         */
+/*     <subtring-specifiers> of P.                                     */
+/*                                                                     */
+/*  Otherwise M like P is false.                                       */
+/***********************************************************************/
+bool EvalLikePattern(LPCSTR sp, LPCSTR tp)
+  {
+  LPSTR p;
+  char  c;
+  ssize_t   n;
+  bool  b, t = false;
+
+  if (trace(2))
+    htrc("Eval Like: sp=%s tp=%s\n", 
+         (sp) ? sp : "Null", (tp) ? tp : "Null");
+
+  /********************************************************************/
+  /*  If pattern is void, Like is true only if string is also void.   */
+  /********************************************************************/
+  if (!*tp)
+    return (!*sp);
+
+  /********************************************************************/
+  /*  Analyse eventual arbitrary specifications ahead of pattern.     */
+  /********************************************************************/
+  for (p = (LPSTR)tp; p;)
+    switch (*p) {                     /*   it can contain % and/or _   */
+      case '%':                       /* An % has been found           */
+        t = true;                     /* Note eventual character skip  */
+        p++;
+        break;
+      case '_':                       /* An _ has been found           */
+        if (*sp) {                    /* If more character in string   */
+          sp++;                       /*   skip it                     */
+          p++;
+        } else
+          return false;               /* Like condition is not met     */
+
+        break;
+      default:
+        tp = p;                       /* Point to rest of template     */
+        p = NULL;                     /* To stop For loop              */
+        break;
+      } /* endswitch */
+
+  if ((p = (LPSTR)strpbrk(tp, "%_"))) /* Get position of next % or _   */
+    n = p - tp;
+  else
+    n = strlen(tp);                   /* Get length of pattern head    */
+
+  if (trace(2))
+    htrc(" testing: t=%d sp=%s tp=%s p=%p\n", t, sp, tp, p);
+
+  if (n > (signed)strlen(sp))         /* If head is longer than strg   */
+    b = false;                        /* Like condition is not met     */
+  else if (n == 0)                    /* If void <substring-specifier> */
+    b = (t || !*sp);                  /*   true if %  or void strg.    */
+  else if (!t) {
+    /*******************************************************************/
+    /*  No character to skip, check occurrence of <subtring-specifier>  */
+    /*  at the very beginning of remaining string.                     */
+    /*******************************************************************/
+    if (p) {
+      if ((b = !strncmp(sp, tp, n)))
+        b = EvalLikePattern(sp + n, p);
+
+    } else
+      b = !strcmp(sp, tp);            /*   strg and tmp heads match    */
+
+  } else
+    if (p)
+      /*****************************************************************/
+      /*  Here is the case explaining why we need a recursive routine. */
+      /*  The test must be done not only against the first occurrence   */
+      /*  of the <substring-specifier> in the remaining string,        */
+      /*  but also with all eventual succeeding ones.                  */
+      /*****************************************************************/
+      for (b = false, c = *p; !b && (signed)strlen(sp) >= n; sp++) {
+        *p = '\0';                    /* Separate pattern header       */
+
+        if ((sp = strstr(sp, tp))) {
+          *p = c;
+          b = EvalLikePattern(sp + n, p);
+        } else {
+          *p = c;
+          b = false;
+          break;
+        } /* endif s */
+
+        } /* endfor b, sp */
+
+    else {
+      sp += (strlen(sp) - n);
+      b = !strcmp(sp, tp);
+    } /* endif p */
+
+  if (trace(2))
+    htrc(" done: b=%d n=%d sp=%s tp=%s\n",
+          b, n, (sp) ? sp : "Null", tp);
+
+  return (b);
+  } /* end of EvalLikePattern */
+
+/***********************************************************************/
+/*  MakeEscape: Escape some characters in a string.                    */
+/***********************************************************************/
+char *MakeEscape(PGLOBAL g, char* str, char q)
+  {
+  char *bufp;
+  int i, k, n = 0, len = (int)strlen(str);
+
+  for (i = 0; i < len; i++)
+    if (str[i] == q || str[i] == '\\')
+      n++;
+
+  if (!n)
+    return str;
+  else
+    bufp = (char*)PlugSubAlloc(g, NULL, len + n + 1);
+
+  for (i = k = 0; i < len; i++) {
+    if (str[i] == q || str[i] == '\\')
+      bufp[k++] = '\\';
+
+    bufp[k++] = str[i];
+    } // endfor i
+
+  bufp[k] = 0;
+  return bufp;
+  } /* end of MakeEscape */
+
+/***********************************************************************/
+/*  PlugConvertConstant: convert a Plug constant to an Xobject.        */
+/***********************************************************************/
+void PlugConvertConstant(PGLOBAL g, void* & value, short& type)
+  {
+  if (trace(1))
+    htrc("PlugConvertConstant: value=%p type=%hd\n", value, type);
+
+  if (type != TYPE_XOBJECT) {
+    value = new(g) CONSTANT(g, value, type);
+    type = TYPE_XOBJECT;
+    } // endif type
+
+  } // end of PlugConvertConstant
+
+/***********************************************************************/
+/*  Call the Flex preparser to convert a date format to a sscanf input */
+/*  format and a Strftime output format. Flag if not 0 indicates that  */
+/*  non quoted blanks are not included in the output format.           */
+/***********************************************************************/
+PDTP MakeDateFormat(PGLOBAL g, PCSZ dfmt, bool in, bool out, int flag)
+{
+	int  rc;
+  PDTP pdp = (PDTP)PlugSubAlloc(g, NULL, sizeof(DATPAR));
+
+  if (trace(1))
+    htrc("MakeDateFormat: dfmt=%s\n", dfmt);
+
+  memset(pdp, 0, sizeof(DATPAR));
+  pdp->Format = pdp->Curp = PlugDup(g, dfmt);
+  pdp->Outsize = 2 * strlen(dfmt) + 1;
+
+  if (in)
+    pdp->InFmt = (char*)PlugSubAlloc(g, NULL, pdp->Outsize);
+
+  if (out)
+    pdp->OutFmt = (char*)PlugSubAlloc(g, NULL, pdp->Outsize);
+
+  pdp->Flag = flag;
+
+  /*********************************************************************/
+  /* Call the FLEX generated parser. In multi-threading mode the next  */
+  /* instruction is protected by mutex fmdflex using static variables. */
+  /*********************************************************************/
+  pthread_mutex_lock(&parmut);
+  rc = fmdflex(pdp);
+  pthread_mutex_unlock(&parmut);
+
+  if (trace(1))
+    htrc("Done: in=%s out=%s rc=%d\n", SVP(pdp->InFmt), SVP(pdp->OutFmt), rc);
+
+  return pdp;
+} // end of MakeDateFormat
+
+/***********************************************************************/
+/* Extract the date from a formatted string according to format.       */
+/***********************************************************************/
+int ExtractDate(char *dts, PDTP pdp, int defy, int val[6])
+  {
+	PCSZ fmt;
+	char c, d, e, W[8][12];
+  int  i, k, m, numval;
+  int  n, y = 30;
+  bool b = true;           // true for null dates
+
+  if (pdp)
+    fmt = pdp->InFmt;
+  else            // assume standard MySQL date format
+    fmt = "%4d-%2d-%2d %2d:%2d:%2d";
+
+  if (trace(2))
+    htrc("ExtractDate: dts=%s fmt=%s defy=%d\n", dts, fmt, defy);
+
+  // Set default values for time only use
+  if (defy) {
+    // This may be a default value for year
+    y = defy;
+    val[0] = y;
+    y = (y < 100) ? y : 30;
+  } else
+    val[0] = 70;
+
+  val[1] = 1;
+  val[2] = 1;
+
+  for (i = 3; i < 6; i++)
+    val[i] = 0;
+
+  numval = 0;
+
+  // Get the date field parse it with derived input format
+  m = sscanf(dts, fmt, W[0], W[1], W[2], W[3], W[4], W[5], W[6], W[7]);
+
+  if (m > pdp->Num)
+    m = pdp->Num;
+
+  for (i = 0; i < m; i++) {
+    if ((n = *(int*)W[i]))
+      b = false;
+
+    switch (k = pdp->Index[i]) {
+      case 0:
+        if (n < y)
+          n += 100;
+
+        val[0] = n;
+        numval = MY_MAX(numval, 1);
+        break;
+      case 1:
+      case 2:
+      case 3:
+      case 4:
+      case 5:
+        val[k] = n;
+        numval = MY_MAX(numval, k + 1);
+        break;
+      case -1:
+        c = toupper(W[i][0]);
+        d = toupper(W[i][1]);
+        e = toupper(W[i][2]);
+
+        switch (c) {
+          case 'J':
+            n = (d == 'A') ? 1
+              : (e == 'N') ? 6 : 7; break;
+          case 'F': n =  2; break;
+          case 'M':
+            n = (e == 'R') ? 3 : 5; break;
+          case 'A':
+            n = (d == 'P') ? 4 : 8; break;
+            break;
+          case 'S': n =  9; break;
+          case 'O': n = 10; break;
+          case 'N': n = 11; break;
+          case 'D': n = 12; break;
+          } /* endswitch c */
+
+        val[1] = n;
+        numval = MY_MAX(numval, 2);
+        break;
+      case -6:
+        c = toupper(W[i][0]);
+        n = val[3] % 12;
+
+        if (c == 'P')
+          n += 12;
+
+        val[3] = n;
+        break;
+      } // endswitch Plugpar
+
+    } // endfor i
+
+  if (trace(2))
+    htrc("numval=%d val=(%d,%d,%d,%d,%d,%d)\n",
+          numval, val[0], val[1], val[2], val[3], val[4], val[5]); 
+
+  return (b) ? 0 : numval;
+  } // end of ExtractDate
+
+/***********************************************************************/
+/*  Open file routine: the purpose of this routine is to make a list   */
+/*  of all open file so they can be closed in SQLINIT on error jump.   */
+/***********************************************************************/
+FILE *PlugOpenFile(PGLOBAL g, LPCSTR fname, LPCSTR ftype)
+  {
+  FILE     *fop;
+  PFBLOCK   fp;
+  PDBUSER   dbuserp = (PDBUSER)g->Activityp->Aptr;
+
+  if (trace(1)) {
+    htrc("PlugOpenFile: fname=%s ftype=%s\n", fname, ftype);
+    htrc("dbuserp=%p\n", dbuserp);
+    } // endif trace
+
+  if ((fop= global_fopen(g, MSGID_OPEN_MODE_STRERROR, fname, ftype)) != NULL) {
+    if (trace(1))
+      htrc(" fop=%p\n", fop);
+
+    fp = (PFBLOCK)PlugSubAlloc(g, NULL, sizeof(FBLOCK));
+
+    if (trace(1))
+      htrc(" fp=%p\n", fp);
+
+    // fname may be in volatile memory such as stack
+    fp->Fname = PlugDup(g, fname);
+    fp->Count = 1;
+    fp->Type = TYPE_FB_FILE;
+    fp->File = fop;
+    fp->Mode = MODE_ANY;                        // ???
+    fp->Next = dbuserp->Openlist;
+    dbuserp->Openlist = fp;
+    } /* endif fop */
+
+  if (trace(1))
+    htrc(" returning fop=%p\n", fop);
+
+  return (fop);
+  } // end of PlugOpenFile
+
+/***********************************************************************/
+/*  Close file routine: the purpose of this routine is to avoid        */
+/*  double closing that freeze the system on some Unix platforms.      */
+/***********************************************************************/
+FILE *PlugReopenFile(PGLOBAL g, PFBLOCK fp, LPCSTR md)
+  {
+  FILE *fop;
+
+  if ((fop = global_fopen(g, MSGID_OPEN_MODE_STRERROR, fp->Fname, md))) {
+    fp->Count = 1;
+    fp->Type = TYPE_FB_FILE;
+    fp->File = fop;
+    } /* endif fop */
+
+  return (fop);
+  } // end of PlugOpenFile
+
+/***********************************************************************/
+/*  Close file routine: the purpose of this routine is to avoid        */
+/*  double closing that freeze the system on some Unix platforms.      */
+/***********************************************************************/
+int PlugCloseFile(PGLOBAL g, PFBLOCK fp, bool all)
+  {
+  int rc = 0;
+
+  if (trace(1))
+    htrc("PlugCloseFile: fp=%p count=%hd type=%hd\n",
+          fp, ((fp) ? fp->Count : 0), ((fp) ? fp->Type : 0));
+
+  if (!fp || !fp->Count)
+    return rc;
+
+  switch (fp->Type) {
+    case TYPE_FB_FILE:
+      if (fclose((FILE *)fp->File) == EOF)
+        rc = errno;
+
+      fp->File = NULL;
+      fp->Mode = MODE_ANY;
+      fp->Count = 0;
+      break;
+    case TYPE_FB_MAP:
+      if ((fp->Count = (all) ? 0 : fp->Count - 1))
+        break;
+
+      if (CloseMemMap(fp->Memory, fp->Length))
+        rc = (int)GetLastError();
+
+      fp->Memory = NULL;
+      fp->Mode = MODE_ANY;
+      // fall through
+    case TYPE_FB_HANDLE:
+      if (fp->Handle && fp->Handle != INVALID_HANDLE_VALUE)
+        if (CloseFileHandle(fp->Handle))
+          rc = (rc) ? rc : (int)GetLastError();
+
+      fp->Handle = INVALID_HANDLE_VALUE;
+      fp->Mode = MODE_ANY;
+      fp->Count = 0;
+      break;
+#ifdef DOMDOC_SUPPORT
+    case TYPE_FB_XML:
+      CloseXMLFile(g, fp, all);
+      break;
+#endif   // DOMDOC_SUPPORT
+#ifdef LIBXML2_SUPPORT
+    case TYPE_FB_XML2:
+      CloseXML2File(g, fp, all);
+      break;
+#endif   // LIBXML2_SUPPORT
+#ifdef ODBC_SUPPORT
+		case TYPE_FB_ODBC:
+			OdbcClose(g, fp);
+			fp->Count = 0;
+			fp->File = NULL;
+			break;
+#endif   // ODBC_SUPPORT
+#ifdef ZIP_SUPPORT
+		case TYPE_FB_ZIP:
+			if (fp->Mode == MODE_INSERT)
+				((ZIPUTIL*)fp->File)->close();
+			else
+				((UNZIPUTL*)fp->File)->close();
+
+			fp->Memory = NULL;
+			fp->Mode = MODE_ANY;
+			fp->Count = 0;
+			fp->File = NULL;
+			break;
+#endif   // ZIP_SUPPORT
+#ifdef JAVA_SUPPORT
+		case TYPE_FB_JAVA:
+			((JAVAConn*)fp->File)->Close();
+			fp->Count = 0;
+			fp->File = NULL;
+			break;
+#endif   // JAVA_SUPPORT
+#ifdef CMGO_SUPPORT
+		case TYPE_FB_MONGO:
+			((CMgoConn*)fp->File)->Close();
+			fp->Count = 0;
+			fp->File = NULL;
+			break;
+#endif   // JAVA_SUPPORT
+		default:
+      rc = RC_FX;
+    } // endswitch Type
+
+  return rc;
+  } // end of PlugCloseFile
+
+/***********************************************************************/
+/*  PlugCleanup: Cleanup remaining items of a SQL query.               */
+/***********************************************************************/
+void PlugCleanup(PGLOBAL g, bool dofree)
+  {
+  PCATLG  cat;
+  PDBUSER dbuserp = (PDBUSER)g->Activityp->Aptr;
+
+  // The test on Catalog is to avoid a Windows bug that can make
+  // LoadString in PlugGetMessage to fail in some case
+  if (!dbuserp || !(cat = dbuserp->Catalog))
+    return;
+
+  /*********************************************************************/
+  /*  Close eventually still open/mapped files.                        */
+  /*********************************************************************/
+  for (PFBLOCK fp = dbuserp->Openlist; fp; fp = fp->Next)
+    PlugCloseFile(g, fp, true);
+
+  dbuserp->Openlist = NULL;
+
+  if (dofree) {
+    /*******************************************************************/
+    /*  Cleanup any non suballocated memory still not freed.           */
+    /*******************************************************************/
+    for (PMBLOCK mp = dbuserp->Memlist; mp; mp = mp->Next)
+      PlgDBfree(*mp);
+
+    dbuserp->Memlist = NULL;
+
+    /*******************************************************************/
+    /*  If not using permanent storage catalog, reset volatile values. */
+    /*******************************************************************/
+    cat->Reset();
+
+    /*******************************************************************/
+    /*  This is the place to reset the pointer on domains.             */
+    /*******************************************************************/
+    dbuserp->Subcor = false;
+    dbuserp->Step = "New query";     // was STEP(PARSING_QUERY);
+    dbuserp->ProgMax = dbuserp->ProgCur = dbuserp->ProgSav = 0;
+    } // endif dofree
+
+  } // end of PlugCleanup
+
+#if 0
+/***********************************************************************/
+/*  That stupid Windows 98 does not provide this function.             */
+/***********************************************************************/
+bool WritePrivateProfileInt(LPCSTR sec, LPCSTR key, int n, LPCSTR ini)
+  {
+  char buf[12];
+
+  sprintf(buf, "%d", n);
+  return WritePrivateProfileString(sec, key, buf, ini);
+  } // end of WritePrivateProfileInt
+
+/***********************************************************************/
+/*  Retrieve a size from an INI file with eventual K or M following.   */
+/***********************************************************************/
+int GetIniSize(char *section, char *key, char *def, char *ini)
+  {
+  char c, buff[32];
+  int  i;
+  int  n = 0;
+
+  GetPrivateProfileString(section, key, def, buff, sizeof(buff), ini);
+
+  if ((i = sscanf(buff, " %d %c ", &n, &c)) == 2)
+    switch (toupper(c)) {
+      case 'M':
+        n *= 1024;
+      case 'K':
+        n *= 1024;
+      } // endswitch c
+
+  if (trace(1))
+    htrc("GetIniSize: key=%s buff=%s i=%d n=%d\n", key, buff, i, n);
+
+  return n;
+  } // end of GetIniSize
+
+/***********************************************************************/
+/* Allocate a string retrieved from an INI file and return its address */
+/***********************************************************************/
+DllExport PSZ GetIniString(PGLOBAL g, void *mp, LPCSTR sec, LPCSTR key,
+                                                LPCSTR def, LPCSTR ini)
+  {
+  char  buff[_MAX_PATH];
+  PSZ   p;
+  int   n, m = sizeof(buff);
+  char *buf = buff;
+
+#if defined(_DEBUG)
+  assert (sec && key);
+#endif
+
+ again:
+  n = GetPrivateProfileString(sec, key, def, buf, m, ini);
+
+  if (n == m - 1) {
+    // String may have been truncated, make sure to have all
+    if (buf != buff)
+      delete [] buf;
+
+    m *= 2;
+    buf = new char[m];
+    goto again;
+    } // endif n
+
+  p = (PSZ)PlugSubAlloc(g, mp, n + 1);
+
+  if (trace(1))
+    htrc("GetIniString: sec=%s key=%s buf=%s\n", sec, key, buf);
+
+  strcpy(p, buf);
+
+  if (buf != buff)
+    delete [] buf;
+
+  return p;
+  } // end of GetIniString
+#endif // 0
+
+/***********************************************************************/
+/*  GetAmName: return the name correponding to an AM code.             */
+/***********************************************************************/
+char *GetAmName(PGLOBAL g, AMT am, void *memp)
+  {
+  char *amn= (char*)PlugSubAlloc(g, memp, 16);
+
+  switch (am) {
+    case TYPE_AM_ERROR: strcpy(amn, "ERROR"); break;
+    case TYPE_AM_ROWID: strcpy(amn, "ROWID"); break;
+    case TYPE_AM_FILID: strcpy(amn, "FILID"); break;
+    case TYPE_AM_VIEW:  strcpy(amn, "VIEW");  break;
+    case TYPE_AM_COUNT: strcpy(amn, "COUNT"); break;
+    case TYPE_AM_DCD:   strcpy(amn, "DCD");   break;
+    case TYPE_AM_CMS:   strcpy(amn, "CMS");   break;
+    case TYPE_AM_MAP:   strcpy(amn, "MAP");   break;
+    case TYPE_AM_FMT:   strcpy(amn, "FMT");   break;
+    case TYPE_AM_CSV:   strcpy(amn, "CSV");   break;
+    case TYPE_AM_MCV:   strcpy(amn, "MCV");   break;
+    case TYPE_AM_DOS:   strcpy(amn, "DOS");   break;
+    case TYPE_AM_FIX:   strcpy(amn, "FIX");   break;
+    case TYPE_AM_BIN:   strcpy(amn, "BIN");   break;
+    case TYPE_AM_VCT:   strcpy(amn, "VEC");   break;
+    case TYPE_AM_VMP:   strcpy(amn, "VMP");   break;
+    case TYPE_AM_DBF:   strcpy(amn, "DBF");   break;
+    case TYPE_AM_QRY:   strcpy(amn, "QRY");   break;
+    case TYPE_AM_SQL:   strcpy(amn, "SQL");   break;
+    case TYPE_AM_PLG:   strcpy(amn, "PLG");   break;
+    case TYPE_AM_PLM:   strcpy(amn, "PLM");   break;
+    case TYPE_AM_DOM:   strcpy(amn, "DOM");   break;
+    case TYPE_AM_DIR:   strcpy(amn, "DIR");   break;
+    case TYPE_AM_ODBC:  strcpy(amn, "ODBC");  break;
+		case TYPE_AM_JDBC:  strcpy(amn, "JDBC");  break;
+		case TYPE_AM_MAC:   strcpy(amn, "MAC");   break;
+    case TYPE_AM_OEM:   strcpy(amn, "OEM");   break;
+    case TYPE_AM_OUT:   strcpy(amn, "OUT");   break;
+    default:           sprintf(amn, "OEM(%d)", am);
+    } // endswitch am
+
+  return amn;
+  } // end of GetAmName
+
+#if defined(SE_CATCH)
+/***********************************************************************/
+/*  GetExceptionDesc: return the description of an exception code.     */
+/***********************************************************************/
+char *GetExceptionDesc(PGLOBAL g, unsigned int e)
+  {
+  char *p;
+
+  switch (e) {
+    case EXCEPTION_GUARD_PAGE:
+      p = MSG(GUARD_PAGE);
+      break;
+    case EXCEPTION_DATATYPE_MISALIGNMENT:
+      p = MSG(DATA_MISALIGN);
+      break;
+    case EXCEPTION_BREAKPOINT:
+      p = MSG(BREAKPOINT);
+      break;
+    case EXCEPTION_SINGLE_STEP:
+      p = MSG(SINGLE_STEP);
+      break;
+    case EXCEPTION_ACCESS_VIOLATION:
+      p = MSG(ACCESS_VIOLATN);
+      break;
+    case EXCEPTION_IN_PAGE_ERROR:
+      p = MSG(PAGE_ERROR);
+      break;
+    case EXCEPTION_INVALID_HANDLE:
+      p = MSG(INVALID_HANDLE);
+      break;
+    case EXCEPTION_ILLEGAL_INSTRUCTION:
+      p = MSG(ILLEGAL_INSTR);
+      break;
+    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
+      p = MSG(NONCONT_EXCEPT);
+      break;
+    case EXCEPTION_INVALID_DISPOSITION:
+      p = MSG(INVALID_DISP);
+      break;
+    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+      p = MSG(ARRAY_BNDS_EXCD);
+      break;
+    case EXCEPTION_FLT_DENORMAL_OPERAND:
+      p = MSG(FLT_DENORMAL_OP);
+      break;
+    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+      p = MSG(FLT_ZERO_DIVIDE);
+      break;
+    case EXCEPTION_FLT_INEXACT_RESULT:
+      p = MSG(FLT_BAD_RESULT);
+      break;
+    case EXCEPTION_FLT_INVALID_OPERATION:
+      p = MSG(FLT_INVALID_OP);
+      break;
+    case EXCEPTION_FLT_OVERFLOW:
+      p = MSG(FLT_OVERFLOW);
+      break;
+    case EXCEPTION_FLT_STACK_CHECK:
+      p = MSG(FLT_STACK_CHECK);
+      break;
+    case EXCEPTION_FLT_UNDERFLOW:
+      p = MSG(FLT_UNDERFLOW);
+      break;
+    case EXCEPTION_INT_DIVIDE_BY_ZERO:
+      p = MSG(INT_ZERO_DIVIDE);
+      break;
+    case EXCEPTION_INT_OVERFLOW:
+      p = MSG(INT_OVERFLOW);
+      break;
+    case EXCEPTION_PRIV_INSTRUCTION:
+      p = MSG(PRIV_INSTR);
+      break;
+    case EXCEPTION_STACK_OVERFLOW:
+      p = MSG(STACK_OVERFLOW);
+      break;
+    case CONTROL_C_EXIT:
+      p = MSG(CONTROL_C_EXIT);
+      break;
+    case STATUS_NO_MEMORY:
+      p = MSG(NO_MEMORY);
+      break;
+    default:
+      p = MSG(UNKNOWN_EXCPT);
+      break;
+    } // endswitch nSE
+
+  return p;
+  } // end of GetExceptionDesc
+#endif   // SE_CATCH
+
+/***********************************************************************/
+/*  PlgDBalloc: allocates or suballocates memory conditionally.        */
+/*  If mp.Sub is true at entry, this forces suballocation.             */
+/*  If the memory is allocated, makes an entry in an allocation list   */
+/*  so it can be freed at the normal or error query completion.        */
+/***********************************************************************/
+void *PlgDBalloc(PGLOBAL g, void *area, MBLOCK& mp)
+{
+//bool        b;
+  size_t      maxsub, minsub;
+  void       *arp = (area) ? area : g->Sarea;
+  PPOOLHEADER pph = (PPOOLHEADER)arp;
+
+  if (mp.Memp) {
+    // This is a reallocation. If this block is not suballocated, it
+    // was already placed in the chain of memory blocks and we must
+    // not do it again as it can trigger a loop when freeing them.
+    // Note: this works if blocks can be reallocated only once.
+    // Otherwise a new boolean must be added to the block that
+    // indicate that it is chained, or a test on the whole chain be
+    // done to check whether the block is already there.
+//  b = mp.Sub;
+    mp.Sub = false;    // Restrict suballocation to one quarter
+  } // endif Memp
+
+  // Suballoc when possible if mp.Sub is initially true, but leaving
+  // a minimum amount of storage for future operations such as the
+  // optimize recalculation after insert; otherwise
+  // suballoc only if size is smaller than one quarter of free mem.
+  minsub = (pph->FreeBlk + pph->To_Free + 524248) >> 2;
+  maxsub = (pph->FreeBlk < minsub) ? 0 : pph->FreeBlk - minsub;
+  mp.Sub = mp.Size <= ((mp.Sub) ? maxsub : (maxsub >> 2));
+
+	if (trace(2))
+		htrc("PlgDBalloc: in %p size=%zd used=%zd free=%zd sub=%d\n",
+			arp, mp.Size, pph->To_Free, pph->FreeBlk, mp.Sub);
+
+	if (!mp.Sub) {
+    // For allocations greater than one fourth of remaining storage
+    // in the area, do allocate from virtual storage.
+		const char*v = "malloc";
+#if defined(_WIN32)
+		if (mp.Size >= BIGMEM) {
+			v = "VirtualAlloc";
+			mp.Memp = VirtualAlloc(NULL, mp.Size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+		} else
+#endif
+      mp.Memp = malloc(mp.Size);
+
+		if (trace(8))
+			htrc("PlgDBalloc: %s(%zd) at %p\n", v, mp.Size, mp.Memp);
+
+		if (!mp.Inlist && mp.Memp) {
+      // New allocated block, put it in the memory block chain.
+      PDBUSER dbuserp = (PDBUSER)g->Activityp->Aptr;
+
+      mp.Next = dbuserp->Memlist;
+      dbuserp->Memlist = &mp;
+      mp.Inlist = true;
+    } // endif mp
+
+  } else
+    // Suballocating is Ok.
+    mp.Memp = PlugSubAlloc(g, area, mp.Size);
+
+  return mp.Memp;
+} // end of PlgDBalloc
+
+/***********************************************************************/
+/*  PlgDBrealloc: reallocates memory conditionally.                    */
+/*  Note that this routine can fail only when block size is increased  */
+/*  because otherwise we keep the old storage on failure.              */
+/***********************************************************************/
+void *PlgDBrealloc(PGLOBAL g, void *area, MBLOCK& mp, size_t newsize)
+  {
+  MBLOCK m;
+
+#if defined(_DEBUG)
+//  assert (mp.Memp != NULL);
+#endif
+
+  if (trace(2))
+    htrc("PlgDBrealloc: %p size=%zd sub=%d\n", mp.Memp, mp.Size, mp.Sub);
+
+  if (newsize == mp.Size)
+    return mp.Memp;      // Nothing to do
+  else
+    m = mp;
+
+  if (!mp.Sub && mp.Size < BIGMEM && newsize < BIGMEM) {
+    // Allocation was done by malloc, try to use realloc but
+    // suballoc if newsize is smaller than one quarter of free mem.
+    size_t      maxsub;
+    PPOOLHEADER pph = (PPOOLHEADER)((area) ? area : g->Sarea);
+
+    maxsub = (pph->FreeBlk < 131072) ? 0 : pph->FreeBlk - 131072;
+
+    if ((mp.Sub = (newsize <= (maxsub >> 2)))) {
+      mp.Memp = PlugSubAlloc(g, area, newsize);
+      memcpy(mp.Memp, m.Memp, MY_MIN(m.Size, newsize));
+      PlgDBfree(m);    // Free the old block
+    } else {
+			if (!(mp.Memp = realloc(mp.Memp, newsize))) {
+				mp = m;          // Possible only if newsize > Size
+				return NULL;     // Failed
+			} else if (trace(8))
+				htrc("PlgDBrealloc: realloc(%ld) at %p\n", newsize, mp.Memp);
+
+		} // endif's
+
+    mp.Size = newsize;
+  } else if (!mp.Sub || newsize > mp.Size) {
+    // Was suballocated or Allocation was done by VirtualAlloc
+    // Make a new allocation and copy the useful part
+    // Note: DO NOT reset Memp and Sub so we know that this
+    // is a reallocation in PlgDBalloc
+    mp.Size = newsize;
+
+    if (PlgDBalloc(g, area, mp)) {
+      memcpy(mp.Memp, m.Memp, MY_MIN(m.Size, newsize));
+      PlgDBfree(m);    // Free the old block
+    } else {
+      mp = m;          // No space to realloc, do nothing
+
+      if (newsize > m.Size)
+        return NULL;   // Failed
+
+    } // endif PlgDBalloc
+
+  } // endif's
+
+  if (trace(8))
+    htrc(" newsize=%zd newp=%p sub=%d\n", mp.Size, mp.Memp, mp.Sub);
+
+  return mp.Memp;
+  } // end of PlgDBrealloc
+
+/***********************************************************************/
+/*  PlgDBfree: free memory if not suballocated.                        */
+/***********************************************************************/
+void PlgDBfree(MBLOCK& mp)
+  {
+	if (!mp.Sub && mp.Memp) {
+		const char*v = "free";
+#if defined(_WIN32)
+		if (mp.Size >= BIGMEM) {
+			v = "VirtualFree";
+			VirtualFree(mp.Memp, 0, MEM_RELEASE);
+		} else
+#endif
+			free(mp.Memp);
+
+		if (trace(8))
+			htrc("PlgDBfree: %s(%p) size=%d\n", v, mp.Memp, mp.Size);
+
+	}	// endif mp
+
+  // Do not reset Next to avoid cutting the Mblock chain
+  mp.Memp = NULL;
+  mp.Sub = false;
+  mp.Size = 0;
+  } // end of PlgDBfree
+
+/***********************************************************************/
+/*  Program for sub-allocating one item in a storage area.             */
+/*  Note: This function is equivalent to PlugSubAlloc except that in   */
+/*  case of insufficient memory, it returns NULL instead of doing a    */
+/*  throw. The caller must test the return value for error.            */
+/***********************************************************************/
+void *PlgDBSubAlloc(PGLOBAL g, void *memp, size_t size)
+  {
+  PPOOLHEADER pph;                           // Points on area header.
+
+  if (!memp)
+    /*******************************************************************/
+    /*  Allocation is to be done in the Sarea.                         */
+    /*******************************************************************/
+    memp = g->Sarea;
+
+//size = ((size + 3) / 4) * 4;       /* Round up size to multiple of 4 */
+  size = ((size + 7) / 8) * 8;       /* Round up size to multiple of 8 */
+  pph = (PPOOLHEADER)memp;
+
+  if (trace(16))
+    htrc("PlgDBSubAlloc: memp=%p size=%zd used=%zd free=%zd\n",
+         memp, size, pph->To_Free, pph->FreeBlk);
+
+  if (size > pph->FreeBlk) {   /* Not enough memory left in pool */
+    snprintf(g->Message, sizeof(g->Message),
+    "Not enough memory in Work area for request of %zd (used=%zd free=%zd)",
+            size, pph->To_Free, pph->FreeBlk);
+
+    if (trace(1))
+      htrc("%s\n", g->Message);
+
+    return NULL;
+    } // endif size
+
+  /*********************************************************************/
+  /*  Do the suballocation the simplest way.                           */
+  /*********************************************************************/
+  memp = MakePtr(memp, pph->To_Free);   // Points to suballocated block
+  pph->To_Free += size;                 // New offset of pool free block
+  pph->FreeBlk -= size;                 // New size   of pool free block
+
+  if (trace(16))
+    htrc("Done memp=%p used=%zd free=%zd\n",
+         memp, pph->To_Free, pph->FreeBlk);
+
+  return (memp);
+  } // end of PlgDBSubAlloc
+
+/***********************************************************************/
+/*  Program for sub-allocating and copying a string in a storage area. */
+/***********************************************************************/
+char *PlgDBDup(PGLOBAL g, const char *str)
+  {
+  if (str) {
+    char *sm = (char*)PlgDBSubAlloc(g, NULL, strlen(str) + 1);
+
+    if (sm)
+      strcpy(sm, str);
+
+    return sm;
+  } else
+    return NULL;
+
+  } // end of PlgDBDup
+
+/***********************************************************************/
+/*  PUTOUT: Plug DB object typing routine.                             */
+/***********************************************************************/
+void PlugPutOut(PGLOBAL g, FILE *f, short t, void *v, uint n)
+  {
+  char  m[64];
+
+  if (trace(1))
+    htrc("PUTOUT: f=%p t=%d v=%p n=%d\n", f, t, v, n);
+
+  if (!v)
+    return;
+
+  memset(m, ' ', n);                             /* Make margin string */
+  m[n] = '\0';
+  n += 2;                                        /* Increase margin    */
+
+  switch (t) {
+    case TYPE_ERROR:
+      fprintf(f, "--> %s\n", (PSZ)v);
+      break;
+
+    case TYPE_STRING:
+    case TYPE_PSZ:
+      fprintf(f, "%s%s\n", m, (PSZ)v);
+      break;
+
+    case TYPE_DOUBLE:
+      fprintf(f, "%s%lf\n", m, *(double *)v);
+      break;
+
+    case TYPE_LIST:
+    case TYPE_COLIST:
+    case TYPE_COL:
+     {PPARM p;
+
+      if (t == TYPE_LIST)
+        fprintf(f, "%s%s\n", m, MSG(LIST));
+      else
+        fprintf(f, "%s%s\n", m, "Colist:");
+
+      for (p = (PPARM)v; p; p = p->Next)
+        PlugPutOut(g, f, p->Type, p->Value, n);
+
+      } break;
+
+    case TYPE_INT:
+      fprintf(f, "%s%d\n", m, *(int *)v);
+      break;
+
+    case TYPE_SHORT:
+      fprintf(f, "%s%hd\n", m, *(short *)v);
+      break;
+
+    case TYPE_TINY:
+      fprintf(f, "%s%d\n", m, (int)*(char *)v);
+      break;
+
+    case TYPE_VOID:
+      break;
+
+    case TYPE_SQL:
+    case TYPE_TABLE:
+    case TYPE_TDB:
+    case TYPE_XOBJECT:
+      ((PBLOCK)v)->Printf(g, f, n-2);
+      break;
+
+    default:
+      fprintf(f, "%s%s %d\n", m, MSG(ANSWER_TYPE), t);
+    } /* endswitch */
+
+  return;
+  } /* end of PlugPutOut */
+
+/***********************************************************************/
+/*  NewPointer: makes a table of pointer values to be changed later.   */
+/***********************************************************************/
+DllExport void NewPointer(PTABS t, void *oldv, void *newv)
+  {
+  PTABPTR tp;
+
+  if (!oldv)                                       /* error ?????????? */
+    return;
+
+  if (!t->P1 || t->P1->Num == 50)
+  {
+    if (!(tp = new TABPTR)) {
+      PGLOBAL g = t->G;
+
+      snprintf(g->Message, sizeof(g->Message), "NewPointer: %s", MSG(MEM_ALLOC_ERROR));
+			throw 3;
+		} else {
+      tp->Next = t->P1;
+      tp->Num = 0;
+      t->P1 = tp;
+    } /* endif tp */
+  }
+
+  t->P1->Old[t->P1->Num] = oldv;
+  t->P1->New[t->P1->Num++] = newv;
+  } /* end of NewPointer */
+
+#if 0
+/***********************************************************************/
+/*  Compare two files and return 0 if they are identical, else 1.      */
+/***********************************************************************/
+int FileComp(PGLOBAL g, char *file1, char *file2)
+  {
+  char *fn[2], *bp[2], buff1[4096], buff2[4096];
+  int   i, k, n[2], h[2] = {-1,-1};
+  int  len[2], rc = -1;
+
+  fn[0] = file1; fn[1] = file2;
+  bp[0] = buff1; bp[1] = buff2;
+
+  for (i = 0; i < 2; i++) {
+#if defined(_WIN32)
+    h[i]= global_open(g, MSGID_NONE, fn[i], _O_RDONLY | _O_BINARY);
+#else   // !_WIN32
+    h[i]= global_open(g, MSGOD_NONE, fn[i], O_RDONLY);
+#endif  // !_WIN32
+
+    if (h[i] == -1) {
+//      if (errno != ENOENT) {
+        snprintf(g->Message, sizeof(g->Message), MSG(OPEN_MODE_ERROR),
+                "rb", (int)errno, fn[i]);
+        strcat(strcat(g->Message, ": "), strerror(errno));
+				throw 666;
+				//      } else
+//        len[i] = 0;          // File does not exist yet
+
+    } else {
+      if ((len[i] = _filelength(h[i])) < 0) {
+        snprintf(g->Message, sizeof(g->Message), MSG(FILELEN_ERROR), "_filelength", fn[i]);
+				throw 666;
+			} // endif len
+
+    } // endif h
+
+    } // endfor i
+
+  if (len[0] != len[1])
+    rc = 1;
+
+  while (rc == -1) {
+    for (i = 0; i < 2; i++)
+      if ((n[i] = read(h[i], bp[i], 4096)) < 0) {
+        snprintf(g->Message, sizeof(g->Message), MSG(READ_ERROR), fn[i], strerror(errno));
+        goto fin;
+        } // endif n
+
+    if (n[0] != n[1])
+      rc = 1;
+    else if (*n == 0)
+      rc = 0;
+    else for (k = 0; k < *n; k++)
+      if (*(bp[0] + k) != *(bp[1] + k)) {
+        rc = 1;
+        goto fin;
+        } // endif bp
+
+    } // endwhile
+
+ fin:
+  for (i = 0; i < 2; i++)
+    if (h[i] != -1)
+      close(h[i]);
+
+  return rc;
+  } // end of FileComp
+#endif // 0