From 06d26cf2a7c3b5c4ab53e947e245c2993dd3983b Mon Sep 17 00:00:00 2001 From: Felipe Pena Date: Sun, 24 Aug 2008 20:50:02 +0000 Subject: [PATCH] - New parameter parsing API - CS --- ext/odbc/php_odbc.c | 1032 +++++++++++++++++-------------------------- 1 file changed, 400 insertions(+), 632 deletions(-) diff --git a/ext/odbc/php_odbc.c b/ext/odbc/php_odbc.c index ba78b49f15..24735203e8 100644 --- a/ext/odbc/php_odbc.c +++ b/ext/odbc/php_odbc.c @@ -910,24 +910,26 @@ void odbc_sql_error(ODBC_SQL_ERROR_PARAMS) void php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAMETERS, int mode) { odbc_result *result; - zval **pv_res, **pv_flag; + zval *pv_res; + long flag; - if (zend_get_parameters_ex(2, &pv_res, &pv_flag) == FAILURE) - WRONG_PARAM_COUNT; - - convert_to_long_ex(pv_flag); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &flag) == FAILURE) { + return; + } - if (Z_LVAL_PP(pv_res)) { - ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result); - if (mode) - result->longreadlen = Z_LVAL_PP(pv_flag); - else - result->binmode = Z_LVAL_PP(pv_flag); + if (Z_LVAL_P(pv_res)) { + ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result); + if (mode) { + result->longreadlen = flag; + } else { + result->binmode = flag; + } } else { - if (mode) - ODBCG(defaultlrl) = Z_LVAL_PP(pv_flag); - else - ODBCG(defaultbinmode) = Z_LVAL_PP(pv_flag); + if (mode) { + ODBCG(defaultlrl) = flag; + } else { + ODBCG(defaultbinmode) = flag; + } } RETURN_TRUE; } @@ -991,13 +993,13 @@ void odbc_transact(INTERNAL_FUNCTION_PARAMETERS, int type) { odbc_connection *conn; RETCODE rc; - zval **pv_conn; + zval *pv_conn; - if (zend_get_parameters_ex(1, &pv_conn) == FAILURE) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_conn) == 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); rc = SQLTransact(conn->henv, conn->hdbc, (UWORD)((type)?SQL_COMMIT:SQL_ROLLBACK)); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { @@ -1035,34 +1037,31 @@ void odbc_column_lengths(INTERNAL_FUNCTION_PARAMETERS, int type) #else SQLINTEGER len; #endif - zval **pv_res, **pv_num; + zval *pv_res; + long pv_num; - if (zend_get_parameters_ex(2, &pv_res, &pv_num) == FAILURE) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) { + return; } - convert_to_long_ex(pv_num); - - 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_LVAL_PP(pv_num) > result->numcols) { + if (pv_num > result->numcols) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index larger than number of fields"); RETURN_FALSE; } - if (Z_LVAL_PP(pv_num) < 1) { + if (pv_num < 1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field numbering starts at 1"); RETURN_FALSE; } - SQLColAttributes(result->stmt, (UWORD)Z_LVAL_PP(pv_num), - (SQLUSMALLINT) (type?SQL_COLUMN_SCALE:SQL_COLUMN_PRECISION), - NULL, 0, NULL, &len); + SQLColAttributes(result->stmt, (UWORD)pv_num, (SQLUSMALLINT) (type?SQL_COLUMN_SCALE:SQL_COLUMN_PRECISION), NULL, 0, NULL, &len); RETURN_LONG(len); } @@ -1132,8 +1131,9 @@ PHP_FUNCTION(odbc_longreadlen) Prepares a statement for execution */ PHP_FUNCTION(odbc_prepare) { - zval **pv_conn, **pv_query; + zval *pv_conn; char *query; + int query_len; odbc_result *result = NULL; odbc_connection *conn; RETCODE rc; @@ -1141,14 +1141,11 @@ PHP_FUNCTION(odbc_prepare) UDWORD scrollopts; #endif - if (zend_get_parameters_ex(2, &pv_conn, &pv_query) == FAILURE) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &pv_conn, &query, &query_len) == FAILURE) { + return; } - ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn); - - convert_to_string_ex(pv_query); - query = Z_STRVAL_PP(pv_query); + ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); @@ -1176,8 +1173,7 @@ PHP_FUNCTION(odbc_prepare) /* Try to set CURSOR_TYPE to dynamic. Driver will replace this with other type if not possible. */ - if (SQLSetStmtOption(result->stmt, SQL_CURSOR_TYPE, SQL_CURSOR_DYNAMIC) - == SQL_ERROR) { + if (SQLSetStmtOption(result->stmt, SQL_CURSOR_TYPE, SQL_CURSOR_DYNAMIC) == SQL_ERROR) { odbc_sql_error(conn, result->stmt, " SQLSetStmtOption"); SQLFreeStmt(result->stmt, SQL_DROP); efree(result); @@ -1227,7 +1223,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 { SDWORD vallen; int fp; @@ -1235,32 +1231,20 @@ PHP_FUNCTION(odbc_execute) params_t *params = NULL; char *filename; unsigned char otype; - SWORD sqltype, ctype, scale; + SWORD sqltype, ctype, scale; SWORD nullable; UDWORD precision; - odbc_result *result; + odbc_result *result; int numArgs, i, ne; RETCODE rc; numArgs = ZEND_NUM_ARGS(); - switch(numArgs) { - case 1: - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) - WRONG_PARAM_COUNT; - break; - case 2: - if (zend_get_parameters_ex(2, &pv_res, &pv_param_arr) == FAILURE) - WRONG_PARAM_COUNT; - if (Z_TYPE_PP(pv_param_arr) != IS_ARRAY) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "No array passed"); - RETURN_FALSE; - } - break; - default: - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|a", &pv_res, &pv_param_arr) == 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); /* XXX check for already bound parameters*/ if (result->numparams > 0 && numArgs == 1) { @@ -1269,16 +1253,16 @@ PHP_FUNCTION(odbc_execute) } if (result->numparams > 0) { - if ((ne = zend_hash_num_elements(Z_ARRVAL_PP(pv_param_arr))) < result->numparams) { + if ((ne = zend_hash_num_elements(Z_ARRVAL_P(pv_param_arr))) < result->numparams) { php_error_docref(NULL TSRMLS_CC, E_WARNING,"Not enough parameters (%d should be %d) given", ne, result->numparams); RETURN_FALSE; } - zend_hash_internal_pointer_reset(Z_ARRVAL_PP(pv_param_arr)); + zend_hash_internal_pointer_reset(Z_ARRVAL_P(pv_param_arr)); params = (params_t *)safe_emalloc(sizeof(params_t), result->numparams, 0); for(i = 1; i <= result->numparams; i++) { - if (zend_hash_get_current_data(Z_ARRVAL_PP(pv_param_arr), (void **) &tmp) == FAILURE) { + if (zend_hash_get_current_data(Z_ARRVAL_P(pv_param_arr), (void **) &tmp) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING,"Error getting parameter"); SQLFreeStmt(result->stmt,SQL_RESET_PARAMS); efree(params); @@ -1294,15 +1278,15 @@ PHP_FUNCTION(odbc_execute) RETURN_FALSE; } - SQLDescribeParam(result->stmt, (UWORD)i, &sqltype, &precision, - &scale, &nullable); + SQLDescribeParam(result->stmt, (UWORD)i, &sqltype, &precision, &scale, &nullable); params[i-1].vallen = Z_STRLEN_PP(tmp); params[i-1].fp = -1; - if (IS_SQL_BINARY(sqltype)) + if (IS_SQL_BINARY(sqltype)) { ctype = SQL_C_BINARY; - else + } else { ctype = SQL_C_CHAR; + } if (Z_STRLEN_PP(tmp) > 2 && Z_STRVAL_PP(tmp)[0] == '\'' && @@ -1351,7 +1335,7 @@ PHP_FUNCTION(odbc_execute) Z_STRVAL_PP(tmp), 0, ¶ms[i-1].vallen); } - zend_hash_move_forward(Z_ARRVAL_PP(pv_param_arr)); + zend_hash_move_forward(Z_ARRVAL_P(pv_param_arr)); } } /* Close cursor, needed for doing multiple selects */ @@ -1367,11 +1351,12 @@ PHP_FUNCTION(odbc_execute) if (rc == SQL_NEED_DATA) { char buf[4096]; int fp, nbytes; - while(rc == SQL_NEED_DATA) { + while (rc == SQL_NEED_DATA) { rc = SQLParamData(result->stmt, (void*)&fp); if (rc == SQL_NEED_DATA) { - while((nbytes = read(fp, &buf, 4096)) > 0) + while((nbytes = read(fp, &buf, 4096)) > 0) { SQLPutData(result->stmt, (void*)&buf, nbytes); + } } } } else { @@ -1391,8 +1376,9 @@ PHP_FUNCTION(odbc_execute) if (result->numparams > 0) { SQLFreeStmt(result->stmt, SQL_RESET_PARAMS); for(i = 0; i < result->numparams; i++) { - if (params[i].fp != -1) + if (params[i].fp != -1) { close(params[i].fp); + } } efree(params); } @@ -1420,20 +1406,19 @@ PHP_FUNCTION(odbc_execute) Get cursor name */ PHP_FUNCTION(odbc_cursor) { - zval **pv_res; + zval *pv_res; SWORD len, max_len; char *cursorname; odbc_result *result; RETCODE rc; - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) { - WRONG_PARAM_COUNT; + 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); - rc = SQLGetInfo(result->conn_ptr->hdbc,SQL_MAX_CURSOR_NAME_LEN, - (void *)&max_len,sizeof(max_len),&len); + 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) { RETURN_FALSE; } @@ -1477,33 +1462,25 @@ PHP_FUNCTION(odbc_cursor) Return information about the currently connected data source */ PHP_FUNCTION(odbc_data_source) { - zval **zv_fetch_type, **zv_conn; + zval *zv_conn; + long zv_fetch_type; RETCODE rc = 0; /* assume all is good */ odbc_connection *conn; - int num_args = ZEND_NUM_ARGS(); - UCHAR server_name[100], - desc[200]; + UCHAR server_name[100], desc[200]; SQLSMALLINT len1=0, len2=0, fetch_type; - if (num_args != 2) { - WRONG_PARAM_COUNT; - } - - if (zend_get_parameters_ex(2, &zv_conn, &zv_fetch_type) == FAILURE) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to get parameters"); - RETURN_FALSE; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zv_conn, &zv_fetch_type) == FAILURE) { + return; } - convert_to_long_ex(zv_fetch_type); - fetch_type = (SQLSMALLINT)Z_LVAL_PP(zv_fetch_type); + fetch_type = (SQLSMALLINT) zv_fetch_type; - if (!(fetch_type == SQL_FETCH_FIRST || - fetch_type == SQL_FETCH_NEXT)) { + if (!(fetch_type == SQL_FETCH_FIRST || fetch_type == SQL_FETCH_NEXT)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid fetch type (%d)", fetch_type); 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, @@ -1540,9 +1517,10 @@ PHP_FUNCTION(odbc_data_source) /* XXX Use flags */ PHP_FUNCTION(odbc_exec) { - zval **pv_conn, **pv_query, **pv_flags; - int numArgs; + zval *pv_conn; char *query; + int numArgs, query_len; + long pv_flags; odbc_result *result = NULL; odbc_connection *conn; RETCODE rc; @@ -1551,20 +1529,13 @@ PHP_FUNCTION(odbc_exec) #endif numArgs = ZEND_NUM_ARGS(); - if (numArgs > 2) { - if (zend_get_parameters_ex(3, &pv_conn, &pv_query, &pv_flags) == FAILURE) - WRONG_PARAM_COUNT; - convert_to_long_ex(pv_flags); - } else { - if (zend_get_parameters_ex(2, &pv_conn, &pv_query) == FAILURE) - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &pv_conn, &query, &query_len, &pv_flags) == FAILURE) { + return; } - ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn); - - convert_to_string_ex(pv_query); - query = Z_STRVAL_PP(pv_query); - + ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); + result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); rc = SQLAllocStmt(conn->hdbc, &(result->stmt)); @@ -1589,8 +1560,7 @@ PHP_FUNCTION(odbc_exec) /* Try to set CURSOR_TYPE to dynamic. Driver will replace this with other type if not possible. */ - if (SQLSetStmtOption(result->stmt, SQL_CURSOR_TYPE, SQL_CURSOR_DYNAMIC) - == SQL_ERROR) { + if (SQLSetStmtOption(result->stmt, SQL_CURSOR_TYPE, SQL_CURSOR_DYNAMIC) == SQL_ERROR) { odbc_sql_error(conn, result->stmt, " SQLSetStmtOption"); SQLFreeStmt(result->stmt, SQL_DROP); efree(result); @@ -1648,34 +1618,25 @@ static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type) UDWORD crow; UWORD RowStatus[1]; SDWORD rownum = -1; - zval **pv_res, **pv_row, *tmp; + zval *pv_res, *tmp; + long pv_row; - switch(ZEND_NUM_ARGS()) { - case 1: - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) { - WRONG_PARAM_COUNT; - } - break; - case 2: - if (zend_get_parameters_ex(2, &pv_res, &pv_row) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_long_ex(pv_row); - rownum = Z_LVAL_PP(pv_row); - break; - default: - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_res, &pv_row) == FAILURE) { + return; + } + + if (ZEND_NUM_ARGS() > 1) { + rownum = pv_row; } - #else - zval **pv_res, *tmp; + zval *pv_res, *tmp; - if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &pv_res) == FAILURE) { - WRONG_PARAM_COUNT; + 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"); @@ -1684,10 +1645,11 @@ static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type) #ifdef HAVE_SQL_EXTENDED_FETCH if (result->fetch_abs) { - if (rownum > 0) + if (rownum > 0) { rc = SQLExtendedFetch(result->stmt,SQL_FETCH_ABSOLUTE,rownum,&crow,RowStatus); - else + } else { rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus); + } } else #endif rc = SQLFetch(result->stmt); @@ -1725,9 +1687,11 @@ static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type) Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC(); break; } - if (buf == NULL) buf = emalloc(result->longreadlen + 1); - rc = SQLGetData(result->stmt, (UWORD)(i + 1), sql_c_type, - buf, result->longreadlen + 1, &result->values[i].vallen); + if (buf == NULL) { + buf = emalloc(result->longreadlen + 1); + } + + rc = SQLGetData(result->stmt, (UWORD)(i + 1), sql_c_type, buf, result->longreadlen + 1, &result->values[i].vallen); if (rc == SQL_ERROR) { odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData"); @@ -1760,15 +1724,15 @@ static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type) zend_hash_index_update(Z_ARRVAL_P(return_value), i, &tmp, sizeof(zval *), NULL); } else { if (!*(result->values[i].name)) { - zend_hash_update(Z_ARRVAL_P(return_value), Z_STRVAL_P(tmp), - Z_STRLEN_P(tmp)+1, &tmp, sizeof(zval *), NULL); + zend_hash_update(Z_ARRVAL_P(return_value), Z_STRVAL_P(tmp), Z_STRLEN_P(tmp)+1, &tmp, sizeof(zval *), NULL); } 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_update(Z_ARRVAL_P(return_value), result->values[i].name, strlen(result->values[i].name)+1, &tmp, sizeof(zval *), NULL); } } } - if (buf) efree(buf); + if (buf) { + efree(buf); + } } /* }}} */ @@ -1797,42 +1761,32 @@ PHP_FUNCTION(odbc_fetch_array) Fetch one result row into an array */ PHP_FUNCTION(odbc_fetch_into) { - int numArgs, i; + int i; odbc_result *result; RETCODE rc; SWORD 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 - zval **pv_row; + long pv_row = 0; UDWORD crow; UWORD RowStatus[1]; - SDWORD rownum = -1; + SDWORD rownum = 0; #endif /* HAVE_SQL_EXTENDED_FETCH */ - - numArgs = ZEND_NUM_ARGS(); - switch(numArgs) { - case 2: - if (zend_get_parameters_ex(2, &pv_res, &pv_res_arr) == FAILURE) { - WRONG_PARAM_COUNT; - } - break; #ifdef HAVE_SQL_EXTENDED_FETCH - case 3: - if (zend_get_parameters_ex(3, &pv_res, &pv_res_arr, &pv_row) == FAILURE) { - WRONG_PARAM_COUNT; - } - SEPARATE_ZVAL(pv_row); - convert_to_long_ex(pv_row); - rownum = Z_LVAL_PP(pv_row); - break; -#endif /* HAVE_SQL_EXTENDED_FETCH */ - default: - WRONG_PARAM_COUNT; + 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) { + 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"); @@ -1845,16 +1799,18 @@ PHP_FUNCTION(odbc_fetch_into) #ifdef HAVE_SQL_EXTENDED_FETCH if (result->fetch_abs) { - if (rownum > 0) + if (rownum > 0) { rc = SQLExtendedFetch(result->stmt,SQL_FETCH_ABSOLUTE,rownum,&crow,RowStatus); - else + } else { rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus); + } } else #endif rc = SQLFetch(result->stmt); - if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) + if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { RETURN_FALSE; + } #ifdef HAVE_SQL_EXTENDED_FETCH if (rownum > 0 && result->fetch_abs) @@ -1884,11 +1840,12 @@ PHP_FUNCTION(odbc_fetch_into) break; } - if (buf == NULL) buf = emalloc(result->longreadlen + 1); - rc = SQLGetData(result->stmt, (UWORD)(i + 1),sql_c_type, - buf, result->longreadlen + 1, &result->values[i].vallen); + if (buf == NULL) { + buf = emalloc(result->longreadlen + 1); + } + rc = SQLGetData(result->stmt, (UWORD)(i + 1),sql_c_type, buf, result->longreadlen + 1, &result->values[i].vallen); - if (rc == SQL_ERROR) { + if (rc == SQL_ERROR) { odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData"); efree(buf); RETURN_FALSE; @@ -1927,13 +1884,13 @@ PHP_FUNCTION(solid_fetch_prev) { odbc_result *result; RETCODE rc; - zval **pv_res; + zval *pv_res; - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) { - WRONG_PARAM_COUNT; + 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->numcols == 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index"); RETURN_FALSE; @@ -1944,7 +1901,9 @@ PHP_FUNCTION(solid_fetch_prev) RETURN_FALSE; } - if (result->fetched > 1) result->fetched--; + if (result->fetched > 1) { + result->fetched--; + } RETURN_TRUE; } @@ -1955,33 +1914,25 @@ PHP_FUNCTION(solid_fetch_prev) Fetch a row */ PHP_FUNCTION(odbc_fetch_row) { - int numArgs; SDWORD rownum = 1; odbc_result *result; RETCODE rc; - zval **pv_res, **pv_row; + zval *pv_res; + long pv_row; #ifdef HAVE_SQL_EXTENDED_FETCH UDWORD crow; UWORD RowStatus[1]; #endif - - numArgs = ZEND_NUM_ARGS(); - switch (numArgs) { - case 1: - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) - WRONG_PARAM_COUNT; - break; - case 2: - if (zend_get_parameters_ex(2, &pv_res, &pv_row) == FAILURE) - WRONG_PARAM_COUNT; - convert_to_long_ex(pv_row); - rownum = Z_LVAL_PP(pv_row); - break; - default: - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_res, &pv_row) == FAILURE) { + return; } - ZEND_FETCH_RESOURCE(result, odbc_result *, pv_res, -1, "ODBC result", le_result); + if (ZEND_NUM_ARGS() > 1) { + rownum = pv_row; + } + + 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"); @@ -1990,10 +1941,11 @@ PHP_FUNCTION(odbc_fetch_row) #ifdef HAVE_SQL_EXTENDED_FETCH if (result->fetch_abs) { - if (numArgs > 1) + if (ZEND_NUM_ARGS() > 1) { rc = SQLExtendedFetch(result->stmt,SQL_FETCH_ABSOLUTE,rownum,&crow,RowStatus); - else + } else { rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus); + } } else #endif rc = SQLFetch(result->stmt); @@ -2002,7 +1954,7 @@ PHP_FUNCTION(odbc_fetch_row) RETURN_FALSE; } - if (numArgs > 1) { + if (ZEND_NUM_ARGS() > 1) { result->fetched = rownum; } else { result->fetched++; @@ -2023,7 +1975,7 @@ PHP_FUNCTION(odbc_result) int i = 0; RETCODE rc; SDWORD fieldsize; - zval **pv_res, **pv_field; + zval *pv_res, **pv_field; #ifdef HAVE_SQL_EXTENDED_FETCH UDWORD crow; UWORD RowStatus[1]; @@ -2032,8 +1984,8 @@ PHP_FUNCTION(odbc_result) field_ind = -1; field = NULL; - if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2 , &pv_res, &pv_field) == FAILURE) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pv_res, &pv_field) == FAILURE) { + return; } if (Z_TYPE_PP(pv_field) == IS_STRING) { @@ -2043,7 +1995,7 @@ PHP_FUNCTION(odbc_result) field_ind = Z_LVAL_PP(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"); @@ -2085,8 +2037,9 @@ PHP_FUNCTION(odbc_result) #endif rc = SQLFetch(result->stmt); - if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) + if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { RETURN_FALSE; + } result->fetched++; } @@ -2099,10 +2052,11 @@ PHP_FUNCTION(odbc_result) if (result->binmode <= 0) break; case SQL_LONGVARCHAR: if (IS_SQL_LONG(result->values[field_ind].coltype)) { - if (result->longreadlen <= 0) + if (result->longreadlen <= 0) { break; - else + } else { fieldsize = result->longreadlen; + } } else { SQLColAttributes(result->stmt, (UWORD)(field_ind + 1), (UWORD)((sql_c_type == SQL_C_BINARY) ? SQL_COLUMN_LENGTH : @@ -2134,12 +2088,13 @@ 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) fieldsize -= 1; + if (result->values[field_ind].coltype == SQL_LONGVARCHAR) { + 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); + RETURN_STRINGL(field, (rc == SQL_SUCCESS_WITH_INFO) ? fieldsize : result->values[field_ind].vallen, 0); break; default: @@ -2159,8 +2114,7 @@ PHP_FUNCTION(odbc_result) /* Call SQLGetData() until SQL_SUCCESS is returned */ while(1) { - rc = SQLGetData(result->stmt, (UWORD)(field_ind + 1),sql_c_type, - field, fieldsize, &result->values[field_ind].vallen); + rc = SQLGetData(result->stmt, (UWORD)(field_ind + 1),sql_c_type, field, fieldsize, &result->values[field_ind].vallen); if (rc == SQL_ERROR) { odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData"); @@ -2173,8 +2127,7 @@ PHP_FUNCTION(odbc_result) RETURN_NULL(); } /* chop the trailing \0 by outputing only 4095 bytes */ - PHPWRITE(field,(rc == SQL_SUCCESS_WITH_INFO) ? 4095 : - result->values[field_ind].vallen); + PHPWRITE(field,(rc == SQL_SUCCESS_WITH_INFO) ? 4095 : result->values[field_ind].vallen); if (rc == SQL_SUCCESS) { /* no more data avail */ efree(field); @@ -2190,26 +2143,22 @@ PHP_FUNCTION(odbc_result) PHP_FUNCTION(odbc_result_all) { char *buf = NULL; - int i, numArgs; odbc_result *result; RETCODE rc; - zval **pv_res, **pv_format; + zval *pv_res; + char *pv_format = NULL; + int i, pv_format_len = 0; SWORD sql_c_type; #ifdef HAVE_SQL_EXTENDED_FETCH UDWORD crow; UWORD RowStatus[1]; #endif - - numArgs = ZEND_NUM_ARGS(); - if (numArgs == 1) { - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) - WRONG_PARAM_COUNT; - } else { - if (zend_get_parameters_ex(2, &pv_res, &pv_format) == FAILURE) - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s", &pv_res, &pv_format, &pv_format_len) == 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"); @@ -2228,15 +2177,15 @@ PHP_FUNCTION(odbc_result_all) } /* Start table tag */ - if (numArgs == 1) { + if (ZEND_NUM_ARGS() == 1) { php_printf(""); } else { - convert_to_string_ex(pv_format); - php_printf("
",Z_STRVAL_PP(pv_format)); + php_printf("
", pv_format); } - for(i = 0; i < result->numcols; i++) + for (i = 0; i < result->numcols; i++) { php_printf("", result->values[i].name); + } php_printf("\n"); @@ -2261,7 +2210,9 @@ PHP_FUNCTION(odbc_result_all) break; } - if (buf == NULL) buf = emalloc(result->longreadlen); + if (buf == NULL) { + buf = emalloc(result->longreadlen); + } rc = SQLGetData(result->stmt, (UWORD)(i + 1),sql_c_type, buf, result->longreadlen, &result->values[i].vallen); @@ -2274,9 +2225,9 @@ PHP_FUNCTION(odbc_result_all) efree(buf); RETURN_FALSE; } - if (rc == SQL_SUCCESS_WITH_INFO) + if (rc == SQL_SUCCESS_WITH_INFO) { PHPWRITE(buf, result->longreadlen); - else if (result->values[i].vallen == SQL_NULL_DATA) { + } else if (result->values[i].vallen == SQL_NULL_DATA) { php_printf(""); break; } else { @@ -2312,15 +2263,15 @@ PHP_FUNCTION(odbc_result_all) Free resources associated with a result */ PHP_FUNCTION(odbc_free_result) { - zval **pv_res; + zval *pv_res; odbc_result *result; int i; - - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) { - WRONG_PARAM_COUNT; + + 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++) { if (result->values[i].value) { @@ -2331,7 +2282,7 @@ PHP_FUNCTION(odbc_free_result) result->values = NULL; } - zend_list_delete(Z_LVAL_PP(pv_res)); + zend_list_delete(Z_LVAL_P(pv_res)); RETURN_TRUE; } @@ -2382,8 +2333,7 @@ int odbc_sqlconnect(odbc_connection **conn, char *db, char *uid, char *pwd, int pwd = NULL; } strlcpy( lpszConnStr, db, CONNSTRSIZE); - } - else { + } else { strcpy(lpszConnStr, "DSN="); strlcat(lpszConnStr, db, CONNSTRSIZE); } @@ -2413,9 +2363,7 @@ int odbc_sqlconnect(odbc_connection **conn, char *db, char *uid, char *pwd, int char dsnbuf[1024]; short dsnbuflen; - rc = SQLDriverConnect((*conn)->hdbc, NULL, db, SQL_NTS, - dsnbuf, sizeof(dsnbuf) - 1, &dsnbuflen, - SQL_DRIVER_NOPROMPT); + rc = SQLDriverConnect((*conn)->hdbc, NULL, db, SQL_NTS, dsnbuf, sizeof(dsnbuf) - 1, &dsnbuflen, SQL_DRIVER_NOPROMPT); } #else if (cur_opt != SQL_CUR_DEFAULT) { @@ -2493,10 +2441,9 @@ int odbc_sqlconnect(odbc_connection **conn, char *db, char *uid, char *pwd, int /* {{{ odbc_do_connect */ void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent) { - char *db = NULL; - char *uid = NULL; - char *pwd = NULL; - zval **pv_db, **pv_uid, **pv_pwd, **pv_opt; + char *db, *uid, *pwd; + int db_len, uid_len, pwd_len; + long pv_opt = SQL_CUR_DEFAULT; odbc_connection *db_conn; char *hashed_details; int hashed_len, cur_opt; @@ -2504,42 +2451,22 @@ void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent) /* Now an optional 4th parameter specifying the cursor type * defaulting to the cursors default */ - switch(ZEND_NUM_ARGS()) { - case 3: - if (zend_get_parameters_ex(3, &pv_db, &pv_uid, &pv_pwd) == FAILURE) { - WRONG_PARAM_COUNT; - } - /* Use Default: Probably a better way to do this */ - cur_opt = SQL_CUR_DEFAULT; - break; - case 4: - if (zend_get_parameters_ex(4, &pv_db, &pv_uid, &pv_pwd, &pv_opt) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_long_ex(pv_opt); - cur_opt = Z_LVAL_PP(pv_opt); - - /* Confirm the cur_opt range */ - if (! (cur_opt == SQL_CUR_USE_IF_NEEDED || - cur_opt == SQL_CUR_USE_ODBC || - cur_opt == SQL_CUR_USE_DRIVER || - cur_opt == SQL_CUR_DEFAULT) ) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Cursor type (%d)", cur_opt); - RETURN_FALSE; - } - break; - default: - WRONG_PARAM_COUNT; - break; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|l", &db, &db_len, &uid, &uid_len, &pwd, &pwd_len, &pv_opt) == FAILURE) { + return; + } + + cur_opt = pv_opt; + + if (ZEND_NUM_ARGS() > 3) { + /* Confirm the cur_opt range */ + if (! (cur_opt == SQL_CUR_USE_IF_NEEDED || + cur_opt == SQL_CUR_USE_ODBC || + cur_opt == SQL_CUR_USE_DRIVER || + cur_opt == SQL_CUR_DEFAULT) ) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Cursor type (%d)", cur_opt); + RETURN_FALSE; + } } - - convert_to_string_ex(pv_db); - convert_to_string_ex(pv_uid); - convert_to_string_ex(pv_pwd); - - db = Z_STRVAL_PP(pv_db); - uid = Z_STRVAL_PP(pv_uid); - pwd = Z_STRVAL_PP(pv_pwd); if (ODBCG(allow_persistent) <= 0) { persistent = 0; @@ -2581,8 +2508,7 @@ try_and_get_another_connection: Z_TYPE(new_le) = 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) { + if (zend_hash_update(&EG(persistent_list), hashed_details, hashed_len + 1, &new_le, sizeof(zend_rsrc_list_entry), NULL) == FAILURE) { free(db_conn); efree(hashed_details); RETURN_FALSE; @@ -2628,15 +2554,16 @@ try_and_get_another_connection: } else { /* non persistent */ zend_rsrc_list_entry *index_ptr, new_index_ptr; - if (zend_hash_find(&EG(regular_list), hashed_details, hashed_len + 1, - (void **) &index_ptr) == SUCCESS) { + if (zend_hash_find(&EG(regular_list), hashed_details, hashed_len + 1, (void **) &index_ptr) == SUCCESS) { int type, conn_id; - void *ptr; + void *ptr; + if (Z_TYPE_P(index_ptr) != 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 */ + if (ptr && (type == le_conn || type == le_pconn)) { zend_list_addref(conn_id); Z_LVAL_P(return_value) = conn_id; @@ -2660,6 +2587,7 @@ try_and_get_another_connection: 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; + if (zend_hash_update(&EG(regular_list), hashed_details, hashed_len + 1, (void *) &new_index_ptr, sizeof(zend_rsrc_list_entry), NULL) == FAILURE) { efree(hashed_details); @@ -2676,7 +2604,7 @@ try_and_get_another_connection: Close an ODBC connection */ PHP_FUNCTION(odbc_close) { - zval **pv_conn; + zval *pv_conn; void *ptr; odbc_connection *conn; odbc_result *res; @@ -2686,11 +2614,11 @@ PHP_FUNCTION(odbc_close) int is_pconn = 0; int found_resource_type = le_conn; - if (zend_get_parameters_ex(1, &pv_conn) == FAILURE) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_conn) == FAILURE) { + 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; } @@ -2707,11 +2635,10 @@ PHP_FUNCTION(odbc_close) } } - zend_list_delete(Z_LVAL_PP(pv_conn)); + zend_list_delete(Z_LVAL_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_PP(pv_conn)) TSRMLS_CC); + zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) _close_pconn_with_id, (void *) &(Z_LVAL_P(pv_conn)) TSRMLS_CC); } } /* }}} */ @@ -2722,12 +2649,12 @@ PHP_FUNCTION(odbc_num_rows) { odbc_result *result; SDWORD rows; - zval **pv_res; + zval *pv_res; - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) { - WRONG_PARAM_COUNT; + 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); } @@ -2738,19 +2665,20 @@ PHP_FUNCTION(odbc_num_rows) Checks if multiple results are avaiable */ PHP_FUNCTION(odbc_next_result) { - odbc_result *result; - zval **pv_res; + odbc_result *result; + zval *pv_res; int rc, i; - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) { - WRONG_PARAM_COUNT; + 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++) { - if (result->values[i].value) + if (result->values[i].value) { efree(result->values[i].value); + } } efree(result->values); result->values = NULL; @@ -2787,12 +2715,12 @@ PHP_FUNCTION(odbc_next_result) PHP_FUNCTION(odbc_num_fields) { odbc_result *result; - zval **pv_res; + zval *pv_res; - if (zend_get_parameters_ex(1, &pv_res) == FAILURE) { - WRONG_PARAM_COUNT; + 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); } /* }}} */ @@ -2802,32 +2730,31 @@ PHP_FUNCTION(odbc_num_fields) PHP_FUNCTION(odbc_field_name) { odbc_result *result; - zval **pv_res, **pv_num; + zval *pv_res; + long pv_num; - if (zend_get_parameters_ex(2, &pv_res, &pv_num) == FAILURE) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) { + return; } - - convert_to_long_ex(pv_num); - 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_LVAL_PP(pv_num) > result->numcols) { + if (pv_num > result->numcols) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index larger than number of fields"); RETURN_FALSE; } - if (Z_LVAL_PP(pv_num) < 1) { + if (pv_num < 1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field numbering starts at 1"); RETURN_FALSE; } - RETURN_STRING(result->values[Z_LVAL_PP(pv_num) - 1].name, 1) + RETURN_STRING(result->values[pv_num - 1].name, 1); } /* }}} */ @@ -2838,33 +2765,31 @@ PHP_FUNCTION(odbc_field_type) odbc_result *result; char tmp[32]; SWORD tmplen; - zval **pv_res, **pv_num; + zval *pv_res; + long pv_num; - if (zend_get_parameters_ex(2, &pv_res, &pv_num) == FAILURE) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) { + return; } - convert_to_long_ex(pv_num); - - 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_LVAL_PP(pv_num) > result->numcols) { + if (pv_num > result->numcols) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index larger than number of fields"); RETURN_FALSE; } - if (Z_LVAL_PP(pv_num) < 1) { + if (pv_num < 1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field numbering starts at 1"); RETURN_FALSE; } - SQLColAttributes(result->stmt, (UWORD)Z_LVAL_PP(pv_num), - SQL_COLUMN_TYPE_NAME, tmp, 31, &tmplen, NULL); + SQLColAttributes(result->stmt, (UWORD) pv_num, SQL_COLUMN_TYPE_NAME, tmp, 31, &tmplen, NULL); RETURN_STRING(tmp,1) } /* }}} */ @@ -2892,31 +2817,30 @@ PHP_FUNCTION(odbc_field_num) int field_ind; char *fname; odbc_result *result; - int i; - zval **pv_res, **pv_name; + int i, fname_len; + zval *pv_res; - if (zend_get_parameters_ex(2, &pv_res, &pv_name) == FAILURE) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &pv_res, &fname, &fname_len) == 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"); RETURN_FALSE; } - convert_to_string_ex(pv_name); - fname = Z_STRVAL_PP(pv_name); - field_ind = -1; - for(i = 0; i < result->numcols; i++) { - if (strcasecmp(result->values[i].name, fname) == 0) + for (i = 0; i < result->numcols; i++) { + if (strcasecmp(result->values[i].name, fname) == 0) { field_ind = i + 1; } + } - if (field_ind == -1) + if (field_ind == -1) { RETURN_FALSE; + } RETURN_LONG(field_ind); } /* }}} */ @@ -2928,29 +2852,17 @@ PHP_FUNCTION(odbc_autocommit) { odbc_connection *conn; RETCODE rc; - zval **pv_conn, **pv_onoff = NULL; - int argc; + zval *pv_conn; + long pv_onoff = 0; - argc = ZEND_NUM_ARGS(); - if (argc == 2) { - if (zend_get_parameters_ex(2, &pv_conn, &pv_onoff) == FAILURE) { - WRONG_PARAM_COUNT; - } - } else if (argc == 1) { - if (zend_get_parameters_ex(1, &pv_conn) == FAILURE) { - WRONG_PARAM_COUNT; - } - } else { - WRONG_PARAM_COUNT; + 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); - if (pv_onoff && (*pv_onoff)) { - convert_to_long_ex(pv_onoff); - rc = SQLSetConnectOption(conn->hdbc, SQL_AUTOCOMMIT, - (Z_LVAL_PP(pv_onoff)) ? - SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF); + ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); + + if (pv_onoff) { + rc = SQLSetConnectOption(conn->hdbc, SQL_AUTOCOMMIT, (pv_onoff) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { odbc_sql_error(conn, SQL_NULL_HSTMT, "Set autocommit"); RETURN_FALSE; @@ -2989,14 +2901,12 @@ PHP_FUNCTION(odbc_rollback) static void php_odbc_lasterror(INTERNAL_FUNCTION_PARAMETERS, int mode) { odbc_connection *conn; - zval **pv_handle; + zval *pv_handle; char *ptr; - int argc, len; - - argc = ZEND_NUM_ARGS(); + int len; - if (argc > 1 || zend_get_parameters_ex(argc, &pv_handle)) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &pv_handle) == FAILURE) { + return; } if (mode == 0) { /* last state */ @@ -3005,8 +2915,8 @@ static void php_odbc_lasterror(INTERNAL_FUNCTION_PARAMETERS, int mode) len = SQL_MAX_MESSAGE_LENGTH; } - if (argc == 1) { - ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_handle, -1, "ODBC-Link", le_conn, le_pconn); + 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); if (mode == 0) { strlcpy(ptr, conn->laststate, len+1); @@ -3054,33 +2964,31 @@ PHP_FUNCTION(odbc_setoption) odbc_connection *conn; odbc_result *result; RETCODE rc; - zval **pv_handle, **pv_which, **pv_opt, **pv_val; + zval *pv_handle; + long pv_which, pv_opt, pv_val; - if (zend_get_parameters_ex(4, &pv_handle, &pv_which, &pv_opt, &pv_val) == FAILURE) { - WRONG_PARAM_COUNT; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &pv_handle, &pv_which, &pv_opt, &pv_val) == FAILURE) { + return; } - convert_to_long_ex(pv_which); - convert_to_long_ex(pv_opt); - convert_to_long_ex(pv_val); - - switch (Z_LVAL_PP(pv_which)) { + 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"); RETURN_FALSE; } - rc = SQLSetConnectOption(conn->hdbc, (unsigned short)(Z_LVAL_PP(pv_opt)), Z_LVAL_PP(pv_val)); + rc = SQLSetConnectOption(conn->hdbc, (unsigned short) pv_opt, pv_val); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { odbc_sql_error(conn, SQL_NULL_HSTMT, "SetConnectOption"); RETURN_FALSE; } 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)(Z_LVAL_PP(pv_opt)), (Z_LVAL_PP(pv_val))); + rc = SQLSetStmtOption(result->stmt, (unsigned short) pv_opt, pv_val); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { odbc_sql_error(result->conn_ptr, result->stmt, "SetStmtOption"); @@ -3105,33 +3013,19 @@ PHP_FUNCTION(odbc_setoption) Call the SQLTables function */ PHP_FUNCTION(odbc_tables) { - zval **pv_conn, **pv_cat, **pv_schema, **pv_table, **pv_type; - odbc_result *result = NULL; + zval *pv_conn; + 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; RETCODE rc; - int argc; - argc = ZEND_NUM_ARGS(); - if (argc < 1 || argc > 5 || zend_get_parameters_ex(argc, &pv_conn, &pv_cat, &pv_schema, &pv_table, &pv_type) == FAILURE) { - WRONG_PARAM_COUNT; - } - switch (argc) { - case 5: - convert_to_string_ex(pv_type); - type = Z_STRVAL_PP(pv_type); - case 4: - convert_to_string_ex(pv_table); - table = Z_STRVAL_PP(pv_table); - case 3: - convert_to_string_ex(pv_schema); - schema = Z_STRVAL_PP(pv_schema); - case 2: - convert_to_string_ex(pv_cat); - cat = Z_STRVAL_PP(pv_cat); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ssss", &pv_conn, &cat, &cat_len, &schema, &schema_len, + &table, &table_len, &type, &type_len) == 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); result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); @@ -3149,7 +3043,9 @@ PHP_FUNCTION(odbc_tables) } /* This hack is needed to access table information in Access databases (fmk) */ - if (table && strlen(table) && schema && !strlen(schema)) schema = NULL; + if (table && table_len && schema && schema_len == 0) { + schema = NULL; + } rc = SQLTables(result->stmt, cat, SAFE_SQL_NTS(cat), @@ -3184,38 +3080,19 @@ PHP_FUNCTION(odbc_tables) Returns a result identifier that can be used to fetch a list of column names in specified tables */ PHP_FUNCTION(odbc_columns) { - zval **pv_conn, **pv_cat, **pv_schema, **pv_table, **pv_column; - odbc_result *result = NULL; + zval *pv_conn; + odbc_result *result = NULL; odbc_connection *conn; char *cat = NULL, *schema = NULL, *table = NULL, *column = NULL; - SWORD cat_len=0, schema_len=0, table_len=0, column_len=0; + int cat_len = 0, schema_len = 0, table_len = 0, column_len = 0; RETCODE rc; - int argc; - - argc = ZEND_NUM_ARGS(); - if (argc < 1 || argc > 5 || zend_get_parameters_ex(argc, &pv_conn, &pv_cat, &pv_schema, &pv_table, &pv_column) == FAILURE) { - WRONG_PARAM_COUNT; - } - switch (argc) { - case 5: - convert_to_string_ex(pv_column); - column = Z_STRVAL_PP(pv_column); - column_len = Z_STRLEN_PP(pv_column); - case 4: - convert_to_string_ex(pv_table); - table = Z_STRVAL_PP(pv_table); - table_len = Z_STRLEN_PP(pv_table); - case 3: - convert_to_string_ex(pv_schema); - schema = Z_STRVAL_PP(pv_schema); - schema_len = Z_STRLEN_PP(pv_schema); - case 2: - convert_to_string_ex(pv_cat); - cat = Z_STRVAL_PP(pv_cat); - cat_len = Z_STRLEN_PP(pv_cat); - } - - ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn); + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ssss", &pv_conn, &cat, &cat_len, &schema, &schema_len, + &table, &table_len, &column, &column_len) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); @@ -3235,13 +3112,15 @@ PHP_FUNCTION(odbc_columns) /* * Needed to make MS Access happy */ - if (table && strlen(table) && schema && !strlen(schema)) schema = NULL; + if (table && table_len && schema && schema_len == 0) { + schema = NULL; + } rc = SQLColumns(result->stmt, - cat, cat_len, - schema, schema_len, - table, table_len, - column, column_len); + cat, (SWORD) cat_len, + schema, (SWORD) schema_len, + table, (SWORD) table_len, + column, (SWORD) column_len); if (rc == SQL_ERROR) { odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLColumns"); @@ -3271,31 +3150,19 @@ PHP_FUNCTION(odbc_columns) Returns a result identifier that can be used to fetch a list of columns and associated privileges for the specified table */ PHP_FUNCTION(odbc_columnprivileges) { - zval **pv_conn, **pv_cat, **pv_schema, **pv_table, **pv_column; + zval *pv_conn; odbc_result *result = NULL; odbc_connection *conn; - char *cat = NULL, *schema = NULL, *table = NULL, *column = NULL; + char *cat, *schema, *table, *column; + int cat_len, schema_len, table_len, column_len; RETCODE rc; - int argc; - - argc = ZEND_NUM_ARGS(); - if (argc == 5) { - if (zend_get_parameters_ex(5, &pv_conn, &pv_cat, &pv_schema, &pv_table, &pv_column) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_string_ex(pv_cat); - cat = Z_STRVAL_PP(pv_cat); - convert_to_string_ex(pv_schema); - schema = Z_STRVAL_PP(pv_schema); - convert_to_string_ex(pv_table); - table = Z_STRVAL_PP(pv_table); - convert_to_string_ex(pv_column); - column = Z_STRVAL_PP(pv_column); - } else { - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rssss", &pv_conn, &cat, &cat_len, &schema, &schema_len, + &table, &table_len, &column, &column_len) == 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); result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); @@ -3347,33 +3214,18 @@ PHP_FUNCTION(odbc_columnprivileges) Returns a result identifier to either a list of foreign keys in the specified table or a list of foreign keys in other tables that refer to the primary key in the specified table */ PHP_FUNCTION(odbc_foreignkeys) { - zval **pv_conn, **pv_pcat, **pv_pschema, **pv_ptable; - zval **pv_fcat, **pv_fschema, **pv_ftable; - odbc_result *result = NULL; + zval *pv_conn; + odbc_result *result = NULL; odbc_connection *conn; - char *pcat = NULL, *pschema = NULL, *ptable = NULL; - char *fcat = NULL, *fschema = NULL, *ftable = NULL; + char *pcat, *pschema, *ptable, *fcat, *fschema, *ftable; + int pcat_len, pschema_len, ptable_len, fcat_len, fschema_len, ftable_len; RETCODE rc; - int argc; - - argc = ZEND_NUM_ARGS(); - if (argc == 7) { - if (zend_get_parameters_ex(7, &pv_conn, &pv_pcat, &pv_pschema, &pv_ptable, - &pv_fcat, &pv_fschema, &pv_ftable) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_string_ex(pv_pcat); - pcat = Z_STRVAL_PP(pv_pcat); - convert_to_string_ex(pv_pschema); - pschema = Z_STRVAL_PP(pv_pschema); - convert_to_string_ex(pv_ptable); - ptable = Z_STRVAL_PP(pv_ptable); - convert_to_string_ex(pv_fcat); - fcat = Z_STRVAL_PP(pv_fcat); - convert_to_string_ex(pv_fschema); - fschema = Z_STRVAL_PP(pv_fschema); - convert_to_string_ex(pv_ftable); - ftable = Z_STRVAL_PP(pv_ftable); + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rssssss", &pv_conn, &pcat, &pcat_len, &pschema, &pschema_len, + &ptable, &ptable_len, &fcat, &fcat_len, &fschema, &fschema_len, &ftable, &ftable_len) == FAILURE) { + return; + } + #if defined(HAVE_DBMAKER) || defined(HAVE_IBMDB2) #define EMPTY_TO_NULL(xstr) \ if ((int)strlen((xstr)) == 0) (xstr) = NULL @@ -3385,11 +3237,8 @@ PHP_FUNCTION(odbc_foreignkeys) EMPTY_TO_NULL(fschema); EMPTY_TO_NULL(ftable); #endif - } else { - WRONG_PARAM_COUNT; - } - 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)); @@ -3442,29 +3291,22 @@ PHP_FUNCTION(odbc_foreignkeys) Returns a result identifier containing information about data types supported by the data source */ PHP_FUNCTION(odbc_gettypeinfo) { - zval **pv_conn, **pv_data_type; - odbc_result *result = NULL; + zval *pv_conn; + long pv_data_type; + odbc_result *result = NULL; odbc_connection *conn; RETCODE rc; - int argc; SWORD data_type = SQL_ALL_TYPES; - - argc = ZEND_NUM_ARGS(); - if (argc == 1) { - if (zend_get_parameters_ex(1, &pv_conn) == FAILURE) { - WRONG_PARAM_COUNT; - } - } else if (argc == 2) { - if (zend_get_parameters_ex(2, &pv_conn, &pv_data_type) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_long_ex(pv_data_type); - data_type = (SWORD) Z_LVAL_PP(pv_data_type); - } else { - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_conn, &pv_data_type) == FAILURE) { + return; + } + + if (ZEND_NUM_ARGS() > 1) { + data_type = (SWORD) 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)); @@ -3510,29 +3352,18 @@ PHP_FUNCTION(odbc_gettypeinfo) Returns a result identifier listing the column names that comprise the primary key for a table */ PHP_FUNCTION(odbc_primarykeys) { - zval **pv_conn, **pv_cat, **pv_schema, **pv_table; - odbc_result *result = NULL; + zval *pv_conn; + odbc_result *result = NULL; odbc_connection *conn; char *cat = NULL, *schema = NULL, *table = NULL; + int cat_len, schema_len, table_len; RETCODE rc; - int argc; - - argc = ZEND_NUM_ARGS(); - if (argc == 4) { - if (zend_get_parameters_ex(4, &pv_conn, &pv_cat, &pv_schema, &pv_table) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_string_ex(pv_cat); - cat = Z_STRVAL_PP(pv_cat); - convert_to_string_ex(pv_schema); - schema = Z_STRVAL_PP(pv_schema); - convert_to_string_ex(pv_table); - table = Z_STRVAL_PP(pv_table); - } else { - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsss", &pv_conn, &cat, &cat_len, &schema, &schema_len, &table, &table_len) == 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); result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); @@ -3549,10 +3380,7 @@ PHP_FUNCTION(odbc_primarykeys) RETURN_FALSE; } - rc = SQLPrimaryKeys(result->stmt, - cat, SAFE_SQL_NTS(cat), - schema, SAFE_SQL_NTS(schema), - table, SAFE_SQL_NTS(table) ); + rc = SQLPrimaryKeys(result->stmt, cat, SAFE_SQL_NTS(cat), schema, SAFE_SQL_NTS(schema), table, SAFE_SQL_NTS(table) ); if (rc == SQL_ERROR) { odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLPrimaryKeys"); @@ -3582,35 +3410,23 @@ PHP_FUNCTION(odbc_primarykeys) Returns a result identifier containing the list of input and output parameters, as well as the columns that make up the result set for the specified procedures */ PHP_FUNCTION(odbc_procedurecolumns) { - zval **pv_conn, **pv_cat, **pv_schema, **pv_proc, **pv_col; - odbc_result *result = NULL; + zval *pv_conn; + 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; RETCODE rc; - int argc; - - argc = ZEND_NUM_ARGS(); - if (argc == 1) { - if (zend_get_parameters_ex(1, &pv_conn) == FAILURE) { - WRONG_PARAM_COUNT; - } - } else if (argc == 5) { - if (zend_get_parameters_ex(5, &pv_conn, &pv_cat, &pv_schema, &pv_proc, &pv_col) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_string_ex(pv_cat); - cat = Z_STRVAL_PP(pv_cat); - convert_to_string_ex(pv_schema); - schema = Z_STRVAL_PP(pv_schema); - convert_to_string_ex(pv_proc); - proc = Z_STRVAL_PP(pv_proc); - convert_to_string_ex(pv_col); - col = Z_STRVAL_PP(pv_col); - } else { + + if (ZEND_NUM_ARGS() != 1 && ZEND_NUM_ARGS() != 5) { WRONG_PARAM_COUNT; } - ZEND_FETCH_RESOURCE2(conn, odbc_connection *, pv_conn, -1, "ODBC-Link", le_conn, le_pconn); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ssss", &pv_conn, &cat, &cat_len, &schema, &schema_len, + &proc, &proc_len, &col, &col_len) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn); result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); @@ -3662,33 +3478,22 @@ PHP_FUNCTION(odbc_procedurecolumns) Returns a result identifier containg the list of procedure names in a datasource */ PHP_FUNCTION(odbc_procedures) { - zval **pv_conn, **pv_cat, **pv_schema, **pv_proc; - odbc_result *result = NULL; + zval *pv_conn; + odbc_result *result = NULL; odbc_connection *conn; char *cat = NULL, *schema = NULL, *proc = NULL; + int cat_len = 0, schema_len = 0, proc_len = 0; RETCODE rc; - int argc; - - argc = ZEND_NUM_ARGS(); - if (argc == 1) { - if (zend_get_parameters_ex(1, &pv_conn) == FAILURE) { - WRONG_PARAM_COUNT; - } - } else if (argc == 4) { - if (zend_get_parameters_ex(4, &pv_conn, &pv_cat, &pv_schema, &pv_proc) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_string_ex(pv_cat); - cat = Z_STRVAL_PP(pv_cat); - convert_to_string_ex(pv_schema); - schema = Z_STRVAL_PP(pv_schema); - convert_to_string_ex(pv_proc); - proc = Z_STRVAL_PP(pv_proc); - } else { + + if (ZEND_NUM_ARGS() != 1 && ZEND_NUM_ARGS() != 4) { WRONG_PARAM_COUNT; } + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|sss", &pv_conn, &cat, &cat_len, &schema, &schema_len, &proc, &proc_len) == 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); result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); @@ -3738,39 +3543,25 @@ PHP_FUNCTION(odbc_procedures) Returns a result identifier containing either the optimal set of columns that uniquely identifies a row in the table or columns that are automatically updated when any value in the row is updated by a transaction */ PHP_FUNCTION(odbc_specialcolumns) { - zval **pv_conn, **pv_type, **pv_cat, **pv_schema, **pv_name; - zval **pv_scope, **pv_nullable; - odbc_result *result = NULL; + zval *pv_conn; + long vtype, vscope, vnullable; + odbc_result *result = NULL; odbc_connection *conn; char *cat = NULL, *schema = NULL, *name = NULL; - UWORD type; - UWORD scope, nullable; + int cat_len, schema_len, name_len; + UWORD type, scope, nullable; RETCODE rc; - int argc; - - argc = ZEND_NUM_ARGS(); - if (argc == 7) { - if (zend_get_parameters_ex(7, &pv_conn, &pv_type, &pv_cat, &pv_schema, - &pv_name, &pv_scope, &pv_nullable) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_long_ex(pv_type); - type = (UWORD) Z_LVAL_PP(pv_type); - convert_to_string_ex(pv_cat); - cat = Z_STRVAL_PP(pv_cat); - convert_to_string_ex(pv_schema); - schema = Z_STRVAL_PP(pv_schema); - convert_to_string_ex(pv_name); - name = Z_STRVAL_PP(pv_name); - convert_to_long_ex(pv_scope); - scope = (UWORD) Z_LVAL_PP(pv_scope); - convert_to_long_ex(pv_nullable); - nullable = (UWORD) Z_LVAL_PP(pv_nullable); - } else { - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlsssll", &pv_conn, &vtype, &cat, &cat_len, &schema, &schema_len, + &name, &name_len, &vscope, &vnullable) == FAILURE) { + return; } + + type = (UWORD) vtype; + scope = (UWORD) vscope; + nullable = (UWORD) 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)); @@ -3822,36 +3613,24 @@ PHP_FUNCTION(odbc_specialcolumns) Returns a result identifier that contains statistics about a single table and the indexes associated with the table */ PHP_FUNCTION(odbc_statistics) { - zval **pv_conn, **pv_cat, **pv_schema, **pv_name; - zval **pv_unique, **pv_reserved; - odbc_result *result = NULL; + zval *pv_conn; + long vunique, vreserved; + odbc_result *result = NULL; odbc_connection *conn; - char *cat = NULL, *schema = NULL, *name = NULL; + char *cat, *schema, *name; + int cat_len, schema_len, name_len; UWORD unique, reserved; RETCODE rc; - int argc; - - argc = ZEND_NUM_ARGS(); - if (argc == 6) { - if (zend_get_parameters_ex(6, &pv_conn, &pv_cat, &pv_schema, - &pv_name, &pv_unique, &pv_reserved) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_string_ex(pv_cat); - cat = Z_STRVAL_PP(pv_cat); - convert_to_string_ex(pv_schema); - schema = Z_STRVAL_PP(pv_schema); - convert_to_string_ex(pv_name); - name = Z_STRVAL_PP(pv_name); - convert_to_long_ex(pv_unique); - unique = (UWORD) Z_LVAL_PP(pv_unique); - convert_to_long_ex(pv_reserved); - reserved = (UWORD) Z_LVAL_PP(pv_reserved); - } else { - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsssll", &pv_conn, &cat, &cat_len, &schema, &schema_len, + &name, &name_len, &vunique, &vreserved) == FAILURE) { + return; } + + unique = (UWORD) vunique; + reserved = (UWORD) 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)); @@ -3903,29 +3682,18 @@ PHP_FUNCTION(odbc_statistics) Returns a result identifier containing a list of tables and the privileges associated with each table */ PHP_FUNCTION(odbc_tableprivileges) { - zval **pv_conn, **pv_cat, **pv_schema, **pv_table; + zval *pv_conn; odbc_result *result = NULL; odbc_connection *conn; char *cat = NULL, *schema = NULL, *table = NULL; + int cat_len, schema_len, table_len; RETCODE rc; - int argc; - - argc = ZEND_NUM_ARGS(); - if (argc == 4) { - if (zend_get_parameters_ex(4, &pv_conn, &pv_cat, &pv_schema, &pv_table) == FAILURE) { - WRONG_PARAM_COUNT; - } - convert_to_string_ex(pv_cat); - cat = Z_STRVAL_PP(pv_cat); - convert_to_string_ex(pv_schema); - schema = Z_STRVAL_PP(pv_schema); - convert_to_string_ex(pv_table); - table = Z_STRVAL_PP(pv_table); - } else { - WRONG_PARAM_COUNT; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsss", &pv_conn, &cat, &cat_len, &schema, &schema_len, &table, &table_len) == 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); result = (odbc_result *)ecalloc(1, sizeof(odbc_result)); -- 2.40.0
%s
NULL