xoonips/AL/xnpal.cc

/*
 * --------------------------------------------------------------------------  
 * XooNiPs Xoops modules for Neuroinformatics Platforms                        
 * Copyright (C) 2005 RIKEN, Japan. All rights reserved.                       
 * http://sourceforge.jp/projects/xoonips/                                     
 * --------------------------------------------------------------------------  
 * This program is free software; you can redistribute it and/or               
 * modify it under the terms of the GNU General Public License                 
 * as published by the Free Software Foundation; either version 2              
 * of the License, or (at your option) any later version.                      
 *                                                                             
 * This program is distributed in the hope that it will be useful,             
 * but WITHOUT ANY WARRANTY; without even the implied warranty of              
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               
 * GNU General Public License for more details.                                
 *                                                                             
 * You should have received a copy of the GNU General Public License           
 * along with this program; if not, write to the Free Software                 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
 * --------------------------------------------------------------------------  
 * 
 * $Revision: 1.58 $
 * XNPAL: XooNiPs Platform Abstract Layer
 * zend_parse_parameters��php4.1.0������
 * .so����������������������������������������
 * C++������extern "C"{}, BEGIN/END_EXTERN_C()��������
 */


#include <stdio.h>
#include "criteria.h"
#include "common.h"
#include "commonal.h"
#include "session.h"
#include "group.h"
#include "index.h"
#include "xnpal.h"
#include "amazonbook.h"

// for inet_aton
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

// global variables

PHP_MSHUTDOWN_FUNCTION(xnpalmod)
{
        uninitializeDB();
        return SUCCESS;
}

PHP_RINIT_FUNCTION(xnpalmod)
{
    useSyslog(false);
        return SUCCESS;
}

/* declaration of functions to be exported */
extern "C" {
ZEND_FUNCTION(first_module         );
ZEND_FUNCTION(xnp_initialize_db     );
ZEND_FUNCTION(xnp_login_user        );
ZEND_FUNCTION(xnp_logout_user       );
ZEND_FUNCTION(xnp_create_session    );
ZEND_FUNCTION(xnp_get_session       );
ZEND_FUNCTION(xnp_is_activated      );
ZEND_FUNCTION(xnp_activate          );
ZEND_FUNCTION(xnp_get_account_count );
ZEND_FUNCTION(xnp_delete_account    );
ZEND_FUNCTION(xnp_get_account       );
ZEND_FUNCTION(xnp_get_accounts      );
ZEND_FUNCTION(xnp_insert_account    );
ZEND_FUNCTION(xnp_update_account    );
ZEND_FUNCTION(xnp_dump_uids         );
ZEND_FUNCTION(xnp_get_group_count   );
ZEND_FUNCTION(xnp_get_groups_by_uid );
ZEND_FUNCTION(xnp_is_group_admin    );
ZEND_FUNCTION(xnp_dump_gids         );
ZEND_FUNCTION(xnp_dump_group_admins );
ZEND_FUNCTION(xnp_delete_member     );
ZEND_FUNCTION(xnp_insert_member     );
ZEND_FUNCTION(xnp_get_members       );
ZEND_FUNCTION(xnp_delete_group      );
ZEND_FUNCTION(xnp_insert_group      );
ZEND_FUNCTION(xnp_update_group      );
ZEND_FUNCTION(xnp_get_group         );
ZEND_FUNCTION(xnp_get_groups        );
ZEND_FUNCTION(xnp_is_moderator      );
ZEND_FUNCTION(xnp_get_uid           );

ZEND_FUNCTION(xnp_get_all_indexes     );
ZEND_FUNCTION(xnp_get_indexes         );
ZEND_FUNCTION(xnp_insert_index        );
ZEND_FUNCTION(xnp_update_index        );
ZEND_FUNCTION(xnp_delete_index        );
ZEND_FUNCTION(xnp_get_index           );
ZEND_FUNCTION(xnp_is_index_readable   );
ZEND_FUNCTION(xnp_is_index_writable   );
ZEND_FUNCTION(xnp_swap_index_sort_number );

ZEND_FUNCTION(xnp_is_valid_session_id );
ZEND_FUNCTION(xnp_get_last_error_string );

ZEND_FUNCTION(xnp_test_criteria     );
ZEND_FUNCTION(xnp_test_uids         );


ZEND_FUNCTION(xnp_get_item_permission      );
ZEND_FUNCTION(xnp_get_index_permission     );
ZEND_FUNCTION(xnp_get_certify_permission   );

ZEND_FUNCTION(xnp_get_certify_state        );
ZEND_FUNCTION(xnp_set_certify_state        );

ZEND_FUNCTION(xnp_insert_change_log        );
ZEND_FUNCTION(xnp_get_change_logs          );

ZEND_FUNCTION(xnp_get_config_value         );
ZEND_FUNCTION(xnp_set_config_value         );

ZEND_FUNCTION(xnp_dump_item_id             );
ZEND_FUNCTION(xnp_get_item_id_by_binder_id );
ZEND_FUNCTION(xnp_get_item_id_by_index_id  );
ZEND_FUNCTION(xnp_get_overlapped_items     );

ZEND_FUNCTION(xnp_insert_item              );
ZEND_FUNCTION(xnp_insert_item_direct       );
ZEND_FUNCTION(xnp_update_item              );
ZEND_FUNCTION(xnp_delete_item              );
ZEND_FUNCTION(xnp_get_item                 );
ZEND_FUNCTION(xnp_get_items                );

ZEND_FUNCTION(xnp_pubmed_complete          );
ZEND_FUNCTION(xnp_amazon_complete          );

//ZEND_FUNCTION(xnp_uninitialize_db          );

ZEND_FUNCTION(xnp_register_binder_item     );
ZEND_FUNCTION(xnp_unregister_binder_item   );

ZEND_FUNCTION(xnp_register_item            );
ZEND_FUNCTION(xnp_unregister_item          );

ZEND_FUNCTION(xnp_get_uncertified_link     );
ZEND_FUNCTION(xnp_get_private_item_id      );
ZEND_FUNCTION(xnp_get_group_item_id        );

ZEND_FUNCTION(xnp_get_item_types           );
ZEND_FUNCTION(xnp_get_index_id_by_item_id  );
ZEND_FUNCTION(xnp_get_own_public_item_id   );

ZEND_FUNCTION(xnp_zip_create               );
ZEND_FUNCTION(xnp_get_item_count           );
ZEND_FUNCTION(xnp_get_item_count_group_by_index );

ZEND_FUNCTION(xnp_extract_public_item_id);
ZEND_FUNCTION(xnp_extract_nonbinder_item_id);
ZEND_FUNCTION(xnp_insert_event);
ZEND_FUNCTION(xnp_get_events);
ZEND_FUNCTION(xnp_get_events_for_rss);

ZEND_FUNCTION(xnp_update_item_status       );
ZEND_FUNCTION(xnp_refresh_item_status      );
ZEND_FUNCTION(xnp_selective_harvesting     );
ZEND_FUNCTION(xnp_get_item_status          );

ZEND_FUNCTION(xnp_insert_related_to );
ZEND_FUNCTION(xnp_delete_related_to );
ZEND_FUNCTION(xnp_get_related_to    );

ZEND_FUNCTION(xnp_use_syslog               );
};


#ifdef ZEND_ENGINE_2
static
        ZEND_BEGIN_ARG_INFO(second_and_third_args_force_ref, 0)
                ZEND_ARG_PASS_INFO(0)
                ZEND_ARG_PASS_INFO(1)
                ZEND_ARG_PASS_INFO(1)
        ZEND_END_ARG_INFO();
#else
static   unsigned char fourth_arg_force_ref[] = { 4, BYREF_NONE, BYREF_NONE, BYREF_NONE, BYREF_FORCE };
static   unsigned char second_and_third_args_force_ref[] = { 3, BYREF_NONE, BYREF_FORCE, BYREF_FORCE };
#endif


/* compiled function list so Zend knows what's in this module */
zend_function_entry xnpalmod_functions[] =
{
        ZEND_FE(first_module          ,NULL)
        ZEND_FE(xnp_initialize_db     ,NULL)
        ZEND_FE(xnp_login_user        ,third_arg_force_ref)
        ZEND_FE(xnp_logout_user       ,NULL)
        ZEND_FE(xnp_create_session    ,third_arg_force_ref)
        ZEND_FE(xnp_get_session       ,second_arg_force_ref )
        ZEND_FE(xnp_is_activated      ,NULL)
        ZEND_FE(xnp_activate          ,NULL)
        ZEND_FE(xnp_get_account_count ,NULL)
        ZEND_FE(xnp_delete_account    ,NULL)
        ZEND_FE(xnp_get_account       ,third_arg_force_ref)
        ZEND_FE(xnp_get_accounts      ,fourth_arg_force_ref)
        ZEND_FE(xnp_insert_account    ,third_arg_force_ref)
        ZEND_FE(xnp_update_account    ,NULL)
        ZEND_FE(xnp_dump_uids         ,third_arg_force_ref)
        ZEND_FE(xnp_get_group_count   ,NULL)
        ZEND_FE(xnp_get_groups_by_uid ,fourth_arg_force_ref)
        ZEND_FE(xnp_is_group_admin    ,NULL)
        ZEND_FE(xnp_dump_gids         ,third_arg_force_ref)
        ZEND_FE(xnp_dump_group_admins ,NULL)
        ZEND_FE(xnp_delete_member     ,NULL)
        ZEND_FE(xnp_insert_member     ,NULL)
        ZEND_FE(xnp_get_members       ,fourth_arg_force_ref)
        ZEND_FE(xnp_delete_group      ,NULL)
        ZEND_FE(xnp_insert_group      ,third_arg_force_ref)
        ZEND_FE(xnp_update_group      ,NULL)
        ZEND_FE(xnp_get_group         ,third_arg_force_ref)
        ZEND_FE(xnp_get_groups        ,fourth_arg_force_ref)
        ZEND_FE(xnp_is_moderator      ,NULL)
        ZEND_FE(xnp_get_uid           ,second_arg_force_ref)

        ZEND_FE(xnp_get_all_indexes     ,third_arg_force_ref)
        ZEND_FE(xnp_get_indexes         ,fourth_arg_force_ref)
        ZEND_FE(xnp_insert_index        ,third_arg_force_ref)
        ZEND_FE(xnp_update_index        ,NULL)
        ZEND_FE(xnp_delete_index        ,NULL)
        ZEND_FE(xnp_get_index           ,third_arg_force_ref)
        ZEND_FE(xnp_is_index_readable   ,NULL)
        ZEND_FE(xnp_is_index_writable   ,NULL)
        ZEND_FE(xnp_swap_index_sort_number ,NULL)

        ZEND_FE(xnp_is_valid_session_id ,NULL)
        ZEND_FE(xnp_get_last_error_string ,NULL)
        ZEND_FE(xnp_test_criteria     ,NULL)
        ZEND_FE(xnp_test_uids         ,NULL)

        ZEND_FE(xnp_get_item_permission      ,NULL)
        ZEND_FE(xnp_get_index_permission     ,NULL)
        ZEND_FE(xnp_get_certify_permission   ,NULL)

        ZEND_FE(xnp_get_certify_state        ,fourth_arg_force_ref)
        ZEND_FE(xnp_set_certify_state        ,NULL)

        ZEND_FE(xnp_insert_change_log        ,NULL)
        ZEND_FE(xnp_get_change_logs          ,third_arg_force_ref)

        ZEND_FE(xnp_get_config_value         ,second_arg_force_ref)
        ZEND_FE(xnp_set_config_value         ,NULL)

        ZEND_FE(xnp_dump_item_id             ,NULL)
        ZEND_FE(xnp_get_item_id_by_binder_id ,fourth_arg_force_ref)
        ZEND_FE(xnp_get_item_id_by_index_id  ,fourth_arg_force_ref)
        ZEND_FE(xnp_get_overlapped_items     ,NULL) /*?*/

        ZEND_FE(xnp_insert_item              ,third_arg_force_ref)
        ZEND_FE(xnp_insert_item_direct       ,third_arg_force_ref)
        ZEND_FE(xnp_update_item              ,NULL)
        ZEND_FE(xnp_delete_item              ,NULL)
        ZEND_FE(xnp_get_item                 ,third_arg_force_ref)
        ZEND_FE(xnp_get_items                ,fourth_arg_force_ref)

        ZEND_FE(xnp_pubmed_complete          ,second_arg_force_ref)
        ZEND_FE(xnp_amazon_complete          ,second_arg_force_ref)

//    ZEND_FE(xnp_uninitialize_db          ,NULL)

        ZEND_FE(xnp_register_binder_item     ,NULL)
        ZEND_FE(xnp_unregister_binder_item   ,NULL)

        ZEND_FE(xnp_register_item            ,NULL)
        ZEND_FE(xnp_unregister_item          ,NULL)

        ZEND_FE(xnp_get_uncertified_link     ,second_and_third_args_force_ref)
        ZEND_FE(xnp_get_private_item_id      ,third_arg_force_ref)
        ZEND_FE(xnp_get_group_item_id        ,third_arg_force_ref)

        ZEND_FE(xnp_get_item_types           ,first_arg_force_ref)
    
    ZEND_FE(xnp_get_index_id_by_item_id  ,third_arg_force_ref)
    ZEND_FE(xnp_get_own_public_item_id   ,third_arg_force_ref)

    ZEND_FE(xnp_zip_create               ,NULL)
    ZEND_FE(xnp_get_item_count           ,NULL)
    ZEND_FE(xnp_get_item_count_group_by_index ,second_arg_force_ref)

    ZEND_FE(xnp_extract_public_item_id   ,third_arg_force_ref)
    ZEND_FE(xnp_extract_nonbinder_item_id,third_arg_force_ref)
    ZEND_FE(xnp_insert_event             ,NULL)
    ZEND_FE(xnp_get_events               ,second_arg_force_ref)
    ZEND_FE(xnp_get_events_for_rss       ,NULL)

    ZEND_FE(xnp_update_item_status       ,NULL)
    ZEND_FE(xnp_refresh_item_status      ,NULL)
    ZEND_FE(xnp_selective_harvesting     ,NULL)
    ZEND_FE(xnp_get_item_status          ,NULL)

    ZEND_FE(xnp_insert_related_to        ,NULL)
    ZEND_FE(xnp_delete_related_to        ,NULL)
    ZEND_FE(xnp_get_related_to           ,NULL)

    ZEND_FE(xnp_use_syslog               ,NULL)
    {NULL, NULL, NULL}
};

/* compiled module information */
zend_module_entry xnpalmod_module_entry =
{
        STANDARD_MODULE_HEADER,
        "XNPAL",
        xnpalmod_functions,
        NULL,
        PHP_MSHUTDOWN(xnpalmod),
        PHP_RINIT(xnpalmod),
        NULL,
        NULL,
        NO_VERSION_YET,
        STANDARD_MODULE_PROPERTIES
};

/* implement standard "stub" routine to introduce ourselves to Zend */
#if COMPILE_DL_FIRST_MODULE
BEGIN_EXTERN_C()
ZEND_GET_MODULE(xnpalmod)
END_EXTERN_C()
#endif


/* implement function that is meant to be made available to PHP */
ZEND_FUNCTION(first_module)
{
        long parameter;
//      if(ZEND_NUM_ARGS() != 2) WRONG_PARAM_COUNT;
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &parameter) == FAILURE) {
                return;
        }
        parameter++;
        RETURN_LONG(parameter);
}
/** zval����C����������������
  */
char *getZvalString( zval **p ){
        convert_to_string_ex(p);
        return Z_STRVAL_PP(p); //(**p).value.str.val;
}

/** zval����int��������
  */
int getZvalInt( zval **p ){
        convert_to_long_ex(p);
        return Z_LVAL_PP(p); // (int)(**p).value.lval;
}

// keylen��������\0��������
static void print_hash_key( int res, const char *key, uint keyLen, ulong index ){
        zend_printf( "print_hash_key : key=0x%08x keylen=%08d index=%08d<br>  ", key, keyLen, index );
        if ( res == HASH_KEY_IS_STRING ){
                char *p = new char[keyLen+1];
                memcpy( p, key, keyLen );
                p[keyLen] = 0;
                zend_printf( "  key is string[%s]<br>\n", p );
        }
        else {
                zend_printf( "  key is integer[%d]<br>\n", index );
        }
}


/** zval*����criteria_t������������������������������������getResult()!=RES_OK <br>
        criteria :
        array( 'start'=>0, 'rows'=>10,
           'orders'=>array(
                array('name'=>'id','order'=>'0'),
                array('name'=>'timestamp','name'=>'1'), ...)
        ); ������������������
  */
class zCriteria_t : public criteria {
private:
        result_t result;

        // pz: array('name'=>'timestamp','name'=>'1')
        // ��������orderby����������������
        void setOrder( zval *pz ){
                char *column = 0;
                order_t order = (order_t)0;

                HashPosition pos;
                zval **ppzTmp = 0;
                int res2;
                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
                while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
                        char *key = 0;
                        uint keyLen = 0;
                        ulong index = 0;
                        int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
                        if ( keyType == HASH_KEY_IS_STRING/*1*/ ||  keyType == HASH_KEY_IS_LONG/*2*/ ){
                                //print_hash_key( keyType, key, keyLen, index );
                                if ( strncasecmp( key, "name", keyLen ) == 0 && keyLen == 5 ){
                                        SEPARATE_ZVAL(ppzTmp);
                                        column = getZvalString(ppzTmp);
//                                      zend_printf( "column=%s<br>\n", column );
                                }
                                else if ( strncasecmp( key, "order", keyLen ) == 0 && keyLen == 6 ){
                                        SEPARATE_ZVAL(ppzTmp);
                                        order = (order_t)getZvalInt(ppzTmp);
//                                      zend_printf( "order=%d<br>\n", order );
                                }
                        }

                        zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
                }
                if ( column ){
                        orderby *o = new orderby( column, order );
                        addOrderBy( o );
                }

                result = RES_OK;
        }

        // pz: array( array('column'=>'hoge','order'=>'1'), array('column'=>'huga','order'=>'2'), ...)
        void setOrders( zval *pz ){
                HashPosition pos;

                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);

                zval **ppzTmp = 0;
                int res2;
                while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
                        char *key = 0;
                        uint keyLen = 0;
                        ulong index = 0;
                        int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
                        if ( keyType == HASH_KEY_IS_STRING/*1*/ ||  keyType == HASH_KEY_IS_LONG/*2*/ ){
                                //print_hash_key( keyType, key, keyLen, index );
                                setOrder( *ppzTmp );
                        }
                        zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
                }
                result = RES_OK;
        }

        void initialize( zval *pz ){
                HashPosition pos;
                zval **ppzTmp = 0;
                int res2;
                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
                while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
                        char *key = 0;
                        uint keyLen = 0;
                        ulong index = 0;
                        int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
                        if ( keyType == HASH_KEY_IS_STRING/*1*/ ||  keyType == HASH_KEY_IS_LONG/*2*/ ){
                                //print_hash_key( keyType, key, keyLen, index );
                                if ( strncasecmp( key, "start", keyLen ) == 0 && keyLen == 6 ){
                                        SEPARATE_ZVAL(ppzTmp);
                                        int tmp = getZvalInt(ppzTmp);
//                                      zend_printf( "start=%d<br>\n", tmp );
                                        setLimit( tmp, getLimitRows() );
                                }
                                else if ( strncasecmp( key, "rows", keyLen ) == 0 && keyLen == 5 ){
                                        SEPARATE_ZVAL(ppzTmp);
                                        int tmp = getZvalInt(ppzTmp);
//                                      zend_printf( "rows=%d<br>\n", tmp );
                                        setLimit( getLimitStart(), tmp );
                                }
                                else if ( strncasecmp( key, "orders", keyLen ) == 0 && keyLen == 7 ){
                                        setOrders( *ppzTmp );
                                }
                                else
                                        ;       // ignore unknown key
                        }
                        else
                                ; // ignore bad key
                        zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
                }
                result = RES_OK;
        }

public:
        zCriteria_t() : criteria(){ result = RES_ERROR; }
        zCriteria_t( zval *pz ) : criteria(){ initialize(pz); }
        zCriteria_t( zval **ppz ) : criteria() { initialize(*ppz); }
        result_t getResult(){ return result; };

        void dump(){
                zend_printf( "dumping zCriteria...<br>\n" );
                zend_printf( "result=%d<br>\n", (int)result );
                zend_printf( "start=%d, rows=%d<br>\n", getLimitStart(), getLimitRows() );
                const orderby *p = headOrderBy();
                while ( p ){
                        zend_printf( "column=%s, order=%d<br>\n", p->getColumn(), p->getOrder() );
                        p = nextOrderBy();
                }
        }
};


/** ����������������������long����������
  @param   ht   ��������
  @param   key  ����
  @param   val  long��������������������
  @return  ��������true
 */
static bool hashGetLong( HashTable *ht, const char *key, long *val ){
        zval         **tmp;
        if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp );
                *val = Z_LVAL_PP(tmp);
                return true;
        }
        return false;
}

/** ������������������������������������
  @param   ht   ��������
  @param   key  ����
  @param   val  ������������������������
  @return  ��������true
 */
static bool hashGetString( HashTable *ht, const char *key, char **val ){
        zval         **tmp;
        if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_string_ex( tmp );
                *val = Z_STRVAL_PP(tmp);
                return true;
        }
        return false;
}

/** ����������������������double����������
  @param   ht   ��������
  @param   key  ����
  @param   val  double��������������������
  @return  ��������true
 */
static bool hashGetDouble( HashTable *ht, const char *key, double *val ){
        zval         **tmp;
        if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_double_ex( tmp );
                *val = Z_DVAL_PP(tmp);
                return true;
        }
        return false;
}

/** zval*����account������������������������ <br>
        ������������getResult()!=RES_OK <br>
  */
class zAccount_t : public account {
private:
        result_t result;
        void initialize(zval *pz){
                HashTable *ht = Z_ARRVAL_P(pz);
                long l;
                char *p;
                double d;
                if ( hashGetLong  ( ht, "uid"               , &l ) ) setUID              ( l );
                if ( hashGetString( ht, "uname"             , &p ) ) setUname            ( p );
                if ( hashGetString( ht, "name"              , &p ) ) setName             ( p );
                if ( hashGetString( ht, "email"             , &p ) ) setEmail            ( p );
                if ( hashGetString( ht, "url"               , &p ) ) setURL              ( p );
                if ( hashGetString( ht, "user_avatar"       , &p ) ) setUserAvatar       ( p );
                if ( hashGetString( ht, "user_icq"          , &p ) ) setUserIcq          ( p );
                if ( hashGetString( ht, "user_from"         , &p ) ) setUserFrom         ( p );
                if ( hashGetString( ht, "user_sig"          , &p ) ) setUserSig          ( p );
                if ( hashGetString( ht, "actkey"            , &p ) ) setActkey           ( p );
                if ( hashGetString( ht, "user_aim"          , &p ) ) setUserAim          ( p );
                if ( hashGetString( ht, "user_yim"          , &p ) ) setUserYim          ( p );
                if ( hashGetString( ht, "user_msnm"         , &p ) ) setUserMsnm         ( p );
                if ( hashGetString( ht, "pass"              , &p ) ) setPass             ( p );
                if ( hashGetString( ht, "theme"             , &p ) ) setTheme            ( p );
                if ( hashGetString( ht, "umode"             , &p ) ) setUmode            ( p );
                if ( hashGetString( ht, "user_occ"          , &p ) ) setUserOcc          ( p );
                if ( hashGetString( ht, "bio"               , &p ) ) setBio              ( p );
                if ( hashGetString( ht, "user_intrest"      , &p ) ) setUserIntrest      ( p );
                if ( hashGetDouble( ht, "timezone_offset"   , &d ) ) setTimezoneOffset   ( d );
                if ( hashGetLong  ( ht, "attachsig"         , &l ) ) setAttachsig        ( l );
                if ( hashGetLong  ( ht, "last_login"        , &l ) ) setLastLogin        ( l );
                if ( hashGetLong  ( ht, "level"             , &l ) ) setLevel            ( l );
                if ( hashGetLong  ( ht, "notify_method"     , &l ) ) setNotifyMethod     ( l );
                if ( hashGetLong  ( ht, "notify_mode"       , &l ) ) setNotifyMode       ( l );
                if ( hashGetLong  ( ht, "posts"             , &l ) ) setPosts            ( l );
                if ( hashGetLong  ( ht, "rank"              , &l ) ) setRank             ( l );
                if ( hashGetLong  ( ht, "uorder"            , &l ) ) setUorder           ( l );
                if ( hashGetLong  ( ht, "user_mailok"       , &l ) ) setUserMailok       ( l );
                if ( hashGetLong  ( ht, "user_regdate"      , &l ) ) setUserRegdate      ( l );
                if ( hashGetLong  ( ht, "user_viewemail"    , &l ) ) setUserViewemail    ( l );
                if ( hashGetLong  ( ht, "activate"          , &l ) ) setActivate         ( l );
                if ( hashGetString( ht, "address"           , &p ) ) setAddress          ( p );
                if ( hashGetString( ht, "division"          , &p ) ) setDivision         ( p );
                if ( hashGetString( ht, "tel"               , &p ) ) setTel              ( p );
                if ( hashGetString( ht, "company_name"      , &p ) ) setCompanyName      ( p );
                if ( hashGetString( ht, "country"           , &p ) ) setCountry          ( p );
                if ( hashGetString( ht, "zipcode"           , &p ) ) setZipcode          ( p );
                if ( hashGetString( ht, "fax"               , &p ) ) setFax              ( p );
                if ( hashGetLong  ( ht, "notice_mail"       , &l ) ) setNoticeMail       ( l );
                if ( hashGetLong  ( ht, "notice_mail_since" , &l ) ) setNoticeMailSince  ( l );
                if ( hashGetLong  ( ht, "private_index_id " , &l ) ) setPrivateIndexID   ( l );
                if ( hashGetLong  ( ht, "item_number_limit" , &l ) ) setItemNumberLimit  ( l );
                if ( hashGetLong  ( ht, "index_number_limit", &l ) ) setIndexNumberLimit ( l );
                if ( hashGetDouble( ht, "item_storage_limit", &d ) ) setItemStorageLimit ( d );

                result = RES_OK;
        }
public:
        zAccount_t() : account(){ result = RES_ERROR; }

        /** ��������������
          @param pz  array( 'uid'=>1, 'uname'=>'root', ... ); ������������������ */
        zAccount_t( zval *pz ) : account(){ initialize(pz); }
        zAccount_t( zval **ppz ) : account() { initialize(*ppz); }
        result_t getResult(){ return result; };
};

class zIndex_t : public index {
private:
        result_t result;

        void initialize(zval *pz){
                HashTable *ht = Z_ARRVAL_P(pz);
                long l;
                char *p;
                if ( hashGetLong  ( ht, "item_id"           , &l ) ) setItemID           ( l );
                if ( hashGetLong  ( ht, "item_type_id"      , &l ) ) setItemTypeID       ( l );
                if ( hashGetLong  ( ht, "contributor_uid"   , &l ) ) setContributorUID   ( l );
                if ( hashGetString( ht, "title"             , &p ) ) setTitle            ( p );
                if ( hashGetString( ht, "keywords"          , &p ) ) setKeywords         ( p );
                if ( hashGetString( ht, "description"       , &p ) ) setDescription      ( p );
                if ( hashGetLong  ( ht, "last_update_date"  , &l ) ) setLastUpdateDate   ( l );
                if ( hashGetLong  ( ht, "creation_date"     , &l ) ) setCreationDate     ( l );
                if ( hashGetLong  ( ht, "parent_index_id"   , &l ) ) setParentIndexID    ( l );
                if ( hashGetLong  ( ht, "owner_uid"         , &l ) ) setOwnerUID         ( l );
                if ( hashGetLong  ( ht, "owner_gid"         , &l ) ) setOwnerGID         ( l );
                if ( hashGetLong  ( ht, "open_level"        , &l ) ) setOpenLevel        ( l );
                if ( hashGetLong  ( ht, "sort_number"       , &l ) ) setSortNumber       ( l );

                result = RES_OK;
        }
public:
        zIndex_t() : index(){ result = RES_ERROR; }
        zIndex_t( zval *pz ) : index(){ initialize(pz); }
        zIndex_t( zval **ppz ) : index() { initialize(*ppz); }
        result_t getResult(){ return result; };

        void dump(){
        }
};

/** zval*����(userid_t *puid,int uidLen)������������������������ <br>
        ������������getResult()!=RES_OK <br>
  */
class zUIDs_t {
private:
        result_t result;
        userid_t *pUID;
        int len;
public:
        zUIDs_t(){
                pUID = 0;
                len = 0;
                result = RES_ERROR;
        }

        /** ��������������
          @param pza  array( '1', '3', '4', '6', ... ); �������������� */
        zUIDs_t( zval *pza ){
                pUID = 0;
                len = 0;
                result = RES_ERROR;

                if ( Z_TYPE_P(pza) != IS_ARRAY ){
                        result = RES_ERROR;
                }
                else {
                        len = zend_hash_num_elements(Z_ARRVAL_P(pza));
                        if(len == 0) {
                                pUID = new userid_t[1];
                                result = RES_OK;
                        }
                        else {
                                /* php/ext/standard/string.c �� implode������������������
                                   zend_hash_*����������������������������������
                                */
                                zval         **tmp;
                                HashPosition   pos;
                                int i = 0;
                                pUID = new userid_t[len];

                                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pza), &pos);
                                while (zend_hash_get_current_data_ex(Z_ARRVAL_P(pza), (void **) &tmp, &pos) == SUCCESS ) {
                                        SEPARATE_ZVAL(tmp); // zend.arguments.write-safety.html ����
                                        convert_to_long_ex(tmp);
                                        if ( i < len )
                                                pUID[i++] = Z_LVAL_PP(tmp);
                                        zend_hash_move_forward_ex(Z_ARRVAL_P(pza), &pos);
                                }
                                len = i;
                                result = RES_OK;
                        }
                }
        }

        ~zUIDs_t(){
                if ( pUID ) delete[] pUID;
        }
        result_t getResult(){ return result; }
        userid_t *getPUID(){ return pUID; }
        int getLen(){ return len; }
        void dump(){
        zend_printf( "dumping zUIDs...<br>\n" );
                zend_printf( "result=%d<br>\n", (int)result );
                zend_printf( "len=%d<br>\n", len );
                for ( int i = 0; i < len; i++ ){
                        zend_printf( "pUID[%d] = %d<br>\n", i, pUID[i] );
                }
        }
};

/** zval*����(itemid_t *piid,int iidLen)������������������������ <br>
        ������������getResult()!=RES_OK <br>
  */
class zIIDs_t {
private:
        result_t result;
        itemid_t *pIID;
        int len;
public:
        zIIDs_t(){
                pIID = 0;
                len = 0;
                result = RES_ERROR;
        }

        /** ��������������
          @param pza  array( '1', '3', '4', '6', ... ); �������������� */
        zIIDs_t( zval *pza ){
                pIID = 0;
                len = 0;
                result = RES_ERROR;

                if ( Z_TYPE_P(pza) != IS_ARRAY ){
                        result = RES_ERROR;
                }
                else {
                        len = zend_hash_num_elements(Z_ARRVAL_P(pza));
                        if(len == 0) {
                                pIID = new itemid_t[1];
                                result = RES_OK;
                        }
                        else {
                                /* php/ext/standard/string.c �� implode������������������
                                   zend_hash_*����������������������������������
                                */
                                zval         **tmp;
                                HashPosition   pos;
                                int i = 0;
                                pIID = new itemid_t[len];

                                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pza), &pos);
                                while (zend_hash_get_current_data_ex(Z_ARRVAL_P(pza), (void **) &tmp, &pos) == SUCCESS ) {
                                        SEPARATE_ZVAL(tmp); // zend.arguments.write-safety.html ����
                                        convert_to_long_ex(tmp);
                                        if ( i < len )
                                                pIID[i++] = Z_LVAL_PP(tmp);
                                        zend_hash_move_forward_ex(Z_ARRVAL_P(pza), &pos);
                                }
                                len = i;
                                result = RES_OK;
                        }
                }
        }

        ~zIIDs_t(){
                if ( pIID ) delete[] pIID;
        }
        result_t getResult(){ return result; }
        itemid_t *getPIID(){ return pIID; }
        int getLen(){ return len; }
        void dump(){
        zend_printf( "dumping zIIDs...<br>\n" );
                zend_printf( "result=%d<br>\n", (int)result );
                zend_printf( "len=%d<br>\n", len );
                for ( int i = 0; i < len; i++ ){
                        zend_printf( "pIID[%d] = %d<br>\n", i, pIID[i] );
                }
        }
};

/**
 *
 * amazonbook_t��������PHP����������������
 * @param pAmazonbook ��������amazonbook_t*
 * @param z        ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t amazonbookToZval( const amazonbook_t *pAmazonbook, zval *z )
{
        zend_hash_clean( z -> value.ht );
        
        add_assoc_string( z, "title", ( char* )pAmazonbook -> getTitle( ), 1 );
        add_assoc_string( z, "author", ( char* )pAmazonbook -> getAuthor( ), 1 );
        add_assoc_string( z, "publisher", ( char* )pAmazonbook -> getPublisher( ), 1 );
        add_assoc_long( z, "year_of_publication", pAmazonbook -> getYearOfPublication( ) );
        add_assoc_string( z, "isbn", ( char* )pAmazonbook -> getISBN( ), 1 );
        add_assoc_string( z, "url", ( char* )pAmazonbook -> getURL( ), 1 );
        
        return RES_OK;
}

/**
 *
 * pubmed_t��������PHP����������������
 * @param pPubmed ��������pubmed_t*
 * @param z        ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t pubmedToZval( const pubmed_t *pPubmed, zval *z )
{
        zend_hash_clean( z -> value.ht );
        
        add_assoc_long( z, "pmid", pPubmed -> getID( ) );
        add_assoc_string( z, "title", ( char* )pPubmed -> getTitle( ), 1 );
        add_assoc_string( z, "author", ( char* )pPubmed -> getAuthor( ), 1 );
        add_assoc_string( z, "journal", ( char* )pPubmed -> getJournal( ), 1 );
        add_assoc_long( z, "year_of_publication", pPubmed -> getYearOfPublication( ) );
        add_assoc_long( z, "volume", pPubmed -> getVolume( ) );
        add_assoc_long( z, "number", pPubmed -> getNumber( ) );
        add_assoc_string( z, "page", ( char* )pPubmed -> getPage( ), 1 );
        add_assoc_string( z, "abstract", ( char* )pPubmed -> getAbstract( ), 1 );
        
        return RES_OK;
}

/**
 *
 * itemid_t��������PHP����������������
 * @param piid ��������itemid_t������
 * @param len  piid������������
 * @param ppz  ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t itemidsToZval( const itemid_t *piid, int len, zval **ppz )
{
        zend_hash_clean( Z_ARRVAL_PP(ppz) );

        // add IDs
        for ( int i = 0; i < len; i++ ){
                add_next_index_long(*ppz, (long)(piid[i]) );
        }

        return RES_OK;
}

/**
 *
 * indexid_t��������PHP����������������
 * @param piid ��������indexid_t������
 * @param len  piid������������
 * @param ppz  ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t indexidsToZval( const indexid_t *piid, int len, zval **ppz )
{
        zend_hash_clean( Z_ARRVAL_PP(ppz) );
    
        // add IDs
        for ( int i = 0; i < len; i++ ){
                add_next_index_long(*ppz, (long)(piid[i]) );
        }

        return RES_OK;
}

/**
 *
 * uids_t��������PHP����������������
 *
 * @param pUID ��������userid_t������
 * @param len pUID������������
 * @param pz ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t uidsToZval( userid_t *pUID, int len, zval **ppz )
{
        zend_hash_clean( Z_ARRVAL_PP(ppz) );

        // add UIDs
        for ( int i = 0; i < len; i++ ){
                add_next_index_long(*ppz, (long)(pUID[i]) );
        }

        return RES_OK;
}

/**
 *
 * groupid_t��������PHP����������������
 * @param pGID ��������groupid_t������
 * @param len  pGID������������
 * @param ppz  ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t gidsToZval( groupid_t *pGID, int len, zval **ppz )
{
        zend_hash_clean( Z_ARRVAL_PP(ppz) );

        // add GIDs
        for ( int i = 0; i < len; i++ ){
                add_next_index_long(*ppz, (long)(pGID[i]) );
        }

        return RES_OK;
}

/**
 *
 * changelog_t��������PHP����������������
 * @param pChangelog ��������changelog_t*
 * @param z        ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t changelogToZval( const changelog_t *pChangelog, zval *z )
{
        zend_hash_clean( z -> value.ht );

        add_assoc_long( z, "log_id", pChangelog -> getChangelogID( ) );
        add_assoc_long( z, "item_id", pChangelog -> getItemID( ) );
        add_assoc_long( z, "log_date", pChangelog -> getDate( ) );
        add_assoc_string( z, "log", ( char* )pChangelog -> getLog( ), 1 );

        return RES_OK;
}

/**
 *
 * item_t��������PHP����������������
 * @param pItem ��������item_t*
 * @param z        ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t itemToZval( const item_t *pItem, zval *z )
{
        zend_hash_clean( z -> value.ht );

        add_assoc_long( z, "item_id", pItem -> getItemID( ) );
        add_assoc_long( z, "item_type_id", pItem -> getItemTypeID( ) );
        add_assoc_long( z, "uid", pItem -> getContributorUID( ) );
        add_assoc_string( z, "title", ( char* )pItem -> getTitle( ), 1 );
        add_assoc_string( z, "keywords", ( char* )pItem -> getKeywords( ), 1 );
        add_assoc_string( z, "description", ( char* )pItem -> getDescription( ), 1 );
        add_assoc_string( z, "doi", ( char* )pItem -> getDOI( ), 1 );
        add_assoc_long( z, "last_update_date", pItem -> getLastUpdateDate( ) );
        add_assoc_long( z, "creation_date", pItem -> getCreationDate( ) );
        add_assoc_long( z, "publication_year", pItem -> getPublicationYear( ) );
        add_assoc_long( z, "publication_month", pItem -> getPublicationMonth( ) );
        add_assoc_long( z, "publication_mday", pItem -> getPublicationMday( ) );
        add_assoc_string( z, "lang", ( char* )pItem -> getLang( ), 1 );

        return RES_OK;
}


result_t itemsToZval( const item_t *pItems, int itemsLen, zval *z )
{
        zend_hash_clean( z -> value.ht );
        for( int i = 0; i < itemsLen; i++ ){
                zval *new_array;
                MAKE_STD_ZVAL(new_array);
                if(array_init(new_array) != SUCCESS){
                        return RES_ERROR;
                }
                add_index_zval( z, i, new_array );
                itemToZval( &pItems[ i ], new_array );
        }
        return RES_OK;
}

/**
 *
 * PHP������������������group_t����������
 *
 * @param z ����������������
 * @param pGroup ��������������������������
 * @return RES_OK
 *
 */
result_t zvalToItem( zval *z, item_t* pItem )
{
        zval         **tmp;
        char* key = 0;

        key = "item_id";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pItem -> setItemID( (*tmp) -> value.lval );
        }
        key = "item_type_id";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pItem -> setItemTypeID( (*tmp) -> value.lval );
        }
        key = "uid";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pItem -> setContributorUID( (*tmp) -> value.lval );
        }
        key = "title";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_string_ex( tmp ) ;
                pItem -> setTitle( (*tmp) -> value.str.val );
        }
        key = "keywords";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_string_ex( tmp ) ;
                pItem -> setKeywords( (*tmp) -> value.str.val );
        }
        key = "description";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_string_ex( tmp ) ;
                pItem -> setDescription( (*tmp) -> value.str.val );
        }
        key = "doi";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_string_ex( tmp ) ;
                pItem -> setDOI( (*tmp) -> value.str.val );
        }
        key = "last_update_date";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pItem -> setLastUpdateDate( (*tmp) -> value.lval );
        }
        key = "creation_date";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pItem -> setCreationDate( (*tmp) -> value.lval );
        }
        key = "publication_year";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pItem -> setPublicationYear( (*tmp) -> value.lval );
        }
        key = "publication_month";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pItem -> setPublicationMonth( (*tmp) -> value.lval );
        }
        key = "publication_mday";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pItem -> setPublicationMday( (*tmp) -> value.lval );
        }
        key = "lang";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_string_ex( tmp ) ;
                pItem -> setLang( (*tmp) -> value.str.val );
        }
        return RES_OK;
}

/**
 *
 * account_t��������PHP����������������
 * @param pAccount ��������account_t*
 * @param z        ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t accountToZval( const account_t *pAccount, zval *z )
{
        zend_hash_clean( z -> value.ht );

        add_assoc_long( z, "uid", pAccount -> getUID( ) );
        add_assoc_string( z, "uname", ( char* )pAccount -> getUname( ), 1 );
        add_assoc_string( z, "name", ( char* )pAccount -> getName( ), 1 );
        add_assoc_string( z, "email", ( char* )pAccount -> getEmail( ), 1 );
        add_assoc_string( z, "url", ( char* )pAccount -> getURL( ), 1 );
        add_assoc_string( z, "user_avatar", ( char* )pAccount -> getUserAvatar( ), 1 );
        add_assoc_string( z, "user_icq", ( char* )pAccount -> getUserIcq( ), 1 );
        add_assoc_string( z, "user_from", ( char* )pAccount -> getUserFrom( ), 1 );
        add_assoc_string( z, "user_sig", ( char* )pAccount -> getUserSig( ), 1 );
        add_assoc_string( z, "actkey", ( char* )pAccount -> getActkey( ), 1 );
        add_assoc_string( z, "user_aim", ( char* )pAccount -> getUserAim( ), 1 );
        add_assoc_string( z, "user_yim", ( char* )pAccount -> getUserYim( ), 1 );
        add_assoc_string( z, "user_msnm", ( char* )pAccount -> getUserMsnm( ), 1 );
        add_assoc_string( z, "pass", ( char* )pAccount -> getPass( ), 1 );
        add_assoc_string( z, "theme", ( char* )pAccount -> getTheme( ), 1 );
        add_assoc_string( z, "umode", ( char* )pAccount -> getUmode( ), 1 );
        add_assoc_string( z, "user_occ", ( char* )pAccount -> getUserOcc( ), 1 );
        add_assoc_string( z, "bio", ( char* )pAccount -> getBio( ), 1 );
        add_assoc_string( z, "user_intrest", ( char* )pAccount -> getUserIntrest( ), 1 );
        add_assoc_double( z, "timezone_offset", pAccount -> getTimezoneOffset( ) );
        add_assoc_long( z, "attachsig", pAccount -> getAttachsig( ) );
        add_assoc_long( z, "last_login", pAccount -> getLastLogin( ) );
        add_assoc_long( z, "level", pAccount -> getLevel( ) );
        add_assoc_long( z, "notify_method", pAccount -> getNotifyMethod( ) );
        add_assoc_long( z, "notify_mode", pAccount -> getNotifyMode( ) );
        add_assoc_long( z, "posts", pAccount -> getPosts( ) );
        add_assoc_long( z, "rank", pAccount -> getRank( ) );
        add_assoc_long( z, "uorder", pAccount -> getUorder( ) );
        add_assoc_long( z, "user_mailok", pAccount -> getUserMailok( ) );
        add_assoc_long( z, "user_regdate", pAccount -> getUserRegdate( ) );
        add_assoc_long( z, "user_viewemail", pAccount -> getUserViewemail( ) );

        add_assoc_long( z, "activate", pAccount -> getActivate( ) );
        add_assoc_string( z, "address", ( char* )pAccount -> getAddress( ), 1 );
        add_assoc_string( z, "division", ( char* )pAccount -> getDivision( ), 1 );
        add_assoc_string( z, "tel", ( char* )pAccount -> getTel( ), 1 );
        add_assoc_string( z, "company_name", ( char* )pAccount -> getCompanyName( ), 1 );
        add_assoc_string( z, "country", ( char* )pAccount -> getCountry( ), 1 );
        add_assoc_string( z, "zipcode", ( char* )pAccount -> getZipcode( ), 1 );
        add_assoc_string( z, "fax", ( char* )pAccount -> getFax( ), 1 );
        add_assoc_long( z, "notice_mail", pAccount -> getNoticeMail( ) );
        add_assoc_long( z, "notice_mail_since", pAccount -> getNoticeMailSince( ) );
        add_assoc_long( z, "private_index_id", pAccount -> getPrivateIndexID( ) );
        add_assoc_long( z, "item_number_limit",  pAccount -> getItemNumberLimit( ) );
        add_assoc_long( z, "index_number_limit",  pAccount -> getIndexNumberLimit( ) );
        add_assoc_double( z, "item_storage_limit",  pAccount -> getItemStorageLimit( ) );
        return RES_OK;
}

/**
 *
 * ������account_t��������PHP����������������������
 * @param pAccounts ��������account_t*
 * @param accountsLen pAccounts������������
 * @param z        ����������������������(��������������������)
 * @return RES_OK
 *
  z: �������������������������� <br>
        array(
          array(
                'uid'=>100,
                'activate'=>1,
                'division'=>'foo',
                'tel'=>'123-456-789',
                ...
          ),
          ...
        )
 */
result_t accountsToZval( const account_t *pAccounts, int accountsLen, zval *z )
{
        zend_hash_clean( z -> value.ht );
        for( int i = 0; i < accountsLen; i++ ){
                zval *new_array;
                MAKE_STD_ZVAL(new_array);
                if(array_init(new_array) != SUCCESS){
                        return RES_ERROR;
                }
                add_index_zval( z, i, new_array );
                accountToZval( &pAccounts[ i ], new_array );
        }
        return RES_OK;
}

/**
 *
 * ������group_t��������PHP����������������������
 * @param pGroups ��������group_t*
 * @param groupsLen pGroups������������
 * @param z        ����������������������(��������������������)
 * @return RES_OK
 *
  z: �������������������������� <br>
        array(
          array(
                'gid'=>1,
                'gname'=>'foo group',
                'gdesc'=>'group of foo'
          ),
          ...
        )
 */
result_t groupsToZval( const group_t *pGroups, int groupsLen, zval *z )
{
        zend_hash_clean( z -> value.ht );
        for( int i = 0; i < groupsLen; i++ ){
                zval *new_array;
                MAKE_STD_ZVAL(new_array);
                if(array_init(new_array) != SUCCESS){
                        return RES_ERROR;
                }
                add_index_zval( z, i, new_array );
                add_assoc_long( new_array, "gid",  pGroups[ i ].getGID( ) );
                add_assoc_string( new_array, "gname", ( char* )pGroups[ i ].getGname( ), 1 );
                add_assoc_string( new_array, "gdesc", ( char* )pGroups[ i ].getDesc( ), 1 );
                add_assoc_long( new_array, "group_index_id",  pGroups[ i ].getGroupIndexID( ) );
                add_assoc_long( new_array, "item_number_limit",  pGroups[ i ].getItemNumberLimit( ) );
                add_assoc_long( new_array, "index_number_limit",  pGroups[ i ].getIndexNumberLimit( ) );
                add_assoc_double( new_array, "item_storage_limit",  pGroups[ i ].getItemStorageLimit( ) );
        }
        return RES_OK;
}

/**
 *
 * group_t��������PHP��������������������
 *
 * @param pGroup ��������������������
 * @param z ��������������������������(��������������������)
 * @return RES_OK
 *
 */
result_t groupToZval( const group_t *pGroup, zval *z )
{
        zend_hash_clean( z -> value.ht );
        add_assoc_long( z, "gid",  pGroup -> getGID( ) );
        add_assoc_string( z, "gname", ( char* )pGroup -> getGname( ), 1 );
        add_assoc_string( z, "gdesc", ( char* )pGroup -> getDesc( ), 1 );
        add_assoc_long( z, "group_index_id",  pGroup -> getGroupIndexID( ) );
        add_assoc_long( z, "item_number_limit",  pGroup -> getItemNumberLimit( ) );
        add_assoc_long( z, "index_number_limit",  pGroup -> getIndexNumberLimit( ) );
        add_assoc_double( z, "item_storage_limit",  pGroup -> getItemStorageLimit( ) );
        return RES_OK;
}

/**
 *
 * PHP������������������group_t����������
 *
 * @param z ����������������
 * @param pGroup ��������������������������
 * @return RES_OK
 *
 */
result_t zvalToGroup( zval *z, group_t *pGroup )
{
        zval         **tmp;
        char* key = 0;

        key = "gid";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pGroup -> setGID( (*tmp) -> value.lval );
        }
        key = "gname";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_string_ex( tmp ) ;
                pGroup -> setGname( (*tmp) -> value.str.val );
        }
        key = "gdesc";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_string_ex( tmp ) ;
                pGroup -> setDesc( (*tmp) -> value.str.val );
        }
        key = "group_index_id";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pGroup -> setGroupIndexID( (*tmp) -> value.lval );
        }
        key = "item_number_limit";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pGroup -> setItemNumberLimit( (*tmp) -> value.lval );
        }
        key = "index_number_limit";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_long_ex( tmp ) ;
                pGroup -> setIndexNumberLimit( (*tmp) -> value.lval );
        }
        key = "item_storage_limit";
        if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
                convert_to_double_ex( tmp ) ;
                pGroup -> setItemStorageLimit( (*tmp) -> value.dval );
        }
        return RES_OK;
}

/**
 *
 * session_t��������PHP��������������������
 *
 * @param pSession ��������session_t
 * @param z ��������������������������(��������������������)
 * @return RES_OK
 *
 */
result_t sessionToZval( const session_t *pSession, zval *z )
{
        string sessionID(unsignedIntToString(pSession->getSessionID()));
        add_assoc_string(z, "session_id", (char *)sessionID.c_str(), 1);

        string date(unsignedIntToString((unsigned int)pSession->getDate()));
        add_assoc_string(z, "date", (char *)date.c_str(), 1);

        string userID(unsignedIntToString((unsigned int)pSession->getUID()));
        add_assoc_string(z, "user_id", (char *)userID.c_str(), 1);

        return RES_OK;
}

/**
 *
 * index_t��������PHP����������������
 * @param pIndex ��������index_t*
 * @param z        ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t indexToZval( const index_t *pIndex, zval *z )
{
        zend_hash_clean( z -> value.ht );

        add_assoc_long( z, "item_id", pIndex -> getItemID( ) );
        add_assoc_long( z, "item_type_id", pIndex -> getItemTypeID( ) );
        add_assoc_long( z, "contributor_uid", pIndex -> getContributorUID( ) );
        add_assoc_string( z, "title", ( char* )pIndex -> getTitle( ), 1 );
        add_assoc_string( z, "keywords", ( char* )pIndex -> getKeywords( ), 1 );
        add_assoc_string( z, "description", ( char* )pIndex -> getDescription( ), 1 );
        add_assoc_long( z, "last_update_date", pIndex -> getLastUpdateDate( ) );
        add_assoc_long( z, "creation_date", pIndex-> getCreationDate( ) );
        add_assoc_long( z, "parent_index_id", pIndex -> getParentIndexID( ) );
        add_assoc_long( z, "owner_uid", pIndex -> getOwnerUID( ) );
        add_assoc_long( z, "owner_gid", pIndex -> getOwnerGID( ) );
        add_assoc_long( z, "open_level", pIndex -> getOpenLevel( ) );
        add_assoc_long( z, "sort_number", pIndex -> getSortNumber( ) );
        return RES_OK;
}

result_t indexesToZval( const index_t *pIndexes, int indexesLen, zval *z )
{
        zend_hash_clean( z -> value.ht );
        for( int i = 0; i < indexesLen; i++ ){
                zval *new_array;
                MAKE_STD_ZVAL(new_array);
                if(array_init(new_array) != SUCCESS){
                        return RES_ERROR;
                }
                add_index_zval( z, i, new_array );
                indexToZval( &pIndexes[ i ], new_array );
        }
        return RES_OK;
}

/**
 *
 * event_t��������PHP����������������
 * @param pevent ��������event_t*
 * @param z        ����������������������(��������������������)
 * @return RES_OK
 *
 */
result_t eventToZval( const event_t *pEvent, zval *z )
{
        zend_hash_clean( z -> value.ht );

        add_assoc_long  ( z, "event_id"      , pEvent -> getEventID()       );
        add_assoc_long  ( z, "event_type_id" , pEvent -> getEventTypeID()   );
        
        if ( pEvent->isValidTimestamp     () ) add_assoc_long  ( z, "timestamp"      , pEvent -> getTimestamp()     );
        if ( pEvent->isValidExecUID       () ) add_assoc_long  ( z, "exec_uid"       , pEvent -> getExecUID()       );
        if ( pEvent->isValidIndexID       () ) add_assoc_long  ( z, "index_id"       , pEvent -> getIndexID()       );
        if ( pEvent->isValidItemID        () ) add_assoc_long  ( z, "item_id"        , pEvent -> getItemID()        );
        if ( pEvent->isValidFileID        () ) add_assoc_long  ( z, "file_id"        , pEvent -> getFileID()        );
        if ( pEvent->isValidUID           () ) add_assoc_long  ( z, "uid"            , pEvent -> getUID()           );
        if ( pEvent->isValidGID           () ) add_assoc_long  ( z, "gid"            , pEvent -> getGID()           );
        if ( pEvent->isValidRemoteHost    () ) add_assoc_string( z, "remote_host"    , (char*)pEvent -> getRemoteHost()    , 1 );
        if ( pEvent->isValidSearchKeyword () ) add_assoc_string( z, "search_keyword" , (char*)pEvent -> getSearchKeyword() , 1 );
        if ( pEvent->isValidAdditionalInfo() ) add_assoc_string( z, "additional_info", (char*)pEvent -> getAdditionalInfo(), 1 );

        return RES_OK;
}

result_t eventsToZval( const event_t *pevents, int eventsLen, zval *z )
{
        zend_hash_clean( z -> value.ht );
        for( int i = 0; i < eventsLen; i++ ){
                zval *new_array;
                MAKE_STD_ZVAL(new_array);
                if(array_init(new_array) != SUCCESS){
                        return RES_ERROR;
                }
                add_index_zval( z, i, new_array );
                eventToZval( &pevents[ i ], new_array );
        }
        return RES_OK;
}


/** ����������������������������<br>
        int xnp_get_group( int sid, int gid, array group );
        @param sid    XNP������������ID
        @param gid    XNP �� group_id
        @param group  ������������������
        @return 0 success <br>
  */
ZEND_FUNCTION(xnp_get_group)
{
        long sid, gid;
        zval *zgroup;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
                                                          &sid, &gid, &zgroup) == FAILURE) {
                return;
        }

        const group_t *pgroup;
        result_t result = getGroup( (sessionid_t)sid, (groupid_t)gid, &pgroup );
        if ( RES_OK == result ){
                groupToZval( pgroup, zgroup );
                freeGroup( pgroup );
        }

        RETURN_LONG(result);
}


/** ����������������(����)������������<br>
        xnp_get_groups( int sid, array gids, array criteria, array groups );
        @param sid      XNP������������ID
        @param gids     XNP �� group_id ������
        @param criteria ����
        @param groups   ������������������������
        @return 0 success <br>
  */
ZEND_FUNCTION(xnp_get_groups)
{
        result_t result;
    long sid;
        zval *zcriteria;
        zval *zgids;
        zval *zgroups;
        zval **ppzTmp = 0;
        HashPosition pos;
        int res2;
        int gidsLen;
        const group_t* groups;
        int groupsLen;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laaa",
                                                          &sid, &zgids, &zcriteria, &zgroups) == FAILURE) {
                return;
        }

        //gids����������ID������������
        gidsLen = zend_hash_num_elements(Z_ARRVAL_P(zgids));
        groupid_t *gids = new groupid_t[ gidsLen ];
        zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(zgids), &pos);
        for( int i = 0; i < gidsLen; i++ ){
                if( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(zgids), (void **)&ppzTmp, &pos)) == SUCCESS ){
                        SEPARATE_ZVAL(ppzTmp);
                        convert_to_long_ex(ppzTmp);
                        gids[ i ] = Z_LVAL_PP(ppzTmp);
                }
                zend_hash_move_forward_ex(Z_ARRVAL_P(zgids), &pos);
        }

        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
                result = getGroups( (sessionid_t)sid, gids, gidsLen, &zcri, &groups, &groupsLen );
                if ( RES_OK == result ){
                        groupsToZval( groups, groupsLen, zgroups );
                        delete[] gids;
                        freeGroup( groups );
                }
        }
        RETURN_LONG(result);
}


/** ������������������������������������������<br>
        int xnp_is_moderator(int sid, int uid)
        @param sid      XNP������������ID
        @param uid      xoops �� uid (xoops_users.uid)
        @return true  ���������������� <br>
  */
ZEND_FUNCTION(xnp_is_moderator)
{
        long xnpSessionID;
        userid_t uid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
                                                          &xnpSessionID, &uid) == FAILURE) {
                return;
        }

        bool result = isModerator( (sessionid_t)xnpSessionID, uid );
        RETURN_BOOL(result)
}

/** ������������uid��������<br>
        int xnp_get_uid(string uname,int &uid)
        @param sid      XNP������������ID
        @param uname    xoops �� uname (xoops_users.uname)
        @param uid      xoops �� uid (xoops_users.uid) ��������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_get_uid)
{
        char *uname;
        int unameLen;
        zval *zuid;
        userid_t uid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz",
          &uname, &unameLen, &zuid) == FAILURE) {
                return;
        }

        if (!PZVAL_IS_REF(zuid)) {
                zend_error(E_WARNING, "2nd parameter wasn't passed by reference");
                RETURN_LONG(RES_PHP_NONREF);
        }

        string strUname( uname, unameLen );
        result_t result = getUid( strUname.c_str(), &uid );
        ZVAL_LONG(zuid, (long)uid);
        RETURN_LONG((long)result);
}

ZEND_FUNCTION(xnp_test_criteria)
{
        zval *z;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a",
          &z) == FAILURE) {
                return;
        }
        zend_printf("zend_printf...<br>\n");
        zCriteria_t zcri(z);
        zcri.dump();
        RETURN_FALSE
}

ZEND_FUNCTION(xnp_test_uids)
{
        zval *z;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a",
          &z) == FAILURE) {
                return;
        }
        zend_printf("zend_printf...<br>\n");
        zUIDs_t zuids(z);
        zuids.dump();
        RETURN_FALSE
}


/** DB������������������������������������������<br>
        int initialize_db( string host[, string user[, string password[, string dbname[, string prefix, int dbtype]]]] );
        @param host      ����������������NULL
        @param user      DB��������������������������NULL
        @param password  DB����������������������������NULL
        @param dbname    DB��������DB������������""
        @param prefix    XOOPS DB ��prefix��
        @param dbtype    1=MySQL 2=SQLite��common.h����
        @return 0 success <br>
  */
ZEND_FUNCTION(xnp_initialize_db)
{
        zval **parameters[5];
        char *host;
        char *user;
        char *password;
        char *dbname;
        char *prefix;
        long dbtype;

        /* get the number of arguments */
        int argNum = ZEND_NUM_ARGS();
        if (argNum > 5)
                WRONG_PARAM_COUNT;

        /* argument count is correct, now retrieve arguments */
        if(zend_get_parameters_array_ex(argNum, parameters) != SUCCESS)
                WRONG_PARAM_COUNT;

        if (argNum < 1) host = NULL;
        else            host = getZvalString( parameters[0] );

        if (argNum < 2) user = NULL;
        else            user = getZvalString( parameters[1] );

        if (argNum < 3) password = NULL;
        else            password = getZvalString( parameters[2] );

        if (argNum < 4) dbname = "";
        else            dbname = getZvalString( parameters[3] );

        if (argNum < 5) prefix = "";
        else            prefix = getZvalString( parameters[4] );

        if (argNum < 6) dbtype = DBTYPE_MYSQL;
        else            dbtype = getZvalInt( parameters[5] );

        result_t result = initializeDB( host, user, password, dbname, prefix, (dbtype_t)dbtype );

        RETURN_LONG(result);
}

/** ��������������<br>
        int xnp_login_user(string uname, string password, int &session_id)
        @param uname      ��������(xoops_users.uname)
        @param password   ����������(md5(password)=xoops_users.pass)
        @return 0 success
  */
ZEND_FUNCTION(xnp_login_user)
{
        char *uname;
        int unameLen;
        char *passwd;
        int passwdLen;
        zval *zXNPSessionID;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz",
          &uname, &unameLen, &passwd, &passwdLen, &zXNPSessionID) == FAILURE) {
                return;
        }

        if (!PZVAL_IS_REF(zXNPSessionID)) {
                zend_error(E_WARNING, "3rd parameter wasn't passed by reference");
                RETURN_LONG(RES_PHP_NONREF);
        }

        sessionid_t xnpSessionID;
        result_t result = loginUser( uname, passwd, &xnpSessionID );
        if ( result == RES_OK )
                ZVAL_LONG(zXNPSessionID, (long)xnpSessionID);
        RETURN_LONG((long)result);
}

/** ����������������<br>
        void xnp_logout_user(int xnp_session_id)
        @param xnp_session_id  XNP������������ID
        @return ����
  */
ZEND_FUNCTION(xnp_logout_user)
{
        long xnpSessionID;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &xnpSessionID) == FAILURE) {
                return;
        }
        logoutUser( (sessionid_t)xnpSessionID );

        RETURN_NULL();
}

/** XNP������������ID ����<br>
        int xnp_create_session( string xoops_sess_id, int uid, int &session )
        @param xoops_sess_id  xoops������������ID
        @param uid  xoops �� uid (xoops_users.uid)
        @param session  ��������XNP��session��������������
        @return 0 ����
  */
ZEND_FUNCTION(xnp_create_session)
{
        char *xoopsSessionID;
        int xoopsSessionIDLen;
        long uid;
        zval *zXNPSessionID;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "slz",
          &xoopsSessionID, &xoopsSessionIDLen, &uid, &zXNPSessionID) == FAILURE) {
                return;
        }

        if (!PZVAL_IS_REF(zXNPSessionID)) {
                zend_error(E_WARNING, "3rd parameter wasn't passed by reference");
                RETURN_LONG(RES_PHP_NONREF);
        }

        sessionid_t xnpSessionID = 0;
        result_t result = createSession( xoopsSessionID, (userid_t)uid, &xnpSessionID );
        if ( result == RES_OK )
                ZVAL_LONG(zXNPSessionID, (long)xnpSessionID);
        RETURN_LONG((long)result);
}

/** XNP �� session ����������������<br>
        int xnp_get_session( int xnp_session_id, array session_info )
        @param xnp_session_id   XNP������������ID
        @param session_info  ������������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_get_session)
{
        long xnpSessionID;
        zval *sessionInfo;
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
          &xnpSessionID, &sessionInfo) == FAILURE) {
                return;
        }
        const session_t *session = 0;
        result_t result = getSession( (sessionid_t)xnpSessionID, &session );
        if ( result == RES_OK ){
                sessionToZval( session, sessionInfo );
                freeSession( session );
        }

        RETURN_LONG((long)result);
}

/** ��������activate��������������<br>
        bool xnp_is_activated( int xnp_session_id, int user_id )
        @param xnp_session_id   XNP������������ID
        @param user_id  xoops_users.uid
        @return 0 success
  */
ZEND_FUNCTION(xnp_is_activated)
{
        long sid, uid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &sid, &uid) == FAILURE) {
                return;
        }

        bool result = isActivated( (sessionid_t)sid, (userid_t)uid );

        RETURN_BOOL(result);
}

/** activate������<br>
        bool xnp_activate( int xnp_session_id, int user_id, bool activated )
        @param xnp_session_id   xnp �� session id
        @param user_id   xoops_users.uid
        @param activated  true:activate, false:inactivate
        @return 0 success
  */
ZEND_FUNCTION(xnp_activate)
{
        long sid, uid;
        bool activated;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llb",
          &sid, &uid, &activated) == FAILURE) {
                return;
        }

        result_t result = activate( (sessionid_t)sid, (userid_t)uid, activated );

        RETURN_LONG(result);
}

/** XNP����������������������<br>
        int xnp_get_account_count( int xnp_session_id )
        @param xnp_session_id   XNP������������ID
        @return 0 success
  */
ZEND_FUNCTION(xnp_get_account_count)
{
        long sid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
          &sid) == FAILURE) {
                return;
        }

        long count = getAccountCount( (sessionid_t)sid );
        RETURN_LONG(count);
}

/** ����������������������<br>
        bool xnp_delete_account( int xnp_session_id, int user_id )
        @param xnp_session_id   XNP������������ID
        @param user_id   xoops_users.uid
        @return 0 success
  */
ZEND_FUNCTION(xnp_delete_account)
{
        long sid, uid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
          &sid, &uid) == FAILURE) {
                return;
        }

        result_t result = deleteAccount( (sessionid_t)sid, (userid_t)uid );

        RETURN_LONG(result);
}

/** ����������������������<br>
        int xnp_get_account( int xnp_session_id, int user_id, array account_info )
        @param xnp_session_id   XNP������������ID
        @param user_id   xoops_users.uid
        @param account_info ��������������������������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_get_account)
{
        long sid, uid;
        zval *zaccount;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
          &sid, &uid, &zaccount) == FAILURE) {
                fprintf( stderr, "error occured " );
                return;
        }

        const account_t *paccount;
        result_t result = getAccount( (sessionid_t)sid, (userid_t)uid, &paccount );
        if ( RES_OK == result ){
                accountToZval( paccount, zaccount );
                freeAccount( paccount );
        }

        RETURN_LONG(result);
}

/** ��������������������������������������<br>
        int xnp_get_accoutns( int sid, array uids, array criteria, array accounts );
        @param xnp_session_id   XNP������������ID
        @param user_id   xoops_users.uid
        @param criteria  ����������������������������
        @param account_info ��������������������������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_get_accounts)
{
        result_t result;
        long sid;
        zval *zuids;
        zval *zcriteria;
        zval *zaccount;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laaa",
          &sid, &zuids, &zcriteria, &zaccount) == FAILURE) {
                return;
        }

        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
                zUIDs_t zUIDs(zuids);
                result = zUIDs.getResult();
                if ( RES_OK == result ){
                        const account_t *paccounts;
                        int accountLen;
                        result = getAccounts( (sessionid_t)sid,
                                zUIDs.getPUID(), zUIDs.getLen(),
                                &zcri, &paccounts, &accountLen );
                        if ( RES_OK == result ){
                                accountsToZval( paccounts, accountLen, zaccount );
                                freeAccount( paccounts );
                        }
                }
        }

        RETURN_LONG(result);
}

/** ��������������������������<br>
        int xnp_insert_account( int sid, array account_info, int &user_id );
        @param xnp_session_id   xnp �� session id
        @param account_info ��������������������������
        @param user_id ������ID(xoops_users.uid)����������������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_insert_account)
{
        result_t result;
        long sid;
        zval *zaccount;
        zval *zuid;
        userid_t uid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
          &sid, &zaccount, &zuid) == FAILURE) {
                return;
        }

        zAccount_t zacc(zaccount);
        result = zacc.getResult();
        if ( RES_OK == result ){
                result = insertAccount( (sessionid_t)sid, &zacc, &uid );
        }
        zuid -> type = IS_LONG;
        zuid -> value.lval = uid;
        RETURN_LONG(result);
}

/** ��������������������������<br>
        int xnp_update_account( int sid, array account );
        @param xnp_session_id   XNP������������ID
        @param account_info ����������������������������������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_update_account)
{
        result_t result;
        long sid;
        zval *zaccount;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
          &sid, &zaccount) == FAILURE) {
                return;
        }

        zAccount_t zacc(zaccount);
        result = zacc.getResult();
        if ( RES_OK == result ){
                result = updateAccount( (sessionid_t)sid, &zacc );
        }

        RETURN_LONG(result);
}

/** ����������������������uid��������������<br>
        int xnp_dump_uids( int xnp_session_id, array criteria, array uids );
        @param xnp_session_id   XNP������������ID
        @param criteria  ����������������������������
        @param uids uid��������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_dump_uids)
{
        result_t result;
        long sid;
        zval *zcriteria;
        zval *zuids;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
          &sid, &zcriteria, &zuids) == FAILURE) {
                return;
        }

        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
                userid_t *puid;
                int uidLen;
                result = dumpUids( (sessionid_t)sid, &zcri, &puid, &uidLen );
                if ( RES_OK == result ){
                        uidsToZval( puid, uidLen, &zuids );
                        freeUID( puid );
                }
        }

        RETURN_LONG(result);
}

/** XNP��������������������<br>
        int xnp_get_group_count( int xnp_session_id );
        @param xnp_session_id   XNP������������ID
        @return ����������
  */
ZEND_FUNCTION(xnp_get_group_count)
{
        long sid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
          &sid) == FAILURE) {
                return;
        }

        int count = getGroupCount( (sessionid_t)sid );

        RETURN_LONG(count);
}

/** uid��������������������������������������������������������������gid������<br>
        int xnp_get_group_by_uid( int xnp_session_id, int uid, array criteria, array gids );
        @param xnp_session_id   XNP������������ID
        @param user_id   xoops_users.uid
        @param criteria  ����������������������������
        @param gids gid��������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_get_groups_by_uid)
{
        result_t result;
        long sid, uid;
        zval *zcriteria;
        zval *zgids;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
          &sid, &uid, &zcriteria, &zgids) == FAILURE) {
                return;
        }

        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
                groupid_t *pgids;
                int gidLen;
                result = getGroupsByUid( (sessionid_t)sid, (userid_t)uid, &zcri, &pgids, &gidLen );
                if ( RES_OK == result ){
                        gidsToZval( pgids, gidLen, &zgids );
                        freeGID( pgids );
                }
        }

        RETURN_LONG(result);
}


/** uid������������������gid������������������������������������������������<br>
        int xnp_is_group_admin( int sid, int gid, int uid );
        @param xnp_session_id   XNP������������ID
        @param group_id  XNP����������ID
        @param user_id   xoops_users.uid
        @return true: ����������������������
        @return false: ��������������������������������������������
  */
ZEND_FUNCTION(xnp_is_group_admin)
{
        long sid, gid, uid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
          &sid, &gid, &uid) == FAILURE) {
                return;
        }

        bool b  = isGroupAdmin( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid );

        RETURN_BOOL(b);
}

/** ������������������������gid��������������<br>
        int xnp_dump_gids( int sid, array criteria, array gids );
        @param xnp_session_id   XNP������������ID
        @param criteria  ����������������������������
        @param gids gid��������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_dump_gids)
{
        result_t result;
        long sid;
        zval *zcriteria;
        zval *zgids;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
          &sid, &zcriteria, &zgids) == FAILURE) {
                return;
        }

        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
                groupid_t *pgid;
                int gidLen;
                result = dumpGids( (sessionid_t)sid, &zcri, &pgid, &gidLen );
                if ( RES_OK == result ){
                        gidsToZval( pgid, gidLen, &zgids );
                        freeGID( pgid );
                }
        }

        RETURN_LONG(result);
}

/** gid����������������������������������������������������������������uid��������������<br>
        int xnp_dump_group_admins(int sid, int group_id, array criteria, array uids )
        @param sid      XNP������������ID
        @param group_id XNP����������ID
        @param criteria ����
        @param uids     uid��������������������
        @return 0 success
  */

ZEND_FUNCTION(xnp_dump_group_admins)
{
        long sid, gid;
        zval *zcriteria;
        zval *zuids;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
                                                          &sid, &gid, &zcriteria, &zuids) == FAILURE) {
                return;
        }

        zCriteria_t zcri(zcriteria);
        result_t result = zcri.getResult();
        if ( result == RES_OK ){
                userid_t *uids;
                int uidsLen;
                result = dumpGroupAdmins( sid, gid, &zcri, &uids, &uidsLen );
                if ( result == RES_OK ){
                        uidsToZval( uids, uidsLen, &zuids );
                        freeUID( uids );
                }
        }
        RETURN_LONG( result );
}

/** ��������������������������������<br>
        int xnp_delete_member(int sid, int group_id, int user_id )
        @param sid      XNP������������ID
        @param group_id XNP����������ID
        @param user_id  ������ID
        @return 0 success
  */

ZEND_FUNCTION(xnp_delete_member)
{
        long sid, gid, uid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
                                                          &sid, &gid, &uid) == FAILURE) {
                return;
        }

        result_t result = deleteMember( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid );
        RETURN_LONG( result );
}

/** ����������������������������<br>
        int xnp_insert_member(int sid, int group_id, int user_id, bool admin )
        @param sid      XNP������������ID
        @param group_id XNP����������ID
        @param user_id  ������ID
        @param admin    ������������������true
        @return 0 success
  */

ZEND_FUNCTION(xnp_insert_member)
{
        long sid, gid, uid;
        zend_bool admin;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllb",
                                                          &sid, &gid, &uid, &admin) == FAILURE) {
                return;
        }

        result_t result = insertMember( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid, (bool)admin );
        RETURN_LONG( result );
}

/** gid������������������������������uid������������<br>
        int xnp_get_members(int sid, int group_id, array criteria, array uids )
        @param sid      XNP������������ID
        @param group_id XNP����������ID
        @param criteria ����
        @param uids     uid��������������������
        @return 0 success
  */

ZEND_FUNCTION(xnp_get_members)
{
        long sid, gid;
        zval *zcriteria;
        zval *zuids;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
                                                          &sid, &gid, &zcriteria, &zuids) == FAILURE) {
                return;
        }

        zCriteria_t zcri(zcriteria);
        result_t result = zcri.getResult();
        if ( result == RES_OK ){
                userid_t *uids;
                int uidsLen;
                result = getMembers( (sessionid_t)sid, (groupid_t)gid, &zcri, &uids, &uidsLen );
                if ( result == RES_OK ){
                        uidsToZval( uids, uidsLen, &zuids );
                        freeUID( uids );
                }
        }
        RETURN_LONG( result );
}

/** ������������������������<br>
        int xnp_update_group(int sid, array group )
        @param sid      XNP������������ID
        @param group    ����������������������
        @return 0 success
  */
ZEND_FUNCTION(xnp_update_group)
{
        long sid;
        zval *zgroup;
        group_t group;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
                                                          &sid, &zgroup) == FAILURE) {
                return;
        }

        zvalToGroup( zgroup, &group );
        result_t result = updateGroup( sid, &group );
        RETURN_LONG( result );
}

/** ������������������������<br>
        int xnp_insert_group( int sid, array group, int &gid )
        @param sid      ����������ID
        @param group    ����������������������
        @param gid      ����������������ID����������������������
        @return RES_OK
        @return RES_DB_NOT_INITIALIZED
        @return RES_NO_SUCH_SESSION
        @return RES_DB_QUERY_ERROR
*/
ZEND_FUNCTION(xnp_insert_group)
{
        long sid;
        zval *zgroup;
        zval *zgid;
        group_t group;
        groupid_t gid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
                                                          &sid, &zgroup, &zgid ) == FAILURE) {
                return;
        }

        zvalToGroup( zgroup, &group );
        result_t result = insertGroup( sid, &group, &gid );
        zgid -> type = IS_LONG;
        zgid -> value.lval = gid;
        RETURN_LONG( result );
}


/** ������������������������<br>
        int xnp_delete_group( int sid, int gid )
        @param sid      XNP������������ID
        @param gid      ��������������������ID
        @return RES_OK
        @return RES_DB_QUERY_ERROR
        @return RES_NO_SUCH_SESSION
        @return RES_DB_NOT_INITIALIZED
  */
ZEND_FUNCTION(xnp_delete_group)
{
        long sid;
        long gid;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
                                                          &sid, &gid) == FAILURE) {
                return;
        }
        RETURN_LONG( deleteGroup( sid, gid ) );
}

/** ������������������������<br>
        int xnp_dump_group_admins( int sid, int gid, array criteria, array uids )
        @param sid      XNP������������ID
        @param gid      XNP����������ID
        @param criteria uids��������������������������������������
        @param uids     ��������UID��������������
        @return RES_OK
        @return RES_DB_QUERY_ERROR
        @return RES_NO_SUCH_SESSION
        @return RES_DB_NOT_INITIALIZED
  */
/*
ZEND_FUNCTION(xnp_dump_group_admins)
{
        long sid;
        long gid;
        zval *zcriteria;
        zval *zuids;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
                                                          &sid, &gid, &zcriteria, &zuids) == FAILURE) {
                return;
        }
        zCriteria_t zcri(zcriteria);
        result_t result = zcri.getResult();
        if ( RES_OK == result ){
                userid_t* uids;
                int uidsLen;
                result_t result = dumpGroupAdmins( sid, gid, &zcri, &uids, &uidsLen );
                if( result != RES_OK ) RETURN_LONG( result );
                uidsToZval( uids, uidsLen, &zuids );
                fprintf( stderr, "uidsLen=%d\n", uidsLen );
                for( int i = 0; i < uidsLen; i++ ){
                        fprintf( stderr, "%d, \n", uids[ i ] );
                }
                freeUID( uids );
                RETURN_LONG( result );
        }
        RETURN_LONG( result );
}
*/

/** ������������������������<br>
 *   int xnp_get_all_indexes( int sid, array criteria, array indexes );
 * @param sid XNP������������ID
 * @param cri ������������������������������
 * @return RES_OK
 */
ZEND_FUNCTION(xnp_get_all_indexes)
{
        long sid;
        zval *zcriteria;
        zval *zindexes;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
                                                          &sid, &zcriteria, &zindexes) == FAILURE) {
                return;
        }
        zCriteria_t zcri(zcriteria);
        result_t result = zcri.getResult();
        if ( RES_OK == result ){
                const index_t *indexes;
                int indexesLen;
                result = getAllIndexes( sid, &zcri, &indexes, &indexesLen );
                if ( RES_OK == result ){
                        result = indexesToZval( indexes, indexesLen, zindexes );
                        freeIndex( indexes );
                }
        }
        RETURN_LONG(result);
}

/** ��������������������������������������������<br>
 *   int xnp_get_indexes( int sid, int parentXID, array criteria, array indexes );
 * @param sid XNP������������ID
 * @param parentXID ����indexID
 * @param cri ������������������������������
 * @param indexes ������������������
 * @return RES_OK
 */
ZEND_FUNCTION(xnp_get_indexes)
{
        long sid;
        long parentXID;
        zval *zcriteria;
        zval *zindexes;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
                                                          &sid, &parentXID, &zcriteria, &zindexes) == FAILURE) {
                return;
        }
        zCriteria_t zcri(zcriteria);
        result_t result = zcri.getResult();
        if ( RES_OK == result ){
                const index_t *indexes;
                int indexesLen;
                result = 