rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/sqlite3/SqliteWrapper/Vdbe_h.cs

@@ -0,0 +1,302 @@
+using i64 = System.Int64;
+using u8 = System.Byte;
+using u64 = System.UInt64;
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 2001 September 15
+    **
+    ** The author disclaims copyright to this source code.  In place of
+    ** a legal notice, here is a blessing:
+    **
+    **    May you do good and not evil.
+    **    May you find forgiveness for yourself and forgive others.
+    **    May you share freely, never taking more than you give.
+    **
+    *************************************************************************
+    ** Header file for the Virtual DataBase Engine (VDBE)
+    **
+    ** This header defines the interface to the virtual database engine
+    ** or VDBE.  The VDBE implements an abstract machine that runs a
+    ** simple program to access and modify the underlying database.
+    *************************************************************************
+    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
+    **  C#-SQLite is an independent reimplementation of the SQLite software library
+    **
+    **  SQLITE_SOURCE_ID: 2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#if !_SQLITE_VDBE_H_
+    //#define _SQLITE_VDBE_H_
+    //#include <stdio.h>
+
+    /*
+    ** A single VDBE is an opaque structure named "Vdbe".  Only routines
+    ** in the source file sqliteVdbe.c are allowed to see the insides
+    ** of this structure.
+    */
+    //typedef struct Vdbe Vdbe;
+
+    /*
+    ** The names of the following types declared in vdbeInt.h are required
+    ** for the VdbeOp definition.
+    */
+    //typedef struct VdbeFunc VdbeFunc;
+    //typedef struct Mem Mem;
+    //typedef struct SubProgram SubProgram;
+
+    /*
+    ** A single instruction of the virtual machine has an opcode
+    ** and as many as three operands.  The instruction is recorded
+    ** as an instance of the following structure:
+    */
+    public class union_p4
+    {             /* fourth parameter */
+      public int i;                /* Integer value if p4type==P4_INT32 */
+      public object p;             /* Generic pointer */
+      //public string z;           /* Pointer to data for string (char array) types */
+      public string z;             // In C# string is unicode, so use byte[] instead
+      public i64 pI64;             /* Used when p4type is P4_INT64 */
+      public double pReal;         /* Used when p4type is P4_REAL */
+      public FuncDef pFunc;        /* Used when p4type is P4_FUNCDEF */
+      public VdbeFunc pVdbeFunc;   /* Used when p4type is P4_VDBEFUNC */
+      public CollSeq pColl;        /* Used when p4type is P4_COLLSEQ */
+      public Mem pMem;             /* Used when p4type is P4_MEM */
+      public VTable pVtab;         /* Used when p4type is P4_VTAB */
+      public KeyInfo pKeyInfo;     /* Used when p4type is P4_KEYINFO */
+      public int[] ai;             /* Used when p4type is P4_INTARRAY */
+      public SubProgram pProgram;  /* Used when p4type is P4_SUBPROGRAM */
+      public dxDel pFuncDel;       /* Used when p4type is P4_FUNCDEL */
+    } ;
+    public class VdbeOp
+    {
+      public u8 opcode;           /* What operation to perform */
+      public int p4type;          /* One of the P4_xxx constants for p4 */
+      public u8 opflags;          /* Mask of the OPFLG_* flags in opcodes.h */
+      public u8 p5;               /* Fifth parameter is an unsigned character */
+#if DEBUG_CLASS_VDBEOP || DEBUG_CLASS_ALL
+public int _p1;              /* First operand */
+public int p1
+{
+get { return _p1; }
+set { _p1 = value; }
+}
+
+public int _p2;              /* Second parameter (often the jump destination) */
+public int p2
+{
+get { return _p2; }
+set { _p2 = value; }
+}
+
+public int _p3;              /* The third parameter */
+public int p3
+{
+get { return _p3; }
+set { _p3 = value; }
+}
+#else
+      public int p1;              /* First operand */
+      public int p2;              /* Second parameter (often the jump destination) */
+      public int p3;              /* The third parameter */
+#endif
+      public union_p4 p4 = new union_p4();
+#if SQLITE_DEBUG || DEBUG
+      public string zComment;     /* Comment to improve readability */
+#endif
+#if VDBE_PROFILE
+public int cnt;             /* Number of times this instruction was executed */
+public u64 cycles;         /* Total time spend executing this instruction */
+#endif
+    };
+    //typedef struct VdbeOp VdbeOp;
+
+    /*
+    ** A sub-routine used to implement a trigger program.
+    */
+    public class SubProgram
+    {
+      public VdbeOp[] aOp;          /* Array of opcodes for sub-program */
+      public int nOp;               /* Elements in aOp[] */
+      public int nMem;              /* Number of memory cells required */
+      public int nCsr;              /* Number of cursors required */
+      public int nRef;              /* Number of pointers to this structure */
+      public int token;             /* id that may be used to recursive triggers */
+    };
+
+    /*
+    ** A smaller version of VdbeOp used for the VdbeAddOpList() function because
+    ** it takes up less space.
+    */
+    public struct VdbeOpList
+    {
+      public u8 opcode;  /* What operation to perform */
+      public int p1;     /* First operand */
+      public int p2;     /* Second parameter (often the jump destination) */
+      public int p3;     /* Third parameter */
+      public VdbeOpList( u8 opcode, int p1, int p2, int p3 )
+      {
+        this.opcode = opcode;
+        this.p1 = p1;
+        this.p2 = p2;
+        this.p3 = p3;
+      }
+
+    };
+    //typedef struct VdbeOpList VdbeOpList;
+
+    /*
+    ** Allowed values of VdbeOp.p4type
+    */
+    const int P4_NOTUSED = 0;   /* The P4 parameter is not used */
+    const int P4_DYNAMIC = ( -1 );  /* Pointer to a string obtained from sqliteMalloc=(); */
+    const int P4_STATIC = ( -2 );  /* Pointer to a static string */
+    const int P4_COLLSEQ = ( -4 );  /* P4 is a pointer to a CollSeq structure */
+    const int P4_FUNCDEF = ( -5 );  /* P4 is a pointer to a FuncDef structure */
+    const int P4_KEYINFO = ( -6 );  /* P4 is a pointer to a KeyInfo structure */
+    const int P4_VDBEFUNC = ( -7 );  /* P4 is a pointer to a VdbeFunc structure */
+    const int P4_MEM = ( -8 );  /* P4 is a pointer to a Mem*    structure */
+    const int P4_TRANSIENT = ( -9 ); /* P4 is a pointer to a transient string */
+    const int P4_VTAB = ( -10 ); /* P4 is a pointer to an sqlite3_vtab structure */
+    const int P4_MPRINTF = ( -11 ); /* P4 is a string obtained from sqlite3_mprintf=(); */
+    const int P4_REAL = ( -12 ); /* P4 is a 64-bit floating point value */
+    const int P4_INT64 = ( -13 ); /* P4 is a 64-bit signed integer */
+    const int P4_INT32 = ( -14 ); /* P4 is a 32-bit signed integer */
+    const int P4_INTARRAY = ( -15 ); /* #define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */
+    const int P4_SUBPROGRAM = ( -18 );/* #define P4_SUBPROGRAM  (-18) /* P4 is a pointer to a SubProgram structure */
+
+    /* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure
+    ** is made.  That copy is freed when the Vdbe is finalized.  But if the
+    ** argument is P4_KEYINFO_HANDOFF, the passed in pointer is used.  It still
+    ** gets freed when the Vdbe is finalized so it still should be obtained
+    ** from a single sqliteMalloc().  But no copy is made and the calling
+    ** function should *not* try to free the KeyInfo.
+    */
+    const int P4_KEYINFO_HANDOFF = ( -16 );  // #define P4_KEYINFO_HANDOFF (-16)
+    const int P4_KEYINFO_STATIC = ( -17 );   // #define P4_KEYINFO_STATIC  (-17)
+
+    /*
+    ** The Vdbe.aColName array contains 5n Mem structures, where n is the
+    ** number of columns of data returned by the statement.
+    */
+    //#define COLNAME_NAME     0
+    //#define COLNAME_DECLTYPE 1
+    //#define COLNAME_DATABASE 2
+    //#define COLNAME_TABLE    3
+    //#define COLNAME_COLUMN   4
+    //#if SQLITE_ENABLE_COLUMN_METADATA
+    //# define COLNAME_N        5      /* Number of COLNAME_xxx symbols */
+    //#else
+    //# ifdef SQLITE_OMIT_DECLTYPE
+    //#   define COLNAME_N      1      /* Store only the name */
+    //# else
+    //#   define COLNAME_N      2      /* Store the name and decltype */
+    //# endif
+    //#endif
+    const int COLNAME_NAME = 0;
+    const int COLNAME_DECLTYPE = 1;
+    const int COLNAME_DATABASE = 2;
+    const int COLNAME_TABLE = 3;
+    const int COLNAME_COLUMN = 4;
+#if SQLITE_ENABLE_COLUMN_METADATA
+const int COLNAME_N = 5;     /* Number of COLNAME_xxx symbols */
+#else
+# if SQLITE_OMIT_DECLTYPE
+const int COLNAME_N = 1;     /* Number of COLNAME_xxx symbols */
+# else
+    const int COLNAME_N = 2;
+# endif
+#endif
+
+    /*
+** The following macro converts a relative address in the p2 field
+** of a VdbeOp structure into a negative number so that
+** sqlite3VdbeAddOpList() knows that the address is relative.  Calling
+** the macro again restores the address.
+*/
+    //#define ADDR(X)  (-1-(X))
+    static int ADDR( int x ) { return -1 - x; }
+    /*
+    ** The makefile scans the vdbe.c source file and creates the "opcodes.h"
+    ** header file that defines a number for each opcode used by the VDBE.
+    */
+    //#include "opcodes.h"
+
+    /*
+    ** Prototypes for the VDBE interface.  See comments on the implementation
+    ** for a description of what each of these routines does.
+    */
+    /*
+    ** Prototypes for the VDBE interface.  See comments on the implementation
+    ** for a description of what each of these routines does.
+    */
+    //Vdbe *sqlite3VdbeCreate(sqlite3*);
+    //int sqlite3VdbeAddOp0(Vdbe*,int);
+    //int sqlite3VdbeAddOp1(Vdbe*,int,int);
+    //int sqlite3VdbeAddOp2(Vdbe*,int,int,int);
+    //int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int);
+    //int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int);
+    //int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int);
+    //int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp);
+    //void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);
+    //void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2);
+    //void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3);
+    //void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
+    //void sqlite3VdbeJumpHere(Vdbe*, int addr);
+    //void sqlite3VdbeChangeToNoop(Vdbe*, int addr, int N);
+    //void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
+    //void sqlite3VdbeUsesBtree(Vdbe*, int);
+    //VdbeOp *sqlite3VdbeGetOp(Vdbe*, int);
+    //int sqlite3VdbeMakeLabel(Vdbe*);
+    //void sqlite3VdbeRunOnlyOnce(Vdbe*);
+    //void sqlite3VdbeDelete(Vdbe*);
+    //void sqlite3VdbeMakeReady(Vdbe*,int,int,int,int,int,int);
+    //int sqlite3VdbeFinalize(Vdbe*);
+    //void sqlite3VdbeResolveLabel(Vdbe*, int);
+    //int sqlite3VdbeCurrentAddr(Vdbe*);
+#if SQLITE_DEBUG
+    //int sqlite3VdbeAssertMayAbort(Vdbe *, int);
+    //void sqlite3VdbeTrace(Vdbe*,FILE*);
+#else
+    static int sqlite3VdbeAssertMayAbort( Vdbe v, int i ) { return 1; }
+#endif
+    //void sqlite3VdbeResetStepResult(Vdbe*);
+    //int sqlite3VdbeReset(Vdbe*);
+    //void sqlite3VdbeSetNumCols(Vdbe*,int);
+    //int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));
+    //void sqlite3VdbeCountChanges(Vdbe*);
+    //sqlite3 *sqlite3VdbeDb(Vdbe*);
+    //void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int);
+    //void sqlite3VdbeSwap(Vdbe*,Vdbe*);
+    //VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*);
+    //void sqlite3VdbeProgramDelete(sqlite3 *, SubProgram *, int);
+    //sqlite3_value *sqlite3VdbeGetValue(Vdbe*, int, u8);
+    //void sqlite3VdbeSetVarmask(Vdbe*, int);
+#if !SQLITE_OMIT_TRACE
+    //char *sqlite3VdbeExpandSql(Vdbe*, const char*);
+#else
+    static string sqlite3VdbeExpandSql(Vdbe P, string S) {return null;}
+#endif
+    //UnpackedRecord *sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,char*,int);
+    //void sqlite3VdbeDeleteUnpackedRecord(UnpackedRecord*);
+    //int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*);
+
+
+#if !NDEBUG
+    //void sqlite3VdbeComment(Vdbe*, const char*, ...);
+    static void VdbeComment( Vdbe v, string zFormat, params object[] ap ) { sqlite3VdbeComment( v, zFormat, ap ); }//# define VdbeComment(X)  sqlite3VdbeComment X
+    //void sqlite3VdbeNoopComment(Vdbe*, const char*, ...);
+    static void VdbeNoopComment( Vdbe v, string zFormat, params object[] ap ) { sqlite3VdbeNoopComment( v, zFormat, ap ); }//# define VdbeNoopComment(X)  sqlite3VdbeNoopComment X
+#else
+//# define VdbeComment(X)
+static void VdbeComment( Vdbe v, string zFormat, params object[] ap ) { }
+//# define VdbeNoopComment(X)
+static void VdbeNoopComment( Vdbe v, string zFormat, params object[] ap ) { }
+#endif
+  }
+}

data/platform/wp7/sqlite3/SqliteWrapper/_Custom.cs

@@ -0,0 +1,449 @@
+/*
+*************************************************************************
+**  $Header$
+*************************************************************************
+*/
+using System;
+using System.Diagnostics;
+using System.IO;
+#if !SQLITE_SILVERLIGHT
+using System.Management;
+#endif
+using System.Text;
+
+using i64 = System.Int64;
+
+using u32 = System.UInt32;
+using time_t = System.Int64;
+
+namespace Community.CsharpSqlite
+{
+  using sqlite3_value = Sqlite3.Mem;
+
+  public partial class Sqlite3
+  {
+
+    static int atoi( byte[] inStr )
+    { return atoi(Encoding.UTF8.GetString(inStr,0,inStr.Length)); }
+
+    static int atoi( string inStr )
+    {
+      int i;
+      for ( i = 0; i < inStr.Length; i++ )
+      {
+        if ( !sqlite3Isdigit( inStr[i] ) && inStr[i] != '-' ) break;
+      }
+      int result = 0;
+
+      return ( Int32.TryParse( inStr.Substring( 0, i ), out result ) ? result : 0 );
+    }
+
+    static void fprintf( TextWriter tw, string zFormat, params object[] ap ) { tw.Write( sqlite3_mprintf( zFormat, ap ) ); }
+    static void printf( string zFormat, params object[] ap ) { Console.Out.Write( sqlite3_mprintf( zFormat, ap ) ); }
+
+
+    //Byte Buffer Testing
+
+    static int memcmp( byte[] bA, byte[] bB, int Limit )
+    {
+      if ( bA.Length < Limit ) return ( bA.Length < bB.Length ) ? -1 : +1;
+      if ( bB.Length < Limit ) return +1;
+      for ( int i = 0; i < Limit; i++ )
+      {
+        if ( bA[i] != bB[i] ) return ( bA[i] < bB[i] ) ? -1 : 1;
+      }
+      return 0;
+    }
+
+    //Byte Buffer  & String Testing
+    static int memcmp( byte[] bA, string B, int Limit )
+    {
+      if ( bA.Length < Limit ) return ( bA.Length < B.Length ) ? -1 : +1;
+      if ( B.Length < Limit ) return +1;
+      for ( int i = 0; i < Limit; i++ )
+      {
+        if ( bA[i] != B[i] ) return ( bA[i] < B[i] ) ? -1 : 1;
+      }
+      return 0;
+    }
+
+    //Byte Buffer  & String Testing
+    static int memcmp( string A, byte[] bB, int Limit )
+    {
+      if ( A.Length < Limit ) return ( A.Length < bB.Length ) ? -1 : +1;
+      if ( bB.Length < Limit ) return +1;
+      for ( int i = 0; i < Limit; i++ )
+      {
+        if ( A[i] != bB[i] ) return ( A[i] < bB[i] ) ? -1 : 1;
+      }
+      return 0;
+    }
+
+    //String with Offset & String Testing
+    static int memcmp( byte[] a, int Offset, byte[] b, int Limit )
+    {
+      if ( a.Length < Offset + Limit ) return ( a.Length - Offset < b.Length ) ? -1 : +1;
+      if ( b.Length < Limit ) return +1;
+      for ( int i = 0; i < Limit; i++ )
+      {
+        if ( a[i + Offset] != b[i] ) return ( a[i + Offset] < b[i] ) ? -1 : 1;
+      }
+      return 0;
+    }
+
+    static int memcmp( string a, int Offset, byte[] b, int Limit )
+    {
+      if ( a.Length < Offset + Limit ) return ( a.Length - Offset < b.Length ) ? -1 : +1;
+      if ( b.Length < Limit ) return +1;
+      for ( int i = 0; i < Limit; i++ )
+      {
+        if ( a[i + Offset] != b[i] ) return ( a[i + Offset] < b[i] ) ? -1 : 1;
+      }
+      return 0;
+    }
+
+    static int memcmp( byte[] a, int Offset, string b, int Limit )
+    {
+      if ( a.Length < Offset + Limit ) return ( a.Length - Offset < b.Length ) ? -1 : +1;
+      if ( b.Length < Limit ) return +1;
+      for ( int i = 0; i < Limit; i++ )
+      {
+        if ( a[i + Offset] != b[i] ) return ( a[i + Offset] < b[i] ) ? -1 : 1;
+      }
+      return 0;
+    }
+
+
+    //String Testing
+    static int memcmp( string A, string B, int Limit )
+    {
+      if ( A.Length < Limit ) return ( A.Length < B.Length ) ? -1 : +1;
+      if ( B.Length < Limit ) return +1;
+      for ( int i = 0; i < Limit; i++ )
+      {
+        if ( A[i] != B[i] ) return ( A[i] < B[i] ) ? -1 : 1;
+      }
+      return 0;
+    }
+
+    // ----------------------------
+    // ** Convertion routines
+    // ----------------------------
+    static string vaFORMAT;
+    static int vaNEXT;
+
+    static void va_start( object[] ap, string zFormat )
+    {
+      vaFORMAT = zFormat;
+      vaNEXT = 0;
+    }
+
+    static object va_arg( object[] ap, string sysType )
+    {
+      vaNEXT += 1;
+      if ( ap == null || ap.Length == 0 )
+        return "";
+      switch ( sysType )
+      {
+        case "double":
+          return Convert.ToDouble( ap[vaNEXT - 1] );
+        case "long":
+        case "long int":
+        case "longlong int":
+        case "i64":
+          if ( ap[vaNEXT - 1].GetType().BaseType.Name == "Object" ) return (i64)( ap[vaNEXT - 1].GetHashCode() ); ;
+          return Convert.ToInt64( ap[vaNEXT - 1] );
+        case "int":
+          if ( Convert.ToInt64( ap[vaNEXT - 1] ) > 0 && ( Convert.ToUInt32( ap[vaNEXT - 1] ) > Int32.MaxValue ) ) return (Int32)( Convert.ToUInt32( ap[vaNEXT - 1] ) - System.UInt32.MaxValue - 1 );
+          else return (Int32)Convert.ToInt32( ap[vaNEXT - 1] );
+        case "SrcList":
+          return (SrcList)ap[vaNEXT - 1];
+        case "char":
+          if ( ap[vaNEXT - 1].GetType().Name == "Int32" && (int)ap[vaNEXT - 1] == 0 )
+          {
+            return (char)'0';
+          }
+          else
+          {
+            if ( ap[vaNEXT - 1].GetType().Name == "Int64" )
+              if ( (i64)ap[vaNEXT - 1] == 0 )
+              {
+                return (char)'0';
+              }
+              else return (char)( (i64)ap[vaNEXT - 1] );
+            else
+              return (char)ap[vaNEXT - 1];
+          }
+        case "char*":
+        case "string":
+          if ( ap[vaNEXT - 1] == null )
+          {
+            return "NULL";
+          }
+          else
+          {
+            if ( ap[vaNEXT - 1].GetType().Name == "Byte[]" )
+              if ( Encoding.UTF8.GetString( (byte[])ap[vaNEXT - 1], 0, ((byte[])ap[vaNEXT - 1]).Length) == "\0" )
+                return "";
+              else
+                return Encoding.UTF8.GetString((byte[])ap[vaNEXT - 1], 0, ((byte[])ap[vaNEXT - 1]).Length);
+            else if ( ap[vaNEXT - 1].GetType().Name == "Int32" )
+              return null;
+            else if ( ap[vaNEXT - 1].GetType().Name == "StringBuilder" )
+              return (string)ap[vaNEXT - 1].ToString();
+            else return (string)ap[vaNEXT - 1];
+          }
+        case "byte[]":
+          if ( ap[vaNEXT - 1] == null )
+          {
+            return null;
+          }
+          else
+          {
+            return (byte[])ap[vaNEXT - 1];
+          }
+        case "byte[][]":
+          if ( ap[vaNEXT - 1] == null )
+          {
+            return null;
+          }
+          else
+          {
+            return (byte[][])ap[vaNEXT - 1];
+          }
+        case "int[]":
+          if ( ap[vaNEXT - 1] == null )
+          {
+            return "NULL";
+          }
+          else
+          {
+            return (int[])ap[vaNEXT - 1];
+          }
+        case "Token":
+          return (Token)ap[vaNEXT - 1];
+        case "u3216":
+          return Convert.ToUInt16( ap[vaNEXT - 1] );
+        case "u32":
+        case "unsigned int":
+          if ( ap[vaNEXT - 1].GetType().IsClass )
+          {
+            return ap[vaNEXT - 1].GetHashCode();
+          }
+          else
+          {
+            return Convert.ToUInt32( ap[vaNEXT - 1] );
+          }
+        case "u64":
+        case "unsigned long":
+        case "unsigned long int":
+          if ( ap[vaNEXT - 1].GetType().IsClass )
+            return Convert.ToUInt64( ap[vaNEXT - 1].GetHashCode() );
+          else
+            return Convert.ToUInt64( ap[vaNEXT - 1] );
+        case "sqlite3_mem_methods":
+          return (sqlite3_mem_methods)ap[vaNEXT - 1];
+        case "void_function":
+          return (void_function)ap[vaNEXT - 1];
+        case "MemPage":
+          return (MemPage)ap[vaNEXT - 1];
+        default:
+          Debugger.Break();
+          return ap[vaNEXT - 1];
+      }
+    }
+    static void va_end( object[] ap )
+    {
+      ap = null;
+      vaFORMAT = "";
+    }
+
+
+    public static tm localtime( time_t baseTime )
+    {
+      System.DateTime RefTime = new System.DateTime( 1970, 1, 1, 0, 0, 0, 0 );
+      RefTime = RefTime.AddSeconds( Convert.ToDouble( baseTime ) ).ToLocalTime();
+      tm tm = new tm();
+      tm.tm_sec = RefTime.Second;
+      tm.tm_min = RefTime.Minute;
+      tm.tm_hour = RefTime.Hour;
+      tm.tm_mday = RefTime.Day;
+      tm.tm_mon = RefTime.Month;
+      tm.tm_year = RefTime.Year;
+      tm.tm_wday = (int)RefTime.DayOfWeek;
+      tm.tm_yday = RefTime.DayOfYear;
+      tm.tm_isdst = RefTime.IsDaylightSavingTime() ? 1 : 0;
+      return tm;
+    }
+
+    public static long ToUnixtime( System.DateTime date )
+    {
+      System.DateTime unixStartTime = new System.DateTime( 1970, 1, 1, 0, 0, 0, 0 );
+      System.TimeSpan timeSpan = date - unixStartTime;
+      return Convert.ToInt64( timeSpan.TotalSeconds );
+    }
+
+    public static System.DateTime ToCSharpTime( long unixTime )
+    {
+      System.DateTime unixStartTime = new System.DateTime( 1970, 1, 1, 0, 0, 0, 0 );
+      return unixStartTime.AddSeconds( Convert.ToDouble( unixTime ) );
+    }
+
+    public struct tm
+    {
+      public int tm_sec;     /* seconds after the minute - [0,59] */
+      public int tm_min;     /* minutes after the hour - [0,59] */
+      public int tm_hour;    /* hours since midnight - [0,23] */
+      public int tm_mday;    /* day of the month - [1,31] */
+      public int tm_mon;     /* months since January - [0,11] */
+      public int tm_year;    /* years since 1900 */
+      public int tm_wday;    /* days since Sunday - [0,6] */
+      public int tm_yday;    /* days since January 1 - [0,365] */
+      public int tm_isdst;   /* daylight savings time flag */
+    };
+
+    public struct FILETIME
+    {
+      public u32 dwLowDateTime;
+      public u32 dwHighDateTime;
+    }
+
+    // Example (C#)
+    public static int GetbytesPerSector( StringBuilder diskPath )
+    {
+#if !SQLITE_SILVERLIGHT
+      ManagementObjectSearcher mosLogicalDisks = new ManagementObjectSearcher( "select * from Win32_LogicalDisk where DeviceID = '" + diskPath.ToString().Remove( diskPath.Length - 1, 1 ) + "'" );
+      try
+      {
+        foreach ( ManagementObject moLogDisk in mosLogicalDisks.Get() )
+        {
+          ManagementObjectSearcher mosDiskDrives = new ManagementObjectSearcher( "select * from Win32_DiskDrive where SystemName = '" + moLogDisk["SystemName"] + "'" );
+          foreach ( ManagementObject moPDisk in mosDiskDrives.Get() )
+          {
+            return int.Parse( moPDisk["BytesPerSector"].ToString() );
+          }
+        }
+      }
+      catch { }
+      return 4096;
+#else
+      return 4096;
+#endif
+    }
+
+    static void SWAP<T>( ref T A, ref T B ) { T t = A; A = B; B = t; }
+
+    static void x_CountStep(
+    sqlite3_context context,
+    int argc,
+    sqlite3_value[] argv
+    )
+    {
+      SumCtx p;
+
+      int type;
+      Debug.Assert( argc <= 1 );
+      Mem pMem = sqlite3_aggregate_context( context, 1 );//sizeof(*p));
+      if ( pMem._SumCtx == null ) pMem._SumCtx = new SumCtx();
+      p = pMem._SumCtx;
+      if ( p.Context == null ) p.Context = pMem;
+      if ( argc == 0 || SQLITE_NULL == sqlite3_value_type( argv[0] ) )
+      {
+        p.cnt++;
+        p.iSum += 1;
+      }
+      else
+      {
+        type = sqlite3_value_numeric_type( argv[0] );
+        if ( p != null && type != SQLITE_NULL )
+        {
+          p.cnt++;
+          if ( type == SQLITE_INTEGER )
+          {
+            i64 v = sqlite3_value_int64( argv[0] );
+            if ( v == 40 || v == 41 )
+            {
+              sqlite3_result_error( context, "value of " + v + " handed to x_count", -1 );
+              return;
+            }
+            else
+            {
+              p.iSum += v;
+              if ( !( p.approx | p.overflow != 0 ) )
+              {
+                i64 iNewSum = p.iSum + v;
+                int s1 = (int)( p.iSum >> ( sizeof( i64 ) * 8 - 1 ) );
+                int s2 = (int)( v >> ( sizeof( i64 ) * 8 - 1 ) );
+                int s3 = (int)( iNewSum >> ( sizeof( i64 ) * 8 - 1 ) );
+                p.overflow = ( ( s1 & s2 & ~s3 ) | ( ~s1 & ~s2 & s3 ) ) != 0 ? 1 : 0;
+                p.iSum = iNewSum;
+              }
+            }
+          }
+          else
+          {
+            p.rSum += sqlite3_value_double( argv[0] );
+            p.approx = true;
+          }
+        }
+      }
+    }
+    static void x_CountFinalize( sqlite3_context context )
+    {
+      SumCtx p;
+      Mem pMem = sqlite3_aggregate_context( context, 0 );
+      p = pMem._SumCtx;
+      if ( p != null && p.cnt > 0 )
+      {
+        if ( p.overflow != 0 )
+        {
+          sqlite3_result_error( context, "integer overflow", -1 );
+        }
+        else if ( p.approx )
+        {
+          sqlite3_result_double( context, p.rSum );
+        }
+        else if ( p.iSum == 42 )
+        {
+          sqlite3_result_error( context, "x_count totals to 42", -1 );
+        }
+        else
+        {
+          sqlite3_result_int64( context, p.iSum );
+        }
+      }
+    }
+#if SQLITE_MUTEX_W32
+//---------------------WIN32 Definitions
+static int GetCurrentThreadId()
+{
+return Thread.CurrentThread.ManagedThreadId;
+}
+static long InterlockedIncrement(long location)
+{
+Interlocked.Increment(ref  location);
+return location;
+}
+
+static void EnterCriticalSection(Mutex mtx)
+{
+Monitor.Enter(mtx);
+}
+static void InitializeCriticalSection(Mutex mtx)
+{
+Monitor.Enter(mtx);
+}
+static void DeleteCriticalSection(Mutex mtx)
+{
+Monitor.Exit(mtx);
+}
+static void LeaveCriticalSection(Mutex mtx)
+{
+Monitor.Exit(mtx);
+}
+
+}
+#endif
+
+  }
+}