LibSq3Lite_cs.cs

Go to the documentation of this file.

 
/* LABEL-NO */
using System;
using System.Threading;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using csmkkernel;
using cssq3lite;
/* LABEL-END */
 
[assembly:AssemblyTitleAttribute("cssq3lite")]
[assembly:AssemblyDescriptionAttribute("Programming-Language-Micro-Kernel for C#")]
[assembly:AssemblyConfigurationAttribute("")]
[assembly:AssemblyCompanyAttribute("IPN")]
[assembly:AssemblyProductAttribute("cssq3lite")]
[assembly:AssemblyCopyrightAttribute("Copyright (c) Andreas Otto - §date§")]
[assembly:AssemblyTrademarkAttribute("NHI1")]
[assembly:AssemblyCultureAttribute("")]
 
[assembly:AssemblyVersionAttribute("10.0.*")]
[assembly:ComVisible(false)]
[assembly:CLSCompliantAttribute(true)]
 
// MARK_D ################################################################
// -----------------------------------------------------------------------
// documentation order
// --------------------------------------------------------------------------------
 
namespace cssq3lite {
 
  public partial class Sq3Lite {
    
 
    static Sq3Lite() {
      // init libsq3lite
      Sq3Lite.Sq3SetupTmpl();
    }
 
    
    private static void SetupThread (IntPtr mkrt) {
      // BEGIN-CLASS - created by 'cs_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
      Sq3ValueC.SetupThreadVAL(mkrt);
      Sq3StmtC.SetupThreadSTMT(mkrt);
      Sq3BlobC.SetupThreadBLOB(mkrt);
      Sq3FileC.SetupThreadFILE(mkrt);
      Sq3LiteC.SetupThreadLITE(mkrt);
 
      // END-CLASS - created by 'cs_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
    }
    
    private static void Sq3SetupTmpl ()  {
      Sq3.Sq3Setup();
      Sq3.Sq3SetupThreadCallback(SetupThread);
    }
    
    private static void Sq3CleanupTmpl ()  {
      Sq3.Sq3SetupThreadCallback(null);
      Sq3.Sq3Cleanup();
    }
  } // END-Sq3Lite
 
  // BEGIN-Sq3Lite - created by 'cs_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Config,sm_
 
    public static string CompileOptionGet (int N)  {
      IntPtr __retVal__L = Sq3.Sq3CompileOptionGet(N);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static bool CompileOptionUsed (string zOptName)  {
      IntPtr zOptName_cstr = Marshal.StringToHGlobalAnsi(zOptName);
      bool __retVal__L = Sq3.Sq3CompileOptionUsed(zOptName_cstr);
      Marshal.FreeHGlobal(zOptName_cstr);
      return __retVal__L;
    }
 
    public static long MemoryHighwater (int resetFlag)  {
      Int64 __retVal__L = Sq3.Sq3MemoryHighwater(resetFlag);
      return __retVal__L;
    }
 
    public static long MemoryUsed ()  {
      Int64 __retVal__L = Sq3.Sq3MemoryUsed();
      return __retVal__L;
    }
 
    public static void Threadsafe ()  {
      MkErrorE errVal = Sq3.Sq3Threadsafe();
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    // Sq3Lite_Config_CS_API
  }
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Enum,sco
 
    public static Sq3AccessE AccessE_FromInt (int value)  {
      Sq3AccessE value_out;
      MkErrorE errVal = Sq3.Sq3AccessE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3AuthActionE AuthActionE_FromInt (int value)  {
      Sq3AuthActionE value_out;
      MkErrorE errVal = Sq3.Sq3AuthActionE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3AuthReturnE AuthReturnE_FromInt (int value)  {
      Sq3AuthReturnE value_out;
      MkErrorE errVal = Sq3.Sq3AuthReturnE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3ChangeSetConflictE ChangeSetConflictE_FromInt (int value)  {
      Sq3ChangeSetConflictE value_out;
      MkErrorE errVal = Sq3.Sq3ChangeSetConflictE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3ChangesetE ChangesetE_FromInt (int value)  {
      Sq3ChangesetE value_out;
      MkErrorE errVal = Sq3.Sq3ChangesetE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3CheckpointE CheckpointE_FromInt (int value)  {
      Sq3CheckpointE value_out;
      MkErrorE errVal = Sq3.Sq3CheckpointE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3ConfigE ConfigE_FromInt (int value)  {
      Sq3ConfigE value_out;
      MkErrorE errVal = Sq3.Sq3ConfigE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3ConflictResolutionE ConflictResolutionE_FromInt (int value)  {
      Sq3ConflictResolutionE value_out;
      MkErrorE errVal = Sq3.Sq3ConflictResolutionE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3DbConfigE DbConfigE_FromInt (int value)  {
      Sq3DbConfigE value_out;
      MkErrorE errVal = Sq3.Sq3DbConfigE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3DbStatusE DbStatusE_FromInt (int value)  {
      Sq3DbStatusE value_out;
      MkErrorE errVal = Sq3.Sq3DbStatusE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3DeSerializeEF DeSerializeEF_FromInt (int value)  {
      Sq3DeSerializeEF value_out;
      MkErrorE errVal = Sq3.Sq3DeSerializeEF_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3ErrorE ErrorE_FromInt (int value)  {
      Sq3ErrorE value_out;
      MkErrorE errVal = Sq3.Sq3ErrorE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3ExtendetResultCodesE ExtendetResultCodesE_FromInt (int value)  {
      Sq3ExtendetResultCodesE value_out;
      MkErrorE errVal = Sq3.Sq3ExtendetResultCodesE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3FcntlE FcntlE_FromInt (int value)  {
      Sq3FcntlE value_out;
      MkErrorE errVal = Sq3.Sq3FcntlE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3FunctionEF FunctionEF_FromInt (int value)  {
      Sq3FunctionEF value_out;
      MkErrorE errVal = Sq3.Sq3FunctionEF_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3IndexConstraintEF IndexConstraintEF_FromInt (int value)  {
      Sq3IndexConstraintEF value_out;
      MkErrorE errVal = Sq3.Sq3IndexConstraintEF_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3IoCapEF IoCapEF_FromInt (int value)  {
      Sq3IoCapEF value_out;
      MkErrorE errVal = Sq3.Sq3IoCapEF_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3LimitE LimitE_FromInt (int value)  {
      Sq3LimitE value_out;
      MkErrorE errVal = Sq3.Sq3LimitE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3LockE LockE_FromInt (int value)  {
      Sq3LockE value_out;
      MkErrorE errVal = Sq3.Sq3LockE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3MutexE MutexE_FromInt (int value)  {
      Sq3MutexE value_out;
      MkErrorE errVal = Sq3.Sq3MutexE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3OpenEF OpenEF_FromInt (int value)  {
      Sq3OpenEF value_out;
      MkErrorE errVal = Sq3.Sq3OpenEF_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3PrepareEF PrepareEF_FromInt (int value)  {
      Sq3PrepareEF value_out;
      MkErrorE errVal = Sq3.Sq3PrepareEF_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3ScanStatE ScanStatE_FromInt (int value)  {
      Sq3ScanStatE value_out;
      MkErrorE errVal = Sq3.Sq3ScanStatE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3SerializeE SerializeE_FromInt (int value)  {
      Sq3SerializeE value_out;
      MkErrorE errVal = Sq3.Sq3SerializeE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3SessionObjConfigE SessionObjConfigE_FromInt (int value)  {
      Sq3SessionObjConfigE value_out;
      MkErrorE errVal = Sq3.Sq3SessionObjConfigE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3ShmLockE ShmLockE_FromInt (int value)  {
      Sq3ShmLockE value_out;
      MkErrorE errVal = Sq3.Sq3ShmLockE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3StatusE StatusE_FromInt (int value)  {
      Sq3StatusE value_out;
      MkErrorE errVal = Sq3.Sq3StatusE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3StmtStatusE StmtStatusE_FromInt (int value)  {
      Sq3StmtStatusE value_out;
      MkErrorE errVal = Sq3.Sq3StmtStatusE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3SyncEF SyncEF_FromInt (int value)  {
      Sq3SyncEF value_out;
      MkErrorE errVal = Sq3.Sq3SyncEF_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3TestCtrlE TestCtrlE_FromInt (int value)  {
      Sq3TestCtrlE value_out;
      MkErrorE errVal = Sq3.Sq3TestCtrlE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3TextE TextE_FromInt (int value)  {
      Sq3TextE value_out;
      MkErrorE errVal = Sq3.Sq3TextE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3TraceEF TraceEF_FromInt (int value)  {
      Sq3TraceEF value_out;
      MkErrorE errVal = Sq3.Sq3TraceEF_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3TxnE TxnE_FromInt (int value)  {
      Sq3TxnE value_out;
      MkErrorE errVal = Sq3.Sq3TxnE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3TypeE TypeE_FromInt (int value)  {
      Sq3TypeE value_out;
      MkErrorE errVal = Sq3.Sq3TypeE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    public static Sq3VtabE VtabE_FromInt (int value)  {
      Sq3VtabE value_out;
      MkErrorE errVal = Sq3.Sq3VtabE_FromInt(value, out value_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return value_out;
    }
 
    // doc-key: Sq3Lite,Sq3Lite-Enum,sm_
 
    public static int AccessE_ToInt (Sq3AccessE value)  {
      Int32 __retVal__L = Sq3.Sq3AccessE_ToInt(value);
      return __retVal__L;
    }
 
    public static string AccessE_ToString (Sq3AccessE value)  {
      IntPtr __retVal__L = Sq3.Sq3AccessE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int AuthActionE_ToInt (Sq3AuthActionE value)  {
      Int32 __retVal__L = Sq3.Sq3AuthActionE_ToInt(value);
      return __retVal__L;
    }
 
    public static string AuthActionE_ToString (Sq3AuthActionE value)  {
      IntPtr __retVal__L = Sq3.Sq3AuthActionE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int AuthReturnE_ToInt (Sq3AuthReturnE value)  {
      Int32 __retVal__L = Sq3.Sq3AuthReturnE_ToInt(value);
      return __retVal__L;
    }
 
    public static string AuthReturnE_ToString (Sq3AuthReturnE value)  {
      IntPtr __retVal__L = Sq3.Sq3AuthReturnE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int ChangeSetConflictE_ToInt (Sq3ChangeSetConflictE value)  {
      Int32 __retVal__L = Sq3.Sq3ChangeSetConflictE_ToInt(value);
      return __retVal__L;
    }
 
    public static string ChangeSetConflictE_ToString (Sq3ChangeSetConflictE value)  {
      IntPtr __retVal__L = Sq3.Sq3ChangeSetConflictE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int ChangesetE_ToInt (Sq3ChangesetE value)  {
      Int32 __retVal__L = Sq3.Sq3ChangesetE_ToInt(value);
      return __retVal__L;
    }
 
    public static string ChangesetE_ToString (Sq3ChangesetE value)  {
      IntPtr __retVal__L = Sq3.Sq3ChangesetE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int CheckpointE_ToInt (Sq3CheckpointE value)  {
      Int32 __retVal__L = Sq3.Sq3CheckpointE_ToInt(value);
      return __retVal__L;
    }
 
    public static string CheckpointE_ToString (Sq3CheckpointE value)  {
      IntPtr __retVal__L = Sq3.Sq3CheckpointE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int ConfigE_ToInt (Sq3ConfigE value)  {
      Int32 __retVal__L = Sq3.Sq3ConfigE_ToInt(value);
      return __retVal__L;
    }
 
    public static string ConfigE_ToString (Sq3ConfigE value)  {
      IntPtr __retVal__L = Sq3.Sq3ConfigE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int ConflictResolutionE_ToInt (Sq3ConflictResolutionE value)  {
      Int32 __retVal__L = Sq3.Sq3ConflictResolutionE_ToInt(value);
      return __retVal__L;
    }
 
    public static string ConflictResolutionE_ToString (Sq3ConflictResolutionE value)  {
      IntPtr __retVal__L = Sq3.Sq3ConflictResolutionE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int DbConfigE_ToInt (Sq3DbConfigE value)  {
      Int32 __retVal__L = Sq3.Sq3DbConfigE_ToInt(value);
      return __retVal__L;
    }
 
    public static string DbConfigE_ToString (Sq3DbConfigE value)  {
      IntPtr __retVal__L = Sq3.Sq3DbConfigE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int DbStatusE_ToInt (Sq3DbStatusE value)  {
      Int32 __retVal__L = Sq3.Sq3DbStatusE_ToInt(value);
      return __retVal__L;
    }
 
    public static string DbStatusE_ToString (Sq3DbStatusE value)  {
      IntPtr __retVal__L = Sq3.Sq3DbStatusE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int DeSerializeEF_ToInt (Sq3DeSerializeEF value)  {
      Int32 __retVal__L = Sq3.Sq3DeSerializeEF_ToInt(value);
      return __retVal__L;
    }
 
    public static string DeSerializeEF_ToString (Sq3DeSerializeEF value)  {
      IntPtr __retVal__L = Sq3.Sq3DeSerializeEF_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int ErrorE_ToInt (Sq3ErrorE value)  {
      Int32 __retVal__L = Sq3.Sq3ErrorE_ToInt(value);
      return __retVal__L;
    }
 
    public static string ErrorE_ToString (Sq3ErrorE value)  {
      IntPtr __retVal__L = Sq3.Sq3ErrorE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int ExtendetResultCodesE_ToInt (Sq3ExtendetResultCodesE value)  {
      Int32 __retVal__L = Sq3.Sq3ExtendetResultCodesE_ToInt(value);
      return __retVal__L;
    }
 
    public static string ExtendetResultCodesE_ToString (Sq3ExtendetResultCodesE value)  {
      IntPtr __retVal__L = Sq3.Sq3ExtendetResultCodesE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int FcntlE_ToInt (Sq3FcntlE value)  {
      Int32 __retVal__L = Sq3.Sq3FcntlE_ToInt(value);
      return __retVal__L;
    }
 
    public static string FcntlE_ToString (Sq3FcntlE value)  {
      IntPtr __retVal__L = Sq3.Sq3FcntlE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int FunctionEF_ToInt (Sq3FunctionEF value)  {
      Int32 __retVal__L = Sq3.Sq3FunctionEF_ToInt(value);
      return __retVal__L;
    }
 
    public static string FunctionEF_ToString (Sq3FunctionEF value)  {
      IntPtr __retVal__L = Sq3.Sq3FunctionEF_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int IndexConstraintEF_ToInt (Sq3IndexConstraintEF value)  {
      Int32 __retVal__L = Sq3.Sq3IndexConstraintEF_ToInt(value);
      return __retVal__L;
    }
 
    public static string IndexConstraintEF_ToString (Sq3IndexConstraintEF value)  {
      IntPtr __retVal__L = Sq3.Sq3IndexConstraintEF_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int IoCapEF_ToInt (Sq3IoCapEF value)  {
      Int32 __retVal__L = Sq3.Sq3IoCapEF_ToInt(value);
      return __retVal__L;
    }
 
    public static string IoCapEF_ToString (Sq3IoCapEF value)  {
      IntPtr __retVal__L = Sq3.Sq3IoCapEF_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int LimitE_ToInt (Sq3LimitE value)  {
      Int32 __retVal__L = Sq3.Sq3LimitE_ToInt(value);
      return __retVal__L;
    }
 
    public static string LimitE_ToString (Sq3LimitE value)  {
      IntPtr __retVal__L = Sq3.Sq3LimitE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int LockE_ToInt (Sq3LockE value)  {
      Int32 __retVal__L = Sq3.Sq3LockE_ToInt(value);
      return __retVal__L;
    }
 
    public static string LockE_ToString (Sq3LockE value)  {
      IntPtr __retVal__L = Sq3.Sq3LockE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int MutexE_ToInt (Sq3MutexE value)  {
      Int32 __retVal__L = Sq3.Sq3MutexE_ToInt(value);
      return __retVal__L;
    }
 
    public static string MutexE_ToString (Sq3MutexE value)  {
      IntPtr __retVal__L = Sq3.Sq3MutexE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int OpenEF_ToInt (Sq3OpenEF value)  {
      Int32 __retVal__L = Sq3.Sq3OpenEF_ToInt(value);
      return __retVal__L;
    }
 
    public static string OpenEF_ToString (Sq3OpenEF value)  {
      IntPtr __retVal__L = Sq3.Sq3OpenEF_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int PrepareEF_ToInt (Sq3PrepareEF value)  {
      Int32 __retVal__L = Sq3.Sq3PrepareEF_ToInt(value);
      return __retVal__L;
    }
 
    public static string PrepareEF_ToString (Sq3PrepareEF value)  {
      IntPtr __retVal__L = Sq3.Sq3PrepareEF_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int ScanStatE_ToInt (Sq3ScanStatE value)  {
      Int32 __retVal__L = Sq3.Sq3ScanStatE_ToInt(value);
      return __retVal__L;
    }
 
    public static string ScanStatE_ToString (Sq3ScanStatE value)  {
      IntPtr __retVal__L = Sq3.Sq3ScanStatE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int SerializeE_ToInt (Sq3SerializeE value)  {
      Int32 __retVal__L = Sq3.Sq3SerializeE_ToInt(value);
      return __retVal__L;
    }
 
    public static string SerializeE_ToString (Sq3SerializeE value)  {
      IntPtr __retVal__L = Sq3.Sq3SerializeE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int SessionObjConfigE_ToInt (Sq3SessionObjConfigE value)  {
      Int32 __retVal__L = Sq3.Sq3SessionObjConfigE_ToInt(value);
      return __retVal__L;
    }
 
    public static string SessionObjConfigE_ToString (Sq3SessionObjConfigE value)  {
      IntPtr __retVal__L = Sq3.Sq3SessionObjConfigE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int ShmLockE_ToInt (Sq3ShmLockE value)  {
      Int32 __retVal__L = Sq3.Sq3ShmLockE_ToInt(value);
      return __retVal__L;
    }
 
    public static string ShmLockE_ToString (Sq3ShmLockE value)  {
      IntPtr __retVal__L = Sq3.Sq3ShmLockE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int StatusE_ToInt (Sq3StatusE value)  {
      Int32 __retVal__L = Sq3.Sq3StatusE_ToInt(value);
      return __retVal__L;
    }
 
    public static string StatusE_ToString (Sq3StatusE value)  {
      IntPtr __retVal__L = Sq3.Sq3StatusE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int StmtStatusE_ToInt (Sq3StmtStatusE value)  {
      Int32 __retVal__L = Sq3.Sq3StmtStatusE_ToInt(value);
      return __retVal__L;
    }
 
    public static string StmtStatusE_ToString (Sq3StmtStatusE value)  {
      IntPtr __retVal__L = Sq3.Sq3StmtStatusE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int SyncEF_ToInt (Sq3SyncEF value)  {
      Int32 __retVal__L = Sq3.Sq3SyncEF_ToInt(value);
      return __retVal__L;
    }
 
    public static string SyncEF_ToString (Sq3SyncEF value)  {
      IntPtr __retVal__L = Sq3.Sq3SyncEF_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int TestCtrlE_ToInt (Sq3TestCtrlE value)  {
      Int32 __retVal__L = Sq3.Sq3TestCtrlE_ToInt(value);
      return __retVal__L;
    }
 
    public static string TestCtrlE_ToString (Sq3TestCtrlE value)  {
      IntPtr __retVal__L = Sq3.Sq3TestCtrlE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int TextE_ToInt (Sq3TextE value)  {
      Int32 __retVal__L = Sq3.Sq3TextE_ToInt(value);
      return __retVal__L;
    }
 
    public static string TextE_ToString (Sq3TextE value)  {
      IntPtr __retVal__L = Sq3.Sq3TextE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int TraceEF_ToInt (Sq3TraceEF value)  {
      Int32 __retVal__L = Sq3.Sq3TraceEF_ToInt(value);
      return __retVal__L;
    }
 
    public static string TraceEF_ToString (Sq3TraceEF value)  {
      IntPtr __retVal__L = Sq3.Sq3TraceEF_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int TxnE_ToInt (Sq3TxnE value)  {
      Int32 __retVal__L = Sq3.Sq3TxnE_ToInt(value);
      return __retVal__L;
    }
 
    public static string TxnE_ToString (Sq3TxnE value)  {
      IntPtr __retVal__L = Sq3.Sq3TxnE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int TypeE_ToInt (Sq3TypeE value)  {
      Int32 __retVal__L = Sq3.Sq3TypeE_ToInt(value);
      return __retVal__L;
    }
 
    public static string TypeE_ToString (Sq3TypeE value)  {
      IntPtr __retVal__L = Sq3.Sq3TypeE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static int VtabE_ToInt (Sq3VtabE value)  {
      Int32 __retVal__L = Sq3.Sq3VtabE_ToInt(value);
      return __retVal__L;
    }
 
    public static string VtabE_ToString (Sq3VtabE value)  {
      IntPtr __retVal__L = Sq3.Sq3VtabE_ToString(value);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // Sq3Lite_Enum_CS_API
  }
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Error,sm_
 
    public static bool ErrorCheckI (Sq3ErrorE ret)  {
      bool __retVal__L = Sq3.Sq3ErrorCheckI(ret);
      return __retVal__L;
    }
 
    // Sq3Lite_Error_CS_API
  }
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Info,sco
 
    public static MkBufferC KeywordNameBUF (int num)  {
      IntPtr kwd_out;
      MkErrorE errVal = Sq3.Sq3KeywordNameBUF(IntPtr.Zero, num, out kwd_out);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      return MkBufferC.MkBufferC_ObjNew(kwd_out);
    }
 
    // doc-key: Sq3Lite,Sq3Lite-Info,sm_
 
    public static void Complete (string sql)  {
      IntPtr sql_cstr = Marshal.StringToHGlobalAnsi(sql);
      MkErrorE errVal = Sq3.Sq3Complete(sql_cstr);
      Marshal.FreeHGlobal(sql_cstr);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    public static void KeywordCheck (string arg0, int arg1)  {
      IntPtr arg0_cstr = Marshal.StringToHGlobalAnsi(arg0);
      MkErrorE errVal = Sq3.Sq3KeywordCheck(arg0_cstr, arg1);
      Marshal.FreeHGlobal(arg0_cstr);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    public static void KeywordCount ()  {
      MkErrorE errVal = Sq3.Sq3KeywordCount();
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    // doc-key: Sq3Lite,Sq3Lite-Info,smo
 
    public static List<object> KeywordName (int num)  {
      IntPtr kwd;
      Int32 kwdsz;
      MkErrorE errVal = Sq3.Sq3KeywordName(num, out kwd, out kwdsz);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      List<object> __retVal__L = new List<object>();
      __retVal__L.Add(kwd);
      __retVal__L.Add(kwdsz);
      return __retVal__L;
    }
 
    public static List<object> Status (Sq3StatusE op, bool resetFlag)  {
      Int32 pCurrent;
      Int32 pHighwater;
      MkErrorE errVal = Sq3.Sq3Status(op, out pCurrent, out pHighwater, resetFlag);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      List<object> __retVal__L = new List<object>();
      __retVal__L.Add(pCurrent);
      __retVal__L.Add(pHighwater);
      return __retVal__L;
    }
 
    public static List<object> Status64 (Sq3StatusE op, bool resetFlag)  {
      Int64 pCurrent;
      Int64 pHighwater;
      MkErrorE errVal = Sq3.Sq3Status64(op, out pCurrent, out pHighwater, resetFlag);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
      List<object> __retVal__L = new List<object>();
      __retVal__L.Add(pCurrent);
      __retVal__L.Add(pHighwater);
      return __retVal__L;
    }
 
    // Sq3Lite_Info_CS_API
  }
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Internal-Memory,sm_
 
    public static long HardHeapLimit64 (long N)  {
      Int64 __retVal__L = Sq3.Sq3HardHeapLimit64(N);
      return __retVal__L;
    }
 
    public static void ReleaseMemory (int N)  {
      MkErrorE errVal = Sq3.Sq3ReleaseMemory(N);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    public static long SoftHeapLimit64 (long N)  {
      Int64 __retVal__L = Sq3.Sq3SoftHeapLimit64(N);
      return __retVal__L;
    }
 
    // Sq3Lite_Internal_Memory_CS_API
  }
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Internal-String,sm_
 
    public static int StrGlob (string zGlob, string zStr)  {
      IntPtr zGlob_cstr = Marshal.StringToHGlobalAnsi(zGlob);
      IntPtr zStr_cstr = Marshal.StringToHGlobalAnsi(zStr);
      Int32 __retVal__L = Sq3.Sq3StrGlob(zGlob_cstr, zStr_cstr);
      Marshal.FreeHGlobal(zGlob_cstr);
      Marshal.FreeHGlobal(zStr_cstr);
      return __retVal__L;
    }
 
    public static int StrIcmp (string arg0, string arg1)  {
      IntPtr arg0_cstr = Marshal.StringToHGlobalAnsi(arg0);
      IntPtr arg1_cstr = Marshal.StringToHGlobalAnsi(arg1);
      Int32 __retVal__L = Sq3.Sq3StrIcmp(arg0_cstr, arg1_cstr);
      Marshal.FreeHGlobal(arg0_cstr);
      Marshal.FreeHGlobal(arg1_cstr);
      return __retVal__L;
    }
 
    public static int StrLike (string zGlob, string zStr, int cEsc)  {
      IntPtr zGlob_cstr = Marshal.StringToHGlobalAnsi(zGlob);
      IntPtr zStr_cstr = Marshal.StringToHGlobalAnsi(zStr);
      Int32 __retVal__L = Sq3.Sq3StrLike(zGlob_cstr, zStr_cstr, cEsc);
      Marshal.FreeHGlobal(zGlob_cstr);
      Marshal.FreeHGlobal(zStr_cstr);
      return __retVal__L;
    }
 
    public static int StrNicmp (string arg0, string arg1, int arg2)  {
      IntPtr arg0_cstr = Marshal.StringToHGlobalAnsi(arg0);
      IntPtr arg1_cstr = Marshal.StringToHGlobalAnsi(arg1);
      Int32 __retVal__L = Sq3.Sq3StrNicmp(arg0_cstr, arg1_cstr, arg2);
      Marshal.FreeHGlobal(arg0_cstr);
      Marshal.FreeHGlobal(arg1_cstr);
      return __retVal__L;
    }
 
    // Sq3Lite_Internal_String_CS_API
  }
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Setup-libsq3lite,sm_
 
    public static void Cleanup ()  {
      Sq3CleanupTmpl();
    }
 
    public static void Setup ()  {
      Sq3SetupTmpl();
    }
 
    // Sq3Lite_Setup_libsq3lite_CS_API
  }
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Setup-libsqlite3,sm_
 
    public static void Initialize ()  {
      MkErrorE errVal = Sq3.Sq3Initialize();
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    public static void OsEnd ()  {
      MkErrorE errVal = Sq3.Sq3OsEnd();
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    public static void OsInit ()  {
      MkErrorE errVal = Sq3.Sq3OsInit();
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    public static void Shutdown ()  {
      MkErrorE errVal = Sq3.Sq3Shutdown();
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    // Sq3Lite_Setup_libsqlite3_CS_API
  }
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Version,sm_
 
    public static string Libversion ()  {
      IntPtr __retVal__L = Sq3.Sq3Libversion();
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static void LibversionNumber ()  {
      MkErrorE errVal = Sq3.Sq3LibversionNumber();
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    public static string Sourceid ()  {
      IntPtr __retVal__L = Sq3.Sq3Sourceid();
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // Sq3Lite_Version_CS_API
  }
 
  public partial class Sq3Lite {
 
 
    // doc-key: Sq3Lite,Sq3Lite-Vfs,sm_
 
    public static string FilenameDatabase (string F)  {
      IntPtr F_cstr = Marshal.StringToHGlobalAnsi(F);
      IntPtr __retVal__L = Sq3.Sq3FilenameDatabase(F_cstr);
      Marshal.FreeHGlobal(F_cstr);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static string FilenameJournal (string F)  {
      IntPtr F_cstr = Marshal.StringToHGlobalAnsi(F);
      IntPtr __retVal__L = Sq3.Sq3FilenameJournal(F_cstr);
      Marshal.FreeHGlobal(F_cstr);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static string FilenameWal (string F)  {
      IntPtr F_cstr = Marshal.StringToHGlobalAnsi(F);
      IntPtr __retVal__L = Sq3.Sq3FilenameWal(F_cstr);
      Marshal.FreeHGlobal(F_cstr);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static void FreeFilename (string arg0)  {
      IntPtr arg0_cstr = Marshal.StringToHGlobalAnsi(arg0);
      Sq3.Sq3FreeFilename(arg0_cstr);
      Marshal.FreeHGlobal(arg0_cstr);
    }
 
    public static void UriBoolean (string z, string zParam, int bDefault)  {
      IntPtr z_cstr = Marshal.StringToHGlobalAnsi(z);
      IntPtr zParam_cstr = Marshal.StringToHGlobalAnsi(zParam);
      MkErrorE errVal = Sq3.Sq3UriBoolean(z_cstr, zParam_cstr, bDefault);
      Marshal.FreeHGlobal(z_cstr);
      Marshal.FreeHGlobal(zParam_cstr);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    public static long UriInt64 (string arg0, string arg1, long arg2)  {
      IntPtr arg0_cstr = Marshal.StringToHGlobalAnsi(arg0);
      IntPtr arg1_cstr = Marshal.StringToHGlobalAnsi(arg1);
      Int64 __retVal__L = Sq3.Sq3UriInt64(arg0_cstr, arg1_cstr, arg2);
      Marshal.FreeHGlobal(arg0_cstr);
      Marshal.FreeHGlobal(arg1_cstr);
      return __retVal__L;
    }
 
    public static string UriKey (string z, int N)  {
      IntPtr z_cstr = Marshal.StringToHGlobalAnsi(z);
      IntPtr __retVal__L = Sq3.Sq3UriKey(z_cstr, N);
      Marshal.FreeHGlobal(z_cstr);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public static string UriParameter (string z, string zParam)  {
      IntPtr z_cstr = Marshal.StringToHGlobalAnsi(z);
      IntPtr zParam_cstr = Marshal.StringToHGlobalAnsi(zParam);
      IntPtr __retVal__L = Sq3.Sq3UriParameter(z_cstr, zParam_cstr);
      Marshal.FreeHGlobal(z_cstr);
      Marshal.FreeHGlobal(zParam_cstr);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // Sq3Lite_Vfs_CS_API
  }
 
  // END-Sq3Lite - created by 'cs_MqC.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
} // END - namespace "cssq3lite"