1 files changed, 92 insertions, 111 deletions

diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c
index 0f4a2456a1..413b50b9d4 100644
--- a/ext/pdo_sqlite/sqlite_driver.c
+++ b/ext/pdo_sqlite/sqlite_driver.c
@@ -1,8 +1,8 @@
 /*
   +----------------------------------------------------------------------+
-  | PHP Version 5                                                        |
+  | PHP Version 7                                                        |
   +----------------------------------------------------------------------+
-  | Copyright (c) 1997-2013 The PHP Group                                |
+  | Copyright (c) 1997-2014 The PHP Group                                |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -93,7 +93,7 @@ static int pdo_sqlite_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *i
 
 	if (einfo->errcode) {
 		add_next_index_long(info, einfo->errcode);
-		add_next_index_string(info, einfo->errmsg, 1);
+		add_next_index_string(info, einfo->errmsg);
 	}
 
 	return 1;
@@ -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 (!Z_ISUNDEF(func->func)) {
 			zval_ptr_dtor(&func->func);
 		}
-		if (func->step) {
+		if (!Z_ISUNDEF(func->step)) {
 			zval_ptr_dtor(&func->step);
 		}
-		if (func->fini) {
+		if (!Z_ISUNDEF(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 (!Z_ISUNDEF(collation->callback)) {
 			zval_ptr_dtor(&collation->callback);
 		}
 		efree(collation);
@@ -175,7 +175,7 @@ static int sqlite_handle_closer(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static int sqlite_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
+static int sqlite_handle_preparer(pdo_dbh_t *dbh, const char *sql, zend_long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
 {
 	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
 	pdo_sqlite_stmt *S = ecalloc(1, sizeof(pdo_sqlite_stmt));
@@ -203,7 +203,7 @@ static int sqlite_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len,
 	return 0;
 }
 
-static long sqlite_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)
+static zend_long sqlite_handle_doer(pdo_dbh_t *dbh, const char *sql, zend_long sql_len TSRMLS_DC)
 {
 	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
 	char *errmsg = NULL;
@@ -280,12 +280,12 @@ static int sqlite_handle_rollback(pdo_dbh_t *dbh TSRMLS_DC)
 	return 1;
 }
 
-static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_value TSRMLS_DC)
+static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, zend_long attr, zval *return_value TSRMLS_DC)
 {
 	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:
@@ -295,7 +295,7 @@ static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_valu
 	return 1;
 }
 
-static int pdo_sqlite_set_attr(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
+static int pdo_sqlite_set_attr(pdo_dbh_t *dbh, zend_long attr, zval *val TSRMLS_DC)
 {
 	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -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;
+	zend_reference *agg_context = NULL;
 	
 	if (is_agg) {
 		is_agg = 2;
@@ -327,63 +327,58 @@ 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 = 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) {
-			MAKE_STD_ZVAL(*agg_context);
-			ZVAL_NULL(*agg_context);
+		agg_context = (zend_reference*)sqlite3_aggregate_context(context, sizeof(zend_reference));
+		if (!agg_context) {
+			ZVAL_NULL(&zargs[0]);
+		} else {
+			if (Z_ISUNDEF(agg_context->val)) {
+				GC_REFCOUNT(agg_context) = 1;
+				GC_TYPE_INFO(agg_context) = IS_REFERENCE;
+				ZVAL_NULL(&agg_context->val);
+			}
+			ZVAL_REF(&zargs[0], 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_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;
 		}
 	}
 
-
 	fc->fci.params = zargs;
 
-
 	if ((ret = zend_call_function(&fc->fci, &fc->fcc TSRMLS_CC)) == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
 	}
@@ -391,12 +386,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 +397,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 (!Z_ISUNDEF(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 +408,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 {
@@ -429,23 +421,23 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 		}
 
 		if (agg_context) {
-			zval_ptr_dtor(agg_context);
+			zval_ptr_dtor(&agg_context->val);
 		}
 	} else {
 		/* we're stepping in an aggregate; the return value goes into
 		 * the context */
 		if (agg_context) {
-			zval_ptr_dtor(agg_context);
+			zval_ptr_dtor(&agg_context->val);
 		}
-		if (retval) {
-			*agg_context = retval;
-			retval = NULL;
+		if (!Z_ISUNDEF(retval)) {
+			ZVAL_COPY_VALUE(&agg_context->val, &retval);
+			ZVAL_UNDEF(&retval);
 		} else {
-			*agg_context = NULL;
+			ZVAL_UNDEF(&agg_context->val);
 		}
 	}
 
-	if (retval) {
+	if (!Z_ISUNDEF(retval)) {
 		zval_ptr_dtor(&retval);
 	}
 
@@ -458,7 +450,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 +459,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 +467,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 +475,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 (!Z_ISUNDEF(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;
 }
@@ -536,9 +521,9 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 	struct pdo_sqlite_func *func;
 	zval *callback;
 	char *func_name;
-	int func_name_len;
-	long argc = -1;
-	char *cbname = NULL;
+	size_t func_name_len;
+	zend_long argc = -1;
+	zend_string *cbname = NULL;
 	pdo_dbh_t *dbh;
 	pdo_sqlite_db_handle *H;
 	int ret;
@@ -548,15 +533,15 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 		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);
+		zend_string_release(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	zend_string_release(cbname);
 	
 	H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -567,8 +552,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;
 
@@ -607,9 +591,9 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 	struct pdo_sqlite_func *func;
 	zval *step_callback, *fini_callback;
 	char *func_name;
-	int func_name_len;
-	long argc = -1;
-	char *cbname = NULL;
+	size_t func_name_len;
+	zend_long argc = -1;
+	zend_string *cbname = NULL;
 	pdo_dbh_t *dbh;
 	pdo_sqlite_db_handle *H;
 	int ret;
@@ -619,21 +603,21 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 		RETURN_FALSE;
 	}
 	
-	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	dbh = Z_PDO_DBH_P(getThis());
 	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);
+		zend_string_release(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	zend_string_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);
+		zend_string_release(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	zend_string_release(cbname);
 	
 	H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -644,11 +628,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;
 
@@ -670,8 +652,8 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
 	struct pdo_sqlite_collation *collation;
 	zval *callback;
 	char *collation_name;
-	int collation_name_len;
-	char *cbname = NULL;
+	size_t collation_name_len;
+	zend_string *cbname = NULL;
 	pdo_dbh_t *dbh;
 	pdo_sqlite_db_handle *H;
 	int ret;
@@ -681,15 +663,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);
+		zend_string_release(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	zend_string_release(cbname);
 
 	H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -699,8 +681,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;
@@ -811,7 +792,7 @@ static int pdo_sqlite_handle_factory(pdo_dbh_t *dbh, zval *driver_options TSRMLS
 {
 	pdo_sqlite_db_handle *H;
 	int i, ret = 0;
-	long timeout = 60;
+	zend_long timeout = 60;
 	char *filename;
 
 	H = pecalloc(1, sizeof(pdo_sqlite_db_handle), dbh->is_persistent);