Refactor pdo_sqlite (only compilable)

diff --git a/ext/pdo/pdo.c b/ext/pdo/pdo.c
index f2527a8583cbf7d10377d5d57e7b38be2bc86e76..27ecdd370ac7d3b9a42286245667ff694b571bf0 100644 (file)
--- a/ext/pdo/pdo.c
+++ b/ext/pdo/pdo.c
@@ -187,7 +187,7 @@ PDO_API int php_pdo_register_driver(pdo_driver_t *driver)
                return FAILURE; /* NOTREACHED */
        }
 
-       return zend_hash_str_add_mem(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len, (void**)&driver, sizeof(pdo_driver_t *)) != NULL;
+       return zend_hash_str_add_ptr(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len, driver) != NULL;
 }
 
 PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver)

diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c
index 06dcd1ecc6a7659a6e4dc3dfdae48bf15b83192d..651015106dd4466733c917f0e13a5a199001d066 100644 (file)
--- a/ext/pdo/pdo_dbh.c
+++ b/ext/pdo/pdo_dbh.c
@@ -207,6 +207,7 @@ static PHP_METHOD(PDO, dbh_constructor)
        zval *options = NULL;
        char alt_dsn[512];
        int call_factory = 1;
+       char tmp;
 
        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!s!a!", &data_source, &data_source_len,
                                &username, &usernamelen, &password, &passwordlen, &options)) {
@@ -254,8 +255,10 @@ static PHP_METHOD(PDO, dbh_constructor)
                }
        }
 
+       tmp = data_source[colon - data_source];
+       data_source[colon - data_source] = '\0';
        driver = pdo_find_driver(data_source, colon - data_source);
-
+       data_source[colon - data_source] = tmp;
        if (!driver) {
                /* NB: don't want to include the data_source in the error message as
                 * it might contain a password */

diff --git a/ext/pdo_sqlite/php_pdo_sqlite_int.h b/ext/pdo_sqlite/php_pdo_sqlite_int.h
index 288cc6335e859967af37e05c4cf8f8e06385fa69..188856a3d1cae11dfb866ba8a920023ff323d3db 100644 (file)
--- a/ext/pdo_sqlite/php_pdo_sqlite_int.h
+++ b/ext/pdo_sqlite/php_pdo_sqlite_int.h
@@ -38,7 +38,7 @@ struct pdo_sqlite_fci {
 struct pdo_sqlite_func {
        struct pdo_sqlite_func *next;
 
-       zval *func, *step, *fini;
+       zval func, step, fini;
        int argc;
        const char *funcname;
        
@@ -50,7 +50,7 @@ struct pdo_sqlite_collation {
        struct pdo_sqlite_collation *next;
 
        const char *name;
-       zval *callback;
+       zval callback;
        struct pdo_sqlite_fci fc;
 };
 

diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c
index bff259e8482e57ea983eca7bab37238626fc5c55..24339fa344c75021739835abcfde2d861f0c7614 100644 (file)
--- a/ext/pdo_sqlite/sqlite_driver.c
+++ b/ext/pdo_sqlite/sqlite_driver.c
@@ -118,13 +118,13 @@ static void pdo_sqlite_cleanup_callbacks(pdo_sqlite_db_handle *H TSRMLS_DC)
                }
 
                efree((char*)func->funcname);
-               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);
@@ -145,7 +145,7 @@ static void pdo_sqlite_cleanup_callbacks(pdo_sqlite_db_handle *H TSRMLS_DC)
                }
 
                efree((char*)collation->name);
-               if (collation->callback) {
+               if (!ZVAL_IS_UNDEF(&collation->callback)) {
                        zval_ptr_dtor(&collation->callback);
                }
                efree(collation);
@@ -285,7 +285,7 @@ static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_valu
        switch (attr) {
                case PDO_ATTR_CLIENT_VERSION:
                case PDO_ATTR_SERVER_VERSION:
-                       ZVAL_STRING(return_value, (char *)sqlite3_libversion(), 1);
+                       ZVAL_STRING(return_value, (char *)sqlite3_libversion());
                        break;
                
                default:
@@ -312,12 +312,12 @@ static int do_callback(struct pdo_sqlite_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;
-       zval **agg_context = NULL;
+       zval *agg_context = NULL;
        
        if (is_agg) {
                is_agg = 2;
@@ -327,55 +327,51 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
        
        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 = (zval**)sqlite3_aggregate_context(context, sizeof(zval*));
-               if (!*agg_context) {
+               /* ????
+               agg_context = (zval*)sqlite3_aggregate_context(context, sizeof(zval));
+               if (!agg_context) {
                        MAKE_STD_ZVAL(*agg_context);
                        ZVAL_NULL(*agg_context);
                }
                zargs[0] = agg_context;
-
-               zargs[1] = emalloc(sizeof(zval*));
-               MAKE_STD_ZVAL(*zargs[1]);
-               ZVAL_LONG(*zargs[1], sqlite3_aggregate_count(context));
+               */
+               ZVAL_NULL(&zargs[0]);
+               ZVAL_LONG(&zargs[1], sqlite3_aggregate_count(context));
        }
        
        for (i = 0; i < argc; i++) {
-               zargs[i + is_agg] = emalloc(sizeof(zval *));
-               MAKE_STD_ZVAL(*zargs[i + is_agg]);
-
                /* get the value */
                switch (sqlite3_value_type(argv[i])) {
                        case SQLITE_INTEGER:
-                               ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int(argv[i]));
+                               ZVAL_LONG(&zargs[i + is_agg], sqlite3_value_int(argv[i]));
                                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;
                }
        }
@@ -391,12 +387,10 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
        /* clean up the params */
        if (zargs) {
                for (i = is_agg; i < fake_argc; 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);
        }
@@ -404,10 +398,10 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
        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:
-                                       sqlite3_result_int(context, Z_LVAL_P(retval));
+                                       sqlite3_result_int(context, Z_LVAL(retval));
                                        break;
 
                                case IS_NULL:
@@ -415,13 +409,12 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
                                        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 {
@@ -436,16 +429,16 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
                 * the context */
                if (agg_context) {
                        zval_ptr_dtor(agg_context);
-               }
+               }/* ???
                if (retval) {
                        *agg_context = retval;
                        retval = NULL;
                } else {
                        *agg_context = NULL;
-               }
+               }*/
        }
 
-       if (retval) {
+       if (!ZVAL_IS_UNDEF(&retval)) {
                zval_ptr_dtor(&retval);
        }
 
@@ -458,7 +451,7 @@ static void php_sqlite3_func_callback(sqlite3_context *context, int argc,
        struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
        TSRMLS_FETCH();
 
-       do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC);
+       do_callback(&func->afunc, &func->func, argc, argv, context, 0 TSRMLS_CC);
 }
 
 static void php_sqlite3_func_step_callback(sqlite3_context *context, int argc,
@@ -467,7 +460,7 @@ static void php_sqlite3_func_step_callback(sqlite3_context *context, int argc,
        struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
        TSRMLS_FETCH();
 
-       do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC);
+       do_callback(&func->astep, &func->step, argc, argv, context, 1 TSRMLS_CC);
 }
 
 static void php_sqlite3_func_final_callback(sqlite3_context *context)
@@ -475,7 +468,7 @@ static void php_sqlite3_func_final_callback(sqlite3_context *context)
        struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
        TSRMLS_FETCH();
 
-       do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC);
+       do_callback(&func->afini, &func->fini, 0, NULL, context, 1 TSRMLS_CC);
 }
 
 static int php_sqlite3_collation_callback(void *context,
@@ -483,48 +476,41 @@ static int php_sqlite3_collation_callback(void *context,
        int string2_len, const void *string2)
 {
        int ret;
-       zval *zstring1, *zstring2;
-       zval **zargs[2];
-       zval *retval = NULL;
+       zval zargs[2];
+       zval retval;
        struct pdo_sqlite_collation *collation = (struct pdo_sqlite_collation*) context;
        TSRMLS_FETCH();
 
        collation->fc.fci.size = sizeof(collation->fc.fci);
        collation->fc.fci.function_table = EG(function_table);
-       collation->fc.fci.function_name = collation->callback;
+       ZVAL_COPY_VALUE(&collation->fc.fci.function_name, &collation->callback);
        collation->fc.fci.symbol_table = NULL;
-       collation->fc.fci.object_ptr = NULL;
-       collation->fc.fci.retval_ptr_ptr = &retval;
+       collation->fc.fci.object = NULL;
+       collation->fc.fci.retval = &retval;
 
        // Prepare the arguments.
-       MAKE_STD_ZVAL(zstring1);
-       ZVAL_STRINGL(zstring1, (char *) string1, string1_len, 1);
-       zargs[0] = &zstring1;
-       MAKE_STD_ZVAL(zstring2);
-       ZVAL_STRINGL(zstring2, (char *) string2, string2_len, 1);
-       zargs[1] = &zstring2;
+       ZVAL_STRINGL(&zargs[0], (char *) string1, string1_len);
+       ZVAL_STRINGL(&zargs[1], (char *) string2, string2_len);
        collation->fc.fci.param_count = 2;
        collation->fc.fci.params = zargs;
 
        if ((ret = zend_call_function(&collation->fc.fci, &collation->fc.fcc TSRMLS_CC)) == FAILURE) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
-       }
-       else if (retval) {
-               if (Z_TYPE_P(retval) != IS_LONG) {
+       } else if (!ZVAL_IS_UNDEF(&retval)) {
+               if (Z_TYPE(retval) != IS_LONG) {
                        convert_to_long_ex(&retval);
                }
                ret = 0;
-               if (Z_LVAL_P(retval) > 0) {
+               if (Z_LVAL(retval) > 0) {
                        ret = 1;
-               }
-               else if (Z_LVAL_P(retval) < 0) {
+               } else if (Z_LVAL(retval) < 0) {
                        ret = -1;
                }
                zval_ptr_dtor(&retval);
        }
 
-       zval_ptr_dtor(zargs[0]);
-       zval_ptr_dtor(zargs[1]);
+       zval_ptr_dtor(&zargs[0]);
+       zval_ptr_dtor(&zargs[1]);
 
        return ret;
 }
@@ -538,7 +524,7 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
        char *func_name;
        int func_name_len;
        long argc = -1;
-       char *cbname = NULL;
+       zend_string *cbname = NULL;
        pdo_dbh_t *dbh;
        pdo_sqlite_db_handle *H;
        int ret;
@@ -548,15 +534,15 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
                RETURN_FALSE;
        }
        
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis() TSRMLS_CC);
        PDO_CONSTRUCT_CHECK;
 
        if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
-               php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-               efree(cbname);
+               php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+               STR_RELEASE(cbname);
                RETURN_FALSE;
        }
-       efree(cbname);
+       STR_RELEASE(cbname);
        
        H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -567,8 +553,7 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
        if (ret == SQLITE_OK) {
                func->funcname = estrdup(func_name);
                
-               MAKE_STD_ZVAL(func->func);
-               MAKE_COPY_ZVAL(&callback, func->func);
+               ZVAL_COPY(&func->func, callback);
                
                func->argc = argc;
 
@@ -609,7 +594,7 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
        char *func_name;
        int func_name_len;
        long argc = -1;
-       char *cbname = NULL;
+       zend_string *cbname = NULL;
        pdo_dbh_t *dbh;
        pdo_sqlite_db_handle *H;
        int ret;
@@ -619,21 +604,21 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
                RETURN_FALSE;
        }
        
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis() TSRMLS_CC);
        PDO_CONSTRUCT_CHECK;
 
        if (!zend_is_callable(step_callback, 0, &cbname TSRMLS_CC)) {
-               php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-               efree(cbname);
+               php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+               STR_RELEASE(cbname);
                RETURN_FALSE;
        }
-       efree(cbname);
+       STR_RELEASE(cbname);
        if (!zend_is_callable(fini_callback, 0, &cbname TSRMLS_CC)) {
-               php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-               efree(cbname);
+               php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+               STR_RELEASE(cbname);
                RETURN_FALSE;
        }
-       efree(cbname);
+       STR_RELEASE(cbname);
        
        H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -644,11 +629,9 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
        if (ret == SQLITE_OK) {
                func->funcname = estrdup(func_name);
                
-               MAKE_STD_ZVAL(func->step);
-               MAKE_COPY_ZVAL(&step_callback, func->step);
+               ZVAL_COPY(&func->step, step_callback);
 
-               MAKE_STD_ZVAL(func->fini);
-               MAKE_COPY_ZVAL(&fini_callback, func->fini);
+               ZVAL_COPY(&func->fini, fini_callback);
                
                func->argc = argc;
 
@@ -671,7 +654,7 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
        zval *callback;
        char *collation_name;
        int collation_name_len;
-       char *cbname = NULL;
+       zend_string *cbname = NULL;
        pdo_dbh_t *dbh;
        pdo_sqlite_db_handle *H;
        int ret;
@@ -681,15 +664,15 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
                RETURN_FALSE;
        }
 
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
 
        if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
-               php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-               efree(cbname);
+               php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+               STR_RELEASE(cbname);
                RETURN_FALSE;
        }
-       efree(cbname);
+       STR_RELEASE(cbname);
 
        H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -699,8 +682,7 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
        if (ret == SQLITE_OK) {
                collation->name = estrdup(collation_name);
 
-               MAKE_STD_ZVAL(collation->callback);
-               MAKE_COPY_ZVAL(&callback, collation->callback);
+               ZVAL_COPY(&collation->callback, callback);
 
                collation->next = H->collations;
                H->collations = collation;

diff --git a/ext/pdo_sqlite/sqlite_statement.c b/ext/pdo_sqlite/sqlite_statement.c
index e3ffa3eb0e19102850bfbba41316d7d4488f7767..83d2a3f238572081cf722bce4d6c50fbde19877e 100644 (file)
--- a/ext/pdo_sqlite/sqlite_statement.c
+++ b/ext/pdo_sqlite/sqlite_statement.c
@@ -90,7 +90,7 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
                        if (param->is_param) {
                                
                                if (param->paramno == -1) {
-                                       param->paramno = sqlite3_bind_parameter_index(S->stmt, param->name) - 1;
+                                       param->paramno = sqlite3_bind_parameter_index(S->stmt, param->name->val) - 1;
                                }
 
                                switch (PDO_PARAM_TYPE(param->param_type)) {
@@ -106,18 +106,18 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
                                        
                                        case PDO_PARAM_INT:
                                        case PDO_PARAM_BOOL:
-                                               if (Z_TYPE_P(param->parameter) == IS_NULL) {
+                                               if (Z_TYPE(param->parameter) == IS_NULL) {
                                                        if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
                                                                return 1;
                                                        }
                                                } else {
-                                                       convert_to_long(param->parameter);
+                                                       convert_to_long(&param->parameter);
 #if LONG_MAX > 2147483647
-                                                       if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(param->parameter))) {
+                                                       if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL(param->parameter))) {
                                                                return 1;
                                                        }
 #else
-                                                       if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(param->parameter))) {
+                                                       if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL(param->parameter))) {
                                                                return 1;
                                                        }
 #endif
@@ -126,31 +126,29 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
                                                return 0;
                                        
                                        case PDO_PARAM_LOB:
-                                               if (Z_TYPE_P(param->parameter) == IS_RESOURCE) {
+                                               if (Z_TYPE(param->parameter) == IS_RESOURCE) {
                                                        php_stream *stm;
                                                        php_stream_from_zval_no_verify(stm, &param->parameter);
                                                        if (stm) {
-                                                               SEPARATE_ZVAL(&param->parameter);
-                                                               Z_TYPE_P(param->parameter) = IS_STRING;
-                                                               Z_STRLEN_P(param->parameter) = php_stream_copy_to_mem(stm,
-                                                                       &Z_STRVAL_P(param->parameter), PHP_STREAM_COPY_ALL, 0);
+                                                               zval_ptr_dtor(&param->parameter);
+                                                               ZVAL_STR(&param->parameter, php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0));
                                                        } else {
                                                                pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource" TSRMLS_CC);
                                                                return 0;
                                                        }
-                                               } else if (Z_TYPE_P(param->parameter) == IS_NULL) {
+                                               } else if (Z_TYPE(param->parameter) == IS_NULL) {
                                                        if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
                                                                return 1;
                                                        }
                                                        pdo_sqlite_error_stmt(stmt);
                                                        return 0;
                                                } else {
-                                                       convert_to_string(param->parameter);
+                                                       convert_to_string(&param->parameter);
                                                }
                                                
                                                if (SQLITE_OK == sqlite3_bind_blob(S->stmt, param->paramno + 1,
-                                                               Z_STRVAL_P(param->parameter),
-                                                               Z_STRLEN_P(param->parameter),
+                                                               Z_STRVAL(param->parameter),
+                                                               Z_STRLEN(param->parameter),
                                                                SQLITE_STATIC)) {
                                                        return 1;       
                                                }
@@ -159,15 +157,15 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
                                                        
                                        case PDO_PARAM_STR:
                                        default:
-                                               if (Z_TYPE_P(param->parameter) == IS_NULL) {
+                                               if (Z_TYPE(param->parameter) == IS_NULL) {
                                                        if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
                                                                return 1;
                                                        }
                                                } else {
-                                                       convert_to_string(param->parameter);
+                                                       convert_to_string(&param->parameter);
                                                        if(SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1,
-                                                                       Z_STRVAL_P(param->parameter),
-                                                                       Z_STRLEN_P(param->parameter),
+                                                                       Z_STRVAL(param->parameter),
+                                                                       Z_STRLEN(param->parameter),
                                                                        SQLITE_STATIC)) {
                                                                return 1;       
                                                        }
@@ -279,7 +277,7 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
 {
        pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
        const char *str;
-       zval *flags;
+       zval flags;
        
        if (!S->stmt) {
                return FAILURE;
@@ -291,8 +289,7 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
        }
 
        array_init(return_value);
-       MAKE_STD_ZVAL(flags);
-       array_init(flags);
+       array_init(&flags);
 
        switch (sqlite3_column_type(S->stmt, colno)) {
                case SQLITE_NULL:
@@ -304,7 +301,7 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
                        break;
 
                case SQLITE_BLOB:
-                       add_next_index_string(flags, "blob");
+                       add_next_index_string(&flags, "blob");
                case SQLITE_TEXT:
                        add_assoc_string(return_value, "native_type", "string");
                        break;
@@ -326,7 +323,7 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
        }
 #endif
 
-       add_assoc_zval(return_value, "flags", flags);
+       add_assoc_zval(return_value, "flags", &flags);
 
        return SUCCESS;
 }