rhodes 2.3.2 → 2.4.0.beta.1

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

@@ -0,0 +1,228 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+
+namespace Community.CsharpSqlite
+{
+  using sqlite3_value = Sqlite3.Mem;
+
+  public partial class Sqlite3
+  {
+    /*
+    ** 2008 June 13
+    **
+    ** 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.
+    **
+    *************************************************************************
+    **
+    ** This file contains definitions of global variables and contants.
+    *************************************************************************
+    **  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$
+    *************************************************************************
+    */
+    //#include "sqliteInt.h"
+
+
+    /* An array to map all upper-case characters into their corresponding
+    ** lower-case character.
+    **
+    ** SQLite only considers US-ASCII (or EBCDIC) characters.  We do not
+    ** handle case conversions for the UTF character set since the tables
+    ** involved are nearly as big or bigger than SQLite itself.
+    */
+    /* An array to map all upper-case characters into their corresponding
+    ** lower-case character.
+    */
+    static int[] sqlite3UpperToLower = new int[]  {
+#if SQLITE_ASCII
+0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
+104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,
+122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
+108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
+126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
+144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
+162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
+180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
+198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
+216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
+234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
+252,253,254,255
+#endif
+#if SQLITE_EBCDIC
+0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* 0x */
+16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */
+32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */
+48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */
+64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */
+80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */
+96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */
+112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */
+128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */
+144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */
+160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */
+176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */
+192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */
+208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */
+224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */
+239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */
+#endif
+};
+
+    /*
+    ** The following 256 byte lookup table is used to support SQLites built-in
+    ** equivalents to the following standard library functions:
+    **
+    **   isspace()                        0x01
+    **   isalpha()                        0x02
+    **   isdigit()                        0x04
+    **   isalnum()                        0x06
+    **   isxdigit()                       0x08
+    **   toupper()                        0x20
+    **   SQLite identifier character      0x40
+    **
+    ** Bit 0x20 is set if the mapped character requires translation to upper
+    ** case. i.e. if the character is a lower-case ASCII character.
+    ** If x is a lower-case ASCII character, then its upper-case equivalent
+    ** is (x - 0x20). Therefore toupper() can be implemented as:
+    **
+    **   (x & ~(map[x]&0x20))
+    **
+    ** Standard function tolower() is implemented using the sqlite3UpperToLower[]
+    ** array. tolower() is used more often than toupper() by SQLite.
+    **
+    ** Bit 0x40 is set if the character non-alphanumeric and can be used in an 
+    ** SQLite identifier.  Identifiers are alphanumerics, "_", "$", and any
+    ** non-ASCII UTF character. Hence the test for whether or not a character is
+    ** part of an identifier is 0x46.
+    **
+    ** SQLite's versions are identical to the standard versions assuming a
+    ** locale of "C". They are implemented as macros in sqliteInt.h.
+    */
+#if SQLITE_ASCII
+    static byte[] sqlite3CtypeMap = new byte[] {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 00..07    ........ */
+  0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,  /* 08..0f    ........ */
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 10..17    ........ */
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 18..1f    ........ */
+  0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,  /* 20..27     !"#$%&' */
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 28..2f    ()*+,-./ */
+  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,  /* 30..37    01234567 */
+  0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 38..3f    89:;<=>? */
+
+  0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02,  /* 40..47    @ABCDEFG */
+  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  /* 48..4f    HIJKLMNO */
+  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  /* 50..57    PQRSTUVW */
+  0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x40,  /* 58..5f    XYZ[\]^_ */
+  0x00, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22,  /* 60..67    `abcdefg */
+  0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,  /* 68..6f    hijklmno */
+  0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,  /* 70..77    pqrstuvw */
+  0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 78..7f    xyz{|}~. */
+
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 80..87    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 88..8f    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 90..97    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 98..9f    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* a0..a7    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* a8..af    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* b0..b7    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* b8..bf    ........ */
+
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* c0..c7    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* c8..cf    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* d0..d7    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* d8..df    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* e0..e7    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* e8..ef    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* f0..f7    ........ */
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40   /* f8..ff    ........ */
+};
+#endif
+
+
+    /*
+** The following singleton contains the global configuration for
+** the SQLite library.
+*/
+    static Sqlite3Config sqlite3Config = new Sqlite3Config(
+    SQLITE_DEFAULT_MEMSTATUS, /* bMemstat */
+    1,                        /* bCoreMutex */
+    SQLITE_THREADSAFE == 1,   /* bFullMutex */
+    0x7ffffffe,               /* mxStrlen */
+    100,                      /* szLookaside */
+    500,                      /* nLookaside */
+    new sqlite3_mem_methods(),   /* m */
+    new sqlite3_mutex_methods( null, null, null, null, null, null, null, null, null ), /* mutex */
+    new sqlite3_pcache_methods(),/* pcache */
+    null,                      /* pHeap */
+    0,                         /* nHeap */
+    0, 0,                      /* mnHeap, mxHeap */
+    null,                      /* pScratch */
+    0,                         /* szScratch */
+    0,                         /* nScratch */
+    null,                      /* pPage */
+    SQLITE_DEFAULT_PAGE_SIZE,  /* szPage */
+    0,                         /* nPage */
+    0,                         /* mxParserStack */
+    false,                     /* sharedCacheEnabled */
+      /* All the rest should always be initialized to zero */
+    0,                         /* isInit */
+    0,                         /* inProgress */
+    0,                         /* isMutexInit */
+    0,                         /* isMallocInit */
+    0,                         /* isPCacheInit */
+    null,                      /* pInitMutex */
+    0,                         /* nRefInitMutex */
+    null,                      /* xLog */
+    0                          /* pLogArg */
+    );
+
+    /*
+    ** Hash table for global functions - functions common to all
+    ** database connections.  After initialization, this table is
+    ** read-only.
+    */
+    static FuncDefHash sqlite3GlobalFunctions;
+
+    /*
+    ** The value of the "pending" byte must be 0x40000000 (1 byte past the
+    ** 1-gibabyte boundary) in a compatible database.  SQLite never uses
+    ** the database page that contains the pending byte.  It never attempts
+    ** to read or write that page.  The pending byte page is set assign
+    ** for use by the VFS layers as space for managing file locks.
+    **
+    ** During testing, it is often desirable to move the pending byte to
+    ** a different position in the file.  This allows code that has to
+    ** deal with the pending byte to run on files that are much smaller
+    ** than 1 GiB.  The sqlite3_test_control() interface can be used to
+    ** move the pending byte.
+    **
+    ** IMPORTANT:  Changing the pending byte to any value other than
+    ** 0x40000000 results in an incompatible database file format!
+    ** Changing the pending byte during operating results in undefined
+    ** and dileterious behavior.
+    */
+    static int sqlite3PendingByte = 0x40000000;
+
+    //#include "opcodes.h"
+    /*
+    ** Properties of opcodes.  The OPFLG_INITIALIZER macro is
+    ** created by mkopcodeh.awk during compilation.  Data is obtained
+    ** from the comments following the "case OP_xxxx:" statements in
+    ** the vdbe.c file.  
+    */
+    public static int[] sqlite3OpcodeProperty;
+  }
+}

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

@@ -0,0 +1,351 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+
+using u8 = System.Byte;
+using u32 = System.UInt32;
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 2001 September 22
+    **
+    ** 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.
+    **
+    *************************************************************************
+    ** This is the implementation of generic hash-tables
+    ** used in SQLite.
+    *************************************************************************
+    **  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: 2009-12-07 16:39:13 1ed88e9d01e9eda5cbc622e7614277f29bcc551c
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#include "sqliteInt.h"
+    //#include <assert.h>
+
+    /* Turn bulk memory into a hash table object by initializing the
+    ** fields of the Hash structure.
+    **
+    ** "pNew" is a pointer to the hash table that is to be initialized.
+    */
+    static void sqlite3HashInit( Hash pNew )
+    {
+      Debug.Assert( pNew != null );
+      pNew.first = null;
+      pNew.count = 0;
+      pNew.htsize = 0;
+      pNew.ht = null;
+    }
+
+    /* Remove all entries from a hash table.  Reclaim all memory.
+    ** Call this routine to delete a hash table or to reset a hash table
+    ** to the empty state.
+    */
+    static void sqlite3HashClear( Hash pH )
+    {
+      HashElem elem;         /* For looping over all elements of the table */
+
+      Debug.Assert( pH != null );
+      elem = pH.first;
+      pH.first = null;
+      //sqlite3_free( ref  pH.ht );
+      pH.ht = null;
+      pH.htsize = 0;
+      while ( elem != null )
+      {
+        HashElem next_elem = elem.next;
+        ////sqlite3_free(ref  elem );
+        elem = next_elem;
+      }
+      pH.count = 0;
+    }
+
+    /*
+    ** The hashing function.
+    */
+    static u32 strHash( string z, int nKey )
+    {
+      int h = 0;
+      Debug.Assert( nKey >= 0 );
+      int _z = 0;
+      while ( nKey > 0 )
+      {
+        h = ( h << 3 ) ^ h ^ ( ( _z < z.Length ) ? (int)sqlite3UpperToLower[(byte)z[_z++]] : 0 );
+        nKey--;
+      }
+      return (u32)h;
+    }
+
+    /* Link pNew element into the hash table pH.  If pEntry!=0 then also
+    ** insert pNew into the pEntry hash bucket.
+    */
+    static void insertElement(
+    Hash pH,              /* The complete hash table */
+    _ht pEntry,           /* The entry into which pNew is inserted */
+    HashElem pNew         /* The element to be inserted */
+    )
+    {
+      HashElem pHead;       /* First element already in pEntry */
+      if ( pEntry != null )
+      {
+        pHead = pEntry.count != 0 ? pEntry.chain : null;
+        pEntry.count++;
+        pEntry.chain = pNew;
+      }
+      else
+      {
+        pHead = null;
+      }
+      if ( pHead != null )
+      {
+        pNew.next = pHead;
+        pNew.prev = pHead.prev;
+        if ( pHead.prev != null ) { pHead.prev.next = pNew; }
+        else { pH.first = pNew; }
+        pHead.prev = pNew;
+      }
+      else
+      {
+        pNew.next = pH.first;
+        if ( pH.first != null ) { pH.first.prev = pNew; }
+        pNew.prev = null;
+        pH.first = pNew;
+      }
+    }
+
+    /* Resize the hash table so that it cantains "new_size" buckets.
+    **
+    ** The hash table might fail to resize if sqlite3_malloc() fails or
+    ** if the new size is the same as the prior size.
+    ** Return TRUE if the resize occurs and false if not.
+    */
+    static bool rehash( ref Hash pH, u32 new_size )
+    {
+      _ht[] new_ht;            /* The new hash table */
+      HashElem elem;
+      HashElem next_elem;    /* For looping over existing elements */
+
+#if SQLITE_MALLOC_SOFT_LIMIT
+if( new_size*sizeof(struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){
+new_size = SQLITE_MALLOC_SOFT_LIMIT/sizeof(struct _ht);
+}
+if( new_size==pH->htsize ) return false;
+#endif
+
+      /* There is a call to sqlite3Malloc() inside rehash(). If there is
+** already an allocation at pH.ht, then if this malloc() fails it
+** is benign (since failing to resize a hash table is a performance
+** hit only, not a fatal error).
+*/
+      sqlite3BeginBenignMalloc();
+      new_ht = new _ht[new_size]; //(struct _ht *)sqlite3Malloc( new_size*sizeof(struct _ht) );
+      for ( int i = 0; i < new_size; i++ ) new_ht[i] = new _ht();
+      sqlite3EndBenignMalloc();
+
+      if ( new_ht == null ) return false;
+      //sqlite3_free( ref  pH.ht );
+      pH.ht = new_ht;
+      // pH.htsize = new_size = sqlite3MallocSize(new_ht)/sizeof(struct _ht);
+      //memset(new_ht, 0, new_size*sizeof(struct _ht));
+      pH.htsize = new_size;
+
+      for ( elem = pH.first, pH.first = null; elem != null; elem = next_elem )
+      {
+        u32 h = strHash( elem.pKey, elem.nKey ) % new_size;
+        next_elem = elem.next;
+        insertElement( pH, new_ht[h], elem );
+      }
+      return true;
+    }
+
+    /* This function (for internal use only) locates an element in an
+    ** hash table that matches the given key.  The hash for this key has
+    ** already been computed and is passed as the 4th parameter.
+    */
+    static HashElem findElementGivenHash(
+    Hash pH,       /* The pH to be searched */
+    string pKey,   /* The key we are searching for */
+    int nKey,      /* Bytes in key (not counting zero terminator) */
+    u32 h         /* The hash for this key. */
+    )
+    {
+      HashElem elem;                /* Used to loop thru the element list */
+      int count;                    /* Number of elements left to test */
+
+      if ( pH.ht != null && pH.ht[h] != null )
+      {
+        _ht pEntry = pH.ht[h];
+        elem = pEntry.chain;
+        count = (int)pEntry.count;
+      }
+      else
+      {
+        elem = pH.first;
+        count = (int)pH.count;
+      }
+      while ( count-- > 0 && ALWAYS( elem ) )
+      {
+        if ( elem.nKey == nKey && sqlite3StrNICmp( elem.pKey, pKey, nKey ) == 0 )
+        {
+          return elem;
+        }
+        elem = elem.next;
+      }
+      return null;
+    }
+
+    /* Remove a single entry from the hash table given a pointer to that
+    ** element and a hash on the element's key.
+    */
+    static void removeElementGivenHash(
+    Hash pH,            /* The pH containing "elem" */
+    ref HashElem elem,  /* The element to be removed from the pH */
+    u32 h               /* Hash value for the element */
+    )
+    {
+      _ht pEntry;
+      if ( elem.prev != null )
+      {
+        elem.prev.next = elem.next;
+      }
+      else
+      {
+        pH.first = elem.next;
+      }
+      if ( elem.next != null )
+      {
+        elem.next.prev = elem.prev;
+      }
+      if ( pH.ht != null && pH.ht[h] != null )
+      {
+        pEntry = pH.ht[h];
+        if ( pEntry.chain == elem )
+        {
+          pEntry.chain = elem.next;
+        }
+        pEntry.count--;
+        Debug.Assert( pEntry.count >= 0 );
+      }
+      //sqlite3_free( ref  elem );
+      pH.count--;
+      if ( pH.count <= 0 )
+      {
+        Debug.Assert( pH.first == null );
+        Debug.Assert( pH.count == 0 );
+        sqlite3HashClear( pH );
+      }
+    }
+
+    /* Attempt to locate an element of the hash table pH with a key
+    ** that matches pKey,nKey.  Return the data for this element if it is
+    ** found, or NULL if there is no match.
+    */
+    static object sqlite3HashFind( Hash pH, string pKey, int nKey )
+    {
+      HashElem elem;  /* The element that matches key */
+      u32 h;          /* A hash on key */
+
+      Debug.Assert( pH != null );
+      Debug.Assert( pKey != null );
+      Debug.Assert( nKey >= 0 );
+      if ( pH.ht != null )
+      {
+        h = strHash( pKey, nKey ) % pH.htsize;
+      }
+      else
+      {
+        h = 0;
+      }
+      elem = findElementGivenHash( pH, pKey, nKey, h );
+      return elem != null ? elem.data : null;
+    }
+
+    /* Insert an element into the hash table pH.  The key is pKey,nKey
+    ** and the data is "data".
+    **
+    ** If no element exists with a matching key, then a new
+    ** element is created and NULL is returned.
+    **
+    ** If another element already exists with the same key, then the
+    ** new data replaces the old data and the old data is returned.
+    ** The key is not copied in this instance.  If a malloc fails, then
+    ** the new data is returned and the hash table is unchanged.
+    **
+    ** If the "data" parameter to this function is NULL, then the
+    ** element corresponding to "key" is removed from the hash table.
+    */
+    static object sqlite3HashInsert( ref Hash pH, string pKey, int nKey, object data )
+    {
+      u32 h;       /* the hash of the key modulo hash table size */
+
+      HashElem elem;       /* Used to loop thru the element list */
+      HashElem new_elem;   /* New element added to the pH */
+
+      Debug.Assert( pH != null );
+      Debug.Assert( pKey != null );
+      Debug.Assert( nKey >= 0 );
+
+      if ( pH.htsize != 0 )
+      {
+        h = strHash( pKey, nKey ) % pH.htsize;
+      }
+      else
+      {
+        h = 0;
+      }
+      elem = findElementGivenHash( pH, pKey, nKey, h );
+      if ( elem != null )
+      {
+        object old_data = elem.data;
+        if ( data == null )
+        {
+          removeElementGivenHash( pH, ref elem, h );
+        }
+        else
+        {
+          elem.data = data;
+          elem.pKey = pKey;
+          Debug.Assert( nKey == elem.nKey );
+        }
+        return old_data;
+      }
+      if ( data == null ) return null;
+      new_elem = new HashElem();//(HashElem*)sqlite3Malloc( sizeof(HashElem) );
+      if ( new_elem == null ) return data;
+      new_elem.pKey = pKey;
+      new_elem.nKey = nKey;
+      new_elem.data = data;
+      pH.count++;
+      if ( pH.count >= 10 && pH.count > 2 * pH.htsize )
+      {
+        if ( rehash( ref  pH, pH.count * 2 ) )
+        {
+          Debug.Assert( pH.htsize > 0 );
+          h = strHash( pKey, nKey ) % pH.htsize;
+        }
+      }
+      if ( pH.ht != null )
+      {
+        insertElement( pH, pH.ht[h], new_elem );
+
+      }
+      else
+      {
+        insertElement( pH, null, new_elem );
+      }
+      return null;
+    }
+
+  }
+}