compilation warnings in Connect

storage/connect/array.cpp

@@ -986,7 +986,7 @@ PSZ ARRAY::MakeArrayList(PGLOBAL g)
 
   for (i = 0; i < Nval; i++) {
     Value->SetValue_pvblk(Vblp, i);
-    Value->Print(g, tp, z);
+    Value->Prints(g, tp, z);
     len += strlen(tp);
     } // enfor i
 
@@ -998,7 +998,7 @@ PSZ ARRAY::MakeArrayList(PGLOBAL g)
 
   for (i = 0; i < Nval;) {
     Value->SetValue_pvblk(Vblp, i);
-    Value->Print(g, tp, z);
+    Value->Prints(g, tp, z);
     strcat(p, tp);
     strcat(p, (++i == Nval) ? ")" : ",");
     } // enfor i
@@ -1012,7 +1012,7 @@ PSZ ARRAY::MakeArrayList(PGLOBAL g)
 /***********************************************************************/
 /*  Make file output of ARRAY  contents.                               */
 /***********************************************************************/
-void ARRAY::Print(PGLOBAL g, FILE *f, uint n)
+void ARRAY::Printf(PGLOBAL g, FILE *f, uint n)
   {
   char m[64];
   int  lim = MY_MIN(Nval,10);
@@ -1029,7 +1029,7 @@ void ARRAY::Print(PGLOBAL g, FILE *f, uint n)
     if (Vblp)
       for (int i = 0; i < lim; i++) {
         Value->SetValue_pvblk(Vblp, i);
-        Value->Print(g, f, n+4);
+        Value->Printf(g, f, n+4);
         } // endfor i
 
   } else
@@ -1040,7 +1040,7 @@ void ARRAY::Print(PGLOBAL g, FILE *f, uint n)
 /***********************************************************************/
 /*  Make string output of ARRAY  contents.                             */
 /***********************************************************************/
-void ARRAY::Print(PGLOBAL, char *ps, uint z)
+void ARRAY::Prints(PGLOBAL, char *ps, uint z)
   {
   if (z < 16)
     return;

storage/connect/array.h

@@ -56,8 +56,8 @@ class DllExport ARRAY : public XOBJECT, public CSORT { // Array descblock
   virtual bool  Compare(PXOB) {assert(false); return false;}
   virtual bool  SetFormat(PGLOBAL, FORMAT&) {assert(false); return false;}
 //virtual int   CheckSpcCol(PTDB, int) {return 0;}
-  virtual void  Print(PGLOBAL g, FILE *f, uint n);
+  virtual void  Printf(PGLOBAL g, FILE *f, uint n);
-  virtual void  Print(PGLOBAL g, char *ps, uint z);
+  virtual void  Prints(PGLOBAL g, char *ps, uint z);
 //        void  Empty(void);
           void  SetPrecision(PGLOBAL g, int p);
           bool  AddValue(PGLOBAL g, PSZ sp);

storage/connect/blkfil.cpp

@@ -56,7 +56,7 @@ BLOCKFILTER::BLOCKFILTER(PTDBDOS tdbp, int op)
 /***********************************************************************/
 /*  Make file output of BLOCKFILTER contents.                          */
 /***********************************************************************/
-void BLOCKFILTER::Print(PGLOBAL, FILE *f, uint n)
+void BLOCKFILTER::Printf(PGLOBAL, FILE *f, uint n)
   {
   char m[64];
 
@@ -70,7 +70,7 @@ void BLOCKFILTER::Print(PGLOBAL, FILE *f, uint n)
 /***********************************************************************/
 /*  Make string output of BLOCKFILTER contents.                        */
 /***********************************************************************/
-void BLOCKFILTER::Print(PGLOBAL, char *ps, uint z)
+void BLOCKFILTER::Prints(PGLOBAL, char *ps, uint z)
   {
   strncat(ps, "BlockFilter(s)", z);
   } // end of Print
@@ -995,7 +995,7 @@ int BLOCKINDEX::BlockEval(PGLOBAL g)
 /***********************************************************************/
 /*  Make file output of BLOCKINDEX contents.                           */
 /***********************************************************************/
-void BLOCKINDEX::Print(PGLOBAL g, FILE *f, UINT n)
+void BLOCKINDEX::Printf(PGLOBAL g, FILE *f, UINT n)
   {
   char m[64];
 
@@ -1013,7 +1013,7 @@ void BLOCKINDEX::Print(PGLOBAL g, FILE *f, UINT n)
 /***********************************************************************/
 /*  Make string output of BLOCKINDEX contents.                         */
 /***********************************************************************/
-void BLOCKINDEX::Print(PGLOBAL g, char *ps, UINT z)
+void BLOCKINDEX::Prints(PGLOBAL g, char *ps, UINT z)
   {
   strncat(ps, "BlockIndex(es)", z);
   } // end of Print

storage/connect/blkfil.h

@@ -27,8 +27,8 @@ class DllExport BLOCKFILTER : public BLOCK {           /* Block Filter */
   // Methods
   virtual void Reset(PGLOBAL) = 0;
   virtual int  BlockEval(PGLOBAL) = 0;
-  virtual void Print(PGLOBAL g, FILE *f, uint n);
+  virtual void Printf(PGLOBAL g, FILE *f, uint n);
-  virtual void Print(PGLOBAL g, char *ps, uint z);
+  virtual void Prints(PGLOBAL g, char *ps, uint z);
 
  protected:
   BLOCKFILTER(void) {}       // Standard constructor not to be used
@@ -234,8 +234,8 @@ class DllExport BLOCKINDEX : public BLOCK {     /* Indexing Test Block */
   // Methods
           void Reset(void);
   virtual int  BlockEval(PGLOBAL);
-  virtual void Print(PGLOBAL g, FILE *f, UINT n);
+  virtual void Printf(PGLOBAL g, FILE *f, UINT n);
-  virtual void Print(PGLOBAL g, char *ps, UINT z);
+  virtual void Prints(PGLOBAL g, char *ps, UINT z);
 
  protected:
   BLOCKINDEX(void) {}   // Standard constructor not to be used

storage/connect/block.h

@@ -44,8 +44,8 @@ class DllExport BLOCK {
     return (PlugSubAlloc(g, p, size));
     } // end of new
 
-  virtual void Print(PGLOBAL, FILE *, uint) {}   // Produce file desc
+  virtual void Printf(PGLOBAL, FILE *, uint) {}   // Produce file desc
-  virtual void Print(PGLOBAL, char *, uint) {}   // Produce string desc
+  virtual void Prints(PGLOBAL, char *, uint) {}   // Produce string desc
   
 #if !defined(__BORLANDC__)
   // Avoid warning C4291 by defining a matching dummy delete operator

storage/connect/colblk.cpp

@@ -214,7 +214,7 @@ void COLBLK::WriteColumn(PGLOBAL g)
 /***********************************************************************/
 /*  Make file output of a column descriptor block.                     */
 /***********************************************************************/
-void COLBLK::Print(PGLOBAL, FILE *f, uint n)
+void COLBLK::Printf(PGLOBAL, FILE *f, uint n)
   {
   char m[64];
   int  i;
@@ -237,7 +237,7 @@ void COLBLK::Print(PGLOBAL, FILE *f, uint n)
 /***********************************************************************/
 /*  Make string output of a column descriptor block.                   */
 /***********************************************************************/
-void COLBLK::Print(PGLOBAL, char *ps, uint)
+void COLBLK::Prints(PGLOBAL, char *ps, uint)
   {
   sprintf(ps, "R%d.%s", To_Tdb->GetTdb_No(), Name);
   } // end of Print

storage/connect/colblk.h

@@ -72,8 +72,8 @@ class DllExport COLBLK : public XOBJECT {
   virtual void    SetTo_Val(PVAL) {}
   virtual void    ReadColumn(PGLOBAL g);
   virtual void    WriteColumn(PGLOBAL g);
-  virtual void    Print(PGLOBAL g, FILE *, uint);
+  virtual void    Printf(PGLOBAL g, FILE *, uint);
-  virtual void    Print(PGLOBAL g, char *, uint);
+  virtual void    Prints(PGLOBAL g, char *, uint);
   virtual bool    VarSize(void) {return false;}
           bool    InitValue(PGLOBAL g);
 

storage/connect/csort.h

@@ -49,8 +49,8 @@ class DllExport CSORT {
  public:
   // Methods
   int Qsort(PGLOBAL g, int n);            /* Sort calling routine    */
-//virtual void Print(PGLOBAL g, FILE *f, uint n);
+//virtual void Printf(PGLOBAL g, FILE *f, uint n);
-//virtual void Print(PGLOBAL g, char *ps, uint z);
+//virtual void Prints(PGLOBAL g, char *ps, uint z);
 #ifdef DEBTRACE
   int GetNcmp(void) {return num_comp;}
 #endif

storage/connect/filamvct.cpp

@@ -569,7 +569,6 @@ bool VCTFAM::InitInsert(PGLOBAL g)
     CurNum = 0;
     AddBlock = !MaxBlk;
   } else {
-    int     rc;
     PVCTCOL cp = (PVCTCOL)Tdbp->GetColumns();
 
     // The starting point must be at the end of file as for append.

storage/connect/filter.cpp

@@ -1409,7 +1409,7 @@ PFIL FILTER::Copy(PTABS t)
 /*********************************************************************/
 /*  Make file output of FILTER contents.                             */
 /*********************************************************************/
-void FILTER::Print(PGLOBAL g, FILE *f, uint n)
+void FILTER::Printf(PGLOBAL g, FILE *f, uint n)
   {
   char m[64];
 
@@ -1431,7 +1431,7 @@ void FILTER::Print(PGLOBAL g, FILE *f, uint n)
       if (lin && fp->GetArgType(i) == TYPE_FILTER)
         fprintf(f, "%s  Filter at %p\n", m, fp->Arg(i));
       else
-        fp->Arg(i)->Print(g, f, n + 2);
+        fp->Arg(i)->Printf(g, f, n + 2);
 
       } // endfor i
 
@@ -1442,7 +1442,7 @@ void FILTER::Print(PGLOBAL g, FILE *f, uint n)
 /***********************************************************************/
 /*  Make string output of TABLE contents (z should be checked).        */
 /***********************************************************************/
-void FILTER::Print(PGLOBAL g, char *ps, uint z)
+void FILTER::Prints(PGLOBAL g, char *ps, uint z)
   {
   #define FLEN 100
 
@@ -1470,7 +1470,7 @@ void FILTER::Print(PGLOBAL g, char *ps, uint z)
       bcp = bxp;
       p = bcp->Cold;
       n = FLEN;
-      fp->Arg(0)->Print(g, p, n);
+      fp->Arg(0)->Prints(g, p, n);
       n = FLEN - strlen(p);
 
       switch (fp->Opc) {
@@ -1516,7 +1516,7 @@ void FILTER::Print(PGLOBAL g, char *ps, uint z)
 
       n = FLEN - strlen(p);
       p += strlen(p);
-      fp->Arg(1)->Print(g, p, n);
+      fp->Arg(1)->Prints(g, p, n);
     } else
       if (!bcp) {
         strncat(ps, "???", z);

storage/connect/filter.h

@@ -61,8 +61,8 @@ class DllExport FILTER : public XOBJECT { /* Filter description block  */
 //virtual PXOB   CheckSubQuery(PGLOBAL, PSQL);
 //virtual bool   CheckLocal(PTDB);
 //virtual int    CheckSpcCol(PTDB tdbp, int n);
-	virtual void   Print(PGLOBAL g, FILE *f, uint n);
+	virtual void   Printf(PGLOBAL g, FILE *f, uint n);
-  virtual void   Print(PGLOBAL g, char *ps, uint z);
+  virtual void   Prints(PGLOBAL g, char *ps, uint z);
 //        PFIL   Linearize(bool nosep);
 //        PFIL   Link(PGLOBAL g, PFIL fil2);
 //        PFIL   RemoveLastSep(void);

storage/connect/ha_connect.cc

@@ -1034,7 +1034,7 @@ PCSZ GetListOption(PGLOBAL g, PCSZ opname, PCSZ oplist, PCSZ def)
     pv= strchr(pk, '=');
 
     if (pv && (!pn || pv < pn)) {
-			n= MY_MIN(pv - pk, sizeof(key) - 1);
+			n= MY_MIN(pv - pk, (int)sizeof(key) - 1);
       memcpy(key, pk, n);
       key[n]= 0;
       pv++;

storage/connect/plgdbutl.cpp

@@ -1492,7 +1492,7 @@ void PlugPutOut(PGLOBAL g, FILE *f, short t, void *v, uint n)
     case TYPE_TABLE:
     case TYPE_TDB:
     case TYPE_XOBJECT:
-      ((PBLOCK)v)->Print(g, f, n-2);
+      ((PBLOCK)v)->Printf(g, f, n-2);
       break;
 
     default:

storage/connect/tabcol.cpp

@@ -73,7 +73,7 @@ PTABLE XTAB::Link(PTABLE tab2)
 /***********************************************************************/
 /*  Make file output of XTAB contents.                                 */
 /***********************************************************************/
-void XTAB::Print(PGLOBAL g, FILE *f, uint n)
+void XTAB::Printf(PGLOBAL g, FILE *f, uint n)
   {
   char  m[64];
 
@@ -91,7 +91,7 @@ void XTAB::Print(PGLOBAL g, FILE *f, uint n)
 /***********************************************************************/
 /*  Make string output of XTAB contents.                               */
 /***********************************************************************/
-void XTAB::Print(PGLOBAL, char *ps, uint z)
+void XTAB::Prints(PGLOBAL, char *ps, uint z)
   {
   char buf[128];
   int  i, n = (int)z - 1;
@@ -134,7 +134,7 @@ bool COLUMN::SetFormat(PGLOBAL g, FORMAT&)
 /***********************************************************************/
 /*  Make file output of COLUMN contents.                               */
 /***********************************************************************/
-void COLUMN::Print(PGLOBAL g, FILE *f, uint n)
+void COLUMN::Printf(PGLOBAL g, FILE *f, uint n)
   {
   char  m[64];
 
@@ -154,7 +154,7 @@ void COLUMN::Print(PGLOBAL g, FILE *f, uint n)
 /***********************************************************************/
 /*  Make string output of COLUMN contents.                             */
 /***********************************************************************/
-void COLUMN::Print(PGLOBAL, char *ps, uint z)
+void COLUMN::Prints(PGLOBAL, char *ps, uint z)
   {
   char buf[80];
 

storage/connect/tabcol.h

@@ -38,8 +38,8 @@ class DllExport XTAB: public BLOCK {  // Table Name-Schema-Srcdef block.
 
   // Methods
   PTABLE Link(PTABLE);
-  void   Print(PGLOBAL g, FILE *f, uint n);
+  void   Printf(PGLOBAL g, FILE *f, uint n);
-  void   Print(PGLOBAL g, char *ps, uint z);
+  void   Prints(PGLOBAL g, char *ps, uint z);
 
  protected:
   // Members
@@ -78,8 +78,8 @@ class DllExport COLUMN: public XOBJECT {  // Column Name/Qualifier block.
           void   SetTo_Col(PCOL colp) {To_Col = colp;}
 
   // Methods
-  virtual void   Print(PGLOBAL g, FILE *f, uint n);
+  virtual void   Printf(PGLOBAL g, FILE *f, uint n);
-  virtual void   Print(PGLOBAL g, char *ps, uint z);
+  virtual void   Prints(PGLOBAL g, char *ps, uint z);
   // All methods below should never be used for COLUMN's
   virtual void   Reset(void) {assert(false);}
   virtual bool   Compare(PXOB) {assert(false); return false;}

storage/connect/tabdos.cpp

@@ -2871,9 +2871,9 @@ bool DOSCOL::AddDistinctValue(PGLOBAL g)
 /***********************************************************************/
 /*  Make file output of a Dos column descriptor block.                 */
 /***********************************************************************/
-void DOSCOL::Print(PGLOBAL g, FILE *f, uint n)
+void DOSCOL::Printf(PGLOBAL g, FILE *f, uint n)
   {
-  COLBLK::Print(g, f, n);
+  COLBLK::Printf(g, f, n);
   } // end of Print
 
 /* ------------------------------------------------------------------- */

storage/connect/tabdos.h

@@ -232,12 +232,12 @@ class DllExport DOSCOL : public COLBLK {
   virtual PVBLK  GetDval(void) {return Dval;}
 
   // Methods
-  using COLBLK::Print;
+  //using COLBLK::Print;
   virtual bool   VarSize(void);
   virtual bool   SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check);
   virtual void   ReadColumn(PGLOBAL g);
   virtual void   WriteColumn(PGLOBAL g);
-  virtual void   Print(PGLOBAL g, FILE *, uint);
+  virtual void   Printf(PGLOBAL g, FILE *, uint);
 
  protected:
   virtual bool   SetMinMax(PGLOBAL g);

storage/connect/tabjdbc.h

@@ -173,7 +173,7 @@ public:
 	// Methods
 	virtual void ReadColumn(PGLOBAL g);
 	virtual void WriteColumn(PGLOBAL g);
-	//        void Print(PGLOBAL g, FILE *, uint);
+	//        void Printf(PGLOBAL g, FILE *, uint);
 
 protected:
 	// Members

storage/connect/table.cpp

@@ -299,7 +299,7 @@ bool TDB::SetRecpos(PGLOBAL g, int)
 	return true;
 } // end of SetRecpos
 
-void TDB::Print(PGLOBAL g, FILE *f, uint n)
+void TDB::Printf(PGLOBAL g, FILE *f, uint n)
   {
   PCOL cp;
   char m[64];
@@ -315,13 +315,13 @@ void TDB::Print(PGLOBAL g, FILE *f, uint n)
     fprintf(f, "%s Columns (deg=%d):\n", m, tp->Degree);
 
     for (cp = tp->Columns; cp; cp = cp->GetNext())
-      cp->Print(g, f, n);
+      cp->Printf(g, f, n);
 
     } /* endfor tp */
 
   } // end of Print
 
-void TDB::Print(PGLOBAL, char *ps, uint)
+void TDB::Prints(PGLOBAL, char *ps, uint)
   {
   sprintf(ps, "R%d.%s", Tdb_No, Name);
   } // end of Print

storage/connect/tabodbc.h

@@ -187,7 +187,7 @@ class XSRCCOL : public ODBCCOL {
   // Methods
   virtual void ReadColumn(PGLOBAL g);
   virtual void WriteColumn(PGLOBAL g);
-//        void Print(PGLOBAL g, FILE *, uint);
+//        void Printf(PGLOBAL g, FILE *, uint);
 
  protected:
   // Members

storage/connect/tabsys.h

@@ -62,7 +62,7 @@ class TDBINI : public TDBASE {
   virtual int   GetProgCur(void) {return N;}
 //virtual int   GetAffectedRows(void) {return 0;}
   virtual PCSZ  GetFile(PGLOBAL g) {return Ifile;}
-  virtual void  SetFile(PGLOBAL g, PSZ fn) {Ifile = fn;}
+  virtual void  SetFile(PGLOBAL g, PCSZ fn) {Ifile = fn;}
   virtual void  ResetDB(void) {Seclist = Section = NULL; N = 0;}
   virtual void  ResetSize(void) {MaxSize = -1; Seclist = NULL;}
   virtual int   RowNumber(PGLOBAL g, bool b = false) {return N;}
@@ -80,7 +80,7 @@ class TDBINI : public TDBASE {
 
  protected:
   // Members
-  char *Ifile;                               // The INI file
+  PCSZ  Ifile;                               // The INI file
   char *Seclist;                             // The section list
   char *Section;                             // The current section
   int   Seclen;                              // Length of seclist buffer

storage/connect/tabxml.h

@@ -75,7 +75,7 @@ class DllExport TDBXML : public TDBASE {
   virtual int   GetRecpos(void);
   virtual int   GetProgCur(void) {return N;}
   virtual PCSZ  GetFile(PGLOBAL g) {return Xfile;}
-  virtual void  SetFile(PGLOBAL g, PSZ fn) {Xfile = fn;}
+  virtual void  SetFile(PGLOBAL g, PCSZ fn) {Xfile = fn;}
   virtual void  ResetDB(void) {N = 0;}
   virtual void  ResetSize(void) {MaxSize = -1;}
   virtual int   RowNumber(PGLOBAL g, bool b = false);

storage/connect/value.cpp

@@ -561,7 +561,7 @@ bool VALUE::Compute(PGLOBAL g, PVAL *, int, OPVAL)
 /***********************************************************************/
 /*  Make file output of an object value.                               */
 /***********************************************************************/
-void VALUE::Print(PGLOBAL g, FILE *f, uint n)
+void VALUE::Printf(PGLOBAL g, FILE *f, uint n)
 {
 	char m[64], buf[64];
 
@@ -571,14 +571,14 @@ void VALUE::Print(PGLOBAL g, FILE *f, uint n)
 	if (Null)
 		fprintf(f, "%s<null>\n", m);
 	else
-		fprintf(f, strcat(strcat(GetCharString(buf), "\n"), m));
+		fprintf(f, "%s%s%s", GetCharString(buf), "\n", m);
 
 } /* end of Print */
 
 /***********************************************************************/
 /*  Make string output of an object value.                             */
 /***********************************************************************/
-void VALUE::Print(PGLOBAL g, char *ps, uint z)
+void VALUE::Prints(PGLOBAL g, char *ps, uint z)
 {
 	char *p, buf[64];
 
@@ -1712,7 +1712,7 @@ bool TYPVAL<PSZ>::SetConstFormat(PGLOBAL, FORMAT& fmt)
 /***********************************************************************/
 /*  Make string output of an object value.                             */
 /***********************************************************************/
-void TYPVAL<PSZ>::Print(PGLOBAL g, char *ps, uint z)
+void TYPVAL<PSZ>::Prints(PGLOBAL g, char *ps, uint z)
 {
 	if (Null)
 		strncpy(ps, "null", z);

storage/connect/value.h

@@ -122,8 +122,8 @@ class DllExport VALUE : public BLOCK {
   virtual bool   IsEqual(PVAL vp, bool chktype) = 0;
   virtual bool   Compute(PGLOBAL g, PVAL *vp, int np, OPVAL op);
   virtual bool   FormatValue(PVAL vp, PCSZ fmt) = 0;
-	virtual void   Print(PGLOBAL g, FILE *, uint);
+	virtual void   Printf(PGLOBAL g, FILE *, uint);
-	virtual void   Print(PGLOBAL g, char *ps, uint z);
+	virtual void   Prints(PGLOBAL g, char *ps, uint z);
 
 	/**
 	Set value from a non-aligned in-memory value in the machine byte order.
@@ -308,7 +308,7 @@ class DllExport TYPVAL<PSZ>: public VALUE {
   virtual bool   Compute(PGLOBAL g, PVAL *vp, int np, OPVAL op);
   virtual bool   FormatValue(PVAL vp, PCSZ fmt);
   virtual bool   SetConstFormat(PGLOBAL, FORMAT&);
-	virtual void   Print(PGLOBAL g, char *ps, uint z);
+	virtual void   Prints(PGLOBAL g, char *ps, uint z);
 
  protected:
   // Members

storage/connect/xindex.cpp

@@ -181,7 +181,7 @@ XXBASE::XXBASE(PTDBDOS tbxp, bool b) : CSORT(b),
 /***********************************************************************/
 /*  Make file output of XINDEX contents.                               */
 /***********************************************************************/
-void XXBASE::Print(PGLOBAL, FILE *f, uint n)
+void XXBASE::Printf(PGLOBAL, FILE *f, uint n)
   {
   char m[64];
 
@@ -193,7 +193,7 @@ void XXBASE::Print(PGLOBAL, FILE *f, uint n)
 /***********************************************************************/
 /*  Make string output of XINDEX contents.                             */
 /***********************************************************************/
-void XXBASE::Print(PGLOBAL, char *ps, uint z)
+void XXBASE::Prints(PGLOBAL, char *ps, uint z)
   {
   *ps = '\0';
   strncat(ps, "Xindex", z);

storage/connect/xindex.h

@@ -200,8 +200,8 @@ class DllExport XXBASE : public CSORT, public BLOCK {
           void FreeIndex(void) {PlgDBfree(Index);}
 
   // Methods
-  virtual void Print(PGLOBAL g, FILE *f, uint n);
+  virtual void Printf(PGLOBAL g, FILE *f, uint n);
-  virtual void Print(PGLOBAL g, char *ps, uint z);
+  virtual void Prints(PGLOBAL g, char *ps, uint z);
   virtual bool Init(PGLOBAL g) = 0;
   virtual bool Make(PGLOBAL g, PIXDEF sxp) = 0;
 #if defined(XMAP)

storage/connect/xobject.cpp

@@ -173,17 +173,17 @@ bool CONSTANT::Rephrase(PGLOBAL g, PSZ work)
 /***********************************************************************/
 /*  Make file output of a constant object.                             */
 /***********************************************************************/
-void CONSTANT::Print(PGLOBAL g, FILE *f, uint n)
+void CONSTANT::Printf(PGLOBAL g, FILE *f, uint n)
   {
-  Value->Print(g, f, n);
+  Value->Printf(g, f, n);
   } /* end of Print */
 
 /***********************************************************************/
 /*  Make string output of a constant object.                           */
 /***********************************************************************/
-void CONSTANT::Print(PGLOBAL g, char *ps, uint z)
+void CONSTANT::Prints(PGLOBAL g, char *ps, uint z)
   {
-  Value->Print(g, ps, z);
+  Value->Prints(g, ps, z);
   } /* end of Print */
 
 /* -------------------------- Class STRING --------------------------- */

storage/connect/xobject.h

@@ -112,8 +112,8 @@ class DllExport CONSTANT : public XOBJECT {
                  {return Value->SetConstFormat(g, fmt);}
           void   Convert(PGLOBAL g, int newtype);
           void   SetValue(PVAL vp) {Value = vp;}
-  virtual void   Print(PGLOBAL g, FILE *, uint);
+  virtual void   Printf(PGLOBAL g, FILE *, uint);
-  virtual void   Print(PGLOBAL g, char *, uint);
+  virtual void   Prints(PGLOBAL g, char *, uint);
   }; // end of class CONSTANT
 
 /***********************************************************************/

storage/connect/xtable.h

@@ -109,8 +109,8 @@ class DllExport TDB: public BLOCK {     // Table Descriptor Block.
   virtual PTDB   Copy(PTABS t);
   virtual void   PrintAM(FILE *f, char *m)
                   {fprintf(f, "%s AM(%d)\n",  m, GetAmType());}
-  virtual void   Print(PGLOBAL g, FILE *f, uint n);
+  virtual void   Printf(PGLOBAL g, FILE *f, uint n);
-  virtual void   Print(PGLOBAL g, char *ps, uint z);
+  virtual void   Prints(PGLOBAL g, char *ps, uint z);
   virtual PCSZ   GetServer(void) = 0;
   virtual int    GetBadLines(void) {return 0;}
 	virtual CHARSET_INFO *data_charset(void);