Merge branch 'master' of https://git.php.net/push/php-src

* 'master' of https://git.php.net/push/php-src: (6215 commits)
  Extra comma
  Moved proxy object support in ASSIGN_ADD (and family) from VM to slow paths of corresponding operators
  Simplification
  zend_get_property_info_quick() cleanup and optimization
  initialize lineno before calling compile file file in phar
  Use ADDREF instead of DUP, it must be enough.
  Removed old irrelevant comment
  fixed compilation error
  Fix bug #68262: Broken reference across cloned objects
  export functions needed for phpdbg
  Fixed compilation
  Optimized property access handlers. Removed EG(std_property_info).
  Fixed bug #68199 (PDO::pgsqlGetNotify doesn't support NOTIFY payloads)
  Don't make difference between undefined and unaccessible properies when call __get() and family
  Don't make useless CSE
  array_pop/array_shift optimization
  check for zlib headers as well as lib for mysqlnd
  a realpath cache key can be int or float, catching this
  News entry for new curl constants
  News entry for new curl constants
  ...

1 files changed, 255 insertions, 243 deletions

diff --git a/ext/odbc/php_odbc.c b/ext/odbc/php_odbc.c
index c84a4ecc60..6729163996 100644
--- a/ext/odbc/php_odbc.c
+++ b/ext/odbc/php_odbc.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        |
@@ -416,7 +416,7 @@ ZEND_GET_MODULE(odbc)
 
 /* {{{ _free_odbc_result
  */
-static void _free_odbc_result(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void _free_odbc_result(zend_resource *rsrc TSRMLS_DC)
 {
 	odbc_result *res = (odbc_result *)rsrc->ptr;
 	int i;
@@ -465,24 +465,21 @@ static void safe_odbc_disconnect( void *handle )
 
 /* {{{ _close_odbc_conn
  */
-static void _close_odbc_conn(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void _close_odbc_conn(zend_resource *rsrc TSRMLS_DC)
 {
-	int i, nument, type;
-	void *ptr;
+	zend_resource *p;
 	odbc_result *res;
 
 	odbc_connection *conn = (odbc_connection *)rsrc->ptr;
 
-	nument = zend_hash_next_free_element(&EG(regular_list));
-	for(i = 1; i < nument; i++) {
-		ptr = zend_list_find(i, &type);
-		if (ptr && (type == le_result)) {
-			res = (odbc_result *)ptr;
+	ZEND_HASH_FOREACH_PTR(&EG(regular_list), p) {
+		if (p->ptr && (p->type == le_result)) {
+			res = (odbc_result *)p->ptr;
 			if (res->conn_ptr == conn) {
-				zend_list_delete(i);
+				zend_list_close(p);
 			}
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
    	safe_odbc_disconnect(conn->hdbc);
 	SQLFreeConnect(conn->hdbc);
@@ -494,24 +491,21 @@ static void _close_odbc_conn(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 
 /* {{{ void _close_odbc_pconn
  */
-static void _close_odbc_pconn(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void _close_odbc_pconn(zend_resource *rsrc TSRMLS_DC)
 {
-	int i, nument, type;
-	void *ptr;
+	zend_resource *p;
 	odbc_result *res;
 	odbc_connection *conn = (odbc_connection *)rsrc->ptr;
 
-	nument = zend_hash_next_free_element(&EG(persistent_list));
-	for(i = 1; i < nument; i++) {
-		ptr = zend_list_find(i, &type);
-		if (ptr && (type == le_result)) {
-			res = (odbc_result *)ptr;
+	ZEND_HASH_FOREACH_PTR(&EG(regular_list), p) {
+		if (p->ptr && (p->type == le_result)) {
+			res = (odbc_result *)p->ptr;
 			if (res->conn_ptr == conn) {
-				zend_list_delete(i);
+				zend_list_close(p);
 			}
 		}
-	}
-	
+	} ZEND_HASH_FOREACH_END();
+
 	safe_odbc_disconnect(conn->hdbc);
 	SQLFreeConnect(conn->hdbc);
 	SQLFreeEnv(conn->henv);
@@ -530,9 +524,9 @@ static PHP_INI_DISP(display_link_nums)
 	TSRMLS_FETCH();
 
 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
-		value = ini_entry->orig_value;
+		value = ini_entry->orig_value->val;
 	} else if (ini_entry->value) {
-		value = ini_entry->value;
+		value = ini_entry->value->val;
 	} else {
 		value = NULL;
 	}
@@ -555,9 +549,9 @@ static PHP_INI_DISP(display_defPW)
 	TSRMLS_FETCH();
 
 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
-		value = ini_entry->orig_value;
+		value = ini_entry->orig_value->val;
 	} else if (ini_entry->value) {
-		value = ini_entry->value;
+		value = ini_entry->value->val;
 	} else {
 		value = NULL;
 	}
@@ -586,9 +580,9 @@ static PHP_INI_DISP(display_binmode)
 	TSRMLS_FETCH();
 	
 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
-		value = ini_entry->orig_value;
+		value = ini_entry->orig_value->val;
 	} else if (ini_entry->value) {
-		value = ini_entry->value;
+		value = ini_entry->value->val;
 	} else {
 		value = NULL;
 	}
@@ -617,9 +611,9 @@ static PHP_INI_DISP(display_lrl)
 	TSRMLS_FETCH();
 
 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
-		value = ini_entry->orig_value;
+		value = ini_entry->orig_value->val;
 	} else if (ini_entry->value) {
-		value = ini_entry->value;
+		value = ini_entry->value->val;
 	} else {
 		value = NULL;
 	}
@@ -643,9 +637,9 @@ static PHP_INI_DISP(display_cursortype)
 	TSRMLS_FETCH();
 
 	if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
-		value = ini_entry->orig_value;
+		value = ini_entry->orig_value->val;
 	} else if (ini_entry->value) {
-		value = ini_entry->value;
+		value = ini_entry->value->val;
 	} else {
 		value = NULL;
 	}
@@ -721,7 +715,7 @@ PHP_MINIT_FUNCTION(odbc)
 	le_result = zend_register_list_destructors_ex(_free_odbc_result, NULL, "odbc result", module_number);
 	le_conn = zend_register_list_destructors_ex(_close_odbc_conn, NULL, "odbc link", module_number);
 	le_pconn = zend_register_list_destructors_ex(NULL, _close_odbc_pconn, "odbc link persistent", module_number);
-	Z_TYPE(odbc_module_entry) = type;
+	odbc_module_entry.type = type;
 	
 	REGISTER_STRING_CONSTANT("ODBC_TYPE", PHP_ODBC_TYPE, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("ODBC_BINMODE_PASSTHRU", 0, CONST_CS | CONST_PERSISTENT);
@@ -780,6 +774,9 @@ PHP_MINIT_FUNCTION(odbc)
 	REGISTER_LONG_CONSTANT("SQL_TYPE_DATE", SQL_TYPE_DATE, CONST_PERSISTENT | CONST_CS);
 	REGISTER_LONG_CONSTANT("SQL_TYPE_TIME", SQL_TYPE_TIME, CONST_PERSISTENT | CONST_CS);
 	REGISTER_LONG_CONSTANT("SQL_TYPE_TIMESTAMP", SQL_TYPE_TIMESTAMP, CONST_PERSISTENT | CONST_CS);
+	REGISTER_LONG_CONSTANT("SQL_WCHAR", SQL_WCHAR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_LONG_CONSTANT("SQL_WVARCHAR", SQL_WVARCHAR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_LONG_CONSTANT("SQL_WLONGVARCHAR", SQL_WLONGVARCHAR, CONST_PERSISTENT | CONST_CS);
 
 	/*
 	 * SQLSpecialColumns values
@@ -844,9 +841,9 @@ PHP_MINFO_FUNCTION(odbc)
 
 	php_info_print_table_start();
 	php_info_print_table_header(2, "ODBC Support", "enabled");
-	snprintf(buf, sizeof(buf), "%ld", ODBCG(num_persistent));
+	snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ODBCG(num_persistent));
 	php_info_print_table_row(2, "Active Persistent Links", buf);
-	snprintf(buf, sizeof(buf), "%ld", ODBCG(num_links));
+	snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ODBCG(num_links));
 	php_info_print_table_row(2, "Active Links", buf);
 	php_info_print_table_row(2, "ODBC library", PHP_ODBC_TYPE);
 #ifndef PHP_WIN32
@@ -914,14 +911,14 @@ void php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAMETERS, int mode)
 {
 	odbc_result *result;
 	zval *pv_res;
-	long flag;
+	zend_long flag;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &flag) == FAILURE) {
 		return;
 	}
 	
 	if (Z_LVAL_P(pv_res)) {
-		ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+		ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
         if (mode) {
             result->longreadlen = flag;
         } else {
@@ -943,8 +940,10 @@ int odbc_bindcols(odbc_result *result TSRMLS_DC)
 {
 	RETCODE rc;
 	int i;
-	SQLSMALLINT colnamelen; /* Not used */
-	SQLLEN      displaysize;
+	SQLSMALLINT 	colnamelen; /* Not used */
+	SQLLEN      	displaysize;
+	SQLUSMALLINT	colfieldid;
+	int		charextraalloc;
 
 	result->values = (odbc_result_value *) safe_emalloc(sizeof(odbc_result_value), result->numcols, 0);
 
@@ -952,6 +951,9 @@ int odbc_bindcols(odbc_result *result TSRMLS_DC)
 	result->binmode = ODBCG(defaultbinmode);
 
 	for(i = 0; i < result->numcols; i++) {
+		charextraalloc = 0;
+		colfieldid = SQL_COLUMN_DISPLAY_SIZE;
+
 		rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_NAME, 
 				result->values[i].name, sizeof(result->values[i].name), &colnamelen, 0);
 		rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_TYPE, 
@@ -966,6 +968,9 @@ int odbc_bindcols(odbc_result *result TSRMLS_DC)
 			case SQL_VARBINARY:
 			case SQL_LONGVARBINARY:
 			case SQL_LONGVARCHAR:
+#if defined(ODBCVER) && (ODBCVER >= 0x0300)
+			case SQL_WLONGVARCHAR:
+#endif
 				result->values[i].value = NULL;
 				break;
 				
@@ -976,15 +981,27 @@ int odbc_bindcols(odbc_result *result TSRMLS_DC)
 							27, &result->values[i].vallen);
 				break;
 #endif /* HAVE_ADABAS */
+			case SQL_CHAR:
+			case SQL_VARCHAR:
+#if defined(ODBCVER) && (ODBCVER >= 0x0300)
+			case SQL_WCHAR:
+			case SQL_WVARCHAR:
+				colfieldid = SQL_DESC_OCTET_LENGTH;
+#else
+				charextraalloc = 1;
+#endif
 			default:
-				rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_DISPLAY_SIZE,
-									NULL, 0, NULL, &displaysize);
-				displaysize = displaysize <= result->longreadlen ? displaysize : 
-								result->longreadlen;
+				rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), colfieldid,
+								NULL, 0, NULL, &displaysize);
 				/* Workaround for Oracle ODBC Driver bug (#50162) when fetching TIMESTAMP column */
 				if (result->values[i].coltype == SQL_TIMESTAMP) {
 					displaysize += 3;
 				}
+
+				if (charextraalloc) {
+					/* Since we don't know the exact # of bytes, allocate extra */
+					displaysize *= 4;
+				}
 				result->values[i].value = (char *)emalloc(displaysize + 1);
 				rc = SQLBindCol(result->stmt, (SQLUSMALLINT)(i+1), SQL_C_CHAR, result->values[i].value,
 							displaysize + 1, &result->values[i].vallen);
@@ -1006,7 +1023,7 @@ void odbc_transact(INTERNAL_FUNCTION_PARAMETERS, int type)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 	
 	rc = SQLTransact(conn->henv, conn->hdbc, (SQLUSMALLINT)((type)?SQL_COMMIT:SQL_ROLLBACK));
 	if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
@@ -1018,10 +1035,10 @@ void odbc_transact(INTERNAL_FUNCTION_PARAMETERS, int type)
 }
 /* }}} */
 
-/* {{{ _close_pconn_with_id */
-static int _close_pconn_with_id(zend_rsrc_list_entry *le, int *id TSRMLS_DC)
+/* {{{ _close_pconn_with_res */
+static int _close_pconn_with_res(zend_resource *le, zend_resource *res TSRMLS_DC)
 {
-	if(Z_TYPE_P(le) == le_pconn && (((odbc_connection *)(le->ptr))->id == *id)){
+	if (le->type == le_pconn && (((odbc_connection *)(le->ptr))->res == res)){
 		return 1;
 	}else{
 		return 0;
@@ -1045,13 +1062,13 @@ void odbc_column_lengths(INTERNAL_FUNCTION_PARAMETERS, int type)
 	SQLLEN len;
 #endif
 	zval *pv_res;
-	long pv_num;
+	zend_long pv_num;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 
 	if (result->numcols == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
@@ -1080,41 +1097,32 @@ void odbc_column_lengths(INTERNAL_FUNCTION_PARAMETERS, int type)
    Close all ODBC connections */
 PHP_FUNCTION(odbc_close_all)
 {
-	void *ptr;
-	int type;
-	int i;
-	int nument;
+	zend_resource *p;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	nument = zend_hash_next_free_element(&EG(regular_list));
-	
 	/* Loop through list and close all statements */
-	for(i = 1; i < nument; i++) {
-		ptr = zend_list_find(i, &type);
-		if (ptr && (type == le_result)){
-			zend_list_delete(i);
+	ZEND_HASH_FOREACH_PTR(&EG(regular_list), p) {
+		if (p->ptr && (p->type == le_result)) {
+			zend_list_close(p);
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	/* Second loop through list, now close all connections */
-	nument = zend_hash_next_free_element(&EG(regular_list));
-	
-	for(i = 1; i < nument; i++) {
-		ptr = zend_list_find(i, &type);
-		if (ptr){
-			if(type == le_conn){
-				zend_list_delete(i);
-			}else if(type == le_pconn){
-				zend_list_delete(i);
+	ZEND_HASH_FOREACH_PTR(&EG(regular_list), p) {
+		if (p->ptr) {
+			if (p->type == le_conn){
+				zend_list_close(p);
+			} else if (p->type == le_pconn){
+				zend_list_close(p);
 				/* Delete the persistent connection */
 				zend_hash_apply_with_argument(&EG(persistent_list), 
-					(apply_func_arg_t) _close_pconn_with_id, (void *) &i TSRMLS_CC);
+					(apply_func_arg_t) _close_pconn_with_res, (void *)p TSRMLS_CC);
 			}
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -1140,7 +1148,7 @@ PHP_FUNCTION(odbc_prepare)
 {
 	zval *pv_conn;
 	char *query;
-	int query_len;
+	size_t query_len;
 	odbc_result *result = NULL;
 	odbc_connection *conn;
 	RETCODE rc;
@@ -1152,7 +1160,7 @@ PHP_FUNCTION(odbc_prepare)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -1210,7 +1218,7 @@ PHP_FUNCTION(odbc_prepare)
 	} else {
 		result->values = NULL;
 	}
-	zend_list_addref(conn->id);
+	Z_ADDREF_P(pv_conn);
 	result->conn_ptr = conn;
 	result->fetched = 0;
 	ZEND_REGISTER_RESOURCE(return_value, result, le_result);  
@@ -1225,7 +1233,7 @@ PHP_FUNCTION(odbc_prepare)
    Execute a prepared statement */
 PHP_FUNCTION(odbc_execute)
 { 
-	zval *pv_res, *pv_param_arr, **tmp;
+	zval *pv_res, *pv_param_arr, *tmp;
 	typedef struct params_t {
 		SQLLEN vallen;
 		int fp;
@@ -1246,7 +1254,7 @@ PHP_FUNCTION(odbc_execute)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	
 	/* XXX check for already bound parameters*/
 	if (result->numparams > 0 && numArgs == 1) {
@@ -1267,7 +1275,7 @@ PHP_FUNCTION(odbc_execute)
 		}
 		
 		for(i = 1; i <= result->numparams; i++) {
-			if (zend_hash_get_current_data(Z_ARRVAL_P(pv_param_arr), (void **) &tmp) == FAILURE) {
+			if ((tmp = zend_hash_get_current_data(Z_ARRVAL_P(pv_param_arr))) == NULL) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING,"Error getting parameter");
 				SQLFreeStmt(result->stmt,SQL_RESET_PARAMS);
 				for (i = 0; i < result->numparams; i++) {
@@ -1279,9 +1287,9 @@ PHP_FUNCTION(odbc_execute)
 				RETURN_FALSE;
 			}
 
-			otype = (*tmp)->type;
+			otype = Z_TYPE_P(tmp);
 			convert_to_string_ex(tmp);
-			if (Z_TYPE_PP(tmp) != IS_STRING) {
+			if (Z_TYPE_P(tmp) != IS_STRING) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING,"Error converting parameter");
 				SQLFreeStmt(result->stmt, SQL_RESET_PARAMS);
 				for (i = 0; i < result->numparams; i++) {
@@ -1294,7 +1302,7 @@ PHP_FUNCTION(odbc_execute)
 			}
 			
 			rc = SQLDescribeParam(result->stmt, (SQLUSMALLINT)i, &sqltype, &precision, &scale, &nullable);
-			params[i-1].vallen = Z_STRLEN_PP(tmp);
+			params[i-1].vallen = Z_STRLEN_P(tmp);
 			params[i-1].fp = -1;
 			if (rc == SQL_ERROR) {
 				odbc_sql_error(result->conn_ptr, result->stmt, "SQLDescribeParameter");	
@@ -1314,14 +1322,14 @@ PHP_FUNCTION(odbc_execute)
 				ctype = SQL_C_CHAR;
 			}
 
-			if (Z_STRLEN_PP(tmp) > 2 &&
-				Z_STRVAL_PP(tmp)[0] == '\'' &&
-				Z_STRVAL_PP(tmp)[Z_STRLEN_PP(tmp) - 1] == '\'') {
+			if (Z_STRLEN_P(tmp) > 2 &&
+				Z_STRVAL_P(tmp)[0] == '\'' &&
+				Z_STRVAL_P(tmp)[Z_STRLEN_P(tmp) - 1] == '\'') {
 					
-				if (CHECK_ZVAL_NULL_PATH(*tmp)) {
+				if (CHECK_ZVAL_NULL_PATH(tmp)) {
 					RETURN_FALSE;
 				}
-				filename = estrndup(&Z_STRVAL_PP(tmp)[1], Z_STRLEN_PP(tmp) - 2);
+				filename = estrndup(&Z_STRVAL_P(tmp)[1], Z_STRLEN_P(tmp) - 2);
 				filename[strlen(filename)] = '\0';
 
 				/* Check the basedir */
@@ -1368,7 +1376,7 @@ PHP_FUNCTION(odbc_execute)
 
 				rc = SQLBindParameter(result->stmt, (SQLUSMALLINT)i, SQL_PARAM_INPUT,
 									  ctype, sqltype, precision, scale,
-									  Z_STRVAL_PP(tmp), 0,
+									  Z_STRVAL_P(tmp), 0,
 									  &params[i-1].vallen);
 			}
 			if (rc == SQL_ERROR) {
@@ -1464,7 +1472,7 @@ PHP_FUNCTION(odbc_cursor)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 
 	rc = SQLGetInfo(result->conn_ptr->hdbc,SQL_MAX_CURSOR_NAME_LEN, (void *)&max_len,sizeof(max_len),&len);
 	if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
@@ -1489,14 +1497,14 @@ PHP_FUNCTION(odbc_cursor)
 					odbc_sql_error(result->conn_ptr, result->stmt, "SQLSetCursorName");
 					RETVAL_FALSE;
 				} else {
-					RETVAL_STRING(cursorname,1);
+					RETVAL_STRING(cursorname);
 				}
 			} else {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQL error: %s, SQL state %s", errormsg, state);
 				RETVAL_FALSE;
 			}
 		} else {
-			RETVAL_STRING(cursorname,1);
+			RETVAL_STRING(cursorname);
 		}
 		efree(cursorname);
 	} else {
@@ -1511,7 +1519,7 @@ PHP_FUNCTION(odbc_cursor)
 PHP_FUNCTION(odbc_data_source)
 {
 	zval *zv_conn;
-	long zv_fetch_type;
+	zend_long zv_fetch_type;
 	RETCODE rc = 0; /* assume all is good */
 	odbc_connection *conn;
 	UCHAR server_name[100], desc[200];
@@ -1528,7 +1536,7 @@ PHP_FUNCTION(odbc_data_source)
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &zv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, zv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	/* now we have the "connection" lets call the DataSource object */
 	rc = SQLDataSources(conn->henv, 
@@ -1553,8 +1561,8 @@ PHP_FUNCTION(odbc_data_source)
 
 	array_init(return_value);
 
-	add_assoc_string_ex(return_value, "server", sizeof("server"), server_name, 1);
-	add_assoc_string_ex(return_value, "description", sizeof("description"), desc, 1);
+	add_assoc_string_ex(return_value, "server", sizeof("server"), server_name);
+	add_assoc_string_ex(return_value, "description", sizeof("description"), desc);
 
 }
 /* }}} */
@@ -1566,7 +1574,7 @@ PHP_FUNCTION(odbc_data_source)
 PHP_FUNCTION(odbc_exec)
 {
 	zval *pv_conn;
-	long pv_flags;
+	zend_long pv_flags;
 	char *query;
 	int numArgs, query_len;
 	odbc_result *result = NULL;
@@ -1582,7 +1590,7 @@ PHP_FUNCTION(odbc_exec)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 		
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 
@@ -1637,7 +1645,7 @@ PHP_FUNCTION(odbc_exec)
 	} else {
 		result->values = NULL;
 	}
-	zend_list_addref(conn->id);
+	Z_ADDREF_P(pv_conn);
 	result->conn_ptr = conn;
 	result->fetched = 0;
 	ZEND_REGISTER_RESOURCE(return_value, result, le_result);
@@ -1660,8 +1668,8 @@ static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type)
 	SQLULEN crow;
 	SQLUSMALLINT RowStatus[1];
 	SQLLEN rownum;
-	zval *pv_res, *tmp;
-	long pv_row = -1;
+	zval *pv_res, tmp;
+	zend_long pv_row = -1;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_res, &pv_row) == FAILURE) {
 		return;
@@ -1669,14 +1677,14 @@ static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type)
 	
 	rownum = pv_row;
 #else
-	zval *pv_res, *tmp;
+	zval *pv_res, tmp;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
 		return;
 	}
 #endif
 
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 
 	if (result->numcols == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
@@ -1708,9 +1716,6 @@ static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type)
 		result->fetched++;
 
 	for(i = 0; i < result->numcols; i++) {
-		ALLOC_INIT_ZVAL(tmp);
-		Z_TYPE_P(tmp) = IS_STRING;
-		Z_STRLEN_P(tmp) = 0;
 		sql_c_type = SQL_C_CHAR;
 
 		switch(result->values[i].coltype) {
@@ -1718,15 +1723,18 @@ static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type)
 			case SQL_VARBINARY:
 			case SQL_LONGVARBINARY:
 				if (result->binmode <= 0) {
-					Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC();
+					ZVAL_EMPTY_STRING(&tmp);
 					break;
 				}
 				if (result->binmode == 1) {
 					sql_c_type = SQL_C_BINARY;
 				}
 			case SQL_LONGVARCHAR:
+#if defined(ODBCVER) && (ODBCVER >= 0x0300)
+			case SQL_WLONGVARCHAR:
+#endif
 				if (IS_SQL_LONG(result->values[i].coltype) && result->longreadlen <= 0) {
-					Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC();
+					ZVAL_EMPTY_STRING(&tmp);
 					break;
 				}				
 				if (buf == NULL) {
@@ -1742,33 +1750,31 @@ static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type)
 				}
 
 				if (rc == SQL_SUCCESS_WITH_INFO) {
-					Z_STRLEN_P(tmp) = result->longreadlen;
+					ZVAL_STRINGL(&tmp, buf, result->longreadlen);
 				} else if (result->values[i].vallen == SQL_NULL_DATA) {
-					ZVAL_NULL(tmp);
+					ZVAL_NULL(&tmp);
 					break;
 				} else {
-					Z_STRLEN_P(tmp) = result->values[i].vallen;
+					ZVAL_STRINGL(&tmp, buf, result->values[i].vallen);
 				}
-				Z_STRVAL_P(tmp) = estrndup(buf, Z_STRLEN_P(tmp));
 				break;
 
 			default:
 				if (result->values[i].vallen == SQL_NULL_DATA) {
-					ZVAL_NULL(tmp);
+					ZVAL_NULL(&tmp);
 					break;
 				}
-				Z_STRLEN_P(tmp) = result->values[i].vallen;
-				Z_STRVAL_P(tmp) = estrndup(result->values[i].value,Z_STRLEN_P(tmp));
+				ZVAL_STRINGL(&tmp, result->values[i].value, result->values[i].vallen);
 				break;
 		}
 
 		if (result_type & ODBC_NUM) {
-			zend_hash_index_update(Z_ARRVAL_P(return_value), i, &tmp, sizeof(zval *), NULL);
+			zend_hash_index_update(Z_ARRVAL_P(return_value), i, &tmp);
 		} else {
-			if (!*(result->values[i].name) && Z_TYPE_P(tmp) == IS_STRING) {
-				zend_hash_update(Z_ARRVAL_P(return_value), Z_STRVAL_P(tmp),	Z_STRLEN_P(tmp)+1, &tmp, sizeof(zval *), NULL);
+			if (!*(result->values[i].name) && Z_TYPE(tmp) == IS_STRING) {
+				zend_hash_update(Z_ARRVAL_P(return_value), Z_STR(tmp), &tmp);
 			} else {
-				zend_hash_update(Z_ARRVAL_P(return_value), result->values[i].name, strlen(result->values[i].name)+1, &tmp, sizeof(zval *), NULL);
+				zend_hash_str_update(Z_ARRVAL_P(return_value), result->values[i].name, strlen(result->values[i].name), &tmp);
 			}
 		}
 	}
@@ -1808,35 +1814,35 @@ PHP_FUNCTION(odbc_fetch_into)
 	RETCODE rc;
 	SQLSMALLINT sql_c_type;
 	char *buf = NULL;
-	zval *pv_res, **pv_res_arr, *tmp;
+	zval *pv_res, *pv_res_arr, tmp;
 #ifdef HAVE_SQL_EXTENDED_FETCH
-	long pv_row = 0;
+	zend_long pv_row = 0;
 	SQLULEN crow;
 	SQLUSMALLINT RowStatus[1];
 	SQLLEN rownum = -1;
 #endif /* HAVE_SQL_EXTENDED_FETCH */
 
 #ifdef HAVE_SQL_EXTENDED_FETCH
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ|l", &pv_res, &pv_res_arr, &pv_row) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz/|l", &pv_res, &pv_res_arr, &pv_row) == FAILURE) {
 		return;
 	}
 	
 	rownum = pv_row;
 #else
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pv_res, &pv_res_arr) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz/", &pv_res, &pv_res_arr) == FAILURE) {
 		return;
 	}
 #endif /* HAVE_SQL_EXTENDED_FETCH */
 
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	
 	if (result->numcols == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
 		RETURN_FALSE;
 	}
 	
-	if (Z_TYPE_PP(pv_res_arr) != IS_ARRAY) {
-		array_init(*pv_res_arr);
+	if (Z_TYPE_P(pv_res_arr) != IS_ARRAY) {
+		array_init(pv_res_arr);
 	}
 
 #ifdef HAVE_SQL_EXTENDED_FETCH
@@ -1862,9 +1868,6 @@ PHP_FUNCTION(odbc_fetch_into)
 		result->fetched++;
 
 	for(i = 0; i < result->numcols; i++) {
-		MAKE_STD_ZVAL(tmp);
-		Z_TYPE_P(tmp) = IS_STRING;
-		Z_STRLEN_P(tmp) = 0;
 		sql_c_type = SQL_C_CHAR;
 
 		switch(result->values[i].coltype) {
@@ -1872,13 +1875,17 @@ PHP_FUNCTION(odbc_fetch_into)
 			case SQL_VARBINARY:
 			case SQL_LONGVARBINARY:
 				if (result->binmode <= 0) {
-					Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC();
+					ZVAL_EMPTY_STRING(&tmp);
 					break;
 				}
 				if (result->binmode == 1) sql_c_type = SQL_C_BINARY; 
+
 			case SQL_LONGVARCHAR:
+#if defined(ODBCVER) && (ODBCVER >= 0x0300)
+			case SQL_WLONGVARCHAR:
+#endif
 				if (IS_SQL_LONG(result->values[i].coltype) && result->longreadlen <= 0) {
-					Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC();
+					ZVAL_EMPTY_STRING(&tmp);
 					break;
 				}
 
@@ -1893,26 +1900,24 @@ PHP_FUNCTION(odbc_fetch_into)
 					RETURN_FALSE;
 				}
 				if (rc == SQL_SUCCESS_WITH_INFO) {
-					Z_STRLEN_P(tmp) = result->longreadlen;
+					ZVAL_STRINGL(&tmp, buf, result->longreadlen);
 				} else if (result->values[i].vallen == SQL_NULL_DATA) {
-					ZVAL_NULL(tmp);
+					ZVAL_NULL(&tmp);
 					break;
 				} else {
-					Z_STRLEN_P(tmp) = result->values[i].vallen;
+					ZVAL_STRINGL(&tmp, buf, result->values[i].vallen);
 				}
-				Z_STRVAL_P(tmp) = estrndup(buf, Z_STRLEN_P(tmp));
 				break;
 
 			default:
 				if (result->values[i].vallen == SQL_NULL_DATA) {
-					ZVAL_NULL(tmp);
+					ZVAL_NULL(&tmp);
 					break;
 				}
-				Z_STRLEN_P(tmp) = result->values[i].vallen;
-				Z_STRVAL_P(tmp) = estrndup(result->values[i].value,Z_STRLEN_P(tmp));
+				ZVAL_STRINGL(&tmp, result->values[i].value, result->values[i].vallen);
 				break;
 		}
-		zend_hash_index_update(Z_ARRVAL_PP(pv_res_arr), i, &tmp, sizeof(zval *), NULL);
+		zend_hash_index_update(Z_ARRVAL_P(pv_res_arr), i, &tmp);
 	}
 	if (buf) efree(buf);
 	RETURN_LONG(result->numcols);	
@@ -1960,7 +1965,7 @@ PHP_FUNCTION(odbc_fetch_row)
 	odbc_result *result;
 	RETCODE rc;
 	zval *pv_res;
-	long pv_row = 1;
+	zend_long pv_row = 1;
 #ifdef HAVE_SQL_EXTENDED_FETCH
 	SQLULEN crow;
 	SQLUSMALLINT RowStatus[1];
@@ -1972,7 +1977,7 @@ PHP_FUNCTION(odbc_fetch_row)
 	
 	rownum = pv_row;
 	
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	
 	if (result->numcols == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
@@ -2015,7 +2020,7 @@ PHP_FUNCTION(odbc_result)
 	int i = 0;
 	RETCODE rc;
 	SQLLEN	fieldsize;
-	zval *pv_res, **pv_field;
+	zval *pv_res, *pv_field;
 #ifdef HAVE_SQL_EXTENDED_FETCH
 	SQLULEN crow;
 	SQLUSMALLINT RowStatus[1];
@@ -2024,18 +2029,18 @@ PHP_FUNCTION(odbc_result)
 	field_ind = -1;
 	field = NULL;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pv_res, &pv_field) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &pv_res, &pv_field) == FAILURE) {
 		return;
 	}
 	
-	if (Z_TYPE_PP(pv_field) == IS_STRING) {
-		field = Z_STRVAL_PP(pv_field);
+	if (Z_TYPE_P(pv_field) == IS_STRING) {
+		field = Z_STRVAL_P(pv_field);
 	} else {
 		convert_to_long_ex(pv_field);
-		field_ind = Z_LVAL_PP(pv_field) - 1;
+		field_ind = Z_LVAL_P(pv_field) - 1;
 	}
 	
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	
 	if ((result->numcols == 0)) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
@@ -2095,6 +2100,9 @@ PHP_FUNCTION(odbc_result)
 				break; 
 			}
 		case SQL_LONGVARCHAR:
+#if defined(ODBCVER) && (ODBCVER >= 0x0300)
+		case SQL_WLONGVARCHAR:
+#endif
 			if (IS_SQL_LONG(result->values[field_ind].coltype)) {
 				if (result->longreadlen <= 0) {
 				   break;
@@ -2132,20 +2140,27 @@ PHP_FUNCTION(odbc_result)
 			}
 			/* Reduce fieldlen by 1 if we have char data. One day we might 
 			   have binary strings... */
-			if (result->values[field_ind].coltype == SQL_LONGVARCHAR) {
+			if ((result->values[field_ind].coltype == SQL_LONGVARCHAR)
+#if defined(ODBCVER) && (ODBCVER >= 0x0300)
+			    || (result->values[field_ind].coltype == SQL_WLONGVARCHAR)
+#endif
+			) {
 				fieldsize -= 1;
 			}
 			/* Don't duplicate result, saves one emalloc.
 			   For SQL_SUCCESS, the length is in vallen.
 			 */
-			RETURN_STRINGL(field, (rc == SQL_SUCCESS_WITH_INFO) ? fieldsize : result->values[field_ind].vallen, 0);
+			RETVAL_STRINGL(field, (rc == SQL_SUCCESS_WITH_INFO) ? fieldsize : result->values[field_ind].vallen);
+			// TODO: avoid dpouble reallocation ???
+			efree(field);
+			return;
 			break;
 			
 		default:
 			if (result->values[field_ind].vallen == SQL_NULL_DATA) {
 				RETURN_NULL();
 			} else {
-				RETURN_STRINGL(result->values[field_ind].value, result->values[field_ind].vallen, 1);
+				RETURN_STRINGL(result->values[field_ind].value, result->values[field_ind].vallen);
 			}
 			break;
 	}
@@ -2191,7 +2206,7 @@ PHP_FUNCTION(odbc_result_all)
 	RETCODE rc;
 	zval *pv_res;
 	char *pv_format = NULL;
-	int i, pv_format_len = 0;
+	size_t i, pv_format_len = 0;
 	SQLSMALLINT sql_c_type;
 #ifdef HAVE_SQL_EXTENDED_FETCH
 	SQLULEN crow;
@@ -2202,7 +2217,7 @@ PHP_FUNCTION(odbc_result_all)
 		return;
 	}
 				
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	
 	if (result->numcols == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
@@ -2248,6 +2263,9 @@ PHP_FUNCTION(odbc_result_all)
 					}
 					if (result->binmode <= 1) sql_c_type = SQL_C_BINARY; 
 				case SQL_LONGVARCHAR:
+#if defined(ODBCVER) && (ODBCVER >= 0x0300)
+				case SQL_WLONGVARCHAR:
+#endif
 					if (IS_SQL_LONG(result->values[i].coltype) && 
 						result->longreadlen <= 0) {
 						php_printf("<td>Not printable</td>"); 
@@ -2314,7 +2332,7 @@ PHP_FUNCTION(odbc_free_result)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	if (result->values) {
 		for (i = 0; i < result->numcols; i++) {
 			if (result->values[i].value) {
@@ -2325,7 +2343,7 @@ PHP_FUNCTION(odbc_free_result)
 		result->values = NULL;
 	}
 			
-	zend_list_delete(Z_LVAL_P(pv_res));
+	zend_list_close(Z_RES_P(pv_res));
 	
 	RETURN_TRUE;
 }
@@ -2483,8 +2501,8 @@ int odbc_sqlconnect(odbc_connection **conn, char *db, char *uid, char *pwd, int
 void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 {
 	char *db, *uid, *pwd;
-	int db_len, uid_len, pwd_len;
-	long pv_opt = SQL_CUR_DEFAULT;
+	size_t db_len, uid_len, pwd_len;
+	zend_long pv_opt = SQL_CUR_DEFAULT;
 	odbc_connection *db_conn;
 	char *hashed_details;
 	int hashed_len, cur_opt;
@@ -2525,11 +2543,11 @@ void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 try_and_get_another_connection:
 
 	if (persistent) {
-		zend_rsrc_list_entry *le;
+		zend_resource *le;
 		
 		/* the link is not in the persistent list */
-		if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_len + 1, (void **) &le)	== FAILURE) {
-			zend_rsrc_list_entry new_le;
+		if ((le = zend_hash_str_find_ptr(&EG(persistent_list), hashed_details, hashed_len)) == NULL) {
+			zend_resource new_le;
 			
 			if (ODBCG(max_links) != -1 && ODBCG(num_links) >= ODBCG(max_links)) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too many open links (%ld)", ODBCG(num_links));
@@ -2547,19 +2565,20 @@ try_and_get_another_connection:
 				RETURN_FALSE;
 			}
 			
-			Z_TYPE(new_le) = le_pconn;
+			new_le.type = le_pconn;
 			new_le.ptr = db_conn;
-			if (zend_hash_update(&EG(persistent_list), hashed_details, hashed_len + 1, &new_le,
-						sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
+			new_le.handle = -1;
+			if (zend_hash_str_update_mem(&EG(persistent_list), hashed_details, hashed_len, &new_le,
+						sizeof(zend_resource)) == NULL) {
 				free(db_conn);
 				efree(hashed_details);
 				RETURN_FALSE;
 			}
 			ODBCG(num_persistent)++;
 			ODBCG(num_links)++;
-			db_conn->id = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_pconn);
+			db_conn->res = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_pconn);
 		} else { /* found connection */
-			if (Z_TYPE_P(le) != le_pconn) {
+			if (le->type != le_pconn) {
 				RETURN_FALSE;
 			}
 			/*
@@ -2580,7 +2599,7 @@ try_and_get_another_connection:
 					d_name, sizeof(d_name), &len);
 
 				if(ret != SQL_SUCCESS || len == 0) {
-					zend_hash_del(&EG(persistent_list), hashed_details, hashed_len + 1);
+					zend_hash_str_del(&EG(persistent_list), hashed_details, hashed_len);
 					/* Commented out to fix a possible double closure error 
 					 * when working with persistent connections as submitted by
 					 * bug #15758
@@ -2592,28 +2611,27 @@ try_and_get_another_connection:
 				}
 			}
 		}
-		db_conn->id = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_pconn);
+		db_conn->res = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_pconn);
 	} else { /* non persistent */
-		zend_rsrc_list_entry *index_ptr, new_index_ptr;
+		zend_resource *index_ptr, new_index_ptr;
 		
-		if (zend_hash_find(&EG(regular_list), hashed_details, hashed_len + 1, (void **) &index_ptr) == SUCCESS) {
-			int type, conn_id;
-			void *ptr;
+		if ((index_ptr = zend_hash_str_find_ptr(&EG(regular_list), hashed_details, hashed_len)) != NULL) {
+			zend_ulong conn_id;
+			zend_resource *p;
 
-			if (Z_TYPE_P(index_ptr) != le_index_ptr) {
+			if (index_ptr->type != le_index_ptr) {
 				RETURN_FALSE;
 			}
-			conn_id = (int)index_ptr->ptr;
-			ptr = zend_list_find(conn_id, &type);   /* check if the connection is still there */
+			conn_id = (zend_ulong)index_ptr->ptr;
+			p = zend_hash_index_find_ptr(&EG(regular_list), conn_id);   /* check if the connection is still there */
 
-			if (ptr && (type == le_conn || type == le_pconn)) {
-				zend_list_addref(conn_id);
-				Z_LVAL_P(return_value) = conn_id;
-				Z_TYPE_P(return_value) = IS_RESOURCE;
+			if (p && p->ptr && (p->type == le_conn || p->type == le_pconn)) {
+				GC_REFCOUNT(p)++;
+				RETVAL_RES(p);
 				efree(hashed_details);
 				return;
 			} else {
-				zend_hash_del(&EG(regular_list), hashed_details, hashed_len + 1);
+				zend_hash_str_del(&EG(regular_list), hashed_details, hashed_len);
 			}
 		}
 		if (ODBCG(max_links) != -1 && ODBCG(num_links) >= ODBCG(max_links)) {
@@ -2626,12 +2644,12 @@ try_and_get_another_connection:
 			efree(hashed_details);
 			RETURN_FALSE;
 		}
-		db_conn->id = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_conn);
-		new_index_ptr.ptr = (void *) Z_LVAL_P(return_value);
-		Z_TYPE(new_index_ptr) = le_index_ptr;
+		db_conn->res = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_conn);
+		new_index_ptr.ptr = (void *) Z_RES_HANDLE_P(return_value);
+		new_index_ptr.type = le_index_ptr;
 
-		if (zend_hash_update(&EG(regular_list), hashed_details, hashed_len + 1, (void *) &new_index_ptr,
-				   sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
+		if (zend_hash_str_update_mem(&EG(regular_list), hashed_details, hashed_len, (void *) &new_index_ptr,
+				   sizeof(zend_resource)) == NULL) {
 			efree(hashed_details);
 			RETURN_FALSE;
 			/* XXX Free Connection */
@@ -2647,12 +2665,9 @@ try_and_get_another_connection:
 PHP_FUNCTION(odbc_close)
 {
 	zval *pv_conn;
-	void *ptr;
+	zend_resource *p;
 	odbc_connection *conn;
 	odbc_result *res;
-	int nument;
-	int i;
-	int type;
 	int is_pconn = 0;
 	int found_resource_type = le_conn;
 
@@ -2660,27 +2675,24 @@ PHP_FUNCTION(odbc_close)
 		return;
 	}
 
-	conn = (odbc_connection *) zend_fetch_resource(&pv_conn TSRMLS_CC, -1, "ODBC-Link", &found_resource_type, 2, le_conn, le_pconn);
+	conn = (odbc_connection *) zend_fetch_resource(pv_conn TSRMLS_CC, -1, "ODBC-Link", &found_resource_type, 2, le_conn, le_pconn);
 	if (found_resource_type==le_pconn) {
 		is_pconn = 1;
 	}
 
-	nument = zend_hash_next_free_element(&EG(regular_list));
-
-	for(i = 1; i < nument; i++){
-		ptr = zend_list_find(i, &type);
-		if(ptr && (type == le_result)){
-			res = (odbc_result *)ptr;
-			if(res->conn_ptr == conn){
-				zend_list_delete(i);
+	ZEND_HASH_FOREACH_PTR(&EG(regular_list), p) {
+		if (p->ptr && (p->type == le_result)) {
+			res = (odbc_result *)p->ptr;
+			if (res->conn_ptr == conn) {
+				zend_list_close(p);
 			}
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 	
-	zend_list_delete(Z_LVAL_P(pv_conn));
+	zend_list_close(Z_RES_P(pv_conn));
 	
 	if(is_pconn){
-		zend_hash_apply_with_argument(&EG(persistent_list),	(apply_func_arg_t) _close_pconn_with_id, (void *) &(Z_LVAL_P(pv_conn)) TSRMLS_CC);	
+		zend_hash_apply_with_argument(&EG(persistent_list),	(apply_func_arg_t) _close_pconn_with_res, (void *) Z_RES_P(pv_conn) TSRMLS_CC);	
 	}
 }
 /* }}} */
@@ -2696,7 +2708,7 @@ PHP_FUNCTION(odbc_num_rows)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	SQLRowCount(result->stmt, &rows);
 	RETURN_LONG(rows);
 }
@@ -2714,7 +2726,7 @@ PHP_FUNCTION(odbc_next_result)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); 
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result); 
 
 	if (result->values) {
 		for(i = 0; i < result->numcols; i++) {
@@ -2762,7 +2774,7 @@ PHP_FUNCTION(odbc_num_fields)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	RETURN_LONG(result->numcols);
 }
 /* }}} */
@@ -2773,13 +2785,13 @@ PHP_FUNCTION(odbc_field_name)
 {
 	odbc_result *result;
 	zval *pv_res;
-	long pv_num;
+	zend_long pv_num;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) {
 		return;
 	}
 	
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	
 	if (result->numcols == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
@@ -2796,7 +2808,7 @@ PHP_FUNCTION(odbc_field_name)
 		RETURN_FALSE;
 	}
 	
-	RETURN_STRING(result->values[pv_num - 1].name, 1);
+	RETURN_STRING(result->values[pv_num - 1].name);
 }
 /* }}} */
 
@@ -2808,13 +2820,13 @@ PHP_FUNCTION(odbc_field_type)
 	char    	tmp[32];
 	SQLSMALLINT	tmplen;
 	zval		*pv_res;
-	long		pv_num;
+	zend_long		pv_num;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 
 	if (result->numcols == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
@@ -2832,7 +2844,7 @@ PHP_FUNCTION(odbc_field_type)
 	}
 
 	SQLColAttributes(result->stmt, (SQLUSMALLINT)pv_num, SQL_COLUMN_TYPE_NAME, tmp, 31, &tmplen, NULL);
-	RETURN_STRING(tmp,1)
+	RETURN_STRING(tmp)
 }
 /* }}} */
 
@@ -2857,7 +2869,7 @@ PHP_FUNCTION(odbc_field_scale)
 PHP_FUNCTION(odbc_field_num)
 {
 	char *fname;
-	int i, field_ind, fname_len;
+	size_t i, field_ind, fname_len;
 	odbc_result *result;
 	zval *pv_res;
 
@@ -2865,7 +2877,7 @@ PHP_FUNCTION(odbc_field_num)
 		return;
 	}
 	
-	ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
+	ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result);
 	
 	if (result->numcols == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
@@ -2894,13 +2906,13 @@ PHP_FUNCTION(odbc_autocommit)
 	odbc_connection *conn;
 	RETCODE rc;
 	zval *pv_conn;
-	long pv_onoff = 0;
+	zend_long pv_onoff = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_conn, &pv_onoff) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 	
 	if (ZEND_NUM_ARGS() > 1) {
 		rc = SQLSetConnectOption(conn->hdbc, SQL_AUTOCOMMIT, (pv_onoff) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
@@ -2917,7 +2929,7 @@ PHP_FUNCTION(odbc_autocommit)
 			odbc_sql_error(conn, SQL_NULL_HSTMT, "Get commit status");
 			RETURN_FALSE;
 		}
-		RETVAL_LONG((long)status);
+		RETVAL_LONG((zend_long)status);
 	}
 }
 /* }}} */
@@ -2943,7 +2955,7 @@ static void php_odbc_lasterror(INTERNAL_FUNCTION_PARAMETERS, int mode)
 {
 	odbc_connection *conn;
 	zval *pv_handle;
-	char *ptr;
+	zend_string *ptr;
 	int len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &pv_handle) == FAILURE) {
@@ -2957,22 +2969,22 @@ static void php_odbc_lasterror(INTERNAL_FUNCTION_PARAMETERS, int mode)
 	}
 
 	if (ZEND_NUM_ARGS() == 1) {
-		ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_handle, -1, "ODBC-Link", le_conn, le_pconn);
-		ptr = ecalloc(len + 1, 1);
+		ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_handle, -1, "ODBC-Link", le_conn, le_pconn);
+		ptr = zend_string_alloc(len + 1, 0);
 		if (mode == 0) {
-			strlcpy(ptr, conn->laststate, len+1);
+			strlcpy(ptr->val, conn->laststate, len+1);
 		} else {
-			strlcpy(ptr, conn->lasterrormsg, len+1);
+			strlcpy(ptr->val, conn->lasterrormsg, len+1);
 		}
 	} else {
-		ptr = ecalloc(len + 1, 1);
+		ptr = zend_string_alloc(len, 0);
 		if (mode == 0) {
-			strlcpy(ptr, ODBCG(laststate), len+1);
+			strlcpy(ptr->val, ODBCG(laststate), len+1);
 		} else {
-			strlcpy(ptr, ODBCG(lasterrormsg), len+1);
+			strlcpy(ptr->val, ODBCG(lasterrormsg), len+1);
 		}
 	}
-	RETVAL_STRING(ptr, 0);
+	RETVAL_STR(ptr);
 }
 /* }}} */
 
@@ -3006,7 +3018,7 @@ PHP_FUNCTION(odbc_setoption)
 	odbc_result	*result;
 	RETCODE rc;
 	zval *pv_handle;
-	long pv_which, pv_opt, pv_val;
+	zend_long pv_which, pv_opt, pv_val;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &pv_handle, &pv_which, &pv_opt, &pv_val) == FAILURE) {
 		return;
@@ -3014,7 +3026,7 @@ PHP_FUNCTION(odbc_setoption)
 
 	switch (pv_which) {
 		case 1:		/* SQLSetConnectOption */
-			ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_handle, -1, "ODBC-Link", le_conn, le_pconn);
+			ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_handle, -1, "ODBC-Link", le_conn, le_pconn);
 
 			if (conn->persistent) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to set option for persistent connection");
@@ -3027,7 +3039,7 @@ PHP_FUNCTION(odbc_setoption)
 			}
 			break;
 		case 2:		/* SQLSetStmtOption */
-			ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_handle, -1, "ODBC result", le_result);
+			ZEND_FETCH_RESOURCE(result, odbc_result *, pv_handle, -1, "ODBC result", le_result);
 			
 			rc = SQLSetStmtOption(result->stmt, (unsigned short) pv_opt, pv_val);
 
@@ -3058,7 +3070,7 @@ PHP_FUNCTION(odbc_tables)
 	odbc_result   *result = NULL;
 	odbc_connection *conn;
 	char *cat = NULL, *schema = NULL, *table = NULL, *type = NULL;
-	int cat_len = 0, schema_len = 0, table_len = 0, type_len = 0;
+	size_t cat_len = 0, schema_len = 0, table_len = 0, type_len = 0;
 	RETCODE rc;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s!sss", &pv_conn, &cat, &cat_len, &schema, &schema_len, 
@@ -3066,7 +3078,7 @@ PHP_FUNCTION(odbc_tables)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3133,7 +3145,7 @@ PHP_FUNCTION(odbc_columns)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3203,7 +3215,7 @@ PHP_FUNCTION(odbc_columnprivileges)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3259,7 +3271,7 @@ PHP_FUNCTION(odbc_foreignkeys)
 	odbc_result *result = NULL;
 	odbc_connection *conn;
 	char *pcat = NULL, *pschema, *ptable, *fcat, *fschema, *ftable;
-	int pcat_len = 0, pschema_len, ptable_len, fcat_len, fschema_len, ftable_len;
+	size_t pcat_len = 0, pschema_len, ptable_len, fcat_len, fschema_len, ftable_len;
 	RETCODE rc;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!sssss", &pv_conn, &pcat, &pcat_len, &pschema, &pschema_len, 
@@ -3279,7 +3291,7 @@ PHP_FUNCTION(odbc_foreignkeys)
 		EMPTY_TO_NULL(ftable);
 #endif
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3333,7 +3345,7 @@ PHP_FUNCTION(odbc_foreignkeys)
 PHP_FUNCTION(odbc_gettypeinfo)
 {
 	zval *pv_conn;
-	long pv_data_type = SQL_ALL_TYPES;
+	zend_long pv_data_type = SQL_ALL_TYPES;
 	odbc_result *result = NULL;
 	odbc_connection *conn;
 	RETCODE rc;
@@ -3345,7 +3357,7 @@ PHP_FUNCTION(odbc_gettypeinfo)
 	
 	data_type = (SQLSMALLINT) pv_data_type;
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3402,7 +3414,7 @@ PHP_FUNCTION(odbc_primarykeys)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3456,7 +3468,7 @@ PHP_FUNCTION(odbc_procedurecolumns)
 	odbc_result *result = NULL;
 	odbc_connection *conn;
 	char *cat = NULL, *schema = NULL, *proc = NULL, *col = NULL;
-	int cat_len = 0, schema_len = 0, proc_len = 0, col_len = 0;
+	size_t cat_len = 0, schema_len = 0, proc_len = 0, col_len = 0;
 	RETCODE rc;
 	
 	if (ZEND_NUM_ARGS() != 1 && ZEND_NUM_ARGS() != 5) {
@@ -3468,7 +3480,7 @@ PHP_FUNCTION(odbc_procedurecolumns)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3535,7 +3547,7 @@ PHP_FUNCTION(odbc_procedures)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3586,15 +3598,15 @@ PHP_FUNCTION(odbc_procedures)
 PHP_FUNCTION(odbc_specialcolumns)
 {
 	zval *pv_conn;
-	long vtype, vscope, vnullable;
+	zend_long vtype, vscope, vnullable;
 	odbc_result *result = NULL;
 	odbc_connection *conn;
 	char *cat = NULL, *schema = NULL, *name = NULL;
-	int cat_len = 0, schema_len, name_len;
+	size_t cat_len = 0, schema_len, name_len;
 	SQLUSMALLINT type, scope, nullable;
 	RETCODE rc;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rls!ssll", &pv_conn, &vtype, &cat, &cat_len, &schema, &schema_len,
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rls!ssl", &pv_conn, &vtype, &cat, &cat_len, &schema, &schema_len,
 		&name, &name_len, &vscope, &vnullable) == FAILURE) {
 		return;
 	}
@@ -3603,7 +3615,7 @@ PHP_FUNCTION(odbc_specialcolumns)
 	scope = (SQLUSMALLINT) vscope;
 	nullable = (SQLUSMALLINT) vnullable;
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3656,7 +3668,7 @@ PHP_FUNCTION(odbc_specialcolumns)
 PHP_FUNCTION(odbc_statistics)
 {
 	zval *pv_conn;
-	long vunique, vreserved;
+	zend_long vunique, vreserved;
 	odbc_result *result = NULL;
 	odbc_connection *conn;
 	char *cat = NULL, *schema, *name;
@@ -3672,7 +3684,7 @@ PHP_FUNCTION(odbc_statistics)
 	unique = (SQLUSMALLINT) vunique;
 	reserved = (SQLUSMALLINT) vreserved;
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
 	
@@ -3735,7 +3747,7 @@ PHP_FUNCTION(odbc_tableprivileges)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
+	ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
 
 	result = (odbc_result *)ecalloc(1, sizeof(odbc_result));