/** * Listen for uncaught exceptions * * @return Phalcon\Debug */ PHP_METHOD(Phalcon_Debug, listenExceptions){ zval *handler; PHALCON_MM_GROW(); PHALCON_INIT_VAR(handler); array_init_size(handler, 2); phalcon_array_append(&handler, this_ptr, PH_COPY); phalcon_array_append_string(&handler, SL("onUncaughtException"), PH_COPY); PHALCON_CALL_FUNCTION(NULL, "set_exception_handler", handler); RETURN_THIS(); }
int phalcon_proc_parse_cmdline(phalcon_process *proc, unsigned int pid) { char path[256]; int fd; char buf[1024]; unsigned int buflen, i, argc; char *c; sprintf(path, "/proc/%i/cmdline", pid); fd = open(path, O_RDONLY); buflen = read(fd, buf, sizeof(buf)); if(buflen == 0) { return 0; } proc->has_commandline = 1; /* cmdline is not null terminated if there are no command line arguments. */ if (buf[buflen-1] != '\0') { buf[buflen++] = '\0'; } /* figure out argc */ argc=0; for (i=0; i < buflen; i++) { if (buf[i] == '\0'){ argc++; } c++; } /* One for each pointer plus null */ array_init_size(&(proc->args), argc); /* And the char arrays */ c = buf; for (i=0; i < argc; i++) { phalcon_array_append_string(&(proc->args), c, strlen(c)+1, 0); while (*c != '\0'){ c++; } c++; } close(fd); return 0; }
/** * Handles routing information received from command-line arguments * * @param array $arguments */ PHP_METHOD(Phalcon_CLI_Router, handle){ zval *arguments = NULL, longopts = {}, options = {}, module_name = {}, namespace_name = {}, task_name = {}, action_name = {}; phalcon_fetch_params(0, 0, 1, &arguments); if (!arguments || Z_TYPE_P(arguments) != IS_ARRAY) { if (unlikely(!strcmp(sapi_module.name, "cli"))) { array_init(&longopts); phalcon_array_append_string(&longopts, SL("module::"), 0); phalcon_array_append_string(&longopts, SL("namespace::"), 0); phalcon_array_append_string(&longopts, SL("task::"), 0); phalcon_array_append_string(&longopts, SL("action::"), 0); phalcon_array_append_string(&longopts, SL("params::"), 0); PHALCON_CALL_FUNCTIONW(&options, "getopt", &PHALCON_GLOBAL(z_null), &longopts); } else { array_init(&options); } } else { PHALCON_CPY_WRT_CTOR(&options, arguments); } /** * Check for a module */ if (phalcon_array_isset_fetch_str(&module_name, &options, SL("module"))) { phalcon_array_unset_str(arguments, SL("module"), PH_COPY); } else { ZVAL_NULL(&module_name); } phalcon_update_property_zval(getThis(), SL("_module"), &module_name); /** * Check for a namespace */ if (phalcon_array_isset_fetch_str(&namespace_name, &options, SL("namespace"))) { phalcon_array_unset_str(arguments, SL("namespace"), PH_COPY); } else { ZVAL_NULL(&namespace_name); } phalcon_update_property_zval(getThis(), SL("_namespace"), &namespace_name); /** * Check for a task */ if (phalcon_array_isset_fetch_str(&task_name, &options, SL("task"))) { phalcon_array_unset_str(arguments, SL("task"), PH_COPY); } else { ZVAL_NULL(&task_name); } phalcon_update_property_zval(getThis(), SL("_task"), &task_name); /** * Check for an action */ if (phalcon_array_isset_fetch_str(&action_name, &options, SL("action"))) { phalcon_array_unset_str(arguments, SL("action"), PH_COPY); } else { ZVAL_NULL(&action_name); } phalcon_update_property_zval(getThis(), SL("_action"), &action_name); phalcon_update_property_zval(getThis(), SL("_params"), &options); }
/** * Inserts data into a table using custom RBDM SQL syntax * * @param string $table * @param array $values * @param array $fields * @return boolean */ PHP_METHOD(Phalcon_Db, insert){ zval *table = NULL, *values = NULL, *fields = NULL, *number_values = NULL, *exception_message = NULL; zval *exception = NULL, *placeholders = NULL, *value = NULL, *position = NULL; zval *str_value = NULL, *comma = NULL, *joined_values = NULL, *joined_fields = NULL; zval *insert_sql = NULL, *success = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table, &values, &fields) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_SEPARATE_PARAM(values); if (!fields) { PHALCON_ALLOC_ZVAL_MM(fields); ZVAL_NULL(fields); } if (Z_TYPE_P(values) == IS_ARRAY) { PHALCON_INIT_VAR(number_values); phalcon_fast_count(number_values, values TSRMLS_CC); if (phalcon_compare_strict_long(number_values, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Unable to insert into ", table, " without data"); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_db_exception_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; } PHALCON_INIT_VAR(placeholders); array_init(placeholders); if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ALLOC_HASHTABLE(ah0); zend_hash_init(ah0, 0, NULL, NULL, 0); zend_hash_copy(ah0, Z_ARRVAL_P(values), NULL, NULL, sizeof(zval*)); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto ph_cycle_end_0; } PHALCON_INIT_VAR(position); PHALCON_GET_FOREACH_KEY(position, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_VAR(str_value); PHALCON_CALL_FUNC_PARAMS_1(str_value, "strval", value); phalcon_array_append(&placeholders, str_value, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, position); } else { if (Z_TYPE_P(value) == IS_NULL) { phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, position); } else { phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC); } } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: zend_hash_destroy(ah0); efree(ah0); PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ", ", 1); PHALCON_INIT_VAR(joined_values); phalcon_fast_join(joined_values, comma, placeholders TSRMLS_CC); if (Z_TYPE_P(fields) == IS_ARRAY) { PHALCON_INIT_VAR(joined_fields); phalcon_fast_join(joined_fields, comma, fields TSRMLS_CC); PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVSVS(insert_sql, "INSERT INTO ", table, " (", joined_fields, ") VALUES (", joined_values, ")"); } else { PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVS(insert_sql, "INSERT INTO ", table, " VALUES (", joined_values, ")"); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_2(success, this_ptr, "execute", insert_sql, values, PH_NO_CHECK); RETURN_CCTOR(success); } PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array"); return; }
/** * Inserts data into a table using custom RBDM SQL syntax * * @param string $table * @param array $values * @param array $fields * @return boolean */ PHP_METHOD(Phalcon_Db, insert){ zval *table = NULL, *values = NULL, *fields = NULL, *placeholders = NULL, *value = NULL; zval *n = NULL, *comma = NULL, *joined_values = NULL, *insert_sql = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *i0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table, &values, &fields) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_SEPARATE_PARAM(values); if (!fields) { PHALCON_ALLOC_ZVAL_MM(fields); ZVAL_NULL(fields); } if (Z_TYPE_P(values) == IS_ARRAY) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_fast_count(r0, values TSRMLS_CC); if (!zend_is_true(r0)) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_db_exception_ce); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, "Unable to insert into ", table, " without data"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r1, PH_CHECK); phalcon_throw_exception(i0 TSRMLS_CC); return; } PHALCON_INIT_VAR(placeholders); array_init(placeholders); if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ALLOC_HASHTABLE(ah0); zend_hash_init(ah0, 0, NULL, NULL, 0); zend_hash_copy(ah0, Z_ARRVAL_P(values), NULL, NULL, sizeof(zval*)); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_e7f0_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_e7f0_1; } PHALCON_INIT_VAR(n); PHALCON_GET_FOREACH_KEY(n, ah0, hp0); PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_VAR(r2); PHALCON_CALL_FUNC_PARAMS_1(r2, "strval", value); phalcon_array_append(&placeholders, r2, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, n); } else { phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_e7f0_1; fee_e7f0_1: zend_hash_destroy(ah0); efree(ah0); PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ", ", 1); PHALCON_INIT_VAR(joined_values); phalcon_fast_join(joined_values, comma, placeholders TSRMLS_CC); if (Z_TYPE_P(fields) == IS_ARRAY) { PHALCON_ALLOC_ZVAL_MM(r3); phalcon_fast_join(r3, comma, fields TSRMLS_CC); PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVSVS(insert_sql, "INSERT INTO ", table, " (", r3, ") VALUES (", joined_values, ")"); } else { PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVS(insert_sql, "INSERT INTO ", table, " VALUES (", joined_values, ")"); } PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_METHOD_PARAMS_2(r4, this_ptr, "execute", insert_sql, values, PH_NO_CHECK); RETURN_CTOR(r4); } PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array"); return; }
/** * Constructor for Phalcon\Session\Adapter\Memcache * * @param array $options */ PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct){ zval *options, host = {}, port = {}, lifetime = {}, persistent = {}, prefix = {}; zval frontend_option = {}, backend_option = {}, frontend_data = {}, memcache = {}; zval callable_open = {}, callable_close = {}, callable_read = {}, callable_write = {}, callable_destroy = {}, callable_gc = {}; phalcon_fetch_params(0, 1, 0, &options); if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STRW(phalcon_session_exception_ce, "The options must be an array"); return; } if (!phalcon_array_isset_fetch_str(&host, options, SL("host"))) { PHALCON_THROW_EXCEPTION_STRW(phalcon_session_exception_ce, "No session host given in options"); return; } if (!phalcon_array_isset_fetch_str(&port, options, SL("port"))) { ZVAL_LONG(&port, 11211); } if (!phalcon_array_isset_fetch_str(&lifetime, options, SL("lifetime"))) { ZVAL_LONG(&lifetime, 8600); } else { phalcon_update_property_this(getThis(), SL("_lifetime"), &lifetime); } if (!phalcon_array_isset_fetch_str(&persistent, options, SL("persistent"))) { ZVAL_FALSE(&persistent); } if (!phalcon_array_isset_fetch_str(&prefix, options, SL("prefix"))) { ZVAL_EMPTY_STRING(&prefix); } /* create memcache instance */ array_init_size(&frontend_option, 1); phalcon_array_update_str(&frontend_option, SL("lifetime"), &lifetime, PH_COPY); object_init_ex(&frontend_data, phalcon_cache_frontend_data_ce); PHALCON_CALL_METHODW(NULL, &frontend_data, "__construct", &frontend_option); array_init_size(&backend_option, 3); phalcon_array_update_str(&backend_option, SL("host"), &host, PH_COPY); phalcon_array_update_str(&backend_option, SL("port"), &port, PH_COPY); phalcon_array_update_str(&backend_option, SL("persistent"), &persistent, PH_COPY); phalcon_array_update_str(&backend_option, SL("prefix"), &prefix, PH_COPY); object_init_ex(&memcache, phalcon_cache_backend_memcache_ce); PHALCON_CALL_METHODW(NULL, &memcache, "__construct", &frontend_data, &backend_option); phalcon_update_property_this(getThis(), SL("_memcache"), &memcache); /* open callback */ array_init_size(&callable_open, 2); phalcon_array_append(&callable_open, getThis(), 0); phalcon_array_append_string(&callable_open, SL("open"), 0); /* close callback */ array_init_size(&callable_close, 2); phalcon_array_append(&callable_close, getThis(), 0); phalcon_array_append_string(&callable_close, SL("close"), 0); /* read callback */ array_init_size(&callable_read, 2); phalcon_array_append(&callable_read, getThis(), 0); phalcon_array_append_string(&callable_read, SL("read"), 0); /* write callback */ array_init_size(&callable_write, 2); phalcon_array_append(&callable_write, getThis(), 0); phalcon_array_append_string(&callable_write, SL("write"), 0); /* destroy callback */ array_init_size(&callable_destroy, 2); phalcon_array_append(&callable_destroy, getThis(), 0); phalcon_array_append_string(&callable_destroy, SL("destroy"), 0); /* gc callback */ array_init_size(&callable_gc, 2); phalcon_array_append(&callable_gc, getThis(), 0); phalcon_array_append_string(&callable_gc, SL("gc"), 0); PHALCON_CALL_FUNCTIONW(NULL, "session_set_save_handler", &callable_open, &callable_close, &callable_read, &callable_write, &callable_destroy, &callable_gc); PHALCON_CALL_PARENTW(NULL, phalcon_session_adapter_memcache_ce, getThis(), "__construct", options); }
/** * Inserts data into a table using custom RBDM SQL syntax * * <code> * //Inserting a new robot * $success = $connection->insert( * "robots", * array("Astro Boy", 1952), * array("name", "year") * ); * * //Next SQL sentence is sent to the database system * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952); * </code> * * @param string $table * @param array $values * @param array $fields * @param array $dataTypes * @return boolean */ PHP_METHOD(Phalcon_Db, insert){ zval *table, *values, *fields = NULL, *data_types = NULL, *exception_message; zval *placeholders, *insert_values, *bind_data_types = NULL; zval *value = NULL, *position = NULL, *str_value = NULL, *bind_type = NULL; zval *joined_values, *joined_fields, *insert_sql = NULL; zval *success; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &table, &values, &fields, &data_types) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!fields) { PHALCON_INIT_NVAR(fields); } if (!data_types) { PHALCON_INIT_NVAR(data_types); } if (Z_TYPE_P(values) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array"); return; } if (!phalcon_fast_count_ev(values TSRMLS_CC)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Unable to insert into ", table, " without data"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_db_exception_ce, exception_message); return; } PHALCON_INIT_VAR(placeholders); array_init(placeholders); PHALCON_INIT_VAR(insert_values); array_init(insert_values); if (Z_TYPE_P(data_types) == IS_ARRAY) { PHALCON_INIT_VAR(bind_data_types); array_init(bind_data_types); } else { PHALCON_CPY_WRT(bind_data_types, data_types); } if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(values); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_KEY(position, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_NVAR(str_value); PHALCON_CALL_FUNC_PARAMS_1(str_value, "strval", value); phalcon_array_append(&placeholders, str_value, PH_SEPARATE TSRMLS_CC); } else { if (Z_TYPE_P(value) == IS_NULL) { phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC); } else { phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC); phalcon_array_append(&insert_values, value, PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(data_types) == IS_ARRAY) { eval_int = phalcon_array_isset(data_types, position); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Incomplete number of bind types"); return; } PHALCON_INIT_NVAR(bind_type); phalcon_array_fetch(&bind_type, data_types, position, PH_NOISY_CC); phalcon_array_append(&bind_data_types, bind_type, PH_SEPARATE TSRMLS_CC); } } } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_VAR(joined_values); phalcon_fast_join_str(joined_values, SL(", "), placeholders TSRMLS_CC); if (Z_TYPE_P(fields) == IS_ARRAY) { PHALCON_INIT_VAR(joined_fields); phalcon_fast_join_str(joined_fields, SL(", "), fields TSRMLS_CC); PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVSVS(insert_sql, "INSERT INTO ", table, " (", joined_fields, ") VALUES (", joined_values, ")"); } else { PHALCON_INIT_NVAR(insert_sql); PHALCON_CONCAT_SVSVS(insert_sql, "INSERT INTO ", table, " VALUES (", joined_values, ")"); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_3(success, this_ptr, "execute", insert_sql, insert_values, bind_data_types, PH_NO_CHECK); RETURN_CCTOR(success); }
/** * Constructor for Phalcon\Session\Adapter\Memcache * * @param array $options */ PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct){ zval *options; zval *host, *port, *lifetime, *persistent, *prefix; zval *frontend_data, *memcache, *option; zval *callable_open , *callable_close , *callable_read , *callable_write , *callable_destroy , *callable_gc; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &options); if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "The options must be an array"); return; } if (!phalcon_array_isset_string_fetch(&host, options, SS("host"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "No session host given in options"); return; } if (!phalcon_array_isset_string_fetch(&port, options, SS("port"))) { PHALCON_INIT_VAR(port); ZVAL_LONG(port, 11211); } if (!phalcon_array_isset_string_fetch(&lifetime, options, SS("lifetime"))) { PHALCON_INIT_VAR(lifetime); ZVAL_LONG(lifetime, 8600); } phalcon_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC); if (!phalcon_array_isset_string_fetch(&persistent, options, SS("persistent"))) { PHALCON_INIT_VAR(persistent); ZVAL_FALSE(persistent); } if (!phalcon_array_isset_string_fetch(&prefix, options, SS("prefix"))) { PHALCON_INIT_VAR(prefix); ZVAL_EMPTY_STRING(prefix); } /* create memcache instance */ PHALCON_INIT_VAR(option); array_init_size(option, 1); phalcon_array_update_string(&option, SL("lifetime"), lifetime, PH_COPY); PHALCON_INIT_VAR(frontend_data); object_init_ex(frontend_data, phalcon_cache_frontend_data_ce); PHALCON_CALL_METHOD(NULL, frontend_data, "__construct", option); PHALCON_INIT_NVAR(option); array_init_size(option, 3); phalcon_array_update_string(&option, SL("host"), host, PH_COPY); phalcon_array_update_string(&option, SL("port"), port, PH_COPY); phalcon_array_update_string(&option, SL("persistent"), persistent, PH_COPY); phalcon_array_update_string(&option, SL("prefix"), prefix, PH_COPY); PHALCON_INIT_VAR(memcache); object_init_ex(memcache, phalcon_cache_backend_memcache_ce); PHALCON_CALL_METHOD(NULL, memcache, "__construct", frontend_data, option); phalcon_update_property_this(this_ptr, SL("_memcache"), memcache TSRMLS_CC); /* open callback */ PHALCON_INIT_VAR(callable_open); array_init_size(callable_open, 2); phalcon_array_append(&callable_open, this_ptr, PH_COPY); phalcon_array_append_string(&callable_open, SL("open"), 0); /* close callback */ PHALCON_INIT_VAR(callable_close); array_init_size(callable_close, 2); phalcon_array_append(&callable_close, this_ptr, PH_COPY); phalcon_array_append_string(&callable_close, SL("close"), 0); /* read callback */ PHALCON_INIT_VAR(callable_read); array_init_size(callable_read, 2); phalcon_array_append(&callable_read, this_ptr, PH_COPY); phalcon_array_append_string(&callable_read, SL("read"), 0); /* write callback */ PHALCON_INIT_VAR(callable_write); array_init_size(callable_write, 2); phalcon_array_append(&callable_write, this_ptr, PH_COPY); phalcon_array_append_string(&callable_write, SL("write"), 0); /* destroy callback */ PHALCON_INIT_VAR(callable_destroy); array_init_size(callable_destroy, 2); phalcon_array_append(&callable_destroy, this_ptr, PH_COPY); phalcon_array_append_string(&callable_destroy, SL("destroy"), 0); /* gc callback */ PHALCON_INIT_VAR(callable_gc); array_init_size(callable_gc, 2); phalcon_array_append(&callable_gc, this_ptr, PH_COPY); phalcon_array_append_string(&callable_gc, SL("gc"), 0); PHALCON_CALL_FUNCTION(NULL, "session_set_save_handler", callable_open, callable_close, callable_read, callable_write, callable_destroy, callable_gc); PHALCON_CALL_PARENT(NULL, phalcon_session_adapter_memcache_ce, this_ptr, "__construct", options); PHALCON_MM_RESTORE(); }