开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
db.c
资源名称：saac.tar.gz　[点击查看]
上传用户：qys8201
上传日期：2021-12-11
资源大小：978k
文件大小：40k
源码类别：

模拟服务器

开发平台：

C/C++

db.c：源码内容
  1. /*
  2.   仿件平件弘窗  勾五犯□正矛□旦及  隶［
  4.   1999 Aug 14 Created by ringo
  6.   犯□正矛□旦反1  及伉件弁及溥匹忡绣今木月［
  7.   
  8.   
  9.  */
  10. #define _DB_C_
  11. #include "db.h"
  12. #include "main.h"
  13. #include "util.h"
  14. #include "version.h"
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <sys/types.h>
  19. #include <dirent.h>
  20. #include <errno.h>
  21. #include <string.h>
  22. #include <sys/stat.h>
  24. /*   侬  巨件玄伉及    length */
  25. //#define CHARVALUE_MAX 1024
  26. #define MAXTABLE 16
  27. // Spock 2000/10/12
  28. #define CHARVALUE_MAX 256 // DB 字串资料的buffer大小
  29. #define KEY_MAX 64 // DB Key字串的buffer大小
  30. #define HASH_SIZE 65536 // Hash table 一次增加的Entry数量
  31. #define HASH_PRIME 65521 // Hash function 使用的质数
  32. #define DBINIT_SIZE 16384 // DB 每次配置Entry的数量
  33. // Spock end
  35. /* 犯□正矛□旦及伉件弁及邰豳1蜊毛丐日歹允［ */
  36. struct dbentry
  37. {
  38.     int use;
  39. //    unsigned int keyhash;       /* 腹绸平□及甩永扑亘戊□玉 */
  40.     int ivalue;                  /* 旦戊失［玄永皿 NODE 反  -1 匹｝
  41.                                  允屯化及旦戊失反 0 动晓匹卅中午中仃卅中*/
  42. //    int nextind;                /* -1 分匀凶日    毛啦  允月 */
  43.     // Spock 2000/10/12
  44.     int prev; // 前一个dbentry, -1表示此项为head
  45.     int next; // 下一个dbentry, -1表示此项为tail
  46.     char key[KEY_MAX];
  47.     char charvalue[CHARVALUE_MAX];
  48. //    char key[64];               /* 腹绸平□午卅月  侬   */
  49. //    int charvalue_index;        /*   侬  田永白央毛今允index */
  50.     // Spock end
  51. };
  53. // Spock 2000/10/12
  54. // Database hashtable
  55. struct hashentry
  56. {
  57.     char key[KEY_MAX]; // 索引key值
  58.     int use; // 是否已被使用
  59.     int dbind; // 指向 dbentry 的 index
  60.     int prev; // 同一key值的上一个 hashentry, -1为head
  61.     int next; // 同一key值的下一个 hashentry, -1为tail
  62. };
  63. // Spock end
  65. typedef enum
  66. {
  67.     DB_INT_SORTED,
  68.     DB_STRING,
  69. }DBTYPE;
  71. /* 1蜊及犯□正矛□旦毛丐日歹允 */
  72. struct table
  73. {
  74.     int use; // 0:未使用 1:已使用
  75.     DBTYPE type;                    /* DB及潘   */
  76.     char name[32];                  /* 犯□正矛□旦及  蟆 */
  77.     int num;                        /* 巨件玄伉及醒 */
  78.     int toplinkindex;
  79.     // Spock 2000/10/12
  80.     struct hashentry *hashtable;
  81.     int hashsize;
  82.     int updated; // 0:dbflush後未更新 1:已更新
  83.     int ent_finder; // 指向最後一次配置的 hashentry
  84.     // Spock end
  85. };
  87. struct dbentry *master_buf;     /* 巨件玄伉筏盛迕 */
  88. int dbsize = 0;                 /*   赓0匹｝1,2,4,8,16...*/
  89. static int dbent_finder = 0;
  91. struct table dbt[MAXTABLE];
  93. static void dbShowAllTable(void);
  95. // Spock 2000/10/12
  96. int dbHash(char* s)
  97. {
  98.     char *p;
  99.     unsigned int h= 0 ,g;
  100.     for( p = s ; *p ; p ++ ){
  101.         h = ( h<< 4 ) + (*p);
  102.         if( (g = h & 0xf0000000) != 0){
  103.             h = h ^ (g>>24);
  104.             h = h ^ g;
  105.         }
  106.     }
  107.     return h % HASH_PRIME;
  108. }
  109. // Spock end
  111. /* Spock deleted 2000/10/12
  112. struct charvalue
  113. {
  114.     int use;
  115.     char buf[CHARVALUE_MAX];
  116. };
  117. struct charvalue *charvalue_buf;
  118. int charvaluesize=0;
  119. */
  121. /*
  122.     侬  田永白央□毛傀舰允月
  123.  */
  124. /* Spock deleted 2000/10/12
  125. int
  126. reallocCharValue(void)
  127. {
  128.     struct charvalue *previous = charvalue_buf;
  129.     struct charvalue *newbuf;
  130.     int new_charvaluesize;
  131.     if( charvaluesize == 0 ){
  132.         new_charvaluesize = 1;
  133.     } else {
  134.         new_charvaluesize = charvaluesize * 2;
  135.     }
  137.     newbuf = ( struct charvalue *) calloc( 1, new_charvaluesize *
  138.                                           sizeof( struct charvalue ));
  139.     if( newbuf == NULL ){
  140.         log( "reallocCharValue: memory shortage!! new_charvaluesize:%dn",
  141.              new_charvaluesize );
  142.         return -1;
  143.     }
  144.     memset( newbuf, 0 , new_charvaluesize * sizeof( struct charvalue ));
  145.     if( previous) memcpy( (char*)newbuf, (char*)previous,
  146.             charvaluesize * sizeof( struct charvalue ));
  147.     free( previous );
  148.     charvaluesize = new_charvaluesize;
  149.     charvalue_buf = newbuf;
  151.     log( "reallocCharValue: "
  152.          "new_charvaluesize:%d Old address:%x New address:%xn",
  153.          new_charvaluesize , (unsigned int )previous,
  154.          (unsigned int)newbuf );
  155.     return 0;
  156. }
  157. */
  159. /*
  160.     侬  田永白央□毛1蜊歹曰丐化月［
  161.   凶曰卅仁卅匀凶日realloc允月［
  162.   
  163. */
  164. /* Spock deleted 2000/10/12
  165. static int charvalue_finder=0;
  166. static int
  167. dbAllocCharValue( void )
  168. {
  169.     int i;
  170.     for(i=0;i<charvaluesize;i++){
  171.         charvalue_finder++;
  172.         if( charvalue_finder == charvaluesize ) charvalue_finder =0;
  173.         if( charvalue_buf[charvalue_finder].use == 0 ){
  174.             charvalue_buf[charvalue_finder].use =1;
  175.             charvalue_buf[charvalue_finder].buf[0] = 0;
  176.             return charvalue_finder;
  177.         }
  179.     }
  180.     log( "dbAllocCharValue: charvalue array full. reallocating....n" );
  181.     if( reallocCharValue() < 0 ){
  182.         log( "dbAllocCharValue: reallocation failn");
  183.     } else {
  184.         return dbAllocCharValue();
  185.     }
  186.     return -1;
  187. }
  188. */
  190. /*
  191.   charvalue 井日/卞袄毛必永玄/本永玄允月
  192.   int index : charvalue index
  193.   
  194.  */
  195. /* Spock deleted 2000/10/12
  196. static char *
  197. dbGetString( int index )
  198. {
  199.     return charvalue_buf[index].buf;
  200. }
  201. static int
  202. dbSetString( int index , char *data )
  203. {
  204.     int l = strlen(data);
  205.     if( l >= (sizeof( charvalue_buf[0].buf )-1)) return -1;
  206.     memcpy( charvalue_buf[index].buf , data, l+1 );
  207.     return 0;
  208. }
  209. */
  211. /*
  212.   DB及云云五今互凶日氏仁卅匀凶日歹曰丐化卅云允［中引及扔奶术及2  卞允月
  213.   0分匀凶日1卞允月
  214.  */
  215. static int
  216. reallocDB( void )
  217. {
  218.     struct dbentry *previous = master_buf;
  219.     struct dbentry *newbuf;
  220.     int new_dbsize;
  221. /* Spock deleted 2000/10/12    
  222.     if( dbsize == 0 ){
  223.         new_dbsize = 1;
  224.     } else {
  225.         new_dbsize = dbsize * 2;
  226.     }
  227. */
  228.     // Spock+1 2000/10/12
  229.     new_dbsize = dbsize + DBINIT_SIZE;
  230.     
  231.     newbuf = (struct dbentry* ) calloc( 1, new_dbsize *
  232.                                          sizeof( struct dbentry) );
  233.     /* 丢乒伉凶曰卅中   */
  234.     if( newbuf == NULL ){
  235.         log( "重新分配数据: 内存不足!!! 新数据大小: %dn", new_dbsize );
  236.         return -1;
  237.     }
  239.     /* 衙中幻丹井日蕙仄中  卞戊疋□仄化 */
  241.     memset( newbuf , 0 , new_dbsize * sizeof( struct dbentry ) );
  242.     /* Spock deleted 2000/10/19
  243.     if( previous )memcpy( (char*)newbuf, (char*)previous,
  244.             dbsize * sizeof( struct dbentry ));
  246.     // 衙中幻丹毛荸  仄
  247.     free( previous );
  248.     */
  249.     // Spock 2000/10/19
  250.     if ( dbsize > 0 )
  251.     {
  252.      memcpy( newbuf , previous , dbsize * sizeof(struct dbentry));
  253.      free( previous );
  254.     }
  255.     // Spock end
  257.     dbent_finder = dbsize; // 将 dbent_finder 指向未使用的 entry
  258.     dbsize = new_dbsize;
  259.     master_buf = newbuf;
  260.     
  261.     log( "重新分配数据: 新数据大小:%d 旧地址: %x 新地址:%xn",
  262.          new_dbsize , (unsigned int)previous, (unsigned int)newbuf );
  264.     return 0;
  265. }
  269. /*
  270.   allocate a node
  271.  */
  272. static int
  273. //dbAllocNode( DBTYPE type  )
  274. // Spock +1 2000/10/13
  275. dbAllocNode()
  276. {
  277.     int i;
  278.     for(i=0;i<dbsize;i++){
  279.         dbent_finder ++;
  280.         if( dbent_finder == dbsize ) {
  281.             dbent_finder = 0;
  282.         }
  283.         if( master_buf[dbent_finder].use == 0 ){
  284.             master_buf[dbent_finder].use = 1;
  285.             /* Spock deleted 2000/10/12
  286.             // int 匹手尥笛树  及啃卞stringbuffer毛  勾仪卞允月 kawata
  287.             if( type == DB_STRING || type == DB_INT_SORTED){
  288.                 if( ( master_buf[dbent_finder].charvalue_index =
  289.                       dbAllocCharValue() ) < 0 ){
  290.                     //   侬  田永白央□互凶曰卅中冗
  291.                     return -1;
  292.                 }
  293.             }
  294.             */
  295.             return dbent_finder;
  296.         }
  297.     }
  298.     log( "数据进入队列失败. 重新分配中....n" );
  299.     if( reallocDB() < 0 ){
  300.         log( "重新分配失败n" );
  301.     } else {
  302.         //return dbAllocNode( type );
  303.         // Spock 2000/10/13
  304.         master_buf[dbent_finder].use = 1;
  305.         log( "数据探测=%dn" , dbent_finder );
  306.         return dbent_finder;
  307.         // Spock end
  308.     }
  309.     return -1;
  310. }
  311. static void
  312. dbReleaseNode( int index )
  313. {
  314.     // Spock 2000/10/12
  315.     int prev = master_buf[index].prev;
  316.     int next = master_buf[index].next;
  317.     master_buf[index].use = 0;
  318.     if ( prev >= 0 ) master_buf[prev].next = next;
  319.     if ( next >= 0 ) master_buf[next].prev = prev;
  320.     // Spock end
  321.     /* Spock deleted 2000/10/12
  322. if( master_buf[index].charvalue_index >= 0 ) {
  323. charvalue_buf[ master_buf[index].charvalue_index].use = 0;
  324. }
  325.     */
  326. }
  327. void
  328. dbShowLink( int topind )
  329. {
  330.     int cur = topind;
  332.     log( "开始从 %d 链接数据n", cur );
  333.     
  334.     /* Spock deleted 2000/10/19
  335.     for(;;){
  336.         if( cur == -1 )break;
  337.     */
  338.     // Spock +1 2000/10/19
  339.     while ( cur >= 0 )
  340.     {
  341.         if( master_buf[cur].use == 0 ){
  342.             log( "dbShowLink: use is 0! key:%sn", master_buf[cur].key );
  343.             return;
  344.         }
  345.         // Spock +1  2000/10/12
  346.         log( "%s %in", master_buf[cur].key, master_buf[cur].ivalue );
  347.         /* Spock deleted 2000/10/12
  348.         log( "%s %u %in", master_buf[cur].key ,
  349.              master_buf[cur].keyhash, master_buf[cur].ivalue );
  350.         */
  351.         cur = master_buf[cur].next;
  352.     }
  353. }
  354. // Spock 2000/10/13
  355. static int
  356. reallocHash( int dbi )
  357. {
  358.     struct hashentry *previous = dbt[dbi].hashtable;
  359.     struct hashentry *newbuf;
  360.     int new_hashsize;
  361.  
  362.     new_hashsize = dbt[dbi].hashsize + HASH_SIZE;
  363.     newbuf = (struct hashentry* ) calloc( 1, new_hashsize *
  364.                                          sizeof( struct hashentry) );
  365.     if( newbuf == NULL ){
  366.         log( "重新分配无用信息: 内存不足!!! 新无用信息大小: %dn", new_hashsize );
  367.         return -1;
  368.     }
  370.     memset( newbuf , 0 , new_hashsize * sizeof( struct hashentry ) );
  371.     if( previous )
  372.     {
  373.      memcpy( newbuf, previous,
  374.             dbt[dbi].hashsize * sizeof( struct hashentry ));
  375.         free( previous );
  376.     }
  378.     if ( dbt[dbi].hashsize > HASH_PRIME )
  379.         dbt[dbi].ent_finder = dbt[dbi].hashsize;
  380.     else
  381.         dbt[dbi].ent_finder = HASH_PRIME;
  382.     dbt[dbi].hashsize = new_hashsize;
  383.     dbt[dbi].hashtable = newbuf;
  384.     
  385.     log( "重新分配无用信息: 新无用信息大小:%d 旧地址: %x 新地址:%xn",
  386.          new_hashsize , (unsigned int)previous, (unsigned int)newbuf );
  388.     return 0;
  389. }
  391. static int tableGetEntry( int dbi , char *k )
  392. {
  393.     int hashkey = dbHash( k );
  394.     struct hashentry *hash = dbt[dbi].hashtable;
  395.     if ( hash[hashkey].use == 0 ) return -1;
  396.     while ( 1 ) {
  397. // if ( hash[hashkey].use == 1 && strcmp( hash[hashkey].key , k ) == 0 ){
  398. if ( hash[hashkey].use == 1 ){
  399. if( strcmp( hash[hashkey].key , k ) == 0 )return hashkey;
  400. }
  401.     hashkey = hash[hashkey].next;
  402. if ( hashkey <= 0 ){
  403. // log("err not found hash[%x] -%s!n", hashkey, k)
  404. return -1;
  405. } 
  406.     }
  407. }
  409. static int tableInsertNode( int dbi , char *k , int dbind )
  410. {
  411.     int hashkey = dbHash( k );
  412.     int hashnext = -1;
  413.     int i;
  414.     struct hashentry *hash = dbt[dbi].hashtable;
  415.   
  416.     if ( hash[hashkey].use == 0 )  {
  417.      strcpy( hash[hashkey].key , k );
  418.     hash[hashkey].use = 1;
  419.      hash[hashkey].dbind = dbind;
  420.      hash[hashkey].prev = -1;
  421.      hash[hashkey].next = -1;
  422.      dbt[dbi].num++;
  423.         return hashkey;
  424.     }else {
  425.      for ( i=0; i<dbt[dbi].hashsize-HASH_PRIME; i++ ){
  426.          dbt[dbi].ent_finder++;
  427.          if ( dbt[dbi].ent_finder >= dbt[dbi].hashsize )
  428.              dbt[dbi].ent_finder = HASH_PRIME;
  429.          if ( hash[dbt[dbi].ent_finder].use == 0 )
  430.          {
  431.              hashnext = dbt[dbi].ent_finder;
  432.              break;
  433.          }
  434.      }
  435.      if ( hashnext < HASH_PRIME )
  436.      {
  437.             log( "tableInsertNode: hashentry array full. reallocating....n" );
  438.             if( reallocHash( dbi ) < 0 ){
  439.                 log( "tableInsertNode: reallocation failn" );
  440.                 return -1;
  441.             }
  442.             else
  443.             {
  444.              hash = dbt[dbi].hashtable;
  445.              hashnext = dbt[dbi].ent_finder;
  446.             }
  447.         }
  448.         strcpy( hash[hashnext].key , k );
  449.         hash[hashnext].use = 1;
  450.         hash[hashnext].dbind = dbind;
  451.         hash[hashnext].prev = hashkey;
  452.         hash[hashnext].next = hash[hashkey].next;
  453.         if ( hash[hashkey].next >= 0 )
  454.             hash[hash[hashkey].next].prev = hashnext;
  455.         hash[hashkey].next = hashnext;
  456.         dbt[dbi].num++;
  457.         return hashnext;
  458.     }
  459. }
  461. static void
  462. tableReleaseNode( int dbi , int ind )
  463. {
  464.     dbt[dbi].hashtable[ind].use = 0;
  465.     if ( dbt[dbi].hashtable[ind].prev >= 0 ){
  466.         dbt[dbi].hashtable[dbt[dbi].hashtable[ind].prev].next =
  467.         dbt[dbi].hashtable[ind].next;
  468.     }
  469.     if ( dbt[dbi].hashtable[ind].next >= 0 ){
  470.         dbt[dbi].hashtable[dbt[dbi].hashtable[ind].next].prev =
  471.         dbt[dbi].hashtable[ind].prev;
  472.     }
  473.     dbt[dbi].num--;
  474. }
  475. // Spock end
  476. /*
  477.   伉件弁及玄永皿毛芨尹日木凶日｝平□毛  曰卞用□玉毛腹绸允月［
  478.   心勾井日卅中桦宁反巨仿□匹反卅中及匹0
  480.  */
  481. /* Spock deleted 2000/10/13
  482. static int
  483. dbExtractNodeByKey( int topind , char *k  )
  484. {
  485.     int cur = topind;
  486.     int prev = -1;
  487.     unsigned int h = hashpjw( k );
  489.     // 伉件弁互坞匹手心勾井日卅中分仃卅及匹0毛井尹允
  490.     if( topind == -1 ) return 0;
  492.     for(;;){
  493.         if( cur == -1 )break;
  494.         if( master_buf[cur].keyhash == h
  495.             && strcmp( master_buf[cur].key , k ) == 0 ){
  496.             // prev 及 戚互 cur 及戚卞卅月方丹卞允月
  497.             if( prev == -1 ){
  498.                 // 燮  分匀凶及匹伉件弁反中元日卅中
  499.             } else {                
  500.                 master_buf[prev].nextind = master_buf[cur].nextind;
  501.             }
  502.             // 公木匹愤坌互伉旦玄井日陆木月及匹荸  允月
  503.             dbReleaseNode( cur );
  504.             log( "find key %s deletedn", k );
  505.             return 0;
  506.         }
  507.         prev = cur;
  508.         cur = master_buf[cur].nextind;
  509.     }
  510.     // not found
  511.     log( "dbExtractNodeBykey: %s not foundn" , k );
  512.     return 0;
  513. }
  514. */
  515. // Spock 2000/10/13
  516. static int
  517. dbExtractNodeByKey( int dbi , char *k  )
  518. {
  519.     int hashind = tableGetEntry( dbi , k );
  521.     if ( hashind < 0 ){
  522.      log( "dbExtractNodeByKey: tableGetEntry fail, key:%sn" , k );
  523.      return -1;
  524.     }
  525.     if ( dbt[dbi].hashtable[hashind].dbind < 0 ){
  526.      log( "dbExtractNodeByKey: invalid dbind in hash, key:%sn" , k );
  527.      return -1;
  528.     }
  529.     dbReleaseNode( dbt[dbi].hashtable[hashind].dbind );
  530.     tableReleaseNode( dbi , hashind );
  531.     return 0;
  532. }
  533. // Spock end
  535. /* Spock deleted 2000/10/12
  536. static int 
  537. dbGetEntryByKey( int topind , char *k )
  538. {
  539.     int cur = topind;
  540.     unsigned int h = hashpjw( k );
  542.     if( topind == -1 ) return 0;
  544.     for(;;){
  545.         if( cur == -1 )break;
  546.         if( master_buf[cur].keyhash == h
  547.             && strcmp( master_buf[cur].key, k ) == 0 ){
  548.             return cur;
  549.         }
  550.         cur = master_buf[cur].nextind;
  551.     }
  552.     return -1;
  553. }
  554. */
  556. /*
  557.   伉件弁及玄永皿毛芨尹日木凶日｝袄毛  曰卞用□玉毛腹绸仄化
  558.   赝濠卅午仇欠卞 Insert 允月［切中今中  井日云云五中  卞卅日氏匹中月午
  559.   移烂
  561.  */
  562. /* Spock deleted 2000/10/13
  563. static int
  564. dbInsertNodeByIValue( int topind , int ins )
  565. {
  566.     int cur = topind;
  567.     int prev = -1;
  569.     if( topind == -1 ) return -1;
  570.     
  571.     for(;;){
  572.         if( cur == -1 ){
  573.             //     引匹中匀凶及匹馨笛允月
  574.             master_buf[prev].nextind = ins;
  575.             master_buf[ins].nextind = -1;
  576.             return 0;
  577.         }
  578.         if( master_buf[cur].ivalue < master_buf[ins].ivalue ){
  579.             if( prev == -1 ){
  580.                 log( "top_node is badly configuredn" );
  581.                 return -1;
  582.             }
  583.             master_buf[prev].nextind = ins;
  584.             master_buf[ins].nextind = cur;
  585.             return 0;
  586.         }
  587.         prev = cur;
  588.         cur = master_buf[cur].nextind;
  589.     }
  590.     
  591.     return -1;
  592. }
  593. */
  594. // Spock 2000/10/13
  595. static int
  596. dbInsertNodeByIValue( int topind , int ins )
  597. {
  598.     int cur = topind;
  599.     if ( (topind < 0)||(topind >= dbsize)||(ins < 0)||(ins >= dbsize ) )
  600.         return -1;
  601.     while ( master_buf[cur].next >= 0 ){
  602.      if ( master_buf[master_buf[cur].next].ivalue < master_buf[ins].ivalue )
  603.          break;
  604.      cur = master_buf[cur].next;
  605.     }
  606.     master_buf[ins].prev = cur;
  607.     master_buf[ins].next = master_buf[cur].next;
  608.     if ( master_buf[cur].next >= 0 )
  609.         master_buf[master_buf[cur].next].prev = ins;
  610.     master_buf[cur].next = ins;
  611.     return 0;
  612. }
  613. // Spock end
  614. /* Spock deleted 2000/10/13
  615. static int
  616. dbAppendNode( int topind , int ins )
  617. {
  618.     int cur =topind;
  619.     int prev = -1;
  620.     if( topind == -1 ) return -1;
  621.     for(;;){
  622.         if( cur == -1 ){
  623.             master_buf[prev].nextind = ins;
  624.             master_buf[ins].nextind = -1;
  625.             return 0;
  626.         }
  627.         prev = cur;
  628.         cur = master_buf[cur].nextind;
  629.     }
  630.     return -1;
  631. }
  632. */
  633. // Spock 2000/10/13
  634. static int
  635. dbAppendNode( int topind , int ins )
  636. {
  638.     if ( (topind < 0)||(topind >= dbsize)||(ins < 0)||(ins >= dbsize ) )
  639.         return -1;
  640.     master_buf[ins].prev = topind;
  641.     master_buf[ins].next = master_buf[topind].next;
  642.     if ( master_buf[topind].next >= 0 )
  643.         master_buf[master_buf[topind].next].prev = ins;
  644.     master_buf[topind].next = ins;
  645.     return 0;
  646. }
  647. // Spock end
  649. /*
  650.   犯□正矛□旦及  蟆毛  月［db反醒互剂卅中及匹  骚卞strcmp仄化方中
  651.   DBTYPE :潘  ［
  653.   云卅元卅引尹及  反｝帮醒午  侬  及    卞绣箕允月仇午互匹五月［
  654.   
  655.  */
  656. static int
  657. dbGetTableIndex( char *tname , DBTYPE type )
  658. {
  659.     int i;
  661.     for(i=0;i<MAXTABLE;i++){
  662.         if( dbt[i].use && strcmp( dbt[i].name , tname ) == 0 &&
  663.             dbt[i].type == type ){
  664.             return i ;
  665.         }
  666.     }
  668.     /* 心勾井日卅井匀凶及匹蕙筋分 */
  669.     for(i=0;i<MAXTABLE;i++){
  670.         if( dbt[i].use == 0 ){
  671.             int topind;
  672.             dbt[i].use = 1;
  673.             dbt[i].type = type;
  674.             snprintf( dbt[i].name , sizeof( dbt[i].name ) , "%s", tname );
  675.             // Spock 2000/10/16
  676.             if ( reallocHash( i ) < 0 )
  677.             {
  678.              log( "重新分配无用信息失败n");
  679.              return -2;
  680.             }
  681.             dbt[i].ent_finder = HASH_PRIME;
  682.             // Spock end
  684.             //topind = dbAllocNode( type );
  685.             // Spock +1 2000/10/16
  686.             topind = dbAllocNode();
  687.             if( topind < 0 ){
  688.                 log( "数据分配节点失败n" );
  689.                 return -2;
  690.             }
  691.             /* Spock deleted 2000/10/16
  692.             snprintf( master_buf[topind].key ,
  693.                       sizeof(master_buf[topind].key), "top_node" );
  694.             master_buf[topind].keyhash = hashpjw( master_buf[topind].key );
  695.             master_buf[topind].nextind = -1;
  696.             */
  697.             
  698.             /* 玄永皿及用□玉毛赓渝祭允月卅曰［
  699.                侬  及桦宁手帮醒及桦宁手云卅元匹方中［
  700.              0x7fffffff午中丹袄反｝  侬  及桦宁反今幻升啦  毛手凶卅中及分［*/
  701.             master_buf[topind].ivalue = 0x7fffffff;    
  702.             /* Spock deleted 2000/10/16
  703.             if( type == DB_INT_SORTED ){
  704.                 master_buf[topind].charvalue_index = -1;
  705.                 //dbSetString( master_buf[topind].charvalue_index, "" );
  706.             } else {
  707.                 dbSetString( master_buf[topind].charvalue_index, "" );
  708.             }
  709.     */
  710.             // Spock 2000/10/16
  711.             master_buf[topind].prev = -1;
  712.             master_buf[topind].next = -1;
  713.             strcpy( master_buf[topind].key , "top_node" );
  714.             master_buf[topind].charvalue[0] = 0;
  715.             // Spock end
  716.             dbt[i].toplinkindex = topind;
  717.             return i;
  718.         }
  719.     }
  721.     /*   互中匀天中分［ */
  722.     log( "dbGetTableIndex: table full. now tables are:n" );
  723.     dbShowAllTable();
  725.     return -1;
  726. }
  728. /*
  730.   午曰丐尹内 strtol 匹五月袄仄井扔禾□玄仄卅中方
  732.   腹绸仄化苇勾仃凶用□玉卞覆仄化｝
  733.   伉件弁井日  五午匀化井日｝漆蘸反末□玄允月及卞银丹袄毛凶方曰卞
  734.   腹绸仄化｝中中桦赭毛心勾仃凶日｝公仇卞犒仄仇戈［
  735.   
  736.  */
  737. /* Spock deleted 2000/10/16
  738. int dbUpdateEntryInt( char *table , char *key , int value, char *info )
  739. {
  740.     int r, dbi = dbGetTableIndex( table , DB_INT_SORTED );
  741.     int entind;
  743.     if( strlen(key) >= sizeof( master_buf[0].key) )return -1;
  744.     
  745.     if( dbi < 0 ) return -1;
  747.     r = dbExtractNodeByKey( dbt[dbi].toplinkindex , key );
  748.     if( r < 0 ){
  749.         log( "dbUpdateEntryInt: dbExtractNodeByKey fail! bug!!!!n" );
  750.         return -1;
  751.     }
  753.     entind = dbAllocNode(DB_INT_SORTED);
  754.     if( entind < 0 ) return -1;
  755.     master_buf[entind].ivalue = value;
  756.     snprintf( master_buf[entind].key ,
  757.               sizeof(master_buf[entind].key), "%s", key );
  758.     master_buf[entind].keyhash = hashpjw( master_buf[entind].key );
  759.     master_buf[entind].nextind = -1; 
  761. // 尥笛树  毛本永玄允月
  762.     dbSetString( master_buf[entind].charvalue_index, info );
  765.     r = dbInsertNodeByIValue( dbt[dbi].toplinkindex , entind );
  766.     if( r < 0 ){
  767.         log( "dbUpdateEntryInt: dbInsertNodeByIValue failedn" );
  768.         return -1;
  769.     }
  771.     log( "dbUpdateEntryInt: successfully updated entry %s:%s:%dn",
  772.              table, key, value );
  773.     return 0;    
  774.     
  775. }
  776. */
  777. // Spock 2000/10/16
  778. int dbUpdateEntryInt( char *table , char *key , int value, char *info )
  779. {
  780.     int dbi = dbGetTableIndex( table , DB_INT_SORTED );
  781.     int dbind, hashind, newpos;
  782.     // Spock 2000/10/23
  783.     if ( strlen( key ) >= KEY_MAX ) {
  784.      log( "dbUpdateEntryInt: key is too long, key:%sn", key );
  785.      return -1;
  786.     }
  787.     if ( strlen( info ) >= CHARVALUE_MAX ) {
  788.      log( "dbUpdateEntryInt: charvalue is too long, charvalue:%sn", info );
  789.      return -1;
  790.     }
  791.     // Spock end
  792.     if ( dbi < 0 ){
  793.      log( "dbUpdateEntryInt: dbGetTableIndex failn");
  794.      return -1;
  795.     }
  796.     hashind = tableGetEntry( dbi , key );
  797.     if ( hashind < 0 )
  798.     {
  799.      dbind = dbAllocNode();
  800.      if ( dbind < 0 )
  801.      {
  802.          log( "dbUpdateEntryInt: dbAllocNode failn" );
  803.          return -1;
  804.      }
  805.      master_buf[dbind].ivalue = value;
  806.      strcpy( master_buf[dbind].key , key );
  807.      strcpy( master_buf[dbind].charvalue , info );
  808.      if ( dbInsertNodeByIValue( dbt[dbi].toplinkindex , dbind ) < 0 )
  809.      {
  810.          master_buf[dbind].use = 0;
  811.          log( "dbUpdateEntryInt: dbInsertNodeByIValue failn" );
  812.          return -1;
  813.      }
  814.      if ( tableInsertNode( dbi , key , dbind ) < 0 )
  815.      {
  816.          dbReleaseNode( dbind );
  817.          log( "dbUpdateEntryInt: tableInsertNode failn" );
  818.          return -1;
  819.      }
  820.     }
  821.     else
  822.     {
  823.      dbind = dbt[dbi].hashtable[hashind].dbind;
  824.      master_buf[dbind].ivalue = value;
  825.      strcpy( master_buf[dbind].charvalue , info );
  826.      newpos = dbind;
  827.      while ( master_buf[newpos].prev >= 0 )
  828.      {
  829.            if ( value <= master_buf[master_buf[newpos].prev].ivalue )
  830.          {
  831.           break;
  832.          }
  833.          newpos = master_buf[newpos].prev;
  834.      }
  835.      if ( newpos != dbind )
  836.      {
  837.          master_buf[master_buf[dbind].prev].next = master_buf[dbind].next;
  838.             if ( master_buf[dbind].next >= 0 )
  839.              master_buf[master_buf[dbind].next].prev = master_buf[dbind].prev;
  840.          master_buf[dbind].prev = master_buf[newpos].prev;
  841.          master_buf[dbind].next = newpos;
  842.          if ( master_buf[newpos].prev >= 0 )
  843.              master_buf[master_buf[newpos].prev].next = dbind;
  844.          master_buf[newpos].prev = dbind;
  845.          dbt[dbi].updated = 1;
  846. /*
  847.     log( "dbUpdateEntryInt: successfully updated entry %s:%s:%dn",
  848.         table, key, value );
  849. */
  850.          return 0;
  851.      }
  852.      while ( master_buf[newpos].next >= 0 )
  853.      {
  854.          if ( value >= master_buf[master_buf[newpos].next].ivalue )
  855.          {
  856.           break;
  857.          }
  858.     newpos = master_buf[newpos].next;
  859.      }
  860.      if ( newpos != dbind )
  861.      {
  862.          master_buf[master_buf[dbind].prev].next = master_buf[dbind].next;
  863.          master_buf[master_buf[dbind].next].prev = master_buf[dbind].prev;
  864.          master_buf[dbind].prev = newpos;
  865.          master_buf[dbind].next = master_buf[newpos].next;
  866.          if ( master_buf[newpos].next >= 0 )
  867.              master_buf[master_buf[newpos].next].prev = dbind;
  868.          master_buf[newpos].next = dbind;
  869.      }
  870.     }
  871.     dbt[dbi].updated = 1;
  872. /*
  873.     log( "dbUpdateEntryInt: successfully updated entry %s:%s:%dn",
  874.              table, key, value );
  875.  */
  876.     return 0;
  877. }
  878. // Spock end
  880. int
  881. dbDeleteEntryInt( char *table, char *key )
  882. {
  883.     int dbi = dbGetTableIndex( table , DB_INT_SORTED );
  884.     int r;
  886.     if ( strlen( key ) >= KEY_MAX ) {
  887.      log( "dbDeleteEntryInt: key is too long, key:%sn", key );
  888.      return -1;
  889.     }
  890.     if( dbi < 0 ) {
  891.      log( "dbDeleteEntryInt: dbGetTableIndex failed for %sn", table );
  892.      return -1;
  893.     }
  894.     //r = dbExtractNodeByKey( dbt[dbi].toplinkindex , key );
  895.     // Spock fixed 2000/10/19
  896.     r = dbExtractNodeByKey( dbi , key );
  897.     if( r < 0 ){
  898.         log( "dbDeleteEntryInt: dbExtractNodeByKey failed for %s in %sn",
  899.              key,table );
  900.         return -1;
  901.     }
  902.     // Spock +1 2000/10/19
  903.     dbt[dbi].updated = 1;
  904.     log( "删除人物 %s 来至表 %sn", key, table );
  905.     return 0;
  906. }
  908. static void
  909. dbShowAllTable(void)
  910. {
  911.     int i;
  913.     for(i=0;i<MAXTABLE;i++){
  914.         if( dbt[i].use ){
  915.             log( "%d Name:%s Use:%d Type:%dn",i,
  916.                      dbt[i].name , dbt[i].num , dbt[i].type );
  917.         }
  918.     }
  919.     
  920. }
  922. /* 犯□正毛1蜊潸曰分允［
  923.  */
  924. int
  925. dbGetEntryInt( char *table, char *key, int *output )
  926. {
  927.     int dbi = dbGetTableIndex( table , DB_INT_SORTED );
  928.     int entind;
  929.     // Spock +1 2000/10/19
  930.     int hashind;
  931.  
  932.     // Spock deleted 2000/10/19
  933.     //if( strlen(key) >= sizeof( master_buf[entind].key) ) return -1;
  934.     if( dbi <0 ) {
  935.      log( "dbGetEntryInt: dbGetTableIndex failn" );
  936.      return -1;
  937.     }
  938.     // Spock 2000/10/19
  939.     if( strlen(key) >= KEY_MAX ) {
  940.      log( "dbGetEntryInt: key is too long, key:%sn" , key );
  941.      return -1;
  942.     }
  943.     hashind = tableGetEntry( dbi , key );
  944.     if( hashind < 0 ) return -1;
  945.     entind = dbt[dbi].hashtable[hashind].dbind;
  946.     //entind = dbGetEntryByKey( dbt[dbi].toplinkindex , key );
  947.     // Spock end
  948.     if( entind < 0 ) {
  949.      log( "dbGetEntryInt: Invalid dbind in hashtable of %sn" , table );
  950.      return -1;
  951.     }
  952.     /* 心勾井匀凶及匹袄毛请  卞  木化忒允 */
  953.     *output = master_buf[entind].ivalue;
  955.     return 0;
  956. }
  958. /*
  959.   巨仿□及桦宁反  ［0分匀凶日岳  ［
  961.   int *rank_out : 仿件弁及请  
  962.   int *count_out : 晓井日窒蜊  井及请  
  964.   int 犯□正矛□旦毁迕友
  965.   
  966.  */
  968. int
  969. dbGetEntryRank( char *table, char *key , int *rank_out, int *count_out)
  970. {
  971.     int dbi = dbGetTableIndex( table , DB_INT_SORTED );
  972.     // Spock deleted 2000/10/19
  973.     //unsigned int hash = hashpjw(key);
  974.     int cur;
  975.     int now_score = 0x7fffffff;     /*int 匹中切壬氏匹井中袄 */
  976.     int r = -1 , i=0;
  978.     // Spock 2000/10/23
  979.     //if( strlen(key) >= sizeof( master_buf[cur].key) ) return -1;
  980.     if( strlen(key) >= KEY_MAX ) {
  981.      log( "dbGetEntryRank: key is too long, key:%sn" , key );
  982.      return -1;
  983.     }
  984.     if( dbi <0 ) {
  985.      log( "dbGetEntryRank: dbGetTableIndex failn" );
  986.      return -1;
  987.     }
  988.     // Spock end
  990.     // Spock 2000/10/23
  991.     //cur = master_buf[dbt[dbi].toplinkindex].nextind;
  992.     cur = master_buf[dbt[dbi].toplinkindex].next;
  993.     //i=0;
  994.     //for(;;){
  995.     //    if( cur == -1 )break;
  996.     while ( cur >= 0 )
  997.     {
  998.     // Spock end
  999.         if( master_buf[cur].ivalue != now_score ){
  1000.             r=i;
  1001.             now_score = master_buf[cur].ivalue;
  1002.         }
  1003.         // Spock 2000/10/19
  1004.         //if( hash == master_buf[cur].keyhash &&
  1005.         //    strcmp( master_buf[cur].key, key )== 0 ){
  1006.         if( strcmp( master_buf[cur].key , key ) == 0 )
  1007.         {
  1008.         // Spock end
  1009.             *rank_out = r;
  1010.             *count_out = i;
  1011.             return 0;
  1012.         }
  1013.         //cur = master_buf[cur].nextind;
  1014.         // Spock fixed 2000/10/19
  1015.         cur = master_buf[cur].next;
  1016.         i++;
  1017.     }
  1018.     *count_out = i;
  1019.     *rank_out = r;
  1020.     return 0;
  1021. }
  1023. /*
  1024.   int 毁迕友
  1025.  */
  1026. int
  1027. dbGetEntryRankRange( char *table,
  1028.                      int start, int end, char *output, int outlen )
  1029. {
  1030. #define MAXHITS 1024        /* 赝癫支卅丐［匹手仇木匹蜗坌日仄中冗 ringo */
  1031.     struct hitent{          /* 仇及厌瞻  卞甲永玄仄凶支勾毛凶户化中仁 */
  1032.         int entind;
  1033.         int rank;
  1034.     };
  1036.     int r=0;
  1037.     struct hitent hits[MAXHITS];
  1038.     int dbi = dbGetTableIndex( table , DB_INT_SORTED );
  1039.     int cur;
  1040.     int hitsuse = 0,i;
  1041.     int now_score = 0x7fffffff;
  1043.     if( dbi <0 ) return -1;
  1044.     if( outlen <= 0 )return -1;
  1045.     
  1046.     cur = dbt[dbi].toplinkindex;
  1047.     // Spock 2000/10/23
  1048.     //for(;;){
  1049.     //    if( cur == -1 )break;
  1050.     while ( cur >= 0 )
  1051.     {
  1052.     // Spock end
  1053.         if( master_buf[cur].ivalue != now_score ){
  1054.             r++;
  1055.             now_score = master_buf[cur].ivalue;
  1056.         }
  1057.         if( r >= start && r <= end ){
  1058.             hits[hitsuse].entind = cur;
  1059.             hits[hitsuse].rank = r;
  1060.             hitsuse++;
  1061.             //if( hitsuse == MAXHITS )break;
  1062.             // Spock fixed 2000/10/23
  1063.             if( hitsuse >= MAXHITS ) break;
  1064.         }
  1065.         //cur = master_buf[cur].nextind;
  1066.         // Spock fixed 2000/10/19
  1067.         cur = master_buf[cur].next;
  1068.     }
  1069.     output[0] = 0;
  1070.     
  1071.     for(i=0;i<hitsuse;i++){
  1072.         char tmp[1024];
  1073.         snprintf( tmp, sizeof(tmp),
  1074.                   "%d,%s,%d,%s", hits[i].rank, master_buf[hits[i].entind].key,
  1075.                   master_buf[hits[i].entind].ivalue,
  1076. //             dbGetString( master_buf[i].charvalue_index ));
  1077. // Spock fixed 2000/10/19
  1078.   master_buf[hits[i].entind].charvalue );
  1079.         strcatsafe( output, outlen, tmp );
  1080.         if( i != ( hitsuse -1 ) ){
  1081.             strcatsafe( output, outlen, "|" );
  1082.         }
  1083.     }
  1084.     return 0;
  1085. }
  1087. int dbFlush( char *dir )
  1088. {
  1089.     int i;
  1091.     for(i=0;i<MAXTABLE;i++){
  1092.         FILE *fp;
  1093.         char filename[1024];
  1094.         int entind;
  1095.         //int j;
  1096.         if( !dbt[i].use ) continue;
  1097.         // Spock 2000/10/23
  1098.         if( dbt[i].updated == 0 )
  1099.         {
  1100.             log( "dbFlush: table %s not updatedn" , dbt[i].name );
  1101.             continue;
  1102.         }
  1103.         // Spock end
  1105.         if( dbt[i].type == DB_INT_SORTED ){
  1106.             snprintf( filename, sizeof(filename),
  1107.                       "%s/int/%s", dir, dbt[i].name );
  1108.         } else {
  1109.             snprintf( filename, sizeof( filename),
  1110.                       "%s/string/%s", dir, dbt[i].name );
  1111.         }
  1112.         
  1113.         fp = fopen( filename, "w" );
  1114.         if( fp == NULL ){
  1115.             log( "cannot open file: %s %sn", filename, strerror( errno ));
  1116.             continue;
  1117.         }
  1119.         // Spock 2000/10/19
  1120.         //entind = master_buf[dbt[i].toplinkindex].nextind;
  1121.         entind = master_buf[dbt[i].toplinkindex].next;
  1122.         //for(j=0;;j++){
  1123.         //    if( entind == -1 )break;
  1124.         while ( entind >= 0 )
  1125.         {
  1126.         // Spock end
  1127.             if( dbt[i].type == DB_INT_SORTED ){
  1128.                 fprintf( fp , "%s %d %sn", master_buf[entind].key,
  1129.                          master_buf[entind].ivalue,
  1130.                          //makeStringFromEscaped(
  1131.                          //    dbGetString(master_buf[entind].charvalue_index)));
  1132.                          // Spock fixed 2000/10/19
  1133.                          makeStringFromEscaped(master_buf[entind].charvalue));
  1134.             } else {
  1135.                 fprintf( fp , "%s %sn", master_buf[entind].key,
  1136.                          //makeStringFromEscaped(
  1137.                          //    dbGetString(master_buf[entind].charvalue_index)));
  1138.                          // Spock fixed 2000/10/19
  1139.                          makeStringFromEscaped(master_buf[entind].charvalue));
  1140.             }
  1141.             //entind = master_buf[entind].nextind;
  1142.             // Spock fixed 2000/10/19
  1143.             entind = master_buf[entind].next;
  1144.         }
  1145.         fclose(fp);
  1146.         dbt[i].updated = 0;
  1147.     }
  1149.     return 0;
  1150. }
  1153. int dbRead( char *dir )
  1154. {
  1155.     char dirname[1024];
  1156.     DIR *d;
  1157.     struct dirent *de;
  1158.     // Spock +1 2000/10/19
  1159.     memset( dbt , 0 , MAXTABLE * sizeof(struct table) );
  1160.     {
  1161.         char tmp[1024];
  1162.         snprintf( tmp, sizeof( tmp ), "%s/int" , dir );
  1163.         if( mkdir( tmp, 0755 )==0){
  1164.             log( "创建 %sn", tmp );
  1165.         }
  1166.         snprintf( tmp, sizeof( tmp ), "%s/string" , dir );
  1167.         if( mkdir( tmp, 0755 )==0){
  1168.             log( "创建 %sn", tmp );
  1169.         }        
  1170.     }
  1171.         
  1172.     snprintf( dirname, sizeof( dirname ),
  1173.               "%s/int" , dir );
  1174.     d = opendir(dirname);
  1175.     if( d == NULL ){
  1176.         log( "不能打开文件 %sn", dirname );
  1177.         return -1;
  1178.     }
  1180.     while(1){
  1181.         de = readdir( d );
  1182.         if( de == NULL )break;
  1183.         if( de->d_name[0] != '.' ){
  1184.             char filename[1024];
  1185.             FILE *fp;
  1186.             struct stat s;
  1187.             snprintf( filename, sizeof(filename),"%s/%s",dirname, de->d_name );
  1188. log( "读取数据:%sn..", filename);
  1189.             if( stat( filename, &s ) < 0 ){
  1190.                 continue;
  1191.             }
  1192.             if( !( s.st_mode & S_IFREG ) ){
  1193.                 continue;
  1194.             }
  1195.             
  1196.             fp = fopen( filename, "r" );            
  1197.             if( fp == NULL ){
  1198.                 log( "不能打开文件 %s %sn",
  1199.                          filename, strerror( errno ));
  1200.                 continue;
  1201.             }
  1202.             while(1){
  1203.                 char line[1024];
  1204.                 char k[1024] , v[1024], info[1024];
  1205.                 if( fgets( line , sizeof( line) , fp ) == NULL )break;
  1206.                 chop( line);
  1207. k[0] = '';
  1208.                 easyGetTokenFromString( line, 1, k, sizeof(k));
  1209. v[0] = '';
  1210.                 easyGetTokenFromString( line, 2, v, sizeof(v));
  1211.                 info[0] = '';
  1212.                 easyGetTokenFromString( line, 3, info, sizeof(info));
  1213.                 dbUpdateEntryInt( de->d_name, k, atoi(v), info);
  1214.             }
  1215.             fclose(fp);
  1216.         }
  1217.     }
  1218.     closedir(d);
  1219.     snprintf( dirname, sizeof( dirname), "%s/string" , dir );
  1220.     d = opendir( dirname );
  1221.     if( d == NULL ){
  1222.         log( "不能打开文件 %sn", dirname );
  1223.         return -1;
  1224.     }
  1225.     while(1){
  1226.         de = readdir( d );
  1227.         if( de == NULL )break;
  1228.         if( de->d_name[0] != '.' ){
  1229.             char filename[1024];
  1230.             FILE *fp;
  1231.             struct stat s;
  1232.             snprintf( filename, sizeof( filename),"%s/%s",dirname,de->d_name );
  1233. log( "读取数据:%sn..", filename);
  1235.             if( stat( filename, &s ) < 0 ){
  1236.                 continue;
  1237.             }
  1238.             if( !(s.st_mode & S_IFREG )){
  1239.                 continue;
  1240.             }
  1241.             fp = fopen( filename, "r" );
  1242.             if( fp == NULL ){
  1243.                 log( "不能打开文件 %s %sn",
  1244.                      filename, strerror(errno ));
  1245.                 continue;
  1246.             }
  1247.             while(1){
  1248.                 char line[CHARVALUE_MAX+1024];     
  1249.                 char k[1024];
  1250.                 if( fgets( line, sizeof( line), fp ) == NULL )break;
  1251.                 /* chop */
  1252.                 chop(line);
  1253. k[0] = '';
  1254.                 easyGetTokenFromString( line, 1, k,sizeof(k));
  1255.                 dbUpdateEntryString( de->d_name, k, line+strlen(k)+1);
  1256.             }
  1257.             // Nuke +1 1027: Close for safe
  1258.             fclose(fp); 
  1259.         }
  1260.     }
  1261.     closedir(d);
  1262.     return 0;
  1263. }
  1265. /* 隙烂仄凶匏  井日隙烂仄凶蜊醒潸曰分允［
  1266.  撩  仄凶日  ｝岳  仄凶日0［岳  仄化手坞及请  及午五互丐月冗［
  1267.    “num互0及午五午井｝竟癫允月巨件玄伉互卅中午五［
  1269.  int 犯□正矛□旦毁迕分冗
  1271.  */
  1272. int dbGetEntryCountRange( char *table, int count_start, int  num,
  1273.                       char *output, int outlen )
  1274. {
  1275.     int dbi = dbGetTableIndex( table , DB_INT_SORTED );
  1276.     int cur;
  1277.     int i;
  1278.     int now_score = 0x7fffffff , r;
  1280.     if( dbi < 0) return -1;
  1281.     if( outlen < 1 ) return -1;
  1282.     output[0]=0;
  1284.     //cur = master_buf[dbt[dbi].toplinkindex].nextind;
  1285.     // Spock fixed 2000/10/19
  1286.     cur = master_buf[dbt[dbi].toplinkindex].next;
  1287.     i=0;
  1288.     r=0;
  1289.     for(;;){
  1290.         if( cur == -1 ) break;
  1292.         if( master_buf[cur].ivalue != now_score ){
  1293.             r=i;
  1294.             now_score = master_buf[cur].ivalue;
  1295.         }
  1297.         if( ( i >= count_start ) &&
  1298.             ( i < (count_start + num ) ) ){
  1299.             char tmp[1024];            
  1300.             if( (i !=count_start)){
  1301.                 strcatsafe( output, outlen, "|" );
  1302.             } 
  1303.               
  1304.             snprintf( tmp, sizeof( tmp),
  1305.                       "%d,%d,%s,%d,%s", i, r, master_buf[cur].key,
  1306.                       master_buf[cur].ivalue,
  1307.             //dbGetString( master_buf[cur].charvalue_index ));
  1308.       // Spock fixed 2000/10/19
  1309.       master_buf[cur].charvalue);
  1310.             strcatsafe( output, outlen,tmp );
  1311.         }
  1312.         i++;
  1313.         //cur = master_buf[cur].nextind;
  1314.         // Spock fixed 2000/10/19
  1315.         cur = master_buf[cur].next;
  1316.     }
  1317.     return 0;
  1318. }
  1321. /*
  1322.     侬  犯□正矛□旦及质  
  1323.  */
  1324. /* Spock deleted 2000/10/19
  1325. int
  1326. dbUpdateEntryString( char *table, char *key, char *value )
  1327. {
  1328.     int dbi = dbGetTableIndex(table, DB_STRING);
  1329.     int r, entind;
  1330.     
  1331.     log( "dbUpdateEntryString: [%s] [%s] [%s]n", table, key, value );
  1332.     
  1333.     if( strlen(key) >= sizeof(master_buf[0].key) )return -1;
  1334.     if( dbi < 0 )return -1;
  1336.     r = dbExtractNodeByKey( dbt[dbi].toplinkindex, key );
  1337.     if( r< 0 ){
  1338.         log( "dbUpdateEntryString dbExtractNodeByKey fail! bug!!n" );
  1339.         return -1;
  1340.     }
  1342.     entind = dbAllocNode( DB_STRING );
  1343.     if( entind < 0 ) return -1;
  1345.     master_buf[entind].ivalue = 0;
  1346.     dbSetString( master_buf[entind].charvalue_index, value );
  1347.     snprintf( master_buf[entind].key,
  1348.               sizeof(master_buf[0].key), "%s",key );
  1349.     master_buf[entind].keyhash = hashpjw( master_buf[entind].key );
  1350.     master_buf[entind].nextind = -1;
  1352.     if(  dbAppendNode( dbt[dbi].toplinkindex, entind ) < 0 ){
  1353.         log( "dbUpdateEntryString: dbAppendNode failedn" );
  1354.         return -1;
  1355.     }
  1356.     log( "dbUpdateEntryString: successfully updated entry %s:%s:%sn",
  1357.          table,key,value );
  1359.     return 0;
  1360. }
  1361. */
  1362. // Spock 2000/10/19
  1363. int dbUpdateEntryString( char *table, char *key, char *value )
  1364. {
  1365.     int dbi = dbGetTableIndex( table , DB_STRING );
  1366.     int dbind, hashind;
  1368.     if ( strlen( key ) >= KEY_MAX ) {
  1369.      log( "dbUpdateEntryString: key is too long, key:%sn", key );
  1370.      return -1;
  1371.     }
  1372.     if ( strlen( value ) >= CHARVALUE_MAX ) {
  1373.      log( "dbUpdateEntryString: charvalue is too long, charvalue:%sn", value );
  1374.      return -1;
  1375.     }
  1376.     if ( dbi < 0 ) {
  1377.      log( "dbUpdateEntryString: dbGetTableIndex fail, table:%sn", table );
  1378.      return -1;
  1379.     }
  1380.     hashind = tableGetEntry( dbi , key );
  1381.     if ( hashind < 0 )
  1382.     {
  1383.      dbind = dbAllocNode();
  1384.      if ( dbind < 0 )
  1385.      {
  1386.          log( "dbUpdateEntryString: dbAllocNode failn" );
  1387.          return -1;
  1388.      }
  1389.      strcpy( master_buf[dbind].key , key );
  1390.      strcpy( master_buf[dbind].charvalue , value );
  1391.      if ( dbAppendNode( dbt[dbi].toplinkindex , dbind ) < 0 )
  1392.      {
  1393.          master_buf[dbind].use = 0;
  1394.          log( "dbUpdateEntryString: dbAppendNode failn" );
  1395.          return -1;
  1396.      }
  1397.      if ( tableInsertNode( dbi , key , dbind ) < 0 )
  1398.      {
  1399.          dbReleaseNode( dbind );
  1400.     log( "dbUpdateEntryString: tableInsertNode failn" );
  1401.     return -1;
  1402. }
  1403.     }
  1404.     else
  1405.     {
  1406.      dbind = dbt[dbi].hashtable[hashind].dbind;
  1407.      strcpy( master_buf[dbind].charvalue , value );
  1408.     }
  1409.     dbt[dbi].updated = 1;
  1410. /*
  1411.     log( "dbUpdateEntryString: successfully updated entry %s:%s:%sn",
  1412.          table,key,value );
  1413.  */
  1414.     return 0;
  1415. }
  1416. // Spock end
  1418. int
  1419. dbGetEntryString( char *table, char *key, char *output, int outlen )
  1420. {
  1421.     int dbi = dbGetTableIndex( table, DB_STRING );
  1422.     int entind;
  1423.     // Spock +1 2000/10/19
  1424.     int hashind;
  1426.     // Spock 2000/10/23
  1427.     //if( strlen(key) >= sizeof( master_buf[entind].key) ) return -1;
  1428.     if ( strlen(key) >= KEY_MAX ) {
  1429.      log( "dbGetEntryString: key is too long, key:%sn", key );
  1430.      return -1;
  1431.     }
  1432.     if( dbi <0 ) {
  1433.      log( "dbGetEntryString: dbGetTableIndex failn" );
  1434.      return -1;
  1435.     }
  1436.     // Spock 2000/10/19
  1437.     hashind = tableGetEntry( dbi , key );
  1438.     if ( hashind < 0 ){
  1439. log("err hashind <0n")
  1440. return -1;
  1441. }
  1442.     entind = dbt[dbi].hashtable[hashind].dbind;
  1444.     if ( entind < 0 ){
  1445. log( "entind < 0 ");
  1446. return -1;
  1447. }
  1448.     snprintf( output , outlen , "%s" , master_buf[entind].charvalue );
  1450.     return 0;
  1451. }
  1453. int
  1454. dbDeleteEntryString( char *table, char *key )
  1455. {
  1456.     int dbi = dbGetTableIndex( table, DB_STRING );
  1457.     int r;
  1459.     // Spock 2000/10/23
  1460.     //if( strlen(key) >= sizeof( master_buf[entind].key) ) return -1;
  1461.     if ( strlen(key) >= KEY_MAX ) {
  1462.      log( "dbDeleteEntryString: key is too long, key:%sn", key );
  1463.      return -1;
  1464.     }
  1465.     if( dbi <0 ) {
  1466.      log( "dbDeleteEntryString: dbGetTableIndex failn" );
  1467.      return -1;
  1468.     }
  1469.     // Spock end
  1470.     //r = dbExtractNodeByKey( dbt[dbi].toplinkindex, key );
  1471.     // Spock fixed 2000/10/19
  1472.     r = dbExtractNodeByKey( dbi , key );
  1473.     if( r < 0 ){
  1474.         log( "dbDeleteEntryString: dbExtractNodeByKey failed for %s in %sn",
  1475.              key,table );
  1476.         return -1;
  1477.     }
  1478.     dbt[dbi].updated = 1;
  1479.     log( "删除人物 %s 来至表 %sn", key, table );
  1480.     return 0;
  1481. }