ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC) /* {{{ */
{
zend_string *str = zval_get_string(expr);
- int len = str->len;
+ size_t len = str->len;
if (len != 0) {
write_func(str->val, len);
}
/* }}} */
-static int parse_arg_object_to_string(zval *arg, char **p, int *pl, int type TSRMLS_DC) /* {{{ */
+static int parse_arg_object_to_string(zval *arg, char **p, size_t *pl, int type TSRMLS_DC) /* {{{ */
{
if (Z_OBJ_HANDLER_P(arg, cast_object)) {
zval obj;
case 's':
{
char **p = va_arg(*va, char **);
- int *pl = va_arg(*va, int *);
+ size_t *pl = va_arg(*va, size_t *);
switch (Z_TYPE_P(arg)) {
case IS_NULL:
if (check_null) {
return 1;
}
-static zend_always_inline int _z_param_string(zval *arg, char **dest, int *dest_len, int check_null TSRMLS_DC)
+static zend_always_inline int _z_param_string(zval *arg, char **dest, size_t *dest_len, int check_null TSRMLS_DC)
{
zend_string *str;
return 1;
}
-static zend_always_inline int _z_param_path(zval *arg, char **dest, int *dest_len, int check_null TSRMLS_DC)
+static zend_always_inline int _z_param_path(zval *arg, char **dest, size_t *dest_len, int check_null TSRMLS_DC)
{
zend_string *str;
ZEND_FUNCTION(error_reporting)
{
char *err;
- int err_len;
+ size_t err_len;
int old_error_reporting;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &err, &err_len) == FAILURE) {
ZEND_FUNCTION(function_exists)
{
char *name;
- int name_len;
+ size_t name_len;
zend_function *func;
zend_string *lcname;
zend_string *class_name;
char *alias_name;
zend_class_entry *ce;
- int alias_name_len;
+ size_t alias_name_len;
zend_bool autoload = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss|b", &class_name, &alias_name, &alias_name_len, &autoload) == FAILURE) {
{
zend_long error_type = E_USER_NOTICE;
char *message;
- int message_len;
+ size_t message_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &message, &message_len, &error_type) == FAILURE) {
return;
{
zend_string *function_name;
char *eval_code, *function_args, *function_code;
- int eval_code_length, function_args_len, function_code_len;
+ size_t eval_code_length, function_args_len, function_code_len;
int retval;
char *eval_name;
ZEND_FUNCTION(extension_loaded)
{
char *extension_name;
- int extension_name_len;
+ size_t extension_name_len;
zend_string *lcname;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
{
char *extension_name;
zend_string *lcname;
- int extension_name_len, array;
+ size_t extension_name_len;
+ int array;
zend_module_entry *module;
zend_function *zif;
char *message = NULL, *filename = NULL;
zend_long code = 0, severity = E_ERROR, lineno;
zval *object, *previous = NULL;
- int argc = ZEND_NUM_ARGS(), message_len, filename_len;
+ int argc = ZEND_NUM_ARGS();
+ size_t message_len, filename_len;
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc TSRMLS_CC, "|sllslO!", &message, &message_len, &code, &severity, &filename, &filename_len, &lineno, &previous, default_exception_ce) == FAILURE) {
zend_error(E_ERROR, "Wrong parameters for ErrorException([string $exception [, long $code, [ long $severity, [ string $filename, [ long $lineno [, Exception $previous = NULL]]]]]])");
char *left, *right;
zend_long scale_param = 0;
bc_num first, second, result;
- int left_len, right_len;
+ size_t left_len, right_len;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
PHP_FUNCTION(bcsub)
{
char *left, *right;
- int left_len, right_len;
+ size_t left_len, right_len;
zend_long scale_param = 0;
bc_num first, second, result;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
PHP_FUNCTION(bcmul)
{
char *left, *right;
- int left_len, right_len;
+ size_t left_len, right_len;
zend_long scale_param = 0;
bc_num first, second, result;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
PHP_FUNCTION(bcdiv)
{
char *left, *right;
- int left_len, right_len;
+ size_t left_len, right_len;
zend_long scale_param = 0;
bc_num first, second, result;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
PHP_FUNCTION(bcmod)
{
char *left, *right;
- int left_len, right_len;
+ size_t left_len, right_len;
bc_num first, second, result;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &left, &left_len, &right, &right_len) == FAILURE) {
PHP_FUNCTION(bcpowmod)
{
char *left, *right, *modulous;
- int left_len, right_len, modulous_len;
+ size_t left_len, right_len, modulous_len;
bc_num first, second, mod, result;
zend_long scale = BCG(bc_precision);
int scale_int;
PHP_FUNCTION(bcpow)
{
char *left, *right;
- int left_len, right_len;
+ size_t left_len, right_len;
zend_long scale_param = 0;
bc_num first, second, result;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
PHP_FUNCTION(bccomp)
{
char *left, *right;
- int left_len, right_len;
+ size_t left_len, right_len;
zend_long scale_param = 0;
bc_num first, second;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
{
zval *file; /* The file to open */
char *mode; /* The mode to open the stream with */
- int mode_len;
+ size_t mode_len;
BZFILE *bz; /* The compressed file stream */
php_stream *stream = NULL;
block_size = 4, /* Block size for compression algorithm */
work_factor = 0, /* Work factor for compression algorithm */
argc; /* Argument count */
- int source_len; /* Length of the source data */
+ size_t source_len; /* Length of the source data */
unsigned int dest_len; /* Length of the destination buffer */
argc = ZEND_NUM_ARGS();
php_com_dotnet_object *obj;
char *module_name, *typelib_name = NULL, *server_name = NULL;
char *user_name = NULL, *domain_name = NULL, *password = NULL;
- int module_name_len, typelib_name_len, server_name_len,
+ size_t module_name_len, typelib_name_len, server_name_len,
user_name_len, domain_name_len, password_len;
OLECHAR *moniker;
CLSID clsid;
if (silent == 0 && FAILED(hr)) {
char *source = NULL, *desc = NULL, *msg = NULL;
- int source_len, desc_len;
+ size_t source_len, desc_len;
switch (hr) {
case DISP_E_EXCEPTION:
/* map an ID to a name */
HRESULT php_com_get_id_of_name(php_com_dotnet_object *obj, char *name,
- int namelen, DISPID *dispid TSRMLS_DC)
+ size_t namelen, DISPID *dispid TSRMLS_DC)
{
OLECHAR *olename;
HRESULT hr;
zval *arg1;
char *ifacename = NULL;
char *typelibname = NULL;
- int ifacelen;
+ size_t ifacelen;
zend_bool wantsink = 0;
php_com_dotnet_object *obj = NULL;
ITypeInfo *typeinfo;
zval *object = getThis();
php_com_dotnet_object *obj;
char *assembly_name, *datatype_name;
- int assembly_name_len, datatype_name_len;
+ size_t assembly_name_len, datatype_name_len;
struct dotnet_runtime_stuff *stuff;
OLECHAR *oleassembly, *oletype;
BSTR oleassembly_sys, oletype_sys;
#include "php_com_dotnet_internal.h"
-PHP_COM_DOTNET_API OLECHAR *php_com_string_to_olestring(char *string, uint string_len, int codepage TSRMLS_DC)
+PHP_COM_DOTNET_API OLECHAR *php_com_string_to_olestring(char *string, size_t string_len, int codepage TSRMLS_DC)
{
OLECHAR *olestring = NULL;
DWORD flags = codepage == CP_UTF8 ? 0 : MB_PRECOMPOSED | MB_ERR_INVALID_CHARS;
return olestring;
}
-PHP_COM_DOTNET_API char *php_com_olestring_to_string(OLECHAR *olestring, uint *string_len, int codepage TSRMLS_DC)
+PHP_COM_DOTNET_API char *php_com_olestring_to_string(OLECHAR *olestring, size_t *string_len, int codepage TSRMLS_DC)
{
char *string;
uint length = 0;
res = IPersistFile_GetCurFile(helper->ipf, &olename);
if (res == S_OK) {
- int len;
+ size_t len;
char *str = php_com_olestring_to_string(olename,
&len, helper->codepage TSRMLS_CC);
RETVAL_STRINGL(str, len);
{
HRESULT res;
char *filename, *fullpath = NULL;
- int filename_len;
+ size_t filename_len;
zend_bool remember = TRUE;
OLECHAR *olefilename = NULL;
CPH_FETCH();
{
HRESULT res;
char *filename, *fullpath;
- int filename_len;
+ size_t filename_len;
zend_long flags = 0;
OLECHAR *olefilename;
CPH_FETCH();
zend_constant c;
zval *exists, results, value;
char *const_name;
- int len;
+ size_t len;
if (TL == NULL) {
return FAILURE;
int i;
OLECHAR *olename;
char *ansiname = NULL;
- unsigned int ansinamelen;
+ size_t ansinamelen;
int ret = 0;
if (FAILED(ITypeInfo_GetTypeAttr(typeinfo, &attr))) {
if (printdef) {
int j;
char *funcdesc;
- unsigned int funcdesclen, cnames = 0;
+ size_t funcdesclen;
+ unsigned int cnames = 0;
BSTR *names;
names = (BSTR*)safe_emalloc((func->cParams + 1), sizeof(BSTR), 0);
/* com_olechar.c */
PHP_COM_DOTNET_API char *php_com_olestring_to_string(OLECHAR *olestring,
- uint *string_len, int codepage TSRMLS_DC);
+ size_t *string_len, int codepage TSRMLS_DC);
PHP_COM_DOTNET_API OLECHAR *php_com_string_to_olestring(char *string,
- uint string_len, int codepage TSRMLS_DC);
+ size_t string_len, int codepage TSRMLS_DC);
/* com_com.c */
static void curlfile_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
char *fname = NULL, *mime = NULL, *postname = NULL;
- int fname_len, mime_len, postname_len;
+ size_t fname_len, mime_len, postname_len;
zval *cf = return_value;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ss", &fname, &fname_len, &mime, &mime_len, &postname, &postname_len) == FAILURE) {
static void curlfile_set_property(char *name, INTERNAL_FUNCTION_PARAMETERS)
{
char *arg = NULL;
- int arg_len;
+ size_t arg_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
return;
php_curl *ch;
CURL *cp;
char *url = NULL;
- int url_len = 0;
+ size_t url_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &url, &url_len) == FAILURE) {
return;
PHP_FUNCTION(curl_escape)
{
char *str = NULL, *res = NULL;
- int str_len = 0;
+ size_t str_len = 0;
zval *zid;
php_curl *ch;
/* }}} */
/* {{{ date_format - (gm)date helper */
-static zend_string *date_format(char *format, int format_len, timelib_time *t, int localtime TSRMLS_DC)
+static zend_string *date_format(char *format, size_t format_len, timelib_time *t, size_t localtime TSRMLS_DC)
{
smart_str string = {0};
int i, length = 0;
static void php_date(INTERNAL_FUNCTION_PARAMETERS, int localtime)
{
char *format;
- int format_len;
+ size_t format_len;
zend_long ts;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &format, &format_len, &ts) == FAILURE) {
PHP_FUNCTION(strtotime)
{
char *times, *initial_ts;
- int time_len, error1, error2;
+ size_t time_len;
+ int error1, error2;
struct timelib_error_container *error;
zend_long preset_ts = 0, ts;
DATEG(last_errors) = last_errors;
} /* }}} */
-PHPAPI int php_date_initialize(php_date_obj *dateobj, /*const*/ char *time_str, int time_str_len, char *format, zval *timezone_object, int ctor TSRMLS_DC) /* {{{ */
+PHPAPI int php_date_initialize(php_date_obj *dateobj, /*const*/ char *time_str, size_t time_str_len, char *format, zval *timezone_object, size_t ctor TSRMLS_DC) /* {{{ */
{
timelib_time *now;
timelib_tzinfo *tzi = NULL;
{
zval *timezone_object = NULL;
char *time_str = NULL, *format_str = NULL;
- int time_str_len = 0, format_str_len = 0;
+ size_t time_str_len = 0, format_str_len = 0;
zval datetime_object;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|O", &format_str, &format_str_len, &time_str, &time_str_len, &timezone_object, date_ce_timezone) == FAILURE) {
PHP_FUNCTION(date_parse)
{
char *date;
- int date_len;
+ size_t date_len;
struct timelib_error_container *error;
timelib_time *parsed_time;
{
char *abbr;
char *tzid;
- int abbr_len;
+ size_t abbr_len;
zend_long gmtoffset = -1;
zend_long isdst = -1;
zval *start, *end = NULL, *interval;
zend_long recurrences = 0, options = 0;
char *isostr = NULL;
- int isostr_len = 0;
+ size_t isostr_len = 0;
timelib_time *clone;
zend_error_handling error_handling;
int i, item_count;
zend_long what = PHP_DATE_TIMEZONE_GROUP_ALL;
char *option = NULL;
- int option_len = 0;
+ size_t option_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ls", &what, &option, &option_len) == FAILURE) {
RETURN_FALSE;
PHP_FUNCTION(date_default_timezone_set)
{
char *zone;
- int zone_len;
+ size_t zone_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &zone, &zone_len) == FAILURE) {
RETURN_FALSE;
/* Functions for creating DateTime objects, and initializing them from a string */
PHPAPI zval *php_date_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC);
-PHPAPI int php_date_initialize(php_date_obj *dateobj, /*const*/ char *time_str, int time_str_len, char *format, zval *timezone_object, int ctor TSRMLS_DC);
+PHPAPI int php_date_initialize(php_date_obj *dateobj, /*const*/ char *time_str, size_t time_str_len, char *format, zval *timezone_object, size_t ctor TSRMLS_DC);
#endif /* PHP_DATE_H */
*/
static void php_dba_update(INTERNAL_FUNCTION_PARAMETERS, int mode)
{
- int val_len;
+ size_t val_len;
zval *id;
dba_info *info = NULL;
int ac = ZEND_NUM_ARGS();
{
zval *zkey;
char *key, *name;
- int key_len;
+ size_t key_len;
if (ZEND_NUM_ARGS() != 1) {
WRONG_PARAM_COUNT;
xmlNodePtr oldnode = NULL;
dom_object *intern;
char *name, *value = NULL;
- int name_len, value_len, name_valid;
+ size_t name_len, value_len, name_valid;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
xmlNodePtr nodep = NULL, oldnode = NULL;
dom_object *intern;
char *value = NULL;
- int value_len;
+ size_t value_len;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
xmlNode *nodep;
dom_object *intern;
char *arg;
- int arg_len;
+ size_t arg_len;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_characterdata_class_entry, &arg, &arg_len) == FAILURE) {
return;
xmlNodePtr nodep = NULL, oldnode = NULL;
dom_object *intern;
char *value = NULL;
- int value_len;
+ size_t value_len;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
xmlNode *node;
xmlDocPtr docp;
dom_object *intern;
- int ret, name_len, value_len;
+ int ret;
+ size_t name_len, value_len;
char *name, *value = NULL;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|s", &id, dom_document_class_entry, &name, &name_len, &value, &value_len) == FAILURE) {
zval *id;
xmlNode *node;
xmlDocPtr docp;
- int ret, value_len;
+ int ret;
+ size_t value_len;
dom_object *intern;
char *value;
{
zval *id;
xmlDocPtr docp;
- int name_len;
+ size_t name_len;
dom_object *intern, *namednode;
char *name;
xmlChar *local;
{
zval *id;
xmlDocPtr docp;
- int uri_len, name_len;
+ size_t uri_len, name_len;
dom_object *intern, *namednode;
char *uri, *name;
xmlChar *local, *nsuri;
xmlDoc *docp = NULL, *olddoc;
dom_object *intern;
char *encoding, *version = NULL;
- int encoding_len = 0, version_len = 0, refcount;
+ size_t encoding_len = 0, version_len = 0, refcount;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
}
/* }}} */
-static xmlDocPtr dom_document_parser(zval *id, int mode, char *source, int source_len, int options TSRMLS_DC) /* {{{ */
+static xmlDocPtr dom_document_parser(zval *id, int mode, char *source, size_t source_len, size_t options TSRMLS_DC) /* {{{ */
{
xmlDocPtr ret;
xmlParserCtxtPtr ctxt = NULL;
{
zval *id;
xmlDoc *docp;
- int file_len = 0, bytes, format, saveempty = 0;
+ size_t file_len = 0, bytes, format, saveempty = 0;
dom_object *intern;
dom_doc_propsptr doc_props;
char *file;
xmlNode *nodep;
dom_object *intern;
char *data = NULL;
- int data_len = 0;
+ size_t data_len = 0;
int err;
xmlNodePtr lst;
*/
PHP_METHOD(domimplementation, hasFeature)
{
- int feature_len, version_len;
+ size_t feature_len, version_len;
char *feature, *version;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &feature, &feature_len, &version, &version_len) == FAILURE) {
PHP_METHOD(domimplementation, createDocumentType)
{
xmlDtd *doctype;
- int ret, name_len = 0, publicid_len = 0, systemid_len = 0;
+ int ret;
+ size_t name_len = 0, publicid_len = 0, systemid_len = 0;
char *name = NULL, *publicid = NULL, *systemid = NULL;
xmlChar *pch1 = NULL, *pch2 = NULL, *localname = NULL;
xmlURIPtr uri;
xmlNode *nodep;
xmlDtdPtr doctype = NULL;
xmlNsPtr nsptr = NULL;
- int ret, uri_len = 0, name_len = 0, errorcode = 0;
+ int ret, errorcode = 0;
+ size_t uri_len = 0, name_len = 0;
char *uri = NULL, *name = NULL;
char *prefix = NULL, *localname = NULL;
dom_object *doctobj;
char *name, *value = NULL, *uri = NULL;
char *localname = NULL, *prefix = NULL;
int errorcode = 0, uri_len = 0;
- int name_len, value_len = 0, name_valid;
+ size_t name_len, value_len = 0;
+ int name_valid;
xmlNsPtr nsptr = NULL;
zend_error_handling error_handling;
zval *id;
xmlNode *nodep;
xmlNodePtr attr = NULL;
- int ret, name_len, value_len, name_valid;
+ int ret, name_valid;
+ size_t name_len, value_len;
dom_object *intern;
char *name, *value;
xmlNodePtr elemp;
xmlNsPtr nsptr;
dom_object *intern;
- int uri_len = 0, name_len = 0;
+ size_t uri_len = 0, name_len = 0;
char *uri, *name;
xmlChar *strattr;
xmlNodePtr elemp, nodep = NULL;
xmlNsPtr nsptr;
xmlAttr *attr;
- int uri_len = 0, name_len = 0, value_len = 0;
+ size_t uri_len = 0, name_len = 0, value_len = 0;
char *uri, *name, *value;
char *localname = NULL, *prefix = NULL;
dom_object *intern;
xmlNodePtr oldnode = NULL;
dom_object *intern;
char *name;
- int name_len, name_valid;
+ size_t name_len, name_valid;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
PHP_FUNCTION(dom_namednodemap_get_named_item)
{
zval *id;
- int ret, namedlen=0;
+ int ret;
+ size_t namedlen=0;
dom_object *intern;
xmlNodePtr itemnode = NULL;
char *named;
PHP_FUNCTION(dom_namednodemap_get_named_item_ns)
{
zval *id;
- int ret, namedlen=0, urilen=0;
+ int ret;
+ size_t namedlen=0, urilen=0;
dom_object *intern;
xmlNodePtr itemnode = NULL;
char *uri, *named;
PHP_FUNCTION(dom_node_is_supported)
{
zval *id;
- int feature_len, version_len;
+ size_t feature_len, version_len;
char *feature, *version;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oss", &id, dom_node_class_entry, &feature, &feature_len, &version, &version_len) == FAILURE) {
xmlNodePtr nodep, lookupp = NULL;
dom_object *intern;
xmlNsPtr nsptr;
- int uri_len = 0;
+ size_t uri_len = 0;
char *uri;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_node_class_entry, &uri, &uri_len) == FAILURE) {
xmlNodePtr nodep;
dom_object *intern;
xmlNsPtr nsptr;
- int uri_len = 0;
+ size_t uri_len = 0;
char *uri;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &id, dom_node_class_entry, &uri, &uri_len) == FAILURE) {
xmlNodePtr nodep;
dom_object *intern;
xmlNsPtr nsptr;
- int prefix_len = 0;
+ size_t prefix_len = 0;
char *prefix=NULL;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os!", &id, dom_node_class_entry, &prefix, &prefix_len) == FAILURE) {
zend_bool exclusive=0, with_comments=0;
xmlChar **inclusive_ns_prefixes = NULL;
char *file = NULL;
- int ret = -1, file_len = 0;
+ int ret = -1;
+ size_t file_len = 0;
xmlOutputBufferPtr buf;
xmlXPathContextPtr ctxp=NULL;
xmlXPathObjectPtr xpathobjp=NULL;
xmlNodePtr nodep = NULL, oldnode = NULL;
dom_object *intern;
char *name, *value = NULL;
- int name_len, value_len, name_valid;
+ size_t name_len, value_len;
+ int name_valid;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
xmlNodePtr nodep = NULL, oldnode = NULL;
dom_object *intern;
char *value = NULL;
- int value_len;
+ size_t value_len;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC);
{
zval *id;
xmlXPathContextPtr ctxp;
- int prefix_len, ns_uri_len;
+ size_t prefix_len, ns_uri_len;
dom_xpath_object *intern;
unsigned char *prefix, *ns_uri;
xmlXPathContextPtr ctxp;
xmlNodePtr nodep = NULL;
xmlXPathObjectPtr xpathobjp;
- int expr_len, nsnbr = 0, xpath_type;
+ size_t expr_len, nsnbr = 0, xpath_type;
dom_xpath_object *intern;
dom_object *nodeobj;
char *expr;
enchant_broker *pbroker;
zend_long dict_type;
char *value;
- int value_len;
+ size_t value_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rls", &broker, &dict_type, &value, &value_len) == FAILURE) {
RETURN_FALSE;
enchant_dict *dict;
EnchantDict *d;
char *pwl;
- int pwllen;
+ size_t pwllen;
int pos;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &broker, &pwl, &pwllen) == FAILURE) {
{
zval *dict, *sugg = NULL;
char *word;
- int wordlen;
+ size_t wordlen;
enchant_dict *pdict;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|z/", &dict, &word, &wordlen, &sugg) == FAILURE) {
{
zval *dict;
char *word;
- int wordlen;
+ size_t wordlen;
enchant_dict *pdict;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &dict, &word, &wordlen) == FAILURE) {
{
zval *dict;
char *word;
- int wordlen;
+ size_t wordlen;
char **suggs;
enchant_dict *pdict;
int n_sugg;
{
zval *dict;
char *word;
- int wordlen;
+ size_t wordlen;
enchant_dict *pdict;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &dict, &word, &wordlen) == FAILURE) {
{
zval *dict;
char *word;
- int wordlen;
+ size_t wordlen;
enchant_dict *pdict;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &dict, &word, &wordlen) == FAILURE) {
{
zval *dict;
char *word;
- int wordlen;
+ size_t wordlen;
enchant_dict *pdict;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &dict, &word, &wordlen) == FAILURE) {
{
zval *dict;
char *mis, *cor;
- int mislen, corlen;
+ size_t mislen, corlen;
enchant_dict *pdict;
zval *regex, /* Regular expression */
*array = NULL; /* Optional register array */
char *findin; /* String to apply expression to */
- int findin_len;
+ size_t findin_len;
regex_t re;
regmatch_t *subs;
int err, match_len, string_len;
regex_t re;
regmatch_t subs[1];
char *spliton, *str, *strp, *endp;
- int spliton_len, str_len;
+ size_t spliton_len, str_len;
int err, size, copts = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", &spliton, &spliton_len, &str, &str_len, &count) == FAILURE) {
PHP_EREG_API PHP_FUNCTION(sql_regcase)
{
char *string, *tmp;
- int string_len;
+ size_t string_len;
unsigned char c;
register int i, j;
PHP_FUNCTION(exif_read_data)
{
char *p_name, *p_sections_needed = NULL;
- int p_name_len, p_sections_needed_len = 0;
+ size_t p_name_len, p_sections_needed_len = 0;
zend_bool sub_arrays=0, read_thumbnail=0, read_all=0;
int i, ret, sections_needed=0;
PHP_FUNCTION(exif_imagetype)
{
char *imagefile;
- int imagefile_len;
+ size_t imagefile_len;
php_stream * stream;
int itype = 0;
{
zend_long options = MAGIC_NONE;
char *file = NULL;
- int file_len = 0;
+ size_t file_len = 0;
php_fileinfo *finfo;
FILEINFO_DECLARE_INIT_OBJECT(object)
char resolved_path[MAXPATHLEN];
{
zend_long options = 0;
char *ret_val = NULL, *buffer = NULL;
- int buffer_len;
+ size_t buffer_len;
php_fileinfo *finfo = NULL;
zval *zfinfo, *zcontext = NULL;
zval *what;
* Returns the filter ID belonging to a named filter */
PHP_FUNCTION(filter_id)
{
- int i, filter_len;
+ int i;
+ size_t filter_len;
int size = sizeof(filter_list) / sizeof(filter_list_entry);
char *filter;
{
ftpbuf_t *ftp;
char *host;
- int host_len;
+ size_t host_len;
zend_long port = 0;
zend_long timeout_sec = FTP_DEFAULT_TIMEOUT;
{
ftpbuf_t *ftp;
char *host;
- int host_len;
+ size_t host_len;
zend_long port = 0;
zend_long timeout_sec = FTP_DEFAULT_TIMEOUT;
zval *z_ftp;
ftpbuf_t *ftp;
char *dir;
- int dir_len;
+ size_t dir_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &dir, &dir_len) == FAILURE) {
return;
zval *z_ftp;
ftpbuf_t *ftp;
char *cmd;
- int cmd_len;
+ size_t cmd_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &cmd, &cmd_len) == FAILURE) {
return;
zval *z_ftp;
ftpbuf_t *ftp;
char *cmd;
- int cmd_len;
+ size_t cmd_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &cmd, &cmd_len) == FAILURE) {
return;
zval *z_ftp;
ftpbuf_t *ftp;
char *filename;
- int filename_len;
+ size_t filename_len;
zend_long mode;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlp", &z_ftp, &mode, &filename, &filename_len) == FAILURE) {
ftptype_t xtype;
php_stream *stream;
char *file;
- int file_len;
+ size_t file_len;
zend_long mode, resumepos=0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrsl|l", &z_ftp, &z_file, &file, &file_len, &mode, &resumepos) == FAILURE) {
ftptype_t xtype;
php_stream *stream;
char *file;
- int file_len;
+ size_t file_len;
zend_long mode, resumepos=0, ret;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrsl|l", &z_ftp, &z_file, &file, &file_len, &mode, &resumepos) == FAILURE) {
ftptype_t xtype;
php_stream *outstream;
char *local, *remote;
- int local_len, remote_len;
+ size_t local_len, remote_len;
zend_long mode, resumepos=0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rppl|l", &z_ftp, &local, &local_len, &remote, &remote_len, &mode, &resumepos) == FAILURE) {
zval *z_ftp, *z_file;
ftpbuf_t *ftp;
ftptype_t xtype;
- int remote_len;
+ size_t remote_len;
zend_long mode, startpos=0;
php_stream *stream;
char *remote;
zval *z_ftp;
ftpbuf_t *ftp;
char *file;
- int file_len;
+ size_t file_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &z_ftp, &file, &file_len) == FAILURE) {
return;
zval *z_ftp;
ftpbuf_t *ftp;
char *file;
- int file_len;
+ size_t file_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &z_ftp, &file, &file_len) == FAILURE) {
return;
zval *z_ftp;
ftpbuf_t *ftp;
char *src, *dest;
- int src_len, dest_len;
+ size_t src_len, dest_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &z_ftp, &src, &src_len, &dest, &dest_len) == FAILURE) {
return;
zval *z_ftp;
ftpbuf_t *ftp;
char *file;
- int file_len;
+ size_t file_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &file, &file_len) == FAILURE) {
return;
static void _php_image_create_from(INTERNAL_FUNCTION_PARAMETERS, int image_type, char *tn, gdImagePtr (*func_p)(), gdImagePtr (*ioctx_func_p)())
{
char *file;
- int file_len;
+ size_t file_len;
zend_long srcx, srcy, width, height;
gdImagePtr im = NULL;
php_stream *stream;
zval *IM;
zend_long SIZE, X, Y, COL;
char *C;
- int C_len;
+ size_t C_len;
gdImagePtr im;
int ch = 0, col, x, y, size, i, l = 0;
unsigned char *str = NULL;
zval *IM, *EXT = NULL;
gdImagePtr im=NULL;
zend_long col = -1, x = -1, y = -1;
- int str_len, fontname_len, i, brect[8];
+ size_t str_len, fontname_len;
+ int i, brect[8];
double ptsize, angle;
char *str = NULL, *fontname = NULL;
char *error = NULL;
{
zval *fnt;
char *enc, **enc_vector;
- int enc_len, *f_ind;
+ size_t enc_len, *f_ind;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &fnt, &enc, &enc_len) == FAILURE) {
return;
static void _php_image_convert(INTERNAL_FUNCTION_PARAMETERS, int image_type )
{
char *f_org, *f_dest;
- int f_org_len, f_dest_len;
+ size_t f_org_len, f_dest_len;
zend_long height, width, threshold;
gdImagePtr im_org, im_dest, im_tmp;
char *fn_org = NULL;
{
zval *imgind;
char *file = NULL;
- int file_len = 0;
+ size_t file_len = 0;
zend_long quality, basefilter;
gdImagePtr im;
int argc = ZEND_NUM_ARGS();
PHP_NAMED_FUNCTION(zif_textdomain)
{
char *domain, *domain_name, *retval;
- int domain_len;
+ size_t domain_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &domain, &domain_len) == FAILURE) {
return;
PHP_NAMED_FUNCTION(zif_gettext)
{
char *msgid, *msgstr;
- int msgid_len;
+ size_t msgid_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &msgid, &msgid_len) == FAILURE) {
return;
PHP_NAMED_FUNCTION(zif_ngettext)
{
char *msgid1, *msgid2, *msgstr;
- int msgid1_len, msgid2_len;
+ size_t msgid1_len, msgid2_len;
zend_long count;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &msgid1, &msgid1_len, &msgid2, &msgid2_len, &count) == FAILURE) {
PHP_NAMED_FUNCTION(zif_bind_textdomain_codeset)
{
char *domain, *codeset, *retval = NULL;
- int domain_len, codeset_len;
+ size_t domain_len, codeset_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &domain, &domain_len, &codeset, &codeset_len) == FAILURE) {
return;
/* Hash Registry Access */
-PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(const char *algo, int algo_len) /* {{{ */
+PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(const char *algo, size_t algo_len) /* {{{ */
{
char *lower = zend_str_tolower_dup(algo, algo_len);
php_hash_ops *ops = zend_hash_str_find_ptr(&php_hash_hashtable, lower, algo_len);
}
}
-static inline void php_hash_hmac_prep_key(unsigned char *K, const php_hash_ops *ops, void *context, const unsigned char *key, const int key_len) {
+static inline void php_hash_hmac_prep_key(unsigned char *K, const php_hash_ops *ops, void *context, const unsigned char *key, const size_t key_len) {
memset(K, 0, ops->block_size);
if (key_len > ops->block_size) {
/* Reduce the key first */
zval *zhash;
php_hash_data *hash;
char *data;
- int data_len;
+ size_t data_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &zhash, &data, &data_len) == FAILURE) {
return;
php_stream_context *context;
php_stream *stream;
char *filename, buf[1024];
- int filename_len, n;
+ size_t filename_len, n;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|r", &zhash, &filename, &filename_len, &zcontext) == FAILURE) {
return;
zend_string *returnval;
char *algo, *salt, *pass = NULL;
unsigned char *computed_salt, *digest, *temp, *result, *K1, *K2 = NULL;
- zend_long loops, i, j, algo_len, pass_len, iterations, length = 0, digest_length = 0;
- int salt_len = 0;
+ zend_long loops, i, j, iterations, digest_length = 0;
+ size_t algo_len, pass_len, length = 0;
+ size_t salt_len = 0;
zend_bool raw_output = 0;
const php_hash_ops *ops;
void *context;
zend_long algorithm, l_bytes;
int bytes;
char *password, *salt;
- int password_len, salt_len;
+ size_t password_len, salt_len;
char padded_salt[SALT_SIZE];
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lssl", &algorithm, &password, &password_len, &salt, &salt_len, &l_bytes) == FAILURE) {
PHP_NAMED_FUNCTION(php_if_md5)
{
char *arg;
- int arg_len;
+ size_t arg_len;
zend_bool raw_output = 0;
char md5str[33];
PHP_MD5_CTX context;
PHP_FUNCTION(sha1)
{
char *arg;
- int arg_len;
+ size_t arg_len;
zend_bool raw_output = 0;
char sha1str[41];
PHP_SHA1_CTX context;
PHP_FUNCTION(iconv_strlen)
{
char *charset = get_internal_encoding(TSRMLS_C);
- int charset_len = 0;
+ size_t charset_len = 0;
zend_string *str;
php_iconv_err_t err;
PHP_FUNCTION(iconv_substr)
{
char *charset = get_internal_encoding(TSRMLS_C);
- int charset_len = 0;
+ size_t charset_len = 0;
zend_string *str;
zend_long offset, length = 0;
PHP_FUNCTION(iconv_strpos)
{
char *charset = get_internal_encoding(TSRMLS_C);
- int charset_len = 0;
+ size_t charset_len = 0;
zend_string *haystk;
zend_string *ndl;
zend_long offset = 0;
PHP_FUNCTION(iconv_strrpos)
{
char *charset = get_internal_encoding(TSRMLS_C);
- int charset_len = 0;
+ size_t charset_len = 0;
zend_string *haystk;
zend_string *ndl;
{
zend_string *encoded_str;
char *charset = get_internal_encoding(TSRMLS_C);
- int charset_len = 0;
+ size_t charset_len = 0;
zend_long mode = 0;
smart_str retval = {0};
{
zend_string *encoded_str;
char *charset = get_internal_encoding(TSRMLS_C);
- int charset_len = 0;
+ size_t charset_len = 0;
zend_long mode = 0;
char *enc_str_tmp;
size_t enc_str_len_tmp;
{
char *in_charset, *out_charset;
zend_string *in_buffer;
- int in_charset_len = 0, out_charset_len = 0;
+ size_t in_charset_len = 0, out_charset_len = 0;
php_iconv_err_t err;
zend_string *out_buffer;
PHP_FUNCTION(iconv_set_encoding)
{
char *type, *charset;
- int type_len, charset_len = 0, retval;
+ size_t type_len, charset_len = 0, retval;
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &type, &type_len, &charset, &charset_len) == FAILURE)
PHP_FUNCTION(ibase_blob_open)
{
char *blob_id;
- int blob_id_len;
+ size_t blob_id_len;
zval *link = NULL;
ibase_db_link *ib_link;
ibase_trans *trans = NULL;
PHP_FUNCTION(ibase_blob_info)
{
char *blob_id;
- int blob_id_len;
+ size_t blob_id_len;
zval *link = NULL;
ibase_db_link *ib_link;
ibase_trans *trans = NULL;
PHP_FUNCTION(ibase_blob_echo)
{
char *blob_id;
- int blob_id_len;
+ size_t blob_id_len;
zval *link = NULL;
ibase_db_link *ib_link;
ibase_trans *trans = NULL;
zval *link_arg, *trans_arg;
ibase_db_link *ib_link;
ibase_trans *trans = NULL;
- int query_len, trans_res_id = 0;
+ size_t query_len, trans_res_id = 0;
ibase_query *ib_query;
char *query;
Connect to the service manager */
PHP_FUNCTION(ibase_service_attach)
{
- int hlen, ulen, plen, spb_len;
+ size_t hlen, ulen, plen, spb_len;
ibase_service *svm;
char buf[128], *host, *user, *pass, *loc;
isc_svc_handle handle = NULL;
*/
zval *res;
char *db, *bk, buf[200];
- int dblen, bklen, spb_len;
+ size_t dblen, bklen, spb_len;
long opts = 0;
zend_bool verbose = 0;
ibase_service *svm;
#endif
/* True globals, no need for thread safety */
-int le_link, le_plink, le_trans;
+size_t le_link, le_plink, le_trans;
/* }}} */
{
zval *link = NULL;
char query[128], *generator;
- int gen_len;
+ size_t gen_len;
long inc = 1;
ibase_db_link *ib_link;
ibase_trans *trans = NULL;
{
BreakIterator *biter;
const char *locale_str = NULL;
- int dummy;
+ size_t dummy;
char *msg;
UErrorCode status = UErrorCode();
intl_error_reset(NULL TSRMLS_CC);
U_CFUNC PHP_FUNCTION(breakiter_set_text)
{
char *text;
- int text_len;
+ size_t text_len;
UText *ut = NULL;
zval *textzv;
BREAKITER_METHOD_INIT_VARS;
{
zval *object = getThis();
char *rules;
- int rules_len;
+ size_t rules_len;
zend_bool compiled = 0;
UErrorCode status = U_ZERO_ERROR;
intl_error_reset(NULL TSRMLS_CC);
{
zval *zv_timezone = NULL;
const char *locale_str = NULL;
- int dummy;
+ size_t dummy;
TimeZone *timeZone;
UErrorCode status = U_ZERO_ERROR;
intl_error_reset(NULL TSRMLS_CC);
UErrorCode status = U_ZERO_ERROR;
char *key,
*locale;
- int key_len,
+ size_t key_len,
locale_len;
zend_bool commonly_used;
intl_error_reset(NULL TSRMLS_CC);
zv_timestamp;
php_date_obj *datetime;
char *locale_str = NULL;
- int locale_str_len;
+ size_t locale_str_len;
TimeZone *timeZone;
UErrorCode status = U_ZERO_ERROR;
Calendar *cal;
zval args_a[6] = {0},
*args = &args_a[0];
char *locale = NULL;
- int locale_len;
+ size_t locale_len;
zend_long largs[6];
UErrorCode status = U_ZERO_ERROR;
int variant;
{
char* str1 = NULL;
char* str2 = NULL;
- int str1_len = 0;
- int str2_len = 0;
+ size_t str1_len = 0;
+ size_t str2_len = 0;
UChar* ustr1 = NULL;
UChar* ustr2 = NULL;
static void collator_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
const char* locale;
- int locale_len = 0;
+ size_t locale_len = 0;
zval* object;
Collator_object* co;
PHP_FUNCTION( collator_get_sort_key )
{
char* str = NULL;
- int str_len = 0;
+ size_t str_len = 0;
UChar* ustr = NULL;
int ustr_len = 0;
uint8_t* key = NULL;
static PHP_METHOD(UConverter, __construct) {
php_converter_object *objval = CONV_GET(getThis());
char *src = "utf-8";
- int src_len = sizeof("utf-8") - 1;
+ size_t src_len = sizeof("utf-8") - 1;
char *dest = src;
- int dest_len = src_len;
+ size_t dest_len = src_len;
intl_error_reset(NULL TSRMLS_CC);
static PHP_METHOD(UConverter, convert) {
php_converter_object *objval = CONV_GET(getThis());
char *str, *dest;
- int str_len, dest_len;
+ size_t str_len, dest_len;
zend_bool reverse = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b",
ZEND_END_ARG_INFO();
static PHP_METHOD(UConverter, getAliases) {
char *name;
- int name_len;
+ size_t name_len;
UErrorCode error = U_ZERO_ERROR;
uint16_t i, count;
PHP_FUNCTION( datefmt_set_pattern )
{
char* value = NULL;
- int value_len = 0;
+ size_t value_len = 0;
int slength = 0;
UChar* svalue = NULL;
zend_bool is_pattern_localized =FALSE;
zval *object;
const char *locale_str;
- int locale_len = 0;
+ size_t locale_len = 0;
Locale locale;
zend_long date_type = 0;
zend_long time_type = 0;
TimeZone *timezone = NULL;
bool explicit_tz;
char* pattern_str = NULL;
- int pattern_str_len = 0;
+ size_t pattern_str_len = 0;
UChar* svalue = NULL; /* UTF-16 pattern_str */
int slength = 0;
IntlDateFormatter_object* dfo;
zval *object,
*format = NULL;
const char *locale_str = NULL;
- int locale_len;
+ size_t locale_len;
bool pattern = false;
UDate date;
TimeZone *timeZone = NULL;
PHP_FUNCTION(datefmt_parse)
{
char* text_to_parse = NULL;
- int32_t text_len =0;
+ size_t text_len =0;
zval* z_parse_pos = NULL;
int32_t parse_pos = -1;
{
zend_long symbol;
char* value = NULL;
- int value_len = 0;
+ size_t value_len = 0;
UChar* svalue = 0;
int slength = 0;
FORMATTER_METHOD_INIT_VARS;
UChar* formatted = format_buf;
int formatted_len = USIZE(format_buf);
char* currency = NULL;
- int currency_len = 0;
+ size_t currency_len = 0;
UChar* scurrency = NULL;
int scurrency_len = 0;
FORMATTER_METHOD_INIT_VARS;
{
const char* locale;
char* pattern = NULL;
- int locale_len = 0, pattern_len = 0;
+ size_t locale_len = 0, pattern_len = 0;
zend_long style;
UChar* spattern = NULL;
int spattern_len = 0;
UChar* sstr = NULL;
int sstr_len = 0;
char* str = NULL;
- int str_len;
+ size_t str_len;
int32_t val32, position = 0;
int64_t val64;
double val_double;
char *currency_str = NULL;
int currency_len = 0;
char *str;
- int str_len;
+ size_t str_len;
int32_t* position_p = NULL;
int32_t position = 0;
zval *zcurrency, *zposition = NULL;
}
/* }}} */
-/* {{{ proto int grapheme_strlen(string str)
+/* {{{ proto size_t grapheme_strlen(string str)
Get number of graphemes in a string */
PHP_FUNCTION(grapheme_strlen)
{
{
const char* loc_name = NULL;
- int loc_name_len = 0;
+ size_t loc_name_len = 0;
char* tag_value = NULL;
char* empty_result = "";
static void get_icu_disp_value_src_php( char* tag_name, INTERNAL_FUNCTION_PARAMETERS)
{
const char* loc_name = NULL;
- int loc_name_len = 0;
+ size_t loc_name_len = 0;
const char* disp_loc_name = NULL;
- int disp_loc_name_len = 0;
+ size_t disp_loc_name_len = 0;
int free_loc_name = 0;
UChar* disp_name = NULL;
PHP_FUNCTION(locale_filter_matches)
{
char* lang_tag = NULL;
- int lang_tag_len = 0;
+ size_t lang_tag_len = 0;
const char* loc_range = NULL;
- int loc_range_len = 0;
+ size_t loc_range_len = 0;
int result = 0;
char* token = 0;
PHP_FUNCTION(locale_lookup)
{
char* fallback_loc = NULL;
- int fallback_loc_len = 0;
+ size_t fallback_loc_len = 0;
const char* loc_range = NULL;
int loc_range_len = 0;
{
UEnumeration *available;
char *http_accept = NULL;
- int http_accept_len;
+ size_t http_accept_len;
UErrorCode status = 0;
int len;
char resultLocale[INTL_MAX_LOCALE_LEN+1];
{
const char* locale;
char* pattern;
- int locale_len = 0, pattern_len = 0;
+ size_t locale_len = 0, pattern_len = 0;
UChar* spattern = NULL;
int spattern_len = 0;
zval* object;
PHP_FUNCTION( msgfmt_set_pattern )
{
char* value = NULL;
- int value_len = 0;
+ size_t value_len = 0;
int spattern_len = 0;
UChar* spattern = NULL;
MSG_FORMAT_METHOD_INIT_VARS;
UChar *spattern = NULL;
int spattern_len = 0;
char *pattern = NULL;
- int pattern_len = 0;
+ size_t pattern_len = 0;
const char *slocale = NULL;
- int slocale_len = 0;
+ size_t slocale_len = 0;
MessageFormatter_object mf = {0};
MessageFormatter_object *mfo = &mf;
#include "intl_convert.h"
/* {{{ */
-static void msgfmt_do_parse(MessageFormatter_object *mfo, char *source, int src_len, zval *return_value TSRMLS_DC)
+static void msgfmt_do_parse(MessageFormatter_object *mfo, char *source, size_t src_len, zval *return_value TSRMLS_DC)
{
zval *fargs;
int count = 0;
PHP_FUNCTION( msgfmt_parse )
{
char *source;
- int source_len;
+ size_t source_len;
MSG_FORMAT_METHOD_INIT_VARS;
UChar *spattern = NULL;
int spattern_len = 0;
char *pattern = NULL;
- int pattern_len = 0;
+ size_t pattern_len = 0;
const char *slocale = NULL;
- int slocale_len = 0;
+ size_t slocale_len = 0;
char *source = NULL;
int src_len = 0;
MessageFormatter_object mf = {0};
char* input = NULL;
/* form is optional, defaults to FORM_C */
zend_long form = NORMALIZER_DEFAULT;
- int input_len = 0;
+ size_t input_len = 0;
UChar* uinput = NULL;
int uinput_len = 0;
static void resourcebundle_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
const char *bundlename;
- int bundlename_len = 0;
+ size_t bundlename_len = 0;
const char *locale;
- int locale_len = 0;
+ size_t locale_len = 0;
zend_bool fallback = 1;
zval *object = return_value;
{
int ret;
char *text;
- int text_len;
+ size_t text_len;
zval *error_code = NULL;
SPOOFCHECKER_METHOD_INIT_VARS;
{
int ret;
char *s1, *s2;
- int s1_len, s2_len;
+ size_t s1_len, s2_len;
zval *error_code = NULL;
SPOOFCHECKER_METHOD_INIT_VARS;
PHP_METHOD(Spoofchecker, setAllowedLocales)
{
char *locales;
- int locales_len;
+ size_t locales_len;
SPOOFCHECKER_METHOD_INIT_VARS;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &locales, &locales_len)) {
U_CFUNC PHP_FUNCTION(intltz_create_time_zone)
{
char *str_id;
- int str_id_len;
+ size_t str_id_len;
intl_error_reset(NULL TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
U_CFUNC PHP_FUNCTION(intltz_count_equivalent_ids)
{
char *str_id;
- int str_id_len;
+ size_t str_id_len;
intl_error_reset(NULL TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
zend_long zoneType,
offset_arg;
char *region = NULL;
- int region_len = 0;
+ size_t region_len = 0;
int32_t offset,
*offsetp = NULL;
int arg3isnull = 0;
U_CFUNC PHP_FUNCTION(intltz_get_canonical_id)
{
char *str_id;
- int str_id_len;
+ size_t str_id_len;
zval *is_systemid = NULL;
intl_error_reset(NULL TSRMLS_CC);
U_CFUNC PHP_FUNCTION(intltz_get_region)
{
char *str_id;
- int str_id_len;
+ size_t str_id_len;
char outbuf[3];
intl_error_reset(NULL TSRMLS_CC);
U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id)
{
char *str_id;
- int str_id_len;
+ size_t str_id_len;
zend_long index;
intl_error_reset(NULL TSRMLS_CC);
zend_bool daylight = 0;
zend_long display_type = TimeZone::LONG;
const char *locale_str = NULL;
- int dummy = 0;
+ size_t dummy = 0;
TIMEZONE_METHOD_INIT_VARS;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
PHP_FUNCTION( transliterator_create_from_rules )
{
char *str_rules;
- int str_rules_len;
+ size_t str_rules_len;
UChar *ustr_rules = NULL;
int32_t ustr_rules_len = 0;
zend_long direction = TRANSLITERATOR_FORWARD;
char *str;
UChar *ustr = NULL,
*uresult = NULL;
- int str_len;
+ size_t str_len;
int32_t ustr_len = 0,
capacity,
uresult_len;
}
/* }}} */
-PHP_JSON_API void php_json_decode_ex(zval *return_value, char *str, int str_len, int options, zend_long depth TSRMLS_DC) /* {{{ */
+PHP_JSON_API void php_json_decode_ex(zval *return_value, char *str, size_t str_len, size_t options, zend_long depth TSRMLS_DC) /* {{{ */
{
- int utf16_len;
+ size_t utf16_len;
unsigned short *utf16;
JSON_parser jp;
PHP_FUNCTION(ldap_connect)
{
char *host = NULL;
- int hostlen;
+ size_t hostlen;
zend_long port = 389; /* Default port */
#ifdef HAVE_ORALDAP
char *wallet = NULL, *walletpasswd = NULL;
- int walletlen = 0, walletpasswdlen = 0;
+ size_t walletlen = 0, walletpasswdlen = 0;
zend_long authmode = GSLC_SSL_NO_AUTH;
int ssl=0;
#endif
{
zval *link;
char *ldap_bind_dn = NULL, *ldap_bind_pw = NULL;
- int ldap_bind_dnlen, ldap_bind_pwlen;
+ size_t ldap_bind_dnlen, ldap_bind_pwlen;
ldap_linkdata *ld;
int rc;
PHP_FUNCTION(ldap_dn2ufn)
{
char *dn, *ufn;
- int dn_len;
+ size_t dn_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &dn, &dn_len) != SUCCESS) {
return;
zval *attrib, *modtype, *vals;
zval *fetched;
char *dn;
- int dn_len;
+ size_t dn_len;
int i, j, k;
int num_mods, num_modprops, num_modvals;
LDAPMod **ldap_mods;
zval *link, *result;
ldap_linkdata *ld;
char *sortfilter;
- int sflen;
+ size_t sflen;
zend_resource *le;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrs", &link, &result, &sortfilter, &sflen) != SUCCESS) {
PHP_FUNCTION(ldap_escape)
{
char *value, *ignores, *result;
- int valuelen = 0, ignoreslen = 0, i;
+ size_t valuelen = 0, ignoreslen = 0;
+ int i;
size_t resultlen;
zend_long flags = 0;
zend_bool map[256] = {0}, havecharlist = 0;
zend_bool iscritical;
zval *link;
char *cookie = NULL;
- int cookie_len = 0;
+ size_t cookie_len = 0;
struct berval lcookie = { 0, NULL };
ldap_linkdata *ld;
LDAP *ldap;
PHP_FUNCTION(mb_http_input)
{
char *typ = NULL;
- int typ_len;
+ size_t typ_len;
int retname;
char *list, *temp;
const mbfl_encoding *result = NULL;
{
zval *track_vars_array = NULL;
char *encstr = NULL;
- int encstr_len;
+ size_t encstr_len;
php_mb_encoding_handler_info_t info;
const mbfl_encoding *detected;
PHP_FUNCTION(mb_output_handler)
{
char *arg_string;
- int arg_string_len;
+ size_t arg_string_len;
zend_long arg_status;
mbfl_string string, result;
const char *charset;
zend_long offset;
mbfl_string haystack, needle;
const char *from_encoding = MBSTRG(current_internal_encoding)->mime_name;
- int from_encoding_len;
+ size_t from_encoding_len;
n = -1;
offset = 0;
zend_long offset;
mbfl_string haystack, needle;
const char *from_encoding = MBSTRG(current_internal_encoding)->mime_name;
- int from_encoding_len;
+ size_t from_encoding_len;
n = -1;
offset = 0;
size_t argc = ZEND_NUM_ARGS();
char *encoding;
zend_long from, len;
- int encoding_len;
+ size_t encoding_len;
zval *z_len = NULL;
mbfl_string string, result, *ret;
{
char *str, *trimmarker, *encoding;
zend_long from, width;
- int str_len, trimmarker_len, encoding_len;
+ size_t str_len, trimmarker_len, encoding_len;
mbfl_string string, result, marker, *ret;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sll|ss", &str, &str_len, &from, &width, &trimmarker, &trimmarker_len, &encoding, &encoding_len) == FAILURE) {
PHP_FUNCTION(mb_convert_encoding)
{
char *arg_str, *arg_new;
- int str_len, new_len;
+ size_t str_len, new_len;
zval *arg_old;
size_t size, l, n;
char *_from_encodings = NULL, *ret, *s_free = NULL;
const mbfl_encoding *from_encoding, *to_encoding;
mbfl_encoding_detector *identd;
mbfl_buffer_converter *convd;
- int n, to_enc_len, argc, stack_level, stack_max;
+ int n, argc, stack_level, stack_max;
+ size_t to_enc_len;
size_t elistsz;
const mbfl_encoding **elist;
char *to_enc;
{
int n;
char *to = NULL;
- int to_len;
+ size_t to_len;
char *message = NULL;
- int message_len;
+ size_t message_len;
char *headers = NULL;
- int headers_len;
+ size_t headers_len;
char *subject = NULL;
zend_string *extra_cmd = NULL;
- int subject_len;
+ size_t subject_len;
int i;
char *to_r = NULL;
char *force_extra_parameters = INI_STR("mail.force_extra_parameters");
PHP_FUNCTION(mb_get_info)
{
char *typ = NULL;
- int typ_len;
+ size_t typ_len;
size_t n;
char *name;
const struct mb_overload_def *over_func;
PHP_FUNCTION(mb_check_encoding)
{
char *var = NULL;
- int var_len;
+ size_t var_len;
char *enc = NULL;
- int enc_len;
+ size_t enc_len;
mbfl_buffer_converter *convd;
const mbfl_encoding *encoding = MBSTRG(current_internal_encoding);
mbfl_string string, result, *ret = NULL;
{
zval *arg_pattern, *array;
char *string;
- int string_len;
+ size_t string_len;
php_mb_regex_t *re;
OnigRegion *regs = NULL;
int i, match_len, beg, end;
zval *arg_pattern_zval;
char *arg_pattern;
- int arg_pattern_len;
+ size_t arg_pattern_len;
char *replace;
- int replace_len;
+ size_t replace_len;
zend_fcall_info arg_replace_fci;
zend_fcall_info_cache arg_replace_fci_cache;
char *string;
- int string_len;
+ size_t string_len;
char *p;
php_mb_regex_t *re;
eval = 0;
{
char *option_str = NULL;
- int option_str_len = 0;
+ size_t option_str_len = 0;
if (!is_callable) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zss|s",
PHP_FUNCTION(mb_split)
{
char *arg_pattern;
- int arg_pattern_len;
+ size_t arg_pattern_len;
php_mb_regex_t *re;
OnigRegion *regs = NULL;
char *string;
OnigUChar *pos, *chunk_pos;
- int string_len;
+ size_t string_len;
int n, err;
zend_long count = -1;
PHP_FUNCTION(mb_ereg_match)
{
char *arg_pattern;
- int arg_pattern_len;
+ size_t arg_pattern_len;
char *string;
- int string_len;
+ size_t string_len;
php_mb_regex_t *re;
OnigSyntaxType *syntax;
{
char *option_str = NULL;
- int option_str_len = 0;
+ size_t option_str_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s",
&arg_pattern, &arg_pattern_len, &string, &string_len,
{
size_t argc = ZEND_NUM_ARGS();
char *arg_pattern, *arg_options;
- int arg_pattern_len, arg_options_len;
+ size_t arg_pattern_len, arg_options_len;
int n, i, err, pos, len, beg, end;
OnigOptionType option;
OnigUChar *str;
OnigOptionType opt;
OnigSyntaxType *syntax;
char *string = NULL;
- int string_len;
+ size_t string_len;
char buf[16];
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s",
char *dir = NULL; \
int dir_len; \
char *module; \
- int module_len; \
+ size_t module_len; \
if (zend_parse_parameters (ZEND_NUM_ARGS() TSRMLS_CC, \
"s|s", &module, &module_len, &dir, &dir_len) == FAILURE) { \
return; \
{
char *cipher, *cipher_dir;
char *mode, *mode_dir;
- int cipher_len, cipher_dir_len;
- int mode_len, mode_dir_len;
+ size_t cipher_len, cipher_dir_len;
+ size_t mode_len, mode_dir_len;
MCRYPT td;
php_mcrypt *pm;
PHP_FUNCTION(mcrypt_generic_init)
{
char *key, *iv;
- int key_len, iv_len;
+ size_t key_len, iv_len;
zval *mcryptind;
unsigned char *key_s, *iv_s;
int max_key_size, key_size, iv_size;
{
zval *mcryptind;
char *data;
- int data_len;
+ size_t data_len;
php_mcrypt *pm;
char* data_s;
int block_size, data_size;
{
zval *mcryptind;
char *data;
- int data_len;
+ size_t data_len;
php_mcrypt *pm;
char* data_s;
int block_size, data_size;
{
char **modules;
char *lib_dir = MCG(algorithms_dir);
- int lib_dir_len;
+ size_t lib_dir_len;
int i, count;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s",
{
char **modules;
char *lib_dir = MCG(modes_dir);
- int lib_dir_len;
+ size_t lib_dir_len;
int i, count;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s",
}
/* }}} */
-static void php_mcrypt_do_crypt(char* cipher, const char *key, int key_len, const char *data, int data_len, char *mode, const char *iv, int iv_len, int dencrypt, zval* return_value TSRMLS_DC) /* {{{ */
+static void php_mcrypt_do_crypt(char* cipher, const char *key, int key_len, const char *data, int data_len, char *mode, const char *iv, size_t iv_len, size_t dencrypt, zval* return_value TSRMLS_DC) /* {{{ */
{
char *cipher_dir_string;
char *module_dir_string;
char *user = NULL, *passwd = NULL;
char *host_and_port = NULL, *socket = NULL;
char *tmp = NULL, *host = NULL;
- int user_len = 0, passwd_len = 0, host_len = 0;
+ size_t user_len = 0, passwd_len = 0, host_len = 0;
int port = MYSQL_PORT;
zend_long client_flags = 0;
php_mysql_conn *mysql = NULL;
PHP_FUNCTION(mysql_select_db)
{
char *db;
- int db_len;
+ size_t db_len;
php_mysql_conn *mysql;
zval *mysql_link = NULL;
PHP_FUNCTION(mysql_create_db)
{
char *db;
- int db_len;
+ size_t db_len;
php_mysql_conn *mysql;
zval *mysql_link = NULL;
PHP_FUNCTION(mysql_drop_db)
{
char *db;
- int db_len;
+ size_t db_len;
php_mysql_conn *mysql;
zval *mysql_link = NULL;
PHP_FUNCTION(mysql_list_tables)
{
char *db;
- int db_len;
+ size_t db_len;
php_mysql_conn *mysql;
zval *mysql_link = NULL;
MYSQL_RES *mysql_result;
PHP_FUNCTION(mysql_list_fields)
{
char *db, *table;
- int db_len, table_len;
+ size_t db_len, table_len;
zval *mysql_link = NULL;
php_mysql_conn *mysql;
MYSQL_RES *mysql_result;
PHP_FUNCTION(mysql_escape_string)
{
char *str;
- int str_len;
+ size_t str_len;
zend_string *escaped_str;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
PHP_FUNCTION(mysql_real_escape_string)
{
char *str;
- int str_len;
+ size_t str_len;
zend_string *new_str;
php_mysql_conn *mysql;
zval *mysql_link = NULL;
MY_STMT *stmt;
MYSQLI_RESOURCE *mysqli_resource;
char *statement;
- int statement_len;
+ size_t statement_len;
switch (ZEND_NUM_ARGS())
{
#if !defined(MYSQLI_USE_MYSQLND)
/* {{{ mysqli_tx_cor_options_to_string */
-static void mysqli_tx_cor_options_to_string(const MYSQL * const conn, smart_str * str, const unsigned int mode)
+static void mysqli_tx_cor_options_to_string(const MYSQL * const conn, smart_str * str, const unsigned size_t mode)
{
if (mode & TRANS_COR_AND_CHAIN && !(mode & TRANS_COR_AND_NO_CHAIN)) {
if (str->s && str->s->len) {
MY_MYSQL *mysql;
zval *mysql_link = NULL;
char *user, *password, *dbname;
- int user_len, password_len, dbname_len;
+ size_t user_len, password_len, dbname_len;
zend_ulong rc;
#if !defined(MYSQLI_USE_MYSQLND) && defined(HAVE_MYSQLI_SET_CHARSET)
const CHARSET_INFO * old_charset;
zval *mysql_link;
zend_long flags = TRANS_COR_NO_OPT;
char * name = NULL;
- int name_len = 0;
+ size_t name_len = 0;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|ls", &mysql_link, mysqli_link_class_entry, &flags, &name, &name_len) == FAILURE) {
return;
PHP_FUNCTION(mysqli_debug)
{
char *debug;
- int debug_len;
+ size_t debug_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &debug, &debug_len) == FAILURE) {
return;
MY_MYSQL *mysql;
MY_STMT *stmt;
char *query = NULL;
- int query_len;
+ size_t query_len;
zval *mysql_link;
MYSQLI_RESOURCE *mysqli_resource;
zval *mysql_link;
zend_long flags = TRANS_COR_NO_OPT;
char * name = NULL;
- int name_len = 0;
+ size_t name_len = 0;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|ls", &mysql_link, mysqli_link_class_entry, &flags, &name, &name_len) == FAILURE) {
return;
zval *mysql_stmt;
char *data;
zend_long param_nr;
- int data_len;
+ size_t data_len;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ols", &mysql_stmt, mysqli_stmt_class_entry, ¶m_nr, &data, &data_len) == FAILURE) {
return;
MY_MYSQL *mysql;
zval *mysql_link;
char *dbname;
- int dbname_len;
+ size_t dbname_len;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &mysql_link, mysqli_link_class_entry, &dbname, &dbname_len) == FAILURE) {
return;
MYSQLI_RESOURCE *mysqli_resource = NULL;
zval *object = getThis();
char *hostname = NULL, *username=NULL, *passwd=NULL, *dbname=NULL, *socket=NULL;
- int hostname_len = 0, username_len = 0, passwd_len = 0, dbname_len = 0, socket_len = 0;
+ size_t hostname_len = 0, username_len = 0, passwd_len = 0, dbname_len = 0, socket_len = 0;
zend_bool persistent = FALSE;
zend_long port = 0, flags = 0;
zend_string *hash_key = NULL;
MY_MYSQL *mysql;
zval *mysql_link;
char *query = NULL;
- int query_len;
+ size_t query_len;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &mysql_link, mysqli_link_class_entry, &query, &query_len) == FAILURE) {
return;
zval *mysql_link;
zend_long flags = TRANS_START_NO_OPT;
char * name = NULL;
- int name_len = -1;
+ size_t name_len = -1;
zend_bool err = FALSE;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|ls", &mysql_link, mysqli_link_class_entry, &flags, &name, &name_len) == FAILURE) {
MY_MYSQL *mysql;
zval *mysql_link;
char * name = NULL;
- int name_len = -1;
+ size_t name_len = -1;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &mysql_link, mysqli_link_class_entry, &name, &name_len) == FAILURE) {
return;
MY_MYSQL *mysql;
zval *mysql_link;
char * name = NULL;
- int name_len = -1;
+ size_t name_len = -1;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &mysql_link, mysqli_link_class_entry, &name, &name_len) == FAILURE) {
return;
PHP_FUNCTION(birdstep_connect)
{
char *serv, *user, *pass;
- int serv_len, user_len, pass_len;
+ size_t serv_len, user_len, pass_len;
RETCODE stat;
HDBC hdbc;
VConn *new;
{
char *query;
zend_long ind;
- int query_len, indx;
+ size_t query_len, indx;
VConn *conn;
Vresult *res;
RETCODE stat;
{
zval *pv_conn;
char *query;
- int query_len;
+ size_t query_len;
odbc_result *result = NULL;
odbc_connection *conn;
RETCODE rc;
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;
void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
{
char *db, *uid, *pwd;
- int db_len, uid_len, pwd_len;
+ size_t db_len, uid_len, pwd_len;
zend_long pv_opt = SQL_CUR_DEFAULT;
odbc_connection *db_conn;
char *hashed_details;
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;
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,
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,
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) {
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;
static ZEND_FUNCTION(opcache_invalidate)
{
char *script_name;
- int script_name_len;
+ size_t script_name_len;
zend_bool force = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &script_name, &script_name_len, &force) == FAILURE) {
static ZEND_FUNCTION(opcache_compile_file)
{
char *script_name;
- int script_name_len;
+ size_t script_name_len;
zend_file_handle handle;
zend_op_array *op_array = NULL;
zend_execute_data *orig_execute_data = NULL;
static ZEND_FUNCTION(opcache_is_script_cached)
{
char *script_name;
- int script_name_len;
+ size_t script_name_len;
if (!validate_api_restriction(TSRMLS_C)) {
RETURN_FALSE;
BIO * bio_out;
zend_resource *certresource;
char * filename;
- int filename_len;
+ size_t filename_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zp|b", &zcert, &filename, &filename_len, ¬ext) == FAILURE) {
return;
outputting results to var */
PHP_FUNCTION(openssl_spki_new)
{
- int challenge_len;
+ size_t challenge_len;
char * challenge = NULL, * spkstr = NULL;
zend_string * s = NULL;
zend_resource *keyresource = NULL;
zend_resource *certresource;
zend_bool raw_output = 0;
char *method = "sha1";
- int method_len;
+ size_t method_len;
zend_string *fingerprint;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|sb", &zcert, &method, &method_len, &raw_output) == FAILURE) {
STACK_OF(X509) * untrustedchain = NULL;
zend_long purpose;
char * untrusted = NULL;
- int untrusted_len = 0, ret;
+ size_t untrusted_len = 0, ret;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl|a!s", &zcert, &purpose, &zcainfo, &untrusted, &untrusted_len) == FAILURE) {
return;
PKCS12 * p12 = NULL;
char * filename;
char * friendly_name = NULL;
- int filename_len;
+ size_t filename_len;
char * pass;
- int pass_len;
+ size_t pass_len;
zval *zcert = NULL, *zpkey = NULL, *args = NULL;
EVP_PKEY *priv_key = NULL;
zend_resource *certresource, *keyresource;
EVP_PKEY *priv_key = NULL;
zend_resource *certresource, *keyresource;
char * pass;
- int pass_len;
+ size_t pass_len;
char * friendly_name = NULL;
zval * item;
STACK_OF(X509) *ca = NULL;
{
zval *zout = NULL, zextracerts, zcert, zpkey;
char *pass, *zp12;
- int pass_len, zp12_len;
+ size_t pass_len, zp12_len;
PKCS12 * p12 = NULL;
EVP_PKEY * pkey = NULL;
X509 * cert = NULL;
X509_REQ * csr;
zval * zcsr = NULL;
zend_bool notext = 1;
- char * filename = NULL; int filename_len;
+ char * filename = NULL; size_t filename_len;
BIO * bio_out;
zend_resource *csr_resource;
{
struct php_x509_request req;
zval * zpkey, * args = NULL;
- char * passphrase = NULL; int passphrase_len = 0;
+ char * passphrase = NULL; size_t passphrase_len = 0;
char * filename = NULL; int filename_len = 0;
zend_resource *key_resource = NULL;
EVP_PKEY * key;
{
struct php_x509_request req;
zval * zpkey, * args = NULL, *out;
- char * passphrase = NULL; int passphrase_len = 0;
+ char * passphrase = NULL; size_t passphrase_len = 0;
zend_resource *key_resource = NULL;
EVP_PKEY * key;
BIO * bio_out = NULL;
PHP_FUNCTION(openssl_pbkdf2)
{
zend_long key_length = 0, iterations = 0;
- char *password; int password_len;
- char *salt; int salt_len;
+ char *password; size_t password_len;
+ char *salt; size_t salt_len;
char *method; int method_len = 0;
zend_string *out_buffer;
PKCS7 * p7 = NULL;
BIO * in = NULL, * datain = NULL, * dataout = NULL;
zend_long flags = 0;
- char * filename; int filename_len;
- char * extracerts = NULL; int extracerts_len = 0;
- char * signersfilename = NULL; int signersfilename_len = 0;
- char * datafilename = NULL; int datafilename_len = 0;
+ char * filename; size_t filename_len;
+ char * extracerts = NULL; size_t extracerts_len = 0;
+ char * signersfilename = NULL; size_t signersfilename_len = 0;
+ char * datafilename = NULL; size_t datafilename_len = 0;
RETVAL_LONG(-1);
const EVP_CIPHER *cipher = NULL;
zend_long cipherid = PHP_OPENSSL_CIPHER_DEFAULT;
zend_string * strindex;
- char * infilename = NULL; int infilename_len;
- char * outfilename = NULL; int outfilename_len;
+ char * infilename = NULL; size_t infilename_len;
+ char * outfilename = NULL; size_t outfilename_len;
RETVAL_FALSE;
STACK_OF(X509) *others = NULL;
zend_resource *certresource = NULL, *keyresource = NULL;
zend_string * strindex;
- char * infilename; int infilename_len;
- char * outfilename; int outfilename_len;
- char * extracertsfilename = NULL; int extracertsfilename_len;
+ char * infilename; size_t infilename_len;
+ char * outfilename; size_t outfilename_len;
+ char * extracertsfilename = NULL; size_t extracertsfilename_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ppzza!|lp",
&infilename, &infilename_len, &outfilename, &outfilename_len,
zend_resource *certresval, *keyresval;
BIO * in = NULL, * out = NULL, * datain = NULL;
PKCS7 * p7 = NULL;
- char * infilename; int infilename_len;
- char * outfilename; int outfilename_len;
+ char * infilename; size_t infilename_len;
+ char * outfilename; size_t outfilename_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ppz|z", &infilename, &infilename_len,
&outfilename, &outfilename_len, &recipcert, &recipkey) == FAILURE) {
int successful = 0;
zend_resource *keyresource = NULL;
char * data;
- int data_len;
+ size_t data_len;
zend_long padding = RSA_PKCS1_PADDING;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
zend_long padding = RSA_PKCS1_PADDING;
zend_resource *keyresource = NULL;
char * data;
- int data_len;
+ size_t data_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
return;
zend_resource *keyresource = NULL;
zend_long padding = RSA_PKCS1_PADDING;
char * data;
- int data_len;
+ size_t data_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE)
return;
zend_resource *keyresource = NULL;
zend_long padding = RSA_PKCS1_PADDING;
char * data;
- int data_len;
+ size_t data_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
return;
zend_string *sigbuf;
zend_resource *keyresource = NULL;
char * data;
- int data_len;
+ size_t data_len;
EVP_MD_CTX md_ctx;
zval *method = NULL;
zend_long signature_algo = OPENSSL_ALGO_SHA1;
EVP_MD_CTX md_ctx;
const EVP_MD *mdtype;
zend_resource *keyresource = NULL;
- char * data; int data_len;
- char * signature; int signature_len;
+ char * data; size_t data_len;
+ char * signature; size_t signature_len;
zval *method = NULL;
zend_long signature_algo = OPENSSL_ALGO_SHA1;
zend_resource ** key_resources; /* so we know what to cleanup */
int i, len1, len2, *eksl, nkeys;
unsigned char *buf = NULL, **eks;
- char * data; int data_len;
+ char * data; size_t data_len;
char *method =NULL;
int method_len = 0;
const EVP_CIPHER *cipher;
unsigned char *buf;
zend_resource *keyresource = NULL;
EVP_CIPHER_CTX ctx;
- char * data; int data_len;
- char * ekey; int ekey_len;
+ char * data; size_t data_len;
+ char * ekey; size_t ekey_len;
char *method =NULL;
int method_len = 0;
const EVP_CIPHER *cipher;
{
zend_long options = 0;
char *data, *method, *password, *iv = "";
- int data_len, method_len, password_len, iv_len = 0, max_iv_len;
+ size_t data_len, method_len, password_len, iv_len = 0, max_iv_len;
const EVP_CIPHER *cipher_type;
EVP_CIPHER_CTX cipher_ctx;
int i=0, outlen, keylen;
if (iv_len <= 0 && max_iv_len > 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Using an empty Initialization Vector (iv) is potentially insecure and not recommended");
}
- free_iv = php_openssl_validate_iv(&iv, &iv_len, max_iv_len TSRMLS_CC);
+ free_iv = php_openssl_validate_iv(&iv, (int *)&iv_len, max_iv_len TSRMLS_CC);
outlen = data_len + EVP_CIPHER_block_size(cipher_type);
outbuf = zend_string_alloc(outlen, 0);
{
zend_long options = 0;
char *data, *method, *password, *iv = "";
- int data_len, method_len, password_len, iv_len = 0;
+ size_t data_len, method_len, password_len, iv_len = 0;
const EVP_CIPHER *cipher_type;
EVP_CIPHER_CTX cipher_ctx;
int i, outlen, keylen;
key = (unsigned char*)password;
}
- free_iv = php_openssl_validate_iv(&iv, &iv_len, EVP_CIPHER_iv_length(cipher_type) TSRMLS_CC);
+ free_iv = php_openssl_validate_iv(&iv, (int *)&iv_len, EVP_CIPHER_iv_length(cipher_type) TSRMLS_CC);
outlen = data_len + EVP_CIPHER_block_size(cipher_type);
outbuf = zend_string_alloc(outlen, 0);
PHP_FUNCTION(openssl_cipher_iv_length)
{
char *method;
- int method_len;
+ size_t method_len;
const EVP_CIPHER *cipher_type;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &method, &method_len) == FAILURE) {
{
zval *key;
char *pub_str;
- int pub_len;
+ size_t pub_len;
EVP_PKEY *pkey;
BIGNUM *pub;
zend_string *data;
int pair_length;
zend_string *key;
char *path;
- int path_len;
+ size_t path_len;
zend_ulong key_num;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|aa", &path, &path_len, &args, &envs) == FAILURE) {
Quote regular expression characters plus an optional character */
static PHP_FUNCTION(preg_quote)
{
- int in_str_len;
+ size_t in_str_len;
char *in_str; /* Input string argument */
char *in_str_end; /* End of the input string */
- int delim_len = 0;
+ size_t delim_len = 0;
char *delim = NULL; /* Additional delimiter argument */
zend_string *out_str; /* Output string with quoted characters */
char *p, /* Iterator for input string */
pdo_dbh_t *dbh = NULL;
zend_bool is_persistent = 0;
char *data_source;
- int data_source_len;
+ size_t data_source_len;
char *colon;
char *username=NULL, *password=NULL;
- int usernamelen, passwordlen;
+ size_t usernamelen, passwordlen;
pdo_driver_t *driver = NULL;
zval *options = NULL;
char alt_dsn[512];
{
pdo_stmt_t *stmt;
char *statement;
- int statement_len;
+ size_t statement_len;
zval *options = NULL, *opt, *item, ctor_args;
zend_class_entry *dbstmt_ce, *pce;
pdo_dbh_object_t *dbh_obj = Z_PDO_OBJECT_P(getThis());
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
char *statement;
- int statement_len;
+ size_t statement_len;
zend_long ret;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &statement, &statement_len)) {
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
char *name = NULL;
- int namelen;
+ size_t namelen;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &name, &namelen)) {
RETURN_FALSE;
{
pdo_stmt_t *stmt;
char *statement;
- int statement_len;
+ size_t statement_len;
pdo_dbh_object_t *dbh_obj = Z_PDO_OBJECT_P(getThis());
pdo_dbh_t *dbh = dbh_obj->inner;
{
pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
char *str;
- int str_len;
+ size_t str_len;
zend_long paramtype = PDO_PARAM_STR;
char *qstr;
int qlen;
const zend_function_entry *funcs;
zend_function func;
zend_internal_function *ifunc = (zend_internal_function*)&func;
- int namelen;
+ size_t namelen;
char *lc_name;
pdo_dbh_t *dbh = dbh_obj->inner;
zval *pg_rows;
char *table_name, *pg_delim = NULL, *pg_null_as = NULL, *pg_fields = NULL;
- int table_name_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len;
+ size_t table_name_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len;
char *query;
PGresult *pgsql_result;
pdo_pgsql_db_handle *H;
char *table_name, *filename, *pg_delim = NULL, *pg_null_as = NULL, *pg_fields = NULL;
- int table_name_len, filename_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len;
+ size_t table_name_len, filename_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len;
char *query;
PGresult *pgsql_result;
ExecStatusType status;
pdo_pgsql_db_handle *H;
char *table_name, *pg_delim = NULL, *pg_null_as = NULL, *pg_fields = NULL;
- int table_name_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len;
+ size_t table_name_len, pg_delim_len = 0, pg_null_as_len = 0, pg_fields_len;
char *query;
PGresult *pgsql_result;
Oid oid;
int lfd;
char *oidstr;
- int oidstrlen;
+ size_t oidstrlen;
char *modestr = "rb";
- int modestrlen;
+ size_t modestrlen;
int mode = INV_READ;
char *end_ptr;
pdo_pgsql_db_handle *H;
Oid oid;
char *oidstr, *end_ptr;
- int oidlen;
+ size_t oidlen;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
&oidstr, &oidlen)) {
struct pdo_sqlite_func *func;
zval *callback;
char *func_name;
- int func_name_len;
+ size_t func_name_len;
zend_long argc = -1;
zend_string *cbname = NULL;
pdo_dbh_t *dbh;
struct pdo_sqlite_func *func;
zval *step_callback, *fini_callback;
char *func_name;
- int func_name_len;
+ size_t func_name_len;
zend_long argc = -1;
zend_string *cbname = NULL;
pdo_dbh_t *dbh;
struct pdo_sqlite_collation *collation;
zval *callback;
char *collation_name;
- int collation_name_len;
+ size_t collation_name_len;
zend_string *cbname = NULL;
pdo_dbh_t *dbh;
pdo_sqlite_db_handle *H;
zval *pgsql_link = NULL;
zval *pv_param_arr, *tmp;
char *query;
- int query_len, id = -1, argc = ZEND_NUM_ARGS();
+ size_t query_len, id = -1, argc = ZEND_NUM_ARGS();
int leftover = 0;
int num_params = 0;
char **params = NULL;
zval *pgsql_link = NULL;
zval *pv_param_arr, *tmp;
char *stmtname;
- int stmtname_len, id = -1, argc = ZEND_NUM_ARGS();
+ size_t stmtname_len, id = -1, argc = ZEND_NUM_ARGS();
int leftover = 0;
int num_params = 0;
char **params = NULL;
PHP_FUNCTION(pg_trace)
{
char *z_filename, *mode = "w";
- int z_filename_len, mode_len;
+ size_t z_filename_len, mode_len;
zval *pgsql_link = NULL;
int id = -1, argc = ZEND_NUM_ARGS();
PGconn *pgsql;
zval *pgsql_link = NULL;
zend_long oid_long;
char *oid_string, *end_ptr;
- int oid_strlen;
+ size_t oid_strlen;
PGconn *pgsql;
Oid oid;
int id = -1;
zval *pgsql_link = NULL;
zend_long oid_long;
char *oid_string, *end_ptr, *mode_string;
- int oid_strlen, mode_strlen;
+ size_t oid_strlen, mode_strlen;
PGconn *pgsql;
Oid oid;
int id = -1, pgsql_mode=0, pgsql_lofd;
zval *pgsql_id;
char *str;
zend_long z_len;
- int str_len, nbytes;
+ size_t str_len, nbytes;
int len;
pgLofp *pgsql;
int argc = ZEND_NUM_ARGS();
{
zval *pgsql_link = NULL, *oid = NULL;
char *file_in;
- int id = -1, name_len;
+ int id = -1;
+ size_t name_len;
int argc = ZEND_NUM_ARGS();
PGconn *pgsql;
Oid returned_oid;
{
zval *pgsql_link = NULL;
char *file_out, *oid_string, *end_ptr;
- int oid_strlen;
- int id = -1, name_len;
+ size_t oid_strlen;
+ int id = -1;
+ size_t name_len;
zend_long oid_long;
Oid oid;
PGconn *pgsql;
{
zval *pgsql_link;
char *table_name, *pg_delim = NULL, *pg_null_as = NULL;
- int table_name_len, pg_delim_len, pg_null_as_len, free_pg_null = 0;
+ size_t table_name_len, pg_delim_len, pg_null_as_len, free_pg_null = 0;
char *query;
int id = -1;
PGconn *pgsql;
zval *pgsql_link = NULL, *pg_rows;
zval *tmp;
char *table_name, *pg_delim = NULL, *pg_null_as = NULL;
- int table_name_len, pg_delim_len, pg_null_as_len;
+ size_t table_name_len, pg_delim_len, pg_null_as_len;
int pg_null_as_free = 0;
char *query;
int id = -1;
{
zval *pgsql_link;
char *query, *stmtname;
- int stmtname_len, query_len, id = -1;
+ size_t stmtname_len, query_len;
+ int id = -1;
PGconn *pgsql;
int is_non_blocking;
int ret;
int num_params = 0;
char **params = NULL;
char *stmtname;
- int stmtname_len, id = -1;
+ size_t stmtname_len;
+ int id = -1;
PGconn *pgsql;
int is_non_blocking;
int ret;
{
zval *pgsql_link;
char *table_name;
- uint table_name_len;
+ size_t table_name_len;
zend_bool extended=0;
PGconn *pgsql;
int id = -1;
{
zval *pgsql_link, *values;
char *table_name;
- int table_name_len;
+ size_t table_name_len;
zend_ulong option = 0;
PGconn *pg_link;
int id = -1;
{
zval *pgsql_link, *values;
char *table;
- int table_len;
+ size_t table_len;
zend_ulong option = PGSQL_DML_EXEC, return_sql;
PGconn *pg_link;
PGresult *pg_result;
{
zval *pgsql_link, *values, *ids;
char *table;
- int table_len;
+ size_t table_len;
zend_ulong option = PGSQL_DML_EXEC;
PGconn *pg_link;
zend_string *sql = NULL;
{
zval *pgsql_link, *ids;
char *table;
- int table_len;
+ size_t table_len;
zend_ulong option = PGSQL_DML_EXEC;
PGconn *pg_link;
zend_string *sql;
{
zval *pgsql_link, *ids;
char *table;
- int table_len;
+ size_t table_len;
zend_ulong option = PGSQL_DML_EXEC;
PGconn *pg_link;
zend_string *sql = NULL;
PHAR_FUNC(phar_opendir) /* {{{ */
{
char *filename;
- int filename_len;
+ size_t filename_len;
zval *zcontext = NULL;
if (!PHAR_G(intercepted)) {
PHAR_FUNC(phar_file_get_contents) /* {{{ */
{
char *filename;
- int filename_len;
+ size_t filename_len;
zend_string *contents;
zend_bool use_include_path = 0;
php_stream *stream;
PHAR_FUNC(phar_readfile) /* {{{ */
{
char *filename;
- int filename_len;
+ size_t filename_len;
int size = 0;
zend_bool use_include_path = 0;
zval *zcontext = NULL;
PHAR_FUNC(phar_fopen) /* {{{ */
{
char *filename, *mode;
- int filename_len, mode_len;
+ size_t filename_len, mode_len;
zend_bool use_include_path = 0;
zval *zcontext = NULL;
php_stream *stream;
}
if (use_include_path || (!IS_ABSOLUTE_PATH(filename, filename_len) && !strstr(filename, "://"))) {
char *arch, *entry, *fname;
- int arch_len, entry_len, fname_len;
+ size_t arch_len, entry_len, fname_len;
php_stream_context *context = NULL;
char *name;
phar_archive_data *phar;
PHAR_G(orig)(INTERNAL_FUNCTION_PARAM_PASSTHRU); \
} else { \
char *filename; \
- int filename_len; \
+ size_t filename_len; \
\
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &filename, &filename_len) == FAILURE) { \
return; \
PHAR_FUNC(phar_is_file) /* {{{ */
{
char *filename;
- int filename_len;
+ size_t filename_len;
if (!PHAR_G(intercepted)) {
goto skip_phar;
PHAR_FUNC(phar_is_link) /* {{{ */
{
char *filename;
- int filename_len;
+ size_t filename_len;
if (!PHAR_G(intercepted)) {
goto skip_phar;
}
/* }}} */
-static void phar_do_404(phar_archive_data *phar, char *fname, int fname_len, char *f404, int f404_len, char *entry, int entry_len TSRMLS_DC) /* {{{ */
+static void phar_do_404(phar_archive_data *phar, char *fname, int fname_len, char *f404, size_t f404_len, char *entry, size_t entry_len TSRMLS_DC) /* {{{ */
{
sapi_header_line ctr = {0};
phar_entry_info *info;
{
zval *mimeoverride = NULL, *rewrite = NULL;
char *alias = NULL, *error, *index_php = NULL, *f404 = NULL, *ru = NULL;
- int alias_len = 0, f404_len = 0, free_pathinfo = 0, ru_len = 0;
+ size_t alias_len = 0, f404_len = 0, free_pathinfo = 0, ru_len = 0;
char *fname, *path_info, *mime_type = NULL, *entry, *pt;
const char *basename;
int fname_len, entry_len, code, index_php_len = 0, not_cgi;
PHP_METHOD(Phar, createDefaultStub)
{
char *index = NULL, *webindex = NULL, *stub, *error;
- int index_len = 0, webindex_len = 0;
+ size_t index_len = 0, webindex_len = 0;
size_t stub_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ss", &index, &index_len, &webindex, &webindex_len) == FAILURE) {
{
zval *obj;
char *error;
- uint base_len = 0;
+ size_t base_len = 0;
char *base = NULL;
struct _phar_t pass;
zend_class_entry *ce;
char *error;
const char *pcr_error;
- int ext_len = ext ? strlen(ext) : 0;
+ size_t ext_len = ext ? strlen(ext) : 0;
int oldname_len;
phar_archive_data *pphar = NULL;
php_stream_statbuf ssb;
{
zend_long algo;
char *error, *key = NULL;
- int key_len = 0;
+ size_t key_len = 0;
PHAR_ARCHIVE_OBJECT();
/* {{{ add a file within the phar archive from a string or resource
*/
-static void phar_add_file(phar_archive_data **pphar, char *filename, int filename_len, char *cont_str, int cont_len, zval *zresource TSRMLS_DC)
+static void phar_add_file(phar_archive_data **pphar, char *filename, int filename_len, char *cont_str, size_t cont_len, zval *zresource TSRMLS_DC)
{
char *error;
size_t contents_len;
PHP_METHOD(Phar, addFromString)
{
char *localname, *cont_str;
- int localname_len, cont_len;
+ size_t localname_len, cont_len;
PHAR_ARCHIVE_OBJECT();
php_stream_statbuf ssb;
phar_entry_info *entry;
char *pathto, *filename, *actual;
- int pathto_len, filename_len;
+ size_t pathto_len, filename_len;
int ret, i;
int nelems;
zval *zval_files = NULL;
PHP_FUNCTION(posix_mkfifo)
{
char *path;
- int path_len;
+ size_t path_len;
zend_long mode;
int result;
PHP_FUNCTION(posix_mknod)
{
char *path;
- int path_len;
+ size_t path_len;
zend_long mode;
zend_long major = 0, minor = 0;
int result;
PHP_FUNCTION(posix_access)
{
zend_long mode = 0;
- int filename_len, ret;
+ size_t filename_len, ret;
char *filename, *path;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|l", &filename, &filename_len, &mode) == FAILURE) {
{
char *name;
struct group *g;
- int name_len;
+ size_t name_len;
#if defined(ZTS) && defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
struct group gbuf;
long buflen;
{
struct passwd *pw;
char *name;
- int name_len;
+ size_t name_len;
#if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWNAM_R)
struct passwd pwbuf;
long buflen;
{
zend_long basegid;
char *name;
- int name_len;
+ size_t name_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &name, &name_len, &basegid) == FAILURE) {
RETURN_FALSE;
static PHP_FUNCTION(pspell_new)
{
char *language, *spelling = NULL, *jargon = NULL, *encoding = NULL;
- int language_len, spelling_len = 0, jargon_len = 0, encoding_len = 0;
+ size_t language_len, spelling_len = 0, jargon_len = 0, encoding_len = 0;
zend_long mode = Z_L(0), speed = Z_L(0);
int argc = ZEND_NUM_ARGS();
zval *ind;
static PHP_FUNCTION(pspell_new_personal)
{
char *personal, *language, *spelling = NULL, *jargon = NULL, *encoding = NULL;
- int personal_len, language_len, spelling_len = 0, jargon_len = 0, encoding_len = 0;
+ size_t personal_len, language_len, spelling_len = 0, jargon_len = 0, encoding_len = 0;
zend_long mode = Z_L(0), speed = Z_L(0);
int argc = ZEND_NUM_ARGS();
zval *ind;
Returns true if word is valid */
static PHP_FUNCTION(pspell_check)
{
- int word_len;
+ size_t word_len;
zend_long scin;
char *word;
PspellManager *manager;
{
zend_long scin;
char *word;
- int word_len;
+ size_t word_len;
PspellManager *manager;
const PspellWordList *wl;
const char *sug;
Notify the dictionary of a user-selected replacement */
static PHP_FUNCTION(pspell_store_replacement)
{
- int miss_len, corr_len;
+ size_t miss_len, corr_len;
zend_long scin;
char *miss, *corr;
PspellManager *manager;
Adds a word to a personal list */
static PHP_FUNCTION(pspell_add_to_personal)
{
- int word_len;
+ size_t word_len;
zend_long scin;
char *word;
PspellManager *manager;
Adds a word to the current session */
static PHP_FUNCTION(pspell_add_to_session)
{
- int word_len;
+ size_t word_len;
zend_long scin;
char *word;
PspellManager *manager;
static PHP_FUNCTION(pspell_config_create)
{
char *language, *spelling = NULL, *jargon = NULL, *encoding = NULL;
- int language_len, spelling_len = 0, jargon_len = 0, encoding_len = 0;
+ size_t language_len, spelling_len = 0, jargon_len = 0, encoding_len = 0;
zval *ind;
PspellConfig *config;
{
zend_long conf;
char *value;
- int value_len;
+ size_t value_len;
PspellConfig *config;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lp", &conf, &value, &value_len) == FAILURE) {
{
zend_long conf;
char *repl;
- int repl_len;
+ size_t repl_len;
PspellConfig *config;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lp", &conf, &repl, &repl_len) == FAILURE) {
PHP_FUNCTION(readline)
{
char *prompt = NULL;
- int prompt_len;
+ size_t prompt_len;
char *result;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &prompt, &prompt_len)) {
{
char *what = NULL;
zval *value = NULL;
- int what_len, oldval;
+ size_t what_len, oldval;
char *oldstr;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sz", &what, &what_len, &value) == FAILURE) {
PHP_FUNCTION(readline_add_history)
{
char *arg;
- int arg_len;
+ size_t arg_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
return;
PHP_FUNCTION(readline_read_history)
{
char *arg = NULL;
- int arg_len;
+ size_t arg_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|p", &arg, &arg_len) == FAILURE) {
return;
PHP_FUNCTION(readline_write_history)
{
char *arg = NULL;
- int arg_len;
+ size_t arg_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|p", &arg, &arg_len) == FAILURE) {
return;
zval *callback;
zend_string *name = NULL;
char *prompt;
- int prompt_len;
+ size_t prompt_len;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &prompt, &prompt_len, &callback)) {
return;
RECODE_REQUEST request = NULL;
char *r = NULL;
size_t r_len = 0, r_alen = 0;
- int req_len, str_len;
+ size_t req_len, str_len;
char *req, *str;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &req, &req_len, &str, &str_len) == FAILURE) {
static zend_object_handlers reflection_object_handlers;
-static zval *_default_load_entry(zval *object, char *name, int name_len TSRMLS_DC) /* {{{ */
+static zval *_default_load_entry(zval *object, char *name, size_t name_len TSRMLS_DC) /* {{{ */
{
zval *value;
reflection_object *intern;
zend_function *fptr;
char *name_str;
- int name_len;
+ size_t name_len;
object = getThis();
intern = Z_REFLECTION_P(object);
zend_class_entry *ce;
zend_function *mptr;
char *name_str, *tmp;
- int name_len, tmp_len;
+ size_t name_len, tmp_len;
zval ztmp;
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "zs", &classname, &name_str, &name_len) == FAILURE) {
PHP_METHOD(SessionHandler, open)
{
char *save_path = NULL, *session_name = NULL;
- int save_path_len, session_name_len;
+ size_t save_path_len, session_name_len;
PS_SANITY_CHECK;
{
zval *lifetime;
char *path = NULL, *domain = NULL;
- int path_len, domain_len, argc = ZEND_NUM_ARGS();
+ size_t path_len, domain_len;
+ int argc = ZEND_NUM_ARGS();
zend_bool secure = 0, httponly = 0;
zend_string *ini_name;
static PHP_FUNCTION(session_cache_limiter)
{
char *limiter = NULL;
- int limiter_len;
+ size_t limiter_len;
zend_string *ini_name;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &limiter, &limiter_len) == FAILURE) {
static PHP_FUNCTION(session_decode)
{
char *str;
- int str_len;
+ size_t str_len;
if (PS(session_status) == php_session_none) {
RETURN_FALSE;
struct php_shmop *shmop;
struct shmid_ds shm;
char *flags;
- int flags_len;
+ size_t flags_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lsll", &key, &flags, &flags_len, &mode, &size) == FAILURE) {
return;
php_sxe_object *sxe;
zval value;
char *query;
- int query_len;
+ size_t query_len;
int i;
int nsnbr = 0;
xmlNsPtr *ns = NULL;
SXE_METHOD(registerXPathNamespace)
{
php_sxe_object *sxe;
- int prefix_len, ns_uri_len;
+ size_t prefix_len, ns_uri_len;
char *prefix, *ns_uri;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &prefix, &prefix_len, &ns_uri, &ns_uri_len) == FAILURE) {
xmlChar *strval;
int strval_len;
char *filename;
- int filename_len;
+ size_t filename_len;
if (ZEND_NUM_ARGS() > 1) {
RETURN_FALSE;
{
php_sxe_object *sxe;
char *nsprefix = NULL;
- int nsprefix_len = 0;
+ size_t nsprefix_len = 0;
xmlNodePtr node;
zend_bool isprefix = 0;
{
php_sxe_object *sxe;
char *nsprefix = NULL;
- int nsprefix_len = 0;
+ size_t nsprefix_len = 0;
xmlNodePtr node;
zend_bool isprefix = 0;
{
php_sxe_object *sxe;
char *qname, *value = NULL, *nsuri = NULL;
- int qname_len, value_len = 0, nsuri_len = 0;
+ size_t qname_len, value_len = 0, nsuri_len = 0;
xmlNodePtr node, newnode;
xmlNsPtr nsptr = NULL;
xmlChar *localname, *prefix = NULL;
{
php_sxe_object *sxe;
char *qname, *value = NULL, *nsuri = NULL;
- int qname_len, value_len = 0, nsuri_len = 0;
+ size_t qname_len, value_len = 0, nsuri_len = 0;
xmlNodePtr node;
xmlAttrPtr attrp = NULL;
xmlNsPtr nsptr = NULL;
int filename_len;
xmlDocPtr docp;
char *ns = NULL;
- int ns_len = 0;
+ size_t ns_len = 0;
zend_long options = 0;
zend_class_entry *ce= sxe_class_entry;
zend_bool isprefix = 0;
{
php_sxe_object *sxe;
char *data;
- int data_len;
+ size_t data_len;
xmlDocPtr docp;
char *ns = NULL;
- int ns_len = 0;
+ size_t ns_len = 0;
zend_long options = 0;
zend_class_entry *ce= sxe_class_entry;
zend_bool isprefix = 0;
{
php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
char *data, *ns = NULL;
- int data_len, ns_len = 0;
+ size_t data_len, ns_len = 0;
xmlDocPtr docp;
zend_long options = 0;
zend_bool is_url = 0, isprefix = 0;
PHP_FUNCTION(confirm_extname_compiled)
{
char *arg = NULL;
- int arg_len, len;
+ size_t arg_len, len;
char *strg;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
{
zval *oid, *value, *type;
char *a1, *a2, *a3, *a4, *a5, *a6, *a7;
- int a1_len, a2_len, a3_len, a4_len, a5_len, a6_len, a7_len;
+ size_t a1_len, a2_len, a3_len, a4_len, a5_len, a6_len, a7_len;
zend_bool use_orignames = 0, suffix_keys = 0;
zend_long timeout = SNMP_DEFAULT_TIMEOUT;
zend_long retries = SNMP_DEFAULT_RETRIES;
PHP_FUNCTION(snmp_read_mib)
{
char *filename;
- int filename_len;
+ size_t filename_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &filename, &filename_len) == FAILURE) {
RETURN_FALSE;
php_snmp_object *snmp_object;
zval *object = getThis();
char *a1, *a2;
- int a1_len, a2_len;
+ size_t a1_len, a2_len;
zend_long timeout = SNMP_DEFAULT_TIMEOUT;
zend_long retries = SNMP_DEFAULT_RETRIES;
zend_long version = SNMP_DEFAULT_VERSION;
php_snmp_object *snmp_object;
zval *object = getThis();
char *a1 = "", *a2 = "", *a3 = "", *a4 = "", *a5 = "", *a6 = "", *a7 = "";
- int a1_len = 0, a2_len = 0, a3_len = 0, a4_len = 0, a5_len = 0, a6_len = 0, a7_len = 0;
+ size_t a1_len = 0, a2_len = 0, a3_len = 0, a4_len = 0, a5_len = 0, a6_len = 0, a7_len = 0;
int argc = ZEND_NUM_ARGS();
snmp_object = Z_SNMP_P(object);
{
zval *data;
char *name;
- int name_length;
+ size_t name_length;
zval *this_ptr;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &data, &name, &name_length) == FAILURE) {
{
zval *data = NULL, *actor = NULL;
char *name, *ns;
- int name_len, ns_len;
+ size_t name_len, ns_len;
zend_bool must_understand = 0;
zval *this_ptr;
PHP_METHOD(SoapFault, SoapFault)
{
char *fault_string = NULL, *fault_code = NULL, *fault_actor = NULL, *name = NULL, *fault_code_ns = NULL;
- int fault_string_len, fault_actor_len = 0, name_len = 0, fault_code_len = 0;
+ size_t fault_string_len, fault_actor_len = 0, name_len = 0, fault_code_len = 0;
zval *code = NULL, *details = NULL, *headerfault = NULL, *this_ptr;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs|s!z!s!z",
{
zval *data, *type, *this_ptr;
char *stype = NULL, *ns = NULL, *name = NULL, *namens = NULL;
- int stype_len = 0, ns_len = 0, name_len = 0, namens_len = 0;
+ size_t stype_len = 0, ns_len = 0, name_len = 0, namens_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z!z|ssss", &data, &type, &stype, &stype_len, &ns, &ns_len, &name, &name_len, &namens, &namens_len) == FAILURE) {
return;
PHP_METHOD(SoapServer, fault)
{
char *code, *string, *actor=NULL, *name=NULL;
- int code_len, string_len, actor_len = 0, name_len = 0;
+ size_t code_len, string_len, actor_len = 0, name_len = 0;
zval* details = NULL;
soapServicePtr service;
xmlCharEncodingHandlerPtr old_encoding;
static void do_soap_call(zval* this_ptr,
char* function,
- int function_len,
+ size_t function_len,
int arg_count,
zval* real_args,
zval* return_value,
PHP_METHOD(SoapClient, __doRequest)
{
char *buf, *location, *action;
- int buf_size, location_size, action_size;
+ size_t buf_size, location_size, action_size;
zend_long version;
zend_long one_way = 0;
zval *this_ptr = getThis();
{
char *name;
char *val = NULL;
- int name_len, val_len = 0;
+ size_t name_len, val_len = 0;
zval *cookies;
zval *this_ptr = getThis();
PHP_METHOD(SoapClient, __setLocation)
{
char *location = NULL;
- int location_len = 0;
+ size_t location_len = 0;
zval *tmp;
zval *this_ptr = getThis();
struct sockaddr *sock_type = (struct sockaddr*) &sa_storage;
php_socket *php_sock;
char *addr;
- int addr_len;
+ size_t addr_len;
zend_long port = 0;
zend_long retval = 0;
{
zval *arg1;
php_socket *php_sock;
- int buf_len, retval;
+ size_t buf_len, retval;
zend_long len, flags;
char *buf;
spl_array_object *intern = Z_SPLARRAY_P(getThis());
char *buf;
- int buf_len;
+ size_t buf_len;
const unsigned char *p, *s;
php_unserialize_data_t var_hash;
zval members, zflags;
}
/* }}} */
-PHPAPI char* spl_filesystem_object_get_path(spl_filesystem_object *intern, int *len TSRMLS_DC) /* {{{ */
+PHPAPI char* spl_filesystem_object_get_path(spl_filesystem_object *intern, size_t *len TSRMLS_DC) /* {{{ */
{
#ifdef HAVE_GLOB
if (intern->type == SPL_FS_DIR) {
}
/* }}} */
-void spl_filesystem_info_set_filename(spl_filesystem_object *intern, char *path, int len, int use_copy TSRMLS_DC) /* {{{ */
+void spl_filesystem_info_set_filename(spl_filesystem_object *intern, char *path, size_t len, size_t use_copy TSRMLS_DC) /* {{{ */
{
char *p1, *p2;
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
char *fname, *suffix = 0;
size_t flen;
- int slen = 0, path_len;
+ size_t slen = 0, path_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &suffix, &slen) == FAILURE) {
return;
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
char delimiter = intern->u.file.delimiter, enclosure = intern->u.file.enclosure, escape = intern->u.file.escape;
char *delim = NULL, *enclo = NULL, *esc = NULL;
- int d_len = 0, e_len = 0, esc_len = 0;
+ size_t d_len = 0, e_len = 0, esc_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sss", &delim, &d_len, &enclo, &e_len, &esc, &esc_len) == SUCCESS) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
char delimiter = ',', enclosure = '"', escape='\\';
char *delim = NULL, *enclo = NULL, *esc = NULL;
- int d_len = 0, e_len = 0, esc_len = 0;
+ size_t d_len = 0, e_len = 0, esc_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sss", &delim, &d_len, &enclo, &e_len, &esc, &esc_len) == SUCCESS) {
switch(ZEND_NUM_ARGS())
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
char *str;
- int str_len;
+ size_t str_len;
zend_long length = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &length) == FAILURE) {
typedef void (*spl_foreign_dtor_t)(spl_filesystem_object *object TSRMLS_DC);
typedef void (*spl_foreign_clone_t)(spl_filesystem_object *src, spl_filesystem_object *dst TSRMLS_DC);
-PHPAPI char* spl_filesystem_object_get_path(spl_filesystem_object *intern, int *len TSRMLS_DC);
+PHPAPI char* spl_filesystem_object_get_path(spl_filesystem_object *intern, size_t *len TSRMLS_DC);
typedef struct _spl_other_handler {
spl_foreign_dtor_t dtor;
spl_dllist_object *intern = Z_SPLDLLIST_P(getThis());
zval flags, elem;
char *buf;
- int buf_len;
+ size_t buf_len;
const unsigned char *p, *s;
php_unserialize_data_t var_hash;
{
zend_long part;
char* prefix;
- int prefix_len;
+ size_t prefix_len;
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(getThis());
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &part, &prefix, &prefix_len) == FAILURE) {
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(getThis());
char* postfix;
- int postfix_len;
+ size_t postfix_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &postfix, &postfix_len) == FAILURE) {
return;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
char *buf;
- int buf_len;
+ size_t buf_len;
const unsigned char *p, *s;
php_unserialize_data_t var_hash;
zval entry, pmembers, pcount, inf;
php_sqlite3_db_object *db_obj;
zval *object = getThis();
char *filename, *encryption_key, *fullpath;
- int filename_len, encryption_key_len = 0;
+ size_t filename_len, encryption_key_len = 0;
zend_long flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
zend_error_handling error_handling;
zval *object = getThis();
char *extension, *lib_path, *extension_dir, *errtext = NULL;
char fullpath[MAXPATHLEN];
- int extension_len, extension_dir_len;
+ size_t extension_len, extension_dir_len;
db_obj = Z_SQLITE3_DB_P(object);
SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
zval *object = getThis();
php_sqlite3_func *func;
char *sql_func;
- int sql_func_len;
+ size_t sql_func_len;
zval *callback_func;
zend_string *callback_name;
zend_long sql_func_num_args = -1;
php_sqlite3_func *func;
char *sql_func;
zend_string *callback_name;
- int sql_func_len;
+ size_t sql_func_len;
zval *step_callback, *fini_callback;
zend_long sql_func_num_args = -1;
db_obj = Z_SQLITE3_DB_P(object);
php_sqlite3_collation *collation;
char *collation_name;
zend_string *callback_name;
- int collation_name_len;
+ size_t collation_name_len;
zval *callback_func;
db_obj = Z_SQLITE3_DB_P(object);
php_sqlite3_db_object *db_obj;
zval *object = getThis();
char *table, *column, *dbname = "main";
- int table_len, column_len, dbname_len;
+ size_t table_len, column_len, dbname_len;
zend_long rowid, flags = 0;
sqlite3_blob *blob = NULL;
php_stream_sqlite3_data *sqlite3_stream;
PHP_FUNCTION(assert)
{
zval *assertion;
- int val, description_len = 0;
+ int val;
+ size_t description_len = 0;
char *myeval = NULL;
char *compiled_string_description, *description = NULL;
PHP_FUNCTION(base64_encode)
{
char *str;
- int str_len;
+ size_t str_len;
zend_string *result;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
{
char *str;
zend_bool strict = 0;
- int str_len;
+ size_t str_len;
zend_string *result;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &str, &str_len, &strict) == FAILURE) {
PHP_FUNCTION(getenv)
{
char *ptr, *str;
- int str_len;
+ size_t str_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
RETURN_FALSE;
PHP_FUNCTION(putenv)
{
char *setting;
- int setting_len;
+ size_t setting_len;
char *p, **env;
putenv_entry pe;
#ifdef PHP_WIN32
char *options = NULL, **argv = NULL;
char opt[2] = { '\0' };
char *optname;
- int argc = 0, options_len = 0, len, o;
+ int argc = 0, len, o;
+ size_t options_len = 0;
char *php_optarg = NULL;
int php_optind = 1;
zval val, *args = NULL, *p_longopts = NULL;
PHP_FUNCTION(get_cfg_var)
{
char *varname;
- int varname_len;
+ size_t varname_len;
zval *retval;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &varname, &varname_len) == FAILURE) {
PHP_FUNCTION(error_log)
{
char *message, *opt = NULL, *headers = NULL;
- int message_len, opt_len = 0, headers_len = 0;
+ size_t message_len, opt_len = 0, headers_len = 0;
int opt_err = 0, argc = ZEND_NUM_ARGS();
zend_long erropt = 0;
PHP_FUNCTION(highlight_file)
{
char *filename;
- int filename_len, ret;
+ size_t filename_len, ret;
zend_syntax_highlighter_ini syntax_highlighter_ini;
zend_bool i = 0;
PHP_FUNCTION(php_strip_whitespace)
{
char *filename;
- int filename_len;
+ size_t filename_len;
zend_lex_state original_lex_state;
zend_file_handle file_handle = {0};
PHP_FUNCTION(ini_get)
{
char *varname, *str;
- int varname_len;
+ size_t varname_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &varname, &varname_len) == FAILURE) {
return;
PHP_FUNCTION(ini_get_all)
{
char *extname = NULL;
- int extname_len = 0, extnumber = 0;
+ size_t extname_len = 0, extnumber = 0;
zend_module_entry *module;
zend_bool details = 1;
{
zend_string *varname;
char *new_value;
- int new_value_len;
+ size_t new_value_len;
char *old_value;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss", &varname, &new_value, &new_value_len) == FAILURE) {
PHP_FUNCTION(set_include_path)
{
char *new_value;
- int new_value_len;
+ size_t new_value_len;
char *old_value;
zend_string *key;
PHP_FUNCTION(ignore_user_abort)
{
char *arg = NULL;
- int arg_len = 0;
+ size_t arg_len = 0;
int old_setting;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &arg, &arg_len) == FAILURE) {
PHP_FUNCTION(getservbyport)
{
char *proto;
- int proto_len;
+ size_t proto_len;
zend_long port;
struct servent *serv;
PHP_FUNCTION(is_uploaded_file)
{
char *path;
- int path_len;
+ size_t path_len;
if (!SG(rfc1867_uploaded_files)) {
RETURN_FALSE;
PHP_FUNCTION(move_uploaded_file)
{
char *path, *new_path;
- int path_len, new_path_len;
+ size_t path_len, new_path_len;
zend_bool successful = 0;
#ifndef PHP_WIN32
PHP_FUNCTION(get_browser)
{
char *agent_name = NULL;
- int agent_name_len = 0;
+ size_t agent_name_len = 0;
zend_bool return_array = 0;
zval *agent, *z_agent_name, *http_user_agent;
zval found_browser_entry;
PHP_NAMED_FUNCTION(php_if_crc32)
{
char *p;
- int nr;
+ size_t nr;
php_uint32 crcinit = 0;
register php_uint32 crc;
{
char salt[PHP_MAX_SALT_LEN + 1];
char *str, *salt_in = NULL;
- int str_len, salt_in_len = 0;
+ size_t str_len, salt_in_len = 0;
zend_string *result;
salt[0] = salt[PHP_MAX_SALT_LEN] = '\0';
PHP_FUNCTION(convert_cyr_string)
{
char *input, *fr_cs, *to_cs;
- int input_len, fr_cs_len, to_cs_len;
+ size_t input_len, fr_cs_len, to_cs_len;
zend_string *str;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &input, &input_len, &fr_cs, &fr_cs_len, &to_cs, &to_cs_len) == FAILURE) {
PHP_FUNCTION(strptime)
{
char *ts;
- int ts_length;
+ size_t ts_length;
char *format;
- int format_length;
+ size_t format_length;
struct tm parsed_time;
char *unparsed_part;
static void _php_do_opendir(INTERNAL_FUNCTION_PARAMETERS, int createobject)
{
char *dirname;
- int dir_len;
+ size_t dir_len;
zval *zcontext = NULL;
php_stream_context *context = NULL;
php_stream *dirp;
PHP_FUNCTION(chroot)
{
char *str;
- int ret, str_len;
+ int ret;
+ size_t str_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
RETURN_FALSE;
PHP_FUNCTION(chdir)
{
char *str;
- int ret, str_len;
+ int ret;
+ size_t str_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &str, &str_len) == FAILURE) {
RETURN_FALSE;
char *result;
#endif
char *pattern = NULL;
- int pattern_len;
+ size_t pattern_len;
zend_long flags = 0;
glob_t globbuf;
int n;
PHP_FUNCTION(scandir)
{
char *dirn;
- int dirn_len;
+ size_t dirn_len;
zend_long flags = 0;
zend_string **namelist;
int n, i;
PHPAPI PHP_FUNCTION(dl)
{
char *filename;
- int filename_len;
+ size_t filename_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
return;
PHP_FUNCTION(gethostbyname)
{
char *hostname;
- int hostname_len;
+ size_t hostname_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &hostname, &hostname_len) == FAILURE) {
return;
PHP_FUNCTION(gethostbynamel)
{
char *hostname;
- int hostname_len;
+ size_t hostname_len;
struct hostent *hp;
struct in_addr in;
int i;
#endif
u_char ans[MAXPACKET];
char *hostname, *rectype = NULL;
- int hostname_len, rectype_len = 0;
+ size_t hostname_len, rectype_len = 0;
int type = T_MX, i;
#if defined(HAVE_DNS_SEARCH)
struct sockaddr_storage from;
PHP_FUNCTION(dns_get_record)
{
char *hostname;
- int hostname_len;
+ size_t hostname_len;
long type_param = PHP_DNS_ANY;
zval *authns = NULL, *addtl = NULL;
int type_to_fetch;
PHP_FUNCTION(dns_get_mx)
{
char *hostname;
- int hostname_len;
+ size_t hostname_len;
zval *mx_list, *weight_list = NULL;
int count, qdc;
u_short type, weight;
PHP_FUNCTION(dns_get_mx) /* {{{ */
{
char *hostname;
- int hostname_len;
+ size_t hostname_len;
zval *mx_list, *weight_list = NULL;
DNS_STATUS status; /* Return value of DnsQuery_A() function */
PHP_FUNCTION(dns_check_record)
{
char *hostname, *rectype = NULL;
- int hostname_len, rectype_len = 0;
+ size_t hostname_len, rectype_len = 0;
int type = DNS_TYPE_MX;
DNS_STATUS status; /* Return value of DnsQuery_A() function */
PHP_FUNCTION(dns_get_record)
{
char *hostname;
- int hostname_len;
+ size_t hostname_len;
long type_param = PHP_DNS_ANY;
zval *authns = NULL, *addtl = NULL;
int type, type_to_fetch, first_query = 1, store_results = 1;
static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
{
char *cmd;
- int cmd_len;
+ size_t cmd_len;
zval *ret_code=NULL, *ret_array=NULL;
int ret;
PHP_FUNCTION(escapeshellcmd)
{
char *command;
- int command_len;
+ size_t command_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &command, &command_len) == FAILURE) {
return;
{
FILE *in;
char *command;
- int command_len;
+ size_t command_len;
zend_string *ret;
php_stream *stream;
PHP_FUNCTION(get_meta_tags)
{
char *filename;
- int filename_len;
+ size_t filename_len;
zend_bool use_include_path = 0;
int in_tag = 0, done = 0;
int looking_for_val = 0, have_name = 0, have_content = 0;
PHP_FUNCTION(file_get_contents)
{
char *filename;
- int filename_len;
+ size_t filename_len;
zend_bool use_include_path = 0;
php_stream *stream;
zend_long offset = -1;
{
php_stream *stream;
char *filename;
- int filename_len;
+ size_t filename_len;
zval *data;
zend_long numbytes = 0;
zend_long flags = 0;
PHP_FUNCTION(file)
{
char *filename;
- int filename_len;
+ size_t filename_len;
char *p, *s, *e;
register int i = 0;
char eol_marker = '\n';
PHP_FUNCTION(tempnam)
{
char *dir, *prefix;
- int dir_len, prefix_len;
+ size_t dir_len, prefix_len;
char *opened_path;
int fd;
zend_string *p;
PHP_NAMED_FUNCTION(php_if_fopen)
{
char *filename, *mode;
- int filename_len, mode_len;
+ size_t filename_len, mode_len;
zend_bool use_include_path = 0;
zval *zcontext = NULL;
php_stream *stream;
PHP_FUNCTION(popen)
{
char *command, *mode;
- int command_len, mode_len;
+ size_t command_len, mode_len;
FILE *fp;
php_stream *stream;
char *posix_mode;
Implements a mostly ANSI compatible fscanf() */
PHP_FUNCTION(fscanf)
{
- int result, format_len, type, argc = 0;
+ int result, type, argc = 0;
+ size_t format_len;
zval *args = NULL;
zval *file_handle;
char *buf, *format;
{
zval *arg1;
char *arg2;
- int arg2len;
+ size_t arg2len;
int ret;
int num_bytes;
zend_long arg3 = 0;
PHP_FUNCTION(readfile)
{
char *filename;
- int filename_len;
+ size_t filename_len;
int size = 0;
zend_bool use_include_path = 0;
zval *zcontext = NULL;
PHP_FUNCTION(unlink)
{
char *filename;
- int filename_len;
+ size_t filename_len;
php_stream_wrapper *wrapper;
zval *zcontext = NULL;
php_stream_context *context = NULL;
PHP_FUNCTION(copy)
{
char *source, *target;
- int source_len, target_len;
+ size_t source_len, target_len;
zval *zcontext = NULL;
php_stream_context *context;
zval *fp = NULL, *fields = NULL;
int ret;
char *delimiter_str = NULL, *enclosure_str = NULL, *escape_str = NULL;
- int delimiter_str_len = 0, enclosure_str_len = 0, escape_str_len = 0;
+ size_t delimiter_str_len = 0, enclosure_str_len = 0, escape_str_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra|sss",
&fp, &fields, &delimiter_str, &delimiter_str_len,
char *delimiter_str = NULL;
int delimiter_str_len = 0;
char *enclosure_str = NULL;
- int enclosure_str_len = 0;
+ size_t enclosure_str_len = 0;
char *escape_str = NULL;
- int escape_str_len = 0;
+ size_t escape_str_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|zsss",
&fd, &len_zv, &delimiter_str, &delimiter_str_len,
PHP_FUNCTION(realpath)
{
char *filename;
- int filename_len;
+ size_t filename_len;
char resolved_path_buff[MAXPATHLEN];
#ifndef FAST_ZPP
PHP_FUNCTION(fnmatch)
{
char *pattern, *filename;
- int pattern_len, filename_len;
+ size_t pattern_len, filename_len;
zend_long flags = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pp|l", &pattern, &pattern_len, &filename, &filename_len, &flags) == FAILURE) {
static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */
{
char *filename;
- int filename_len;
+ size_t filename_len;
zval *group;
#if !defined(WINDOWS)
gid_t gid;
static void php_do_chown(INTERNAL_FUNCTION_PARAMETERS, int do_lchown) /* {{{ */
{
char *filename;
- int filename_len;
+ size_t filename_len;
zval *user;
#if !defined(WINDOWS)
uid_t uid;
PHP_FUNCTION(chmod)
{
char *filename;
- int filename_len;
+ size_t filename_len;
zend_long mode;
int ret;
mode_t imode;
PHP_FUNCTION(touch)
{
char *filename;
- int filename_len;
+ size_t filename_len;
zend_long filetime = 0, fileatime = 0;
int ret, argc = ZEND_NUM_ARGS();
FILE *file;
# define FileFunction(name, funcnum) \
void name(INTERNAL_FUNCTION_PARAMETERS) { \
char *filename; \
- int filename_len; \
+ size_t filename_len; \
\
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &filename, &filename_len) == FAILURE) { \
return; \
# define FileFunction(name, funcnum) \
void name(INTERNAL_FUNCTION_PARAMETERS) { \
char *filename; \
- int filename_len; \
+ size_t filename_len; \
\
ZEND_PARSE_PARAMETERS_START(1, 1) \
Z_PARAM_PATH(filename, filename_len) \
static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent)
{
char *host;
- int host_len;
+ size_t host_len;
zend_long port = -1;
zval *zerrno = NULL, *zerrstr = NULL;
double timeout = FG(default_socket_timeout);
PHP_FUNCTION(ftok)
{
char *pathname, *proj;
- int pathname_len, proj_len;
+ size_t pathname_len, proj_len;
key_t k;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ps", &pathname, &pathname_len, &proj, &proj_len) == FAILURE) {
}
-PHPAPI int php_setcookie(char *name, int name_len, char *value, int value_len, time_t expires, char *path, int path_len, char *domain, int domain_len, int secure, int url_encode, int httponly TSRMLS_DC)
+PHPAPI int php_setcookie(char *name, size_t name_len, char *value, size_t value_len, time_t expires, char *path, size_t path_len, char *domain, size_t domain_len, size_t secure, size_t url_encode, size_t httponly TSRMLS_DC)
{
char *cookie;
int len=sizeof("Set-Cookie: ");
PHP_FUNCTION(htmlspecialchars_decode)
{
char *str;
- int str_len;
+ size_t str_len;
zend_long quote_style = ENT_COMPAT;
zend_string *replaced;
entity_table_opt entity_table;
const enc_to_uni *to_uni_table = NULL;
char *charset_hint = NULL;
- int charset_hint_len;
+ size_t charset_hint_len;
enum entity_charset charset;
/* in this function we have to jump through some loops because we're
zend_string *key = NULL;
char *newprefix, *p;
const char *prop_name;
- int arg_sep_len, newprefix_len, prop_len;
+ size_t arg_sep_len, newprefix_len, prop_len;
zend_ulong idx;
zval *zdata = NULL, copyzval;
zval *info = NULL;
php_stream *stream = NULL;
char *input;
- int input_len;
+ size_t input_len;
const int argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc TSRMLS_CC, "s|z/", &input, &input_len, &info) == FAILURE) {
PHP_FUNCTION(php_uname)
{
char *mode = "a";
- int modelen = sizeof("a")-1;
+ size_t modelen = sizeof("a")-1;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &mode, &modelen) == FAILURE) {
return;
PHP_FUNCTION(iptcembed)
{
char *iptcdata, *jpeg_file;
- int iptcdata_len, jpeg_file_len;
+ size_t iptcdata_len, jpeg_file_len;
zend_long spool = 0;
FILE *fp;
unsigned int marker, done = 0;
unsigned int tagsfound = 0;
unsigned char *buffer, recnum, dataset, key[ 16 ];
char *str;
- int str_len;
+ size_t str_len;
zval values, *element;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) != SUCCESS) {
int argc = ZEND_NUM_ARGS();
char *str1, *str2;
char *callback_name;
- int str1_len, str2_len, callback_len;
+ size_t str1_len, str2_len, callback_len;
zend_long cost_ins, cost_rep, cost_del;
int distance = -1;
PHP_FUNCTION(readlink)
{
char *link;
- int link_len;
+ size_t link_len;
char buff[MAXPATHLEN];
int ret;
PHP_FUNCTION(symlink)
{
char *topath, *frompath;
- int topath_len, frompath_len;
+ size_t topath_len, frompath_len;
int ret;
char source_p[MAXPATHLEN];
char dest_p[MAXPATHLEN];
PHP_FUNCTION(link)
{
char *topath, *frompath;
- int topath_len, frompath_len;
+ size_t topath_len, frompath_len;
int ret;
char source_p[MAXPATHLEN];
char dest_p[MAXPATHLEN];
PHP_FUNCTION(readlink)
{
char *link;
- int link_len;
+ size_t link_len;
char target[MAXPATHLEN];
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &link, &link_len) == FAILURE) {
PHP_FUNCTION(linkinfo)
{
char *link;
- int link_len;
+ size_t link_len;
zend_stat_t sb;
int ret;
PHP_FUNCTION(symlink)
{
char *topath, *frompath;
- int topath_len, frompath_len;
+ size_t topath_len, frompath_len;
BOOLEAN ret;
char source_p[MAXPATHLEN];
char dest_p[MAXPATHLEN];
PHP_FUNCTION(link)
{
char *topath, *frompath;
- int topath_len, frompath_len;
+ size_t topath_len, frompath_len;
int ret;
char source_p[MAXPATHLEN];
char dest_p[MAXPATHLEN];
PHP_FUNCTION(ezmlm_hash)
{
char *str = NULL;
- unsigned int h = 5381;
- int j, str_len;
+ zend_ulong h = 5381;
+ size_t j, str_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;
}
for (j = 0; j < str_len; j++) {
- h = (h + (h << 5)) ^ (unsigned long) (unsigned char) tolower(str[j]);
+ h = (h + (h << Z_UL(5))) ^ (zend_ulong) (unsigned char) tolower(str[j]);
}
- h = (h % 53);
+ h = (h % Z_UL(53));
- RETURN_LONG((int) h);
+ RETURN_LONG((zend_long) h);
}
/* }}} */
char *to=NULL, *message=NULL, *headers=NULL, *headers_trimmed=NULL;
char *subject=NULL;
zend_string *extra_cmd=NULL;
- int to_len, message_len, headers_len = 0;
- int subject_len, i;
+ size_t to_len, message_len, headers_len = 0;
+ size_t subject_len, i;
char *force_extra_parameters = INI_STR("mail.force_extra_parameters");
char *to_r, *subject_r;
char *p, *e;
zend_long dec = 0;
char *thousand_sep = NULL, *dec_point = NULL;
char thousand_sep_chr = ',', dec_point_chr = '.';
- int thousand_sep_len = 0, dec_point_len = 0;
+ size_t thousand_sep_len = 0, dec_point_len = 0;
#ifndef FAST_ZPP
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d|ls!s!", &num, &dec, &dec_point, &dec_point_len, &thousand_sep, &thousand_sep_len) == FAILURE) {
PHP_NAMED_FUNCTION(php_if_md5_file)
{
char *arg;
- int arg_len;
+ size_t arg_len;
zend_bool raw_output = 0;
char md5str[33];
unsigned char buf[1024];
PHP_FUNCTION(password_get_info)
{
php_password_algo algo;
- int hash_len;
+ size_t hash_len;
char *hash, *algo_name;
zval options;
{
zend_long new_algo = 0;
php_password_algo algo;
- int hash_len;
+ size_t hash_len;
char *hash;
HashTable *options = 0;
zval *option_buffer;
PHP_FUNCTION(password_verify)
{
int status = 0, i;
- int password_len, hash_len;
+ size_t password_len, hash_len;
char *password, *hash;
zend_string *ret;
PHP_FUNCTION(proc_open)
{
char *command, *cwd=NULL;
- int command_len, cwd_len = 0;
+ size_t command_len, cwd_len = 0;
zval *descriptorspec;
zval *pipes;
zval *environment = NULL;
PHP_FUNCTION(sha1_file)
{
char *arg;
- int arg_len;
+ size_t arg_len;
zend_bool raw_output = 0;
char sha1str[41];
unsigned char buf[1024];
PHP_FUNCTION(soundex)
{
char *str;
- int i, _small, str_len, code, last;
+ size_t i, _small, str_len, code, last;
char soundex[4 + 1];
static char soundex_table[26] =
PHP_FUNCTION(stream_socket_client)
{
char *host;
- int host_len;
+ size_t host_len;
zval *zerrno = NULL, *zerrstr = NULL, *zcontext = NULL;
double timeout = FG(default_socket_timeout);
php_timeout_ull conv;
PHP_FUNCTION(stream_socket_server)
{
char *host;
- int host_len;
+ size_t host_len;
zval *zerrno = NULL, *zerrstr = NULL, *zcontext = NULL;
php_stream *stream = NULL;
int err = 0;
zval *zstream;
zend_long flags = 0;
char *data, *target_addr = NULL;
- int datalen, target_addr_len = 0;
+ size_t datalen, target_addr_len = 0;
php_sockaddr_storage sa;
socklen_t sl = 0;
zval *options = NULL, *zcontext = NULL, *zvalue = NULL;
php_stream_context *context;
char *wrappername, *optionname;
- int wrapperlen, optionlen;
+ size_t wrapperlen, optionlen;
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
"rssz", &zcontext, &wrappername, &wrapperlen,
zval *zstream;
php_stream *stream;
char *filtername;
- int filternamelen;
+ size_t filternamelen;
zend_long read_write = 0;
zval *filterparams = NULL;
php_stream_filter *filter = NULL;
PHP_FUNCTION(stream_get_line)
{
char *str = NULL;
- int str_len = 0;
+ size_t str_len = 0;
zend_long max_length;
zval *zstream;
zend_string *buf;
PHP_FUNCTION(stream_resolve_include_path)
{
char *filename, *resolved_path;
- int filename_len;
+ size_t filename_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
return;
Wraps buffer to selected number of characters using string break char */
PHP_FUNCTION(wordwrap)
{
- zend_string *text, *breakchar = NULL, *breakchar_save = NULL;
- size_t newtextlen, chk;
+ zend_string *text;
+ char *breakchar = "\n";
+ size_t newtextlen, chk, breakchar_len = 1;
size_t alloced;
zend_long current = 0, laststart = 0, lastspace = 0;
zend_long linelength = 75;
zend_bool docut = 0;
zend_string *newtext;
- breakchar = breakchar_save = zend_string_init("\n", 1, 1);
- if (!breakchar) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|lsb", &text, &linelength, &breakchar, &breakchar_len, &docut) == FAILURE) {
return;
}
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|lSb", &text, &linelength, &breakchar, &docut) == FAILURE) {
- zend_string_free(breakchar);
- return;
- }
-
- if (breakchar != breakchar_save) {
- zend_string_free(breakchar_save);
- }
-
if (text->len == 0) {
RETURN_EMPTY_STRING();
}
- if (breakchar->len == 0) {
+ if (breakchar_len == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Break string cannot be empty");
RETURN_FALSE;
}
/* Special case for a single-character break as it needs no
additional storage space */
- if (breakchar->len == 1 && !docut) {
+ if (breakchar_len == 1 && !docut) {
newtext = zend_string_init(text->val, text->len, 0);
laststart = lastspace = 0;
for (current = 0; current < text->len; current++) {
- if (text->val[current] == breakchar->val[0]) {
+ if (text->val[current] == breakchar[0]) {
laststart = lastspace = current + 1;
} else if (text->val[current] == ' ') {
if (current - laststart >= linelength) {
- newtext->val[current] = breakchar->val[0];
+ newtext->val[current] = breakchar[0];
laststart = current + 1;
}
lastspace = current;
} else if (current - laststart >= linelength && laststart != lastspace) {
- newtext->val[lastspace] = breakchar->val[0];
+ newtext->val[lastspace] = breakchar[0];
laststart = lastspace + 1;
}
}
/* Multiple character line break or forced cut */
if (linelength > 0) {
chk = (size_t)(text->len/linelength + 1);
- newtext = zend_string_alloc(chk * breakchar->len + text->len, 0);
- alloced = text->len + chk * breakchar->len + 1;
+ newtext = zend_string_alloc(chk * breakchar_len + text->len, 0);
+ alloced = text->len + chk * breakchar_len + 1;
} else {
chk = text->len;
- alloced = text->len * (breakchar->len + 1) + 1;
- newtext = zend_string_alloc(text->len * (breakchar->len + 1), 0);
+ alloced = text->len * (breakchar_len + 1) + 1;
+ newtext = zend_string_alloc(text->len * (breakchar_len + 1), 0);
}
/* now keep track of the actual new text length */
laststart = lastspace = 0;
for (current = 0; current < text->len; current++) {
if (chk <= 0) {
- alloced += (size_t) (((text->len - current + 1)/linelength + 1) * breakchar->len) + 1;
+ alloced += (size_t) (((text->len - current + 1)/linelength + 1) * breakchar_len) + 1;
newtext = zend_string_realloc(newtext, alloced, 0);
chk = (size_t) ((text->len - current)/linelength) + 1;
}
/* when we hit an existing break, copy to new buffer, and
* fix up laststart and lastspace */
- if (text->val[current] == breakchar->val[0]
- && current + breakchar->len < text->len
- && !strncmp(text->val+current, breakchar->val, breakchar->len)) {
- memcpy(newtext->val + newtextlen, text->val + laststart, current - laststart + breakchar->len);
- newtextlen += current - laststart + breakchar->len;
- current += breakchar->len - 1;
+ if (text->val[current] == breakchar[0]
+ && current + breakchar_len < text->len
+ && !strncmp(text->val+current, breakchar, breakchar_len)) {
+ memcpy(newtext->val + newtextlen, text->val + laststart, current - laststart + breakchar_len);
+ newtextlen += current - laststart + breakchar_len;
+ current += breakchar_len - 1;
laststart = lastspace = current + 1;
chk--;
}
if (current - laststart >= linelength) {
memcpy(newtext->val + newtextlen, text->val + laststart, current - laststart);
newtextlen += current - laststart;
- memcpy(newtext->val + newtextlen, breakchar->val, breakchar->len);
- newtextlen += breakchar->len;
+ memcpy(newtext->val + newtextlen, breakchar, breakchar_len);
+ newtextlen += breakchar_len;
laststart = current + 1;
chk--;
}
&& docut && laststart >= lastspace) {
memcpy(newtext->val + newtextlen, text->val + laststart, current - laststart);
newtextlen += current - laststart;
- memcpy(newtext->val + newtextlen, breakchar->val, breakchar->len);
- newtextlen += breakchar->len;
+ memcpy(newtext->val + newtextlen, breakchar, breakchar_len);
+ newtextlen += breakchar_len;
laststart = lastspace = current;
chk--;
}
&& laststart < lastspace) {
memcpy(newtext->val + newtextlen, text->val + laststart, lastspace - laststart);
newtextlen += lastspace - laststart;
- memcpy(newtext->val + newtextlen, breakchar->val, breakchar->len);
- newtextlen += breakchar->len;
+ memcpy(newtext->val + newtextlen, breakchar, breakchar_len);
+ newtextlen += breakchar_len;
laststart = lastspace = lastspace + 1;
chk--;
}
PHP_FUNCTION(basename)
{
char *string, *suffix = NULL;
- int string_len, suffix_len = 0;
+ size_t string_len, suffix_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &string, &string_len, &suffix, &suffix_len) == FAILURE) {
return;
{
char *str;
zend_string *ret;
- int str_len;
+ size_t str_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
return;
Returns ASCII value of character */
PHP_FUNCTION(ord)
{
- char *str;
- int str_len;
+ char *str;
+ size_t str_len;
#ifndef FAST_ZPP
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
zend_string *str;
char *delims = " \t\r\n\f\v";
register char *r, *r_end;
- int delims_len = 6;
+ size_t delims_len = 6;
char mask[256];
#ifndef FAST_ZPP
{
zval *from;
char *str, *to = NULL;
- int str_len, to_len = 0;
+ size_t str_len, to_len = 0;
int ac = ZEND_NUM_ARGS();
#ifndef FAST_ZPP
int block_start, block_end, block_type, block_length, i;
zend_long max_chars=0;
int begin, end, char_count, orig_begin;
- int str_len;
+ size_t str_len;
zend_string *broken_str;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &max_chars) == FAILURE) {
char *arg;
zval *arrayArg = NULL;
char *res = NULL;
- int arglen;
+ size_t arglen;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/", &arg, &arglen, &arrayArg) == FAILURE) {
return;
zend_string *str;
char delim = ',', enc = '"', esc = '\\';
char *delim_str = NULL, *enc_str = NULL, *esc_str = NULL;
- int delim_len = 0, enc_len = 0, esc_len = 0;
+ size_t delim_len = 0, enc_len = 0, esc_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|sss", &str, &delim_str, &delim_len,
&enc_str, &enc_len, &esc_str, &esc_len) == FAILURE) {
zend_long offset = 0, length = 0;
int ac = ZEND_NUM_ARGS();
int count = 0;
- int haystack_len, needle_len;
+ size_t haystack_len, needle_len;
char *p, *endp, cmp;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &haystack, &haystack_len, &needle, &needle_len, &offset, &length) == FAILURE) {
/* Helper variables */
size_t num_pad_chars; /* Number of padding characters (total - input size) */
- zend_string *pad_str, *pad_str_save; /* Pointer to padding string */
+ zend_string *pad_str_save; /* Pointer to padding string */
+ char *pad_str = " ";
+ size_t pad_str_len = 1;
zend_long pad_type_val = STR_PAD_RIGHT; /* The padding type value */
- int i, left_pad=0, right_pad=0;
+ size_t i, left_pad=0, right_pad=0;
zend_string *result = NULL; /* Resulting string */
- pad_str = pad_str_save = zend_string_init(" ", 1, 1);
- if (!pad_str) {
- return;
- }
-
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sl|Sl", &input, &pad_length, &pad_str, &pad_type_val) == FAILURE) {
- zend_string_free(pad_str);
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sl|sl", &input, &pad_length, &pad_str, &pad_str_len, &pad_type_val) == FAILURE) {
return;
}
- if (pad_str != pad_str_save) {
- zend_string_free(pad_str_save);
- }
-
/* If resulting string turns out to be shorter than input string,
we simply copy the input and return. */
- if (pad_length < 0 || pad_length <= input->len) {
+ if (pad_length <= input->len) {
RETURN_STRINGL(input->val, input->len);
}
- if (pad_str->len == 0) {
+ if (pad_str_len == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding string cannot be empty");
return;
}
/* First we pad on the left. */
for (i = 0; i < left_pad; i++)
- result->val[result->len++] = pad_str->val[i % pad_str->len];
+ result->val[result->len++] = pad_str[i % pad_str_len];
/* Then we copy the input string. */
memcpy(result->val + result->len, input->val, input->len);
/* Finally, we pad on the right. */
for (i = 0; i < right_pad; i++)
- result->val[result->len++] = pad_str->val[i % pad_str->len];
+ result->val[result->len++] = pad_str[i % pad_str_len];
result->val[result->len] = '\0';
{
zend_string *str;
char *char_list = NULL, *p, *e, *s, ch[256];
- int char_list_len = 0, word_count = 0;
+ size_t char_list_len = 0, word_count = 0;
zend_long type = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|ls", &str, &type, &char_list, &char_list_len) == FAILURE) {
Convert monetary value(s) to string */
PHP_FUNCTION(money_format)
{
- int format_len = 0;
+ size_t format_len = 0;
char *format, *p, *e;
double value;
zend_bool check = 0;
{
char *ident;
zend_long option, facility;
- int ident_len;
+ size_t ident_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sll", &ident,
&ident_len, &option, &facility) == FAILURE) {
{
zend_long priority;
char *message;
- int message_len;
+ size_t message_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &priority,
&message, &message_len) == FAILURE) {
{
zval *var;
char *type;
- int type_len = 0;
+ size_t type_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &var, &type, &type_len) == FAILURE) {
return;
zend_bool more_entropy = 0;
#endif
zend_string *uniqid;
- int sec, usec, prefix_len = 0;
+ int sec, usec;
+ size_t prefix_len = 0;
struct timeval tv;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sb", &prefix, &prefix_len,
PHP_FUNCTION(get_headers)
{
char *url;
- int url_len;
+ size_t url_len;
php_stream_context *context;
php_stream *stream;
zval *prev_val, *hdr = NULL, *h;
php_stream *stream;
char *buffer;
char *pbuffer;
- int buffer_len;
+ size_t buffer_len;
php_stream_bucket *bucket;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &zstream, &buffer, &buffer_len) == FAILURE) {
PHP_FUNCTION(unserialize)
{
char *buf = NULL;
- int buf_len;
+ size_t buf_len;
const unsigned char *p;
php_unserialize_data_t var_hash;
PHP_FUNCTION(version_compare)
{
char *v1, *v2, *op = NULL;
- int v1_len, v2_len, op_len = 0;
+ size_t v1_len, v2_len, op_len = 0;
int compare, argc;
argc = ZEND_NUM_ARGS();
zval *sybase_link_index = NULL;
zend_bool store = 1;
char *query;
- int len, id, deadlock_count;
+ size_t len, id, deadlock_count;
sybase_link *sybase_ptr;
sybase_result *result;
CS_INT restype;
static void php_tidy_quick_repair(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_file)
{
char *enc = NULL;
- int enc_len = 0;
+ size_t enc_len = 0;
zend_bool use_include_path = 0;
TidyDoc doc;
TidyBuffer *errbuf;
static PHP_FUNCTION(tidy_parse_string)
{
char *enc = NULL;
- int enc_len = 0;
+ size_t enc_len = 0;
zend_string *input;
zval *options = NULL;
PHPTidyObj *obj;
static PHP_FUNCTION(tidy_parse_file)
{
char *enc = NULL;
- int enc_len = 0;
+ size_t enc_len = 0;
zend_bool use_include_path = 0;
zend_string *inputfile, *contents;
zval *options = NULL;
{
PHPTidyObj *obj;
char *optval, *optname;
- int optname_len;
+ size_t optname_len;
TidyOption opt;
TIDY_SET_CONTEXT;
PHPTidyObj *obj;
char *optname;
void *optval;
- int optname_len;
+ size_t optname_len;
TidyOption opt;
TidyOptionType optt;
static TIDY_DOC_METHOD(__construct)
{
char *enc = NULL;
- int enc_len = 0;
+ size_t enc_len = 0;
zend_bool use_include_path = 0;
zval *options = NULL;
zend_string *contents, *inputfile = NULL;
static TIDY_DOC_METHOD(parseFile)
{
char *enc = NULL;
- int enc_len = 0;
+ size_t enc_len = 0;
zend_bool use_include_path = 0;
zval *options = NULL;
zend_string *inputfile, *contents;
static TIDY_DOC_METHOD(parseString)
{
char *enc = NULL;
- int enc_len = 0;
+ size_t enc_len = 0;
zval *options = NULL;
PHPTidyObj *obj;
zend_string *input;
/* {{{ php_wddx_packet_start
*/
-void php_wddx_packet_start(wddx_packet *packet, char *comment, int comment_len)
+void php_wddx_packet_start(wddx_packet *packet, char *comment, size_t comment_len)
{
php_wddx_add_chunk_static(packet, WDDX_PACKET_S);
if (comment) {
xml_parser *parser;
zval *pind;
char *data;
- int data_len, ret;
+ size_t data_len, ret;
zend_long isFinal = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &pind, &data, &data_len, &isFinal) == FAILURE) {
xml_parser *parser;
zval *pind, *xdata, *info = NULL;
char *data;
- int data_len, ret;
+ size_t data_len, ret;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz/|z/", &pind, &data, &data_len, &xdata, &info) == FAILURE) {
return;
PHP_FUNCTION(utf8_encode)
{
char *arg;
- int arg_len;
+ size_t arg_len;
zend_string *encoded;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
PHP_FUNCTION(utf8_decode)
{
char *arg;
- int arg_len;
+ size_t arg_len;
zend_string *decoded;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
#ifdef LIBXML_SCHEMAS_ENABLED
/* {{{ _xmlreader_get_relaxNG */
-static xmlRelaxNGPtr _xmlreader_get_relaxNG(char *source, int source_len, int type,
+static xmlRelaxNGPtr _xmlreader_get_relaxNG(char *source, size_t source_len, size_t type,
xmlRelaxNGValidityErrorFunc error_func,
xmlRelaxNGValidityWarningFunc warn_func TSRMLS_DC)
{
/* {{{ php_xmlreader_string_arg */
static void php_xmlreader_string_arg(INTERNAL_FUNCTION_PARAMETERS, xmlreader_read_one_char_t internal_function) {
zval *id;
- int name_len = 0;
+ size_t name_len = 0;
char *retchar = NULL;
xmlreader_object *intern;
char *name;
PHP_METHOD(xmlreader, getAttributeNs)
{
zval *id;
- int name_len = 0, ns_uri_len = 0;
+ size_t name_len = 0, ns_uri_len = 0;
xmlreader_object *intern;
char *name, *ns_uri, *retchar = NULL;
PHP_METHOD(xmlreader, open)
{
zval *id;
- int source_len = 0, encoding_len = 0;
+ size_t source_len = 0, encoding_len = 0;
zend_long options = 0;
xmlreader_object *intern = NULL;
char *source, *valid_file = NULL;
PHP_METHOD(xmlreader, XML)
{
zval *id;
- int source_len = 0, encoding_len = 0;
+ size_t source_len = 0, encoding_len = 0;
zend_long options = 0;
xmlreader_object *intern = NULL;
char *source, *uri = NULL, *encoding = NULL;
char *outBuf;
zval *vals, *out_opts = NULL;
char *method = NULL;
- int method_len;
+ size_t method_len;
php_output_options out;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!z|a", &method, &method_len, &vals, &out_opts) == FAILURE) {
{
char *xml, *encoding = NULL;
zval *method;
- int xml_len, encoding_len = 0;
+ size_t xml_len, encoding_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) {
return;
PHP_FUNCTION(xmlrpc_decode)
{
char *arg1, *arg2 = NULL;
- int arg1_len, arg2_len = 0;
+ size_t arg1_len, arg2_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &arg1, &arg1_len, &arg2, &arg2_len) == FAILURE) {
return;
PHP_FUNCTION(xmlrpc_server_register_method)
{
char *method_key;
- int method_key_len;
+ size_t method_key_len;
zval *handle, *method_name;
xmlrpc_server_data* server;
xmlrpc_server_data* server;
zval *caller_params, *handle, *output_opts = NULL;
char *rawxml;
- int rawxml_len;
+ size_t rawxml_len;
php_output_options out;
int argc = ZEND_NUM_ARGS();
{
zval *arg;
char *type;
- int type_len;
+ size_t type_len;
XMLRPC_VALUE_TYPE vtype;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/s", &arg, &type, &type_len) == FAILURE) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name;
- int name_len, retval;
+ size_t name_len, retval;
zval *self = getThis();
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *prefix, *uri;
- int name_len, prefix_len, uri_len, retval;
+ size_t name_len, prefix_len, uri_len;
+ int retval;
zval *self = getThis();
if (self) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *content;
- int name_len, content_len, retval;
+ size_t name_len, content_len;
+ int retval;
zval *self = getThis();
if (self) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *prefix, *uri, *content;
- int name_len, prefix_len, uri_len, content_len, retval;
+ size_t name_len, prefix_len, uri_len, content_len;
+ int retval;
zval *self = getThis();
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *prefix, *uri;
- int name_len, prefix_len, uri_len, retval;
+ size_t name_len, prefix_len, uri_len;
+ int retval;
zval *self = getThis();
if (self) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *content = NULL;
- int name_len, content_len, retval;
+ size_t name_len, content_len;
+ int retval;
zval *self = getThis();
if (self) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *prefix, *uri, *content = NULL;
- int name_len, prefix_len, uri_len, content_len, retval;
+ size_t name_len, prefix_len, uri_len, content_len;
+ int retval;
zval *self = getThis();
if (self) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *content;
- int name_len, content_len, retval;
+ size_t name_len, content_len;
+ int retval;
zval *self = getThis();
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *version = NULL, *enc = NULL, *alone = NULL;
- int version_len, enc_len, alone_len, retval;
+ size_t version_len, enc_len, alone_len;
+ int retval;
zval *self = getThis();
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *pubid = NULL, *sysid = NULL;
- int name_len, pubid_len, sysid_len, retval;
+ size_t name_len, pubid_len, sysid_len;
+ int retval;
zval *self = getThis();
if (self) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *pubid = NULL, *sysid = NULL, *subset = NULL;
- int name_len, pubid_len, sysid_len, subset_len, retval;
+ size_t name_len, pubid_len, sysid_len, subset_len;
+ int retval;
zval *self = getThis();
if (self) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *content;
- int name_len, content_len, retval;
+ size_t name_len, content_len;
+ int retval;
zval *self = getThis();
if (self) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *content;
- int name_len, content_len, retval;
+ size_t name_len, content_len;
+ int retval;
zval *self = getThis();
if (self) {
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name;
- int name_len, retval;
+ size_t name_len, retval;
zend_bool isparm;
zval *self = getThis();
xmlwriter_object *intern;
xmlTextWriterPtr ptr;
char *name, *content;
- int name_len, content_len, retval;
+ size_t name_len, content_len;
+ int retval;
/* Optional parameters */
char *pubid = NULL, *sysid = NULL, *ndataid = NULL;
zend_bool pe = 0;
- int pubid_len, sysid_len, ndataid_len;
+ size_t pubid_len, sysid_len, ndataid_len;
zval *self = getThis();
if (self) {
xmlTextWriterPtr ptr;
char *source;
char resolved_path[MAXPATHLEN + 1];
- int source_len;
+ size_t source_len;
zval *self = getThis();
ze_xmlwriter_object *ze_obj = NULL;
zval *id, *docp = NULL;
xmlDoc *newdocp;
xsltStylesheetPtr sheetp;
- int ret, uri_len;
+ int ret;
+ size_t uri_len;
char *uri;
xsl_object *intern;
xsl_object *intern;
zend_ulong idx;
char *namespace;
- int namespace_len;
+ size_t namespace_len;
zend_string *string_key, *name, *value;
DOM_GET_THIS(id);
zval *id;
xsl_object *intern;
char *filename = NULL;
- int filename_len;
+ size_t filename_len;
DOM_GET_THIS(id);
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "p!", &filename, &filename_len) == SUCCESS) {
# define add_ascii_assoc_long add_assoc_long
/* Flatten a path by making a relative path (to .)*/
-static char * php_zip_make_relative_path(char *path, int path_len) /* {{{ */
+static char * php_zip_make_relative_path(char *path, size_t path_len) /* {{{ */
{
char *path_begin = path;
size_t i;
zval * zip;
zval * zip_entry;
char *mode = NULL;
- int mode_len = 0;
+ size_t mode_len = 0;
zip_read_rsrc * zr_rsrc;
zip_rsrc *z_rsrc;
struct zip *intern;
zval *self = getThis();
char *entry_name = NULL;
- int entry_name_len = 0;
+ size_t entry_name_len = 0;
zend_long offset_start = 0, offset_len = 0;
zend_string *filename;
zval *self = getThis();
zend_string *buffer;
char *name;
- int name_len;
+ size_t name_len;
ze_zip_object *ze_obj;
struct zip_source *zs;
int pos = 0;
{
struct zip *intern;
zval *self = getThis();
- int name_len;
+ size_t name_len;
char *name;
zend_long flags=0, opsys, attr;
zip_int64_t idx;
{
struct zip *intern;
zval *self = getThis(), *z_opsys, *z_attr;
- int name_len;
+ size_t name_len;
char *name;
zend_long flags=0;
zip_uint8_t opsys;
{
struct zip *intern;
zval *self = getThis();
- int name_len;
+ size_t name_len;
char *name;
struct zip_stat sb;
zval *self = getThis();
char *new_name;
- int new_name_len;
+ size_t new_name_len;
zend_long index;
if (!self) {
zval *self = getThis();
struct zip_stat sb;
char *name;
- int name_len;
+ size_t name_len;
if (!self) {
RETURN_FALSE;
zval *zval_file = NULL;
php_stream_statbuf ssb;
char *pathto;
- int pathto_len;
+ size_t pathto_len;
int ret, i;
int nelems;
static PHP_FUNCTION(ob_gzhandler)
{
char *in_str;
- int in_len;
+ size_t in_len;
zend_long flags = 0;
php_output_context ctx = {0};
int encoding, rv;
static PHP_FUNCTION(gzfile)
{
char *filename;
- int filename_len;
+ size_t filename_len;
int flags = REPORT_ERRORS;
char buf[8192] = {0};
register int i = 0;
{
char *filename;
char *mode;
- int filename_len, mode_len;
+ size_t filename_len, mode_len;
int flags = REPORT_ERRORS;
php_stream *stream;
zend_long use_include_path = 0;
static PHP_FUNCTION(readgzfile)
{
char *filename;
- int filename_len;
+ size_t filename_len;
int flags = REPORT_ERRORS;
php_stream *stream;
int size;
static PHP_FUNCTION(name) \
{ \
char *in_buf, *out_buf; \
- int in_len; \
+ size_t in_len; \
size_t out_len; \
zend_long max_len = 0; \
if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &in_buf, &in_len, &max_len)) { \
PHP_FUNCTION(output_add_rewrite_var)
{
char *name, *value;
- int name_len, value_len;
+ size_t name_len, value_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &name, &name_len, &value, &value_len) == FAILURE) {
return;
size_t pattern_len;
} glob_s_t;
-PHPAPI char* _php_glob_stream_get_path(php_stream *stream, int copy, int *plen STREAMS_DC TSRMLS_DC) /* {{{ */
+PHPAPI char* _php_glob_stream_get_path(php_stream *stream, int copy, size_t *plen STREAMS_DC TSRMLS_DC) /* {{{ */
{
glob_s_t *pglob = (glob_s_t *)stream->abstract;
}
/* }}} */
-PHPAPI char* _php_glob_stream_get_pattern(php_stream *stream, int copy, int *plen STREAMS_DC TSRMLS_DC) /* {{{ */
+PHPAPI char* _php_glob_stream_get_pattern(php_stream *stream, int copy, size_t *plen STREAMS_DC TSRMLS_DC) /* {{{ */
{
glob_s_t *pglob = (glob_s_t *)stream->abstract;
BEGIN_EXTERN_C()
-PHPAPI char* _php_glob_stream_get_path(php_stream *stream, int copy, int *plen STREAMS_DC TSRMLS_DC);
+PHPAPI char* _php_glob_stream_get_path(php_stream *stream, int copy, size_t *plen STREAMS_DC TSRMLS_DC);
#define php_glob_stream_get_path(stream, copy, plen) _php_glob_stream_get_path((stream), (copy), (plen) STREAMS_CC TSRMLS_CC)
-PHPAPI char* _php_glob_stream_get_pattern(php_stream *stream, int copy, int *plen STREAMS_DC TSRMLS_DC);
+PHPAPI char* _php_glob_stream_get_pattern(php_stream *stream, int copy, size_t *plen STREAMS_DC TSRMLS_DC);
#define php_glob_stream_get_pattern(stream, copy, plen) _php_glob_stream_get_pattern((stream), (copy), (plen) STREAMS_CC TSRMLS_CC)
PHPAPI int _php_glob_stream_get_count(php_stream *stream, int *pflags STREAMS_DC TSRMLS_DC);
PHP_FUNCTION(stream_wrapper_unregister)
{
char *protocol;
- int protocol_len;
+ size_t protocol_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &protocol, &protocol_len) == FAILURE) {
RETURN_FALSE;
PHP_FUNCTION(virtual)
{
char *filename;
- int filename_len;
+ size_t filename_len;
request_rec *rr;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &filename, &filename_len) == FAILURE) {
{
request_rec *rr;
char *filename;
- int filename_len;
+ size_t filename_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &filename, &filename_len) == FAILURE) {
return;
{
php_struct *ctx;
char *note_name, *note_val = NULL;
- int note_name_len, note_val_len;
+ size_t note_name_len, note_val_len;
char *old_note_val=NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", ¬e_name, ¬e_name_len, ¬e_val, ¬e_val_len) == FAILURE) {
{
php_struct *ctx;
char *variable=NULL, *string_val=NULL;
- int variable_len, string_val_len;
+ size_t variable_len, string_val_len;
zend_bool walk_to_top = 0;
int arg_count = ZEND_NUM_ARGS();
request_rec *r;
PHP_FUNCTION(cli_set_process_title)
{
char *title = NULL;
- int title_len;
+ size_t title_len;
int rc;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &title, &title_len) == FAILURE) {
{
long element = 0L;
char *color = NULL;
- int color_len = 0;
+ size_t color_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &element, &color, &color_len) == FAILURE) {
return;
static PHP_FUNCTION(phpdbg_prompt)
{
char *prompt = NULL;
- int prompt_len = 0;
+ size_t prompt_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &prompt, &prompt_len) == FAILURE) {
return;
projects / php / commitdiff