static PHP_GINIT_FUNCTION(sqlite3);
static int php_sqlite3_authorizer(void *autharg, int access_type, const char *arg3, const char *arg4, const char *arg5, const char *arg6);
-static void sqlite3_param_dtor(void *data);
+static void sqlite3_param_dtor(zval *data);
static int php_sqlite3_compare_stmt_zval_free(php_sqlite3_free_list **free_list, zval *statement);
/* {{{ Error Handler
long flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
zend_error_handling error_handling;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|ls", &filename, &filename_len, &flags, &encryption_key, &encryption_key_len)) {
php_sqlite3_db_object *db_obj;
zval *object = getThis();
int errcode;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
zval *object = getThis();
char *sql, *errtext = NULL;
int sql_len;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
{
php_sqlite3_db_object *db_obj;
zval *object = getThis();
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
{
php_sqlite3_db_object *db_obj;
zval *object = getThis();
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->db, SQLite3)
{
php_sqlite3_db_object *db_obj;
zval *object = getThis();
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->db, SQLite3)
return;
}
- RETVAL_STRING((char *)sqlite3_errmsg(db_obj->db), 1);
+ RETVAL_STRING((char *)sqlite3_errmsg(db_obj->db));
}
/* }}} */
zval *object = getThis();
long ms;
int return_code;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
char *extension, *lib_path, *extension_dir, *errtext = NULL;
char fullpath[MAXPATHLEN];
int extension_len, extension_dir_len;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
{
php_sqlite3_db_object *db_obj;
zval *object = getThis();
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
if (sql_len) {
ret = sqlite3_mprintf("%q", sql);
if (ret) {
- RETVAL_STRING(ret, 1);
+ RETVAL_STRING(ret);
sqlite3_free(ret);
}
} else {
int sql_len, errcode;
php_sqlite3_free_list *free_item;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
}
object_init_ex(return_value, php_sqlite3_stmt_entry);
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(return_value TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(return_value);
stmt_obj->db_obj = db_obj;
- stmt_obj->db_obj_zval = getThis();
-
- Z_ADDREF_P(object);
+ ZVAL_COPY(&stmt_obj->db_obj_zval, object);
errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
if (errcode != SQLITE_OK) {
free_item = emalloc(sizeof(php_sqlite3_free_list));
free_item->stmt_obj = stmt_obj;
- free_item->stmt_obj_zval = return_value;
+ ZVAL_COPY_VALUE(&free_item->stmt_obj_zval, return_value);
zend_llist_add_element(&(db_obj->free_list), &free_item);
}
php_sqlite3_result *result;
php_sqlite3_stmt *stmt_obj;
zval *object = getThis();
- zval *stmt = NULL;
+ zval stmt;
char *sql, *errtext = NULL;
int sql_len, return_code;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
}
/* If there was no return value then just execute the query */
- if (!return_value_used) {
+ if (!USED_RET()) {
if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
php_sqlite3_error(db_obj, "%s", errtext);
sqlite3_free(errtext);
return;
}
- MAKE_STD_ZVAL(stmt);
-
- object_init_ex(stmt, php_sqlite3_stmt_entry);
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(stmt TSRMLS_CC);
+ object_init_ex(&stmt, php_sqlite3_stmt_entry);
+ stmt_obj = Z_SQLITE3_STMT_P(&stmt);
stmt_obj->db_obj = db_obj;
- stmt_obj->db_obj_zval = getThis();
-
- Z_ADDREF_P(object);
+ ZVAL_COPY(&stmt_obj->db_obj_zval, object);
return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
if (return_code != SQLITE_OK) {
stmt_obj->initialised = 1;
object_init_ex(return_value, php_sqlite3_result_entry);
- result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC);
+ result = Z_SQLITE3_RESULT_P(return_value TSRMLS_CC);
result->db_obj = db_obj;
result->stmt_obj = stmt_obj;
- result->stmt_obj_zval = stmt;
+ ZVAL_COPY_VALUE(&result->stmt_obj_zval, &stmt);
return_code = sqlite3_step(result->stmt_obj->stmt);
}
/* }}} */
-static zval* sqlite_value_to_zval(sqlite3_stmt *stmt, int column) /* {{{ */
+static void sqlite_value_to_zval(sqlite3_stmt *stmt, int column, zval *data) /* {{{ */
{
- zval *data;
- MAKE_STD_ZVAL(data);
switch (sqlite3_column_type(stmt, column)) {
case SQLITE_INTEGER:
if ((sqlite3_column_int64(stmt, column)) >= INT_MAX || sqlite3_column_int64(stmt, column) <= INT_MIN) {
- ZVAL_STRINGL(data, (char *)sqlite3_column_text(stmt, column), sqlite3_column_bytes(stmt, column), 1);
+ ZVAL_STRINGL(data, (char *)sqlite3_column_text(stmt, column), sqlite3_column_bytes(stmt, column));
} else {
ZVAL_LONG(data, sqlite3_column_int64(stmt, column));
}
break;
case SQLITE3_TEXT:
- ZVAL_STRING(data, (char*)sqlite3_column_text(stmt, column), 1);
+ ZVAL_STRING(data, (char*)sqlite3_column_text(stmt, column));
break;
case SQLITE_BLOB:
default:
- ZVAL_STRINGL(data, (char*)sqlite3_column_blob(stmt, column), sqlite3_column_bytes(stmt, column), 1);
+ ZVAL_STRINGL(data, (char*)sqlite3_column_blob(stmt, column), sqlite3_column_bytes(stmt, column));
}
- return data;
}
/* }}} */
int sql_len, return_code;
zend_bool entire_row = 0;
sqlite3_stmt *stmt;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
}
/* If there was no return value then just execute the query */
- if (!return_value_used) {
+ if (!USED_RET()) {
if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
php_sqlite3_error(db_obj, "%s", errtext);
sqlite3_free(errtext);
case SQLITE_ROW: /* Valid Row */
{
if (!entire_row) {
- zval *data;
- data = sqlite_value_to_zval(stmt, 0);
- *return_value = *data;
- zval_copy_ctor(return_value);
- zval_dtor(data);
- FREE_ZVAL(data);
+ sqlite_value_to_zval(stmt, 0, return_value);
} else {
int i = 0;
array_init(return_value);
for (i = 0; i < sqlite3_data_count(stmt); i++) {
- zval *data;
- data = sqlite_value_to_zval(stmt, i);
- add_assoc_zval(return_value, (char*)sqlite3_column_name(stmt, i), data);
+ zval data;
+ sqlite_value_to_zval(stmt, i, &data);
+ add_assoc_zval(return_value, (char*)sqlite3_column_name(stmt, i), &data);
}
}
break;
static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, int argc, sqlite3_value **argv, sqlite3_context *context, int is_agg TSRMLS_DC) /* {{{ */
{
- zval ***zargs = NULL;
- zval *retval = NULL;
+ zval *zargs = NULL;
+ zval retval;
int i;
int ret;
int fake_argc;
fc->fci.size = sizeof(fc->fci);
fc->fci.function_table = EG(function_table);
- fc->fci.function_name = cb;
+ ZVAL_COPY_VALUE(&fc->fci.function_name, cb);
fc->fci.symbol_table = NULL;
- fc->fci.object_ptr = NULL;
- fc->fci.retval_ptr_ptr = &retval;
+ fc->fci.object = NULL;
+ fc->fci.retval = &retval;
fc->fci.param_count = fake_argc;
/* build up the params */
if (fake_argc) {
- zargs = (zval ***)safe_emalloc(fake_argc, sizeof(zval **), 0);
+ zargs = (zval *)safe_emalloc(fake_argc, sizeof(zval), 0);
}
if (is_agg) {
/* summon the aggregation context */
agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context(context, sizeof(php_sqlite3_agg_context));
- if (!agg_context->zval_context) {
- MAKE_STD_ZVAL(agg_context->zval_context);
- ZVAL_NULL(agg_context->zval_context);
+ if (ZVAL_IS_UNDEF(&agg_context->zval_context)) {
+ ZVAL_NULL(&agg_context->zval_context);
}
- zargs[0] = &agg_context->zval_context;
-
- zargs[1] = emalloc(sizeof(zval*));
- MAKE_STD_ZVAL(*zargs[1]);
- ZVAL_LONG(*zargs[1], agg_context->row_count);
+ ZVAL_COPY_VALUE(&zargs[0], &agg_context->zval_context);
+ ZVAL_LONG(&zargs[1], agg_context->row_count);
}
for (i = 0; i < argc; i++) {
- zargs[i + is_agg] = emalloc(sizeof(zval *));
- MAKE_STD_ZVAL(*zargs[i + is_agg]);
-
switch (sqlite3_value_type(argv[i])) {
case SQLITE_INTEGER:
#if LONG_MAX > 2147483647
- ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int64(argv[i]));
+ ZVAL_LONG(&zargs[i + is_agg], sqlite3_value_int64(argv[i]));
#else
- ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int(argv[i]));
+ ZVAL_LONG(&zargs[i + is_agg], sqlite3_value_int(argv[i]));
#endif
break;
case SQLITE_FLOAT:
- ZVAL_DOUBLE(*zargs[i + is_agg], sqlite3_value_double(argv[i]));
+ ZVAL_DOUBLE(&zargs[i + is_agg], sqlite3_value_double(argv[i]));
break;
case SQLITE_NULL:
- ZVAL_NULL(*zargs[i + is_agg]);
+ ZVAL_NULL(&zargs[i + is_agg]);
break;
case SQLITE_BLOB:
case SQLITE3_TEXT:
default:
- ZVAL_STRINGL(*zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]), 1);
+ ZVAL_STRINGL(&zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]));
break;
}
}
/* clean up the params */
if (fake_argc) {
for (i = is_agg; i < argc + is_agg; i++) {
- zval_ptr_dtor(zargs[i]);
- efree(zargs[i]);
+ zval_ptr_dtor(&zargs[i]);
}
if (is_agg) {
- zval_ptr_dtor(zargs[1]);
- efree(zargs[1]);
+ zval_ptr_dtor(&zargs[1]);
}
efree(zargs);
}
if (!is_agg || !argv) {
/* only set the sqlite return value if we are a scalar function,
* or if we are finalizing an aggregate */
- if (retval) {
- switch (Z_TYPE_P(retval)) {
+ if (!ZVAL_IS_UNDEF(&retval)) {
+ switch (Z_TYPE(retval)) {
case IS_LONG:
#if LONG_MAX > 2147483647
- sqlite3_result_int64(context, Z_LVAL_P(retval));
+ sqlite3_result_int64(context, Z_LVAL(retval));
#else
- sqlite3_result_int(context, Z_LVAL_P(retval));
+ sqlite3_result_int(context, Z_LVAL(retval));
#endif
break;
break;
case IS_DOUBLE:
- sqlite3_result_double(context, Z_DVAL_P(retval));
+ sqlite3_result_double(context, Z_DVAL(retval));
break;
default:
convert_to_string_ex(&retval);
- sqlite3_result_text(context, Z_STRVAL_P(retval), Z_STRLEN_P(retval), SQLITE_TRANSIENT);
+ sqlite3_result_text(context, Z_STRVAL(retval), Z_STRLEN(retval), SQLITE_TRANSIENT);
break;
}
} else {
sqlite3_result_error(context, "failed to invoke callback", 0);
}
- if (agg_context && agg_context->zval_context) {
+ if (agg_context && !ZVAL_IS_UNDEF(&agg_context->zval_context)) {
zval_ptr_dtor(&agg_context->zval_context);
}
} else {
/* we're stepping in an aggregate; the return value goes into
* the context */
- if (agg_context && agg_context->zval_context) {
+ if (agg_context && !ZVAL_IS_UNDEF(&agg_context->zval_context)) {
zval_ptr_dtor(&agg_context->zval_context);
}
- if (retval) {
- agg_context->zval_context = retval;
- retval = NULL;
- } else {
- agg_context->zval_context = NULL;
- }
+ ZVAL_COPY_VALUE(&agg_context->zval_context, &retval);
+ ZVAL_UNDEF(&retval);
}
- if (retval) {
+ if (!ZVAL_IS_UNDEF(&retval)) {
zval_ptr_dtor(&retval);
}
return ret;
php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context);
TSRMLS_FETCH();
- sqlite3_do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC);
+ sqlite3_do_callback(&func->afunc, &func->func, argc, argv, context, 0 TSRMLS_CC);
}
/* }}}*/
TSRMLS_FETCH();
agg_context->row_count++;
- sqlite3_do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC);
+ sqlite3_do_callback(&func->astep, &func->step, argc, argv, context, 1 TSRMLS_CC);
}
/* }}} */
TSRMLS_FETCH();
agg_context->row_count = 0;
- sqlite3_do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC);
+ sqlite3_do_callback(&func->afini, &func->fini, 0, NULL, context, 1 TSRMLS_CC);
}
/* }}} */
static int php_sqlite3_callback_compare(void *coll, int a_len, const void *a, int b_len, const void* b) /* {{{ */
{
php_sqlite3_collation *collation = (php_sqlite3_collation*)coll;
- zval ***zargs = NULL;
- zval *retval = NULL;
+ zval *zargs = NULL;
+ zval retval;
int ret;
TSRMLS_FETCH();
collation->fci.fci.size = (sizeof(collation->fci.fci));
collation->fci.fci.function_table = EG(function_table);
- collation->fci.fci.function_name = collation->cmp_func;
+ ZVAL_COPY_VALUE(&collation->fci.fci.function_name, &collation->cmp_func);
collation->fci.fci.symbol_table = NULL;
- collation->fci.fci.object_ptr = NULL;
- collation->fci.fci.retval_ptr_ptr = &retval;
+ collation->fci.fci.object = NULL;
+ collation->fci.fci.retval = &retval;
collation->fci.fci.param_count = 2;
- zargs = (zval***)safe_emalloc(2, sizeof(zval**), 0);
- zargs[0] = emalloc(sizeof(zval*));
- zargs[1] = emalloc(sizeof(zval*));
-
- MAKE_STD_ZVAL(*zargs[0]);
- ZVAL_STRINGL(*zargs[0], a, a_len, 1);
-
- MAKE_STD_ZVAL(*zargs[1]);
- ZVAL_STRINGL(*zargs[1], b, b_len, 1);
+ zargs = safe_emalloc(2, sizeof(zval), 0);
+ ZVAL_STRINGL(&zargs[0], a, a_len);
+ ZVAL_STRINGL(&zargs[1], b, b_len);
collation->fci.fci.params = zargs;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the compare callback");
}
- zval_ptr_dtor(zargs[0]);
- zval_ptr_dtor(zargs[1]);
- efree(zargs[0]);
- efree(zargs[1]);
+ zval_ptr_dtor(&zargs[0]);
+ zval_ptr_dtor(&zargs[1]);
efree(zargs);
//retval ought to contain a ZVAL_LONG by now
// (the result of a comparison, i.e. most likely -1, 0, or 1)
//I suppose we could accept any scalar return type, though.
- if (Z_TYPE_P(retval) != IS_LONG){
+ if (Z_TYPE(retval) != IS_LONG){
php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the compare callback (invalid return type). Collation behaviour is undefined.");
}else{
- ret = Z_LVAL_P(retval);
+ ret = Z_LVAL(retval);
}
zval_ptr_dtor(&retval);
php_sqlite3_db_object *db_obj;
zval *object = getThis();
php_sqlite3_func *func;
- char *sql_func, *callback_name;
+ char *sql_func;
int sql_func_len;
zval *callback_func;
+ zend_string *callback_name;
long sql_func_num_args = -1;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
}
if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
- php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
- efree(callback_name);
+ php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name->val);
+ STR_RELEASE(callback_name);
RETURN_FALSE;
}
- efree(callback_name);
+ STR_RELEASE(callback_name);
func = (php_sqlite3_func *)ecalloc(1, sizeof(*func));
if (sqlite3_create_function(db_obj->db, sql_func, sql_func_num_args, SQLITE_UTF8, func, php_sqlite3_callback_func, NULL, NULL) == SQLITE_OK) {
func->func_name = estrdup(sql_func);
- MAKE_STD_ZVAL(func->func);
- MAKE_COPY_ZVAL(&callback_func, func->func);
+ ZVAL_COPY(&func->func, callback_func);
func->argc = sql_func_num_args;
func->next = db_obj->funcs;
php_sqlite3_db_object *db_obj;
zval *object = getThis();
php_sqlite3_func *func;
- char *sql_func, *callback_name;
+ char *sql_func;
+ zend_string *callback_name;
int sql_func_len;
zval *step_callback, *fini_callback;
long sql_func_num_args = -1;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
}
if (!zend_is_callable(step_callback, 0, &callback_name TSRMLS_CC)) {
- php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
- efree(callback_name);
+ php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name->val);
+ STR_RELEASE(callback_name);
RETURN_FALSE;
}
- efree(callback_name);
+ STR_RELEASE(callback_name);
if (!zend_is_callable(fini_callback, 0, &callback_name TSRMLS_CC)) {
- php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
- efree(callback_name);
+ php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name->val);
+ STR_RELEASE(callback_name);
RETURN_FALSE;
}
- efree(callback_name);
+ STR_RELEASE(callback_name);
func = (php_sqlite3_func *)ecalloc(1, sizeof(*func));
if (sqlite3_create_function(db_obj->db, sql_func, sql_func_num_args, SQLITE_UTF8, func, NULL, php_sqlite3_callback_step, php_sqlite3_callback_final) == SQLITE_OK) {
func->func_name = estrdup(sql_func);
- MAKE_STD_ZVAL(func->step);
- MAKE_COPY_ZVAL(&step_callback, func->step);
-
- MAKE_STD_ZVAL(func->fini);
- MAKE_COPY_ZVAL(&fini_callback, func->fini);
+ ZVAL_COPY(&func->step, step_callback);
+ ZVAL_COPY(&func->fini, fini_callback);
func->argc = sql_func_num_args;
func->next = db_obj->funcs;
php_sqlite3_db_object *db_obj;
zval *object = getThis();
php_sqlite3_collation *collation;
- char *collation_name, *callback_name;
+ char *collation_name;
+ zend_string *callback_name;
int collation_name_len;
zval *callback_func;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
}
if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
- php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
- efree(callback_name);
+ php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name->val);
+ STR_RELEASE(callback_name);
RETURN_FALSE;
}
- efree(callback_name);
+ STR_RELEASE(callback_name);
collation = (php_sqlite3_collation *)ecalloc(1, sizeof(*collation));
if (sqlite3_create_collation(db_obj->db, collation_name, SQLITE_UTF8, collation, php_sqlite3_callback_compare) == SQLITE_OK) {
collation->collation_name = estrdup(collation_name);
- MAKE_STD_ZVAL(collation->cmp_func);
- MAKE_COPY_ZVAL(&callback_func, collation->cmp_func);
+ ZVAL_COPY(&collation->cmp_func, callback_func);
collation->next = db_obj->collations;
db_obj->collations = collation;
php_stream_sqlite3_data *sqlite3_stream;
php_stream *stream;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
zval *object = getThis();
zend_bool enableExceptions = 0;
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(object);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &enableExceptions) == FAILURE) {
return;
{
php_sqlite3_stmt *stmt_obj;
zval *object = getThis();
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
{
php_sqlite3_stmt *stmt_obj;
zval *object = getThis();
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
{
php_sqlite3_stmt *stmt_obj;
zval *object = getThis();
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
{
php_sqlite3_stmt *stmt_obj;
zval *object = getThis();
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
{
php_sqlite3_stmt *stmt_obj;
zval *object = getThis();
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
}
if (param->name) {
- zend_hash_update(hash, param->name, param->name_len, param, sizeof(*param), NULL);
+ zend_hash_str_update_mem(hash, param->name, param->name_len, param, sizeof(struct php_sqlite3_bound_param));
} else {
- zend_hash_index_update(hash, param->param_number, param, sizeof(*param), NULL);
+ zend_hash_index_update_mem(hash, param->param_number, param, sizeof(struct php_sqlite3_bound_param));
}
return 1;
php_sqlite3_stmt *stmt_obj;
zval *object = getThis();
struct php_sqlite3_bound_param param = {0};
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(object);
+ zval *parameter;
param.param_number = -1;
param.type = SQLITE3_TEXT;
- if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz|l", ¶m.param_number, ¶m.parameter, ¶m.type) == FAILURE) {
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", ¶m.name, ¶m.name_len, ¶m.parameter, ¶m.type) == FAILURE) {
+ if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz|l", ¶m.param_number, ¶meter, ¶m.type) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", ¶m.name, ¶m.name_len, ¶meter, ¶m.type) == FAILURE) {
return;
}
}
- Z_ADDREF_P(param.parameter);
+ ZVAL_COPY(¶m.parameter, parameter);
if (!register_bound_parameter_to_sqlite(¶m, stmt_obj TSRMLS_CC)) {
- if (param.parameter) {
+ if (!ZVAL_IS_UNDEF(¶m.parameter)) {
zval_ptr_dtor(&(param.parameter));
- param.parameter = NULL;
+ ZVAL_UNDEF(¶m.parameter);
}
RETURN_FALSE;
}
php_sqlite3_stmt *stmt_obj;
zval *object = getThis();
struct php_sqlite3_bound_param param = {0};
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(object);
+ zval *parameter;
param.param_number = -1;
param.type = SQLITE3_TEXT;
- if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz/|l", ¶m.param_number, ¶m.parameter, ¶m.type) == FAILURE) {
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|l", ¶m.name, ¶m.name_len, ¶m.parameter, ¶m.type) == FAILURE) {
+ if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz/|l", ¶m.param_number, ¶meter, ¶m.type) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|l", ¶m.name, ¶m.name_len, ¶meter, ¶m.type) == FAILURE) {
return;
}
}
- Z_ADDREF_P(param.parameter);
+ ZVAL_COPY(¶m.parameter, parameter);
if (!register_bound_parameter_to_sqlite(¶m, stmt_obj TSRMLS_CC)) {
- if (param.parameter) {
+ if (!ZVAL_IS_UNDEF(¶m.parameter)) {
zval_ptr_dtor(&(param.parameter));
- param.parameter = NULL;
+ ZVAL_UNDEF(¶m.parameter);
}
RETURN_FALSE;
}
int return_code = 0;
struct php_sqlite3_bound_param *param;
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(object);
if (zend_parse_parameters_none() == FAILURE) {
return;
SQLITE3_CHECK_INITIALIZED(stmt_obj->db_obj, stmt_obj->initialised, SQLite3)
if (stmt_obj->bound_params) {
- zend_hash_internal_pointer_reset(stmt_obj->bound_params);
- while (zend_hash_get_current_data(stmt_obj->bound_params, (void **)¶m) == SUCCESS) {
+ ZEND_HASH_FOREACH_PTR(stmt_obj->bound_params, param) {
+ zval parameter;
+ ZVAL_COPY_VALUE(¶meter, ¶m->parameter);
+
+ if (Z_ISREF_P(¶meter)) {
+ ZVAL_DUP(¶meter, Z_REFVAL(parameter));
+ }
+
/* If the ZVAL is null then it should be bound as that */
- if (Z_TYPE_P(param->parameter) == IS_NULL) {
+ if (Z_TYPE(parameter) == IS_NULL) {
sqlite3_bind_null(stmt_obj->stmt, param->param_number);
- zend_hash_move_forward(stmt_obj->bound_params);
continue;
}
switch (param->type) {
case SQLITE_INTEGER:
- convert_to_long(param->parameter);
+ convert_to_long(¶meter);
#if LONG_MAX > 2147483647
- sqlite3_bind_int64(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter));
+ sqlite3_bind_int64(stmt_obj->stmt, param->param_number, Z_LVAL(parameter));
#else
- sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter));
+ sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL(parameter));
#endif
break;
case SQLITE_FLOAT:
- /* convert_to_double(param->parameter);*/
- sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL_P(param->parameter));
+ /* convert_to_double(parameter);*/
+ sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL(parameter));
break;
case SQLITE_BLOB:
{
php_stream *stream = NULL;
- int blength;
- char *buffer = NULL;
- if (Z_TYPE_P(param->parameter) == IS_RESOURCE) {
- php_stream_from_zval_no_verify(stream, ¶m->parameter);
+ zend_string *buffer;
+ if (Z_TYPE(parameter) == IS_RESOURCE) {
+ php_stream_from_zval_no_verify(stream, ¶meter);
if (stream == NULL) {
php_sqlite3_error(stmt_obj->db_obj, "Unable to read stream for parameter %ld", param->param_number);
RETURN_FALSE;
}
- blength = php_stream_copy_to_mem(stream, (void *)&buffer, PHP_STREAM_COPY_ALL, 0);
+ buffer = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0);
} else {
- convert_to_string(param->parameter);
- blength = Z_STRLEN_P(param->parameter);
- buffer = Z_STRVAL_P(param->parameter);
+ convert_to_string(¶meter);
+ buffer = Z_STR(parameter);
}
- sqlite3_bind_blob(stmt_obj->stmt, param->param_number, buffer, blength, SQLITE_TRANSIENT);
+ sqlite3_bind_blob(stmt_obj->stmt, param->param_number, buffer->val, buffer->len, SQLITE_TRANSIENT);
if (stream) {
- pefree(buffer, 0);
+ STR_RELEASE(buffer);
}
break;
}
case SQLITE3_TEXT:
- convert_to_string(param->parameter);
- sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL_P(param->parameter), Z_STRLEN_P(param->parameter), SQLITE_STATIC);
+ convert_to_string(¶meter);
+ sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL(parameter), Z_STRLEN(parameter), SQLITE_STATIC);
break;
case SQLITE_NULL:
php_sqlite3_error(stmt_obj->db_obj, "Unknown parameter type: %ld for parameter %ld", param->type, param->param_number);
RETURN_FALSE;
}
- zend_hash_move_forward(stmt_obj->bound_params);
- }
+ } ZEND_HASH_FOREACH_END();
}
return_code = sqlite3_step(stmt_obj->stmt);
{
sqlite3_reset(stmt_obj->stmt);
object_init_ex(return_value, php_sqlite3_result_entry);
- result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC);
+ result = Z_SQLITE3_RESULT_P(return_value TSRMLS_CC);
- Z_ADDREF_P(object);
-
result->is_prepared_statement = 1;
result->db_obj = stmt_obj->db_obj;
result->stmt_obj = stmt_obj;
- result->stmt_obj_zval = getThis();
+ ZVAL_COPY(&result->stmt_obj_zval, object);
break;
}
zend_error_handling error_handling;
php_sqlite3_free_list *free_item;
- stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+ stmt_obj = Z_SQLITE3_STMT_P(object);
zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &db_zval, php_sqlite3_sc_entry, &sql, &sql_len) == FAILURE) {
return;
}
- db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(db_zval TSRMLS_CC);
+ db_obj = Z_SQLITE3_DB_P(db_zval);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
}
stmt_obj->db_obj = db_obj;
- stmt_obj->db_obj_zval = db_zval;
-
- Z_ADDREF_P(db_zval);
+ ZVAL_COPY(&stmt_obj->db_obj_zval, db_zval);
errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
if (errcode != SQLITE_OK) {
free_item = emalloc(sizeof(php_sqlite3_free_list));
free_item->stmt_obj = stmt_obj;
- free_item->stmt_obj_zval = getThis();
+ //?? free_item->stmt_obj_zval = getThis();
+ ZVAL_COPY_VALUE(&free_item->stmt_obj_zval, object);
zend_llist_add_element(&(db_obj->free_list), &free_item);
}
{
php_sqlite3_result *result_obj;
zval *object = getThis();
- result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+ result_obj = Z_SQLITE3_RESULT_P(object);
SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
zval *object = getThis();
long column = 0;
char *column_name;
- result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+ result_obj = Z_SQLITE3_RESULT_P(object);
SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
RETURN_FALSE;
}
- RETVAL_STRING(column_name, 1);
+ RETVAL_STRING(column_name);
}
/* }}} */
php_sqlite3_result *result_obj;
zval *object = getThis();
long column = 0;
- result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+ result_obj = Z_SQLITE3_RESULT_P(object);
SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
zval *object = getThis();
int i, ret;
long mode = PHP_SQLITE3_BOTH;
- result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+ result_obj = Z_SQLITE3_RESULT_P(object);
SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
switch (ret) {
case SQLITE_ROW:
/* If there was no return value then just skip fetching */
- if (!return_value_used) {
+ if (!USED_RET()) {
return;
}
array_init(return_value);
for (i = 0; i < sqlite3_data_count(result_obj->stmt_obj->stmt); i++) {
- zval *data;
+ zval data;
- data = sqlite_value_to_zval(result_obj->stmt_obj->stmt, i);
+ sqlite_value_to_zval(result_obj->stmt_obj->stmt, i, &data);
if (mode & PHP_SQLITE3_NUM) {
- add_index_zval(return_value, i, data);
+ add_index_zval(return_value, i, &data);
}
if (mode & PHP_SQLITE3_ASSOC) {
if (mode & PHP_SQLITE3_NUM) {
- Z_ADDREF_P(data);
+ if (Z_REFCOUNTED(data)) {
+ Z_ADDREF(data);
+ }
}
- add_assoc_zval(return_value, (char*)sqlite3_column_name(result_obj->stmt_obj->stmt, i), data);
+ add_assoc_zval(return_value, (char*)sqlite3_column_name(result_obj->stmt_obj->stmt, i), &data);
}
}
break;
{
php_sqlite3_result *result_obj;
zval *object = getThis();
- result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+ result_obj = Z_SQLITE3_RESULT_P(object);
SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
{
php_sqlite3_result *result_obj;
zval *object = getThis();
- result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+ result_obj = Z_SQLITE3_RESULT_P(object);
SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
/* We need to finalize an internal statement */
if (result_obj->is_prepared_statement == 0) {
- zend_llist_del_element(&(result_obj->db_obj->free_list), result_obj->stmt_obj_zval,
+ zend_llist_del_element(&(result_obj->db_obj->free_list), &result_obj->stmt_obj_zval,
(int (*)(void *, void *)) php_sqlite3_compare_stmt_zval_free);
} else {
sqlite3_reset(result_obj->stmt_obj->stmt);
}
/* }}} */
-static int php_sqlite3_compare_stmt_zval_free( php_sqlite3_free_list **free_list, zval *statement ) /* {{{ */
+static int php_sqlite3_compare_stmt_zval_free(php_sqlite3_free_list **free_list, zval *statement ) /* {{{ */
{
- return ((*free_list)->stmt_obj->initialised && statement == (*free_list)->stmt_obj_zval);
+ //????? return ((*free_list)->stmt_obj->initialised && statement == (*free_list)->stmt_obj_zval);
+ return ((*free_list)->stmt_obj->initialised && Z_PTR_P(statement) == Z_PTR((*free_list)->stmt_obj_zval));
}
/* }}} */
}
/* }}} */
-static void php_sqlite3_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void php_sqlite3_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
{
- php_sqlite3_db_object *intern = (php_sqlite3_db_object *)object;
+ php_sqlite3_db_object *intern = php_sqlite3_db_from_obj(object);
php_sqlite3_func *func;
php_sqlite3_collation *collation;
efree((char*)func->func_name);
- if (func->func) {
+ if (!ZVAL_IS_UNDEF(&func->func)) {
zval_ptr_dtor(&func->func);
}
- if (func->step) {
+ if (!ZVAL_IS_UNDEF(&func->step)) {
zval_ptr_dtor(&func->step);
}
- if (func->fini) {
+ if (!ZVAL_IS_UNDEF(&func->fini)) {
zval_ptr_dtor(&func->fini);
}
efree(func);
sqlite3_create_collation(intern->db, collation->collation_name, SQLITE_UTF8, NULL, NULL);
}
efree((char*)collation->collation_name);
- if (collation->cmp_func){
+ if (!ZVAL_IS_UNDEF(&collation->cmp_func)) {
zval_ptr_dtor(&collation->cmp_func);
}
efree(collation);
}
zend_object_std_dtor(&intern->zo TSRMLS_CC);
- efree(intern);
}
/* }}} */
-static void php_sqlite3_stmt_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void php_sqlite3_stmt_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
{
- php_sqlite3_stmt *intern = (php_sqlite3_stmt *)object;
+ php_sqlite3_stmt *intern = php_sqlite3_stmt_from_obj(object);
if (!intern) {
return;
(int (*)(void *, void *)) php_sqlite3_compare_stmt_free);
}
- if (intern->db_obj_zval) {
+ if (!ZVAL_IS_UNDEF(&intern->db_obj_zval)) {
zval_ptr_dtor(&intern->db_obj_zval);
}
zend_object_std_dtor(&intern->zo TSRMLS_CC);
- efree(intern);
}
/* }}} */
-static void php_sqlite3_result_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void php_sqlite3_result_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
{
- php_sqlite3_result *intern = (php_sqlite3_result *)object;
+ php_sqlite3_result *intern = php_sqlite3_result_from_obj(object);
if (!intern) {
return;
}
- if (intern->stmt_obj_zval) {
+ if (!ZVAL_IS_NULL(&intern->stmt_obj_zval)) {
if (intern->stmt_obj->initialised) {
sqlite3_reset(intern->stmt_obj->stmt);
}
- if (intern->is_prepared_statement == 0) {
- zval_dtor(intern->stmt_obj_zval);
- FREE_ZVAL(intern->stmt_obj_zval);
- } else {
- zval_ptr_dtor(&intern->stmt_obj_zval);
- }
+ zval_ptr_dtor(&intern->stmt_obj_zval);
}
zend_object_std_dtor(&intern->zo TSRMLS_CC);
- efree(intern);
}
/* }}} */
-static zend_object_value php_sqlite3_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *php_sqlite3_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
{
- zend_object_value retval;
php_sqlite3_db_object *intern;
/* Allocate memory for it */
- intern = emalloc(sizeof(php_sqlite3_db_object));
- memset(intern, 0, sizeof(php_sqlite3_db_object));
- intern->exception = 0;
+ intern = ecalloc(1, sizeof(php_sqlite3_db_object) + sizeof(zval) * (class_type->default_properties_count - 1));
/* Need to keep track of things to free */
- zend_llist_init(&(intern->free_list), sizeof(php_sqlite3_free_list *), (llist_dtor_func_t)php_sqlite3_free_list_dtor, 0);
+ zend_llist_init(&(intern->free_list), sizeof(php_sqlite3_free_list *), (llist_dtor_func_t)php_sqlite3_free_list_dtor, 0);
zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
object_properties_init(&intern->zo, class_type);
- retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_object_free_storage, NULL TSRMLS_CC);
- retval.handlers = (zend_object_handlers *) &sqlite3_object_handlers;
+ intern->zo.handlers = &sqlite3_object_handlers;
- return retval;
+ return &intern->zo;
}
/* }}} */
-static zend_object_value php_sqlite3_stmt_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *php_sqlite3_stmt_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
{
- zend_object_value retval;
php_sqlite3_stmt *intern;
/* Allocate memory for it */
- intern = emalloc(sizeof(php_sqlite3_stmt));
- memset(intern, 0, sizeof(php_sqlite3_stmt));
-
- intern->db_obj_zval = NULL;
+ intern = ecalloc(1, sizeof(php_sqlite3_stmt) + sizeof(zval) * (class_type->default_properties_count - 1));
zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
object_properties_init(&intern->zo, class_type);
- retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_stmt_object_free_storage, NULL TSRMLS_CC);
- retval.handlers = (zend_object_handlers *) &sqlite3_stmt_object_handlers;
+ intern->zo.handlers = &sqlite3_stmt_object_handlers;
- return retval;
+ return &intern->zo;
}
/* }}} */
-static zend_object_value php_sqlite3_result_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *php_sqlite3_result_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
{
- zend_object_value retval;
php_sqlite3_result *intern;
/* Allocate memory for it */
- intern = emalloc(sizeof(php_sqlite3_result));
- memset(intern, 0, sizeof(php_sqlite3_result));
-
- intern->complete = 0;
- intern->is_prepared_statement = 0;
- intern->stmt_obj_zval = NULL;
+ intern = ecalloc(1, sizeof(php_sqlite3_result) + sizeof(zval) * (class_type->default_properties_count - 1));
zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
object_properties_init(&intern->zo, class_type);
- retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_result_object_free_storage, NULL TSRMLS_CC);
- retval.handlers = (zend_object_handlers *) &sqlite3_result_object_handlers;
+ intern->zo.handlers = &sqlite3_result_object_handlers;
- return retval;
+ return &intern->zo;
}
/* }}} */
-static void sqlite3_param_dtor(void *data) /* {{{ */
+static void sqlite3_param_dtor(zval *data) /* {{{ */
{
- struct php_sqlite3_bound_param *param = (struct php_sqlite3_bound_param*)data;
+ struct php_sqlite3_bound_param *param = (struct php_sqlite3_bound_param*)Z_PTR_P(data);
if (param->name) {
efree(param->name);
}
- if (param->parameter) {
+ if (!ZVAL_IS_NULL(¶m->parameter)) {
zval_ptr_dtor(&(param->parameter));
- param->parameter = NULL;
+ ZVAL_UNDEF(¶m->parameter);
}
+ efree(param);
}
/* }}} */
/* Register SQLite 3 Class */
INIT_CLASS_ENTRY(ce, "SQLite3", php_sqlite3_class_methods);
ce.create_object = php_sqlite3_object_new;
+ sqlite3_object_handlers.offset = XtOffsetOf(php_sqlite3_db_object, zo);
sqlite3_object_handlers.clone_obj = NULL;
+ sqlite3_object_handlers.free_obj = php_sqlite3_object_free_storage;
php_sqlite3_sc_entry = zend_register_internal_class(&ce TSRMLS_CC);
/* Register SQLite 3 Prepared Statement Class */
INIT_CLASS_ENTRY(ce, "SQLite3Stmt", php_sqlite3_stmt_class_methods);
ce.create_object = php_sqlite3_stmt_object_new;
+ sqlite3_stmt_object_handlers.offset = XtOffsetOf(php_sqlite3_stmt, zo);
sqlite3_stmt_object_handlers.clone_obj = NULL;
+ sqlite3_stmt_object_handlers.free_obj = php_sqlite3_stmt_object_free_storage;
php_sqlite3_stmt_entry = zend_register_internal_class(&ce TSRMLS_CC);
/* Register SQLite 3 Result Class */
INIT_CLASS_ENTRY(ce, "SQLite3Result", php_sqlite3_result_class_methods);
ce.create_object = php_sqlite3_result_object_new;
+ sqlite3_result_object_handlers.offset = XtOffsetOf(php_sqlite3_result, zo);
sqlite3_result_object_handlers.clone_obj = NULL;
+ sqlite3_result_object_handlers.free_obj = php_sqlite3_result_object_free_storage;
php_sqlite3_result_entry = zend_register_internal_class(&ce TSRMLS_CC);
REGISTER_INI_ENTRIES();
projects / php / commitdiff