Mirrors
/
php
mirror of https://github.com/php/php-src
3
0
Fork 0
Code Releases Activity
Browse Source

Whitespace

migration/unlabaled-1.67.2
Zeev Suraski 25 years ago
parent
adf89828d2
commit
4f6c95d17a
20 changed files with 158 additions and 158 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      Zend/zend.c
  2. 10
      Zend/zend.h
  3. 34
      Zend/zend_API.c
  4. 60
      Zend/zend_API.h
  5. 6
      Zend/zend_alloc.c
  6. 22
      Zend/zend_alloc.h
  7. 14
      Zend/zend_builtin_functions.c
  8. 4
      Zend/zend_compile.c
  9. 12
      Zend/zend_constants.c
  10. 16
      Zend/zend_constants.h
  11. 4
      Zend/zend_execute_API.c
  12. 8
      Zend/zend_hash.c
  13. 38
      Zend/zend_hash.h
  14. 12
      Zend/zend_ini.h
  15. 10
      Zend/zend_ini_scanner.l
  16. 12
      Zend/zend_language_parser.y
  17. 28
      Zend/zend_language_scanner.l
  18. 12
      Zend/zend_list.c
  19. 2
      Zend/zend_list.h
  20. 6
      Zend/zend_llist.c

6
Zend/zend.c
View File

@ -103,7 +103,7 @@ static void print_hash(HashTable *ht, int indent)
ZEND_PUTS(string_key);
break;
case HASH_KEY_IS_LONG:
zend_printf("%ld",num_key);
zend_printf("%ld", num_key);
break;
}
ZEND_PUTS("] => ");
@ -183,7 +183,7 @@ ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int in
}
return 0;
}
write_func(expr->value.str.val,expr->value.str.len);
write_func(expr->value.str.val, expr->value.str.len);
if (use_copy) {
zval_dtor(expr);
}
@ -207,7 +207,7 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int
expr->value.ht->nApplyCount=0;
return;
}
print_hash(expr->value.ht,indent);
print_hash(expr->value.ht, indent);
expr->value.ht->nApplyCount--;
break;
case IS_OBJECT:

10
Zend/zend.h
View File

@ -292,8 +292,8 @@ typedef int (*zend_write_func_t)(const char *str, uint str_length);
#undef MIN
#undef MAX
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a, b) (((a)>(b))?(a):(b))
#define MIN(a, b) (((a)<(b))?(a):(b))
#define ZEND_STRL(str) (str), (sizeof(str)-1)
#define ZEND_STRS(str) (str), (sizeof(str))
#define ZEND_NORMALIZE_BOOL(n) \
@ -490,15 +490,15 @@ ZEND_API int zend_get_configuration_directive(char *name, uint name_length, zval
} \
INIT_PZVAL(&(zv));
#define REPLACE_ZVAL_VALUE(ppzv_dest,pzv_src,copy) { \
int is_ref,refcount; \
#define REPLACE_ZVAL_VALUE(ppzv_dest, pzv_src, copy) { \
int is_ref, refcount; \
\
SEPARATE_ZVAL_IF_NOT_REF(ppzv_dest); \
is_ref = (*ppzv_dest)->is_ref; \
refcount = (*ppzv_dest)->refcount; \
zval_dtor(*ppzv_dest); \
**ppzv_dest = *pzv_src; \
if (copy) { \
if (copy) { \
zval_copy_ctor(*ppzv_dest); \
} \
(*ppzv_dest)->is_ref = is_ref; \

34
Zend/zend_API.c
View File

@ -593,7 +593,7 @@ ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC TSRMLS_DC)
}
ZEND_API int add_assoc_function(zval *arg, char *key,void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS))
ZEND_API int add_assoc_function(zval *arg, char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS))
{
zend_error(E_WARNING, "add_assoc_function() is no longer supported");
return FAILURE;
@ -686,7 +686,7 @@ ZEND_API int add_index_long(zval *arg, uint index, long n)
MAKE_STD_ZVAL(tmp);
ZVAL_LONG(tmp, n);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *),NULL);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
}
@ -707,7 +707,7 @@ ZEND_API int add_index_bool(zval *arg, uint index, int b)
MAKE_STD_ZVAL(tmp);
ZVAL_BOOL(tmp, b);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *),NULL);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
}
@ -718,7 +718,7 @@ ZEND_API int add_index_resource(zval *arg, uint index, int r)
MAKE_STD_ZVAL(tmp);
ZVAL_RESOURCE(tmp, r);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *),NULL);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
}
@ -729,7 +729,7 @@ ZEND_API int add_index_double(zval *arg, uint index, double d)
MAKE_STD_ZVAL(tmp);
ZVAL_DOUBLE(tmp, d);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *),NULL);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
}
@ -823,7 +823,7 @@ ZEND_API int add_next_index_string(zval *arg, char *str, int duplicate)
MAKE_STD_ZVAL(tmp);
ZVAL_STRING(tmp, str, duplicate);
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *),NULL);
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
}
@ -834,7 +834,7 @@ ZEND_API int add_next_index_stringl(zval *arg, char *str, uint length, int dupli
MAKE_STD_ZVAL(tmp);
ZVAL_STRINGL(tmp, str, length, duplicate);
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *),NULL);
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
}
@ -895,7 +895,7 @@ ZEND_API int add_get_index_string(zval *arg, uint index, char *str, void **dest,
MAKE_STD_ZVAL(tmp);
ZVAL_STRING(tmp, str, duplicate);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *),dest);
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
}
@ -995,7 +995,7 @@ ZEND_API int zend_startup_module(zend_module_entry *module)
TSRMLS_FETCH();
if (module->module_startup_func(MODULE_PERSISTENT, module->module_number TSRMLS_CC)==FAILURE) {
zend_error(E_CORE_ERROR,"Unable to start %s module",module->name);
zend_error(E_CORE_ERROR,"Unable to start %s module", module->name);
return FAILURE;
}
}
@ -1012,7 +1012,7 @@ int zend_register_functions(zend_function_entry *functions, HashTable *function_
zend_function_entry *ptr = functions;
zend_function function;
zend_internal_function *internal_function = (zend_internal_function *)&function;
int count=0,unload=0;
int count=0, unload=0;
HashTable *target_function_table = function_table;
int error_type;
@ -1046,7 +1046,7 @@ int zend_register_functions(zend_function_entry *functions, HashTable *function_
if (unload) { /* before unloading, display all remaining bad function in the module */
while (ptr->fname) {
if (zend_hash_exists(target_function_table, ptr->fname, strlen(ptr->fname)+1)) {
zend_error(error_type, "Function registration failed - duplicate name - %s",ptr->fname);
zend_error(error_type, "Function registration failed - duplicate name - %s", ptr->fname);
}
ptr++;
}
@ -1087,14 +1087,14 @@ ZEND_API int zend_register_module(zend_module_entry *module)
TSRMLS_FETCH();
#if 0
zend_printf("%s: Registering module %d\n",module->name, module->module_number);
zend_printf("%s: Registering module %d\n", module->name, module->module_number);
#endif
if (module->functions && zend_register_functions(module->functions, NULL, module->type TSRMLS_CC)==FAILURE) {
zend_error(E_CORE_WARNING,"%s: Unable to register functions, unable to load",module->name);
zend_error(E_CORE_WARNING,"%s: Unable to register functions, unable to load", module->name);
return FAILURE;
}
module->module_started=1;
return zend_hash_add(&module_registry, module->name,strlen(module->name)+1,(void *)module,sizeof(zend_module_entry),NULL);
return zend_hash_add(&module_registry, module->name, strlen(module->name)+1, (void *)module, sizeof(zend_module_entry), NULL);
}
@ -1111,7 +1111,7 @@ void module_destructor(zend_module_entry *module)
if (module->module_started && module->module_shutdown_func) {
#if 0
zend_printf("%s: Module shutdown\n",module->name);
zend_printf("%s: Module shutdown\n", module->name);
#endif
module->module_shutdown_func(module->type, module->module_number TSRMLS_CC);
}
@ -1133,7 +1133,7 @@ int module_registry_request_startup(zend_module_entry *module TSRMLS_DC)
{
if (module->request_startup_func) {
#if 0
zend_printf("%s: Request startup\n",module->name);
zend_printf("%s: Request startup\n", module->name);
#endif
if (module->request_startup_func(module->type, module->module_number TSRMLS_CC)==FAILURE) {
zend_error(E_WARNING, "request_startup() for %s module failed", module->name);
@ -1153,7 +1153,7 @@ int module_registry_cleanup(zend_module_entry *module TSRMLS_DC)
case MODULE_PERSISTENT:
if (module->request_shutdown_func) {
#if 0
zend_printf("%s: Request shutdown\n",module->name);
zend_printf("%s: Request shutdown\n", module->name);
#endif
module->request_shutdown_func(module->type, module->module_number TSRMLS_CC);
}

60
Zend/zend_API.h
View File

@ -161,7 +161,7 @@ ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC TSRMLS_DC);
ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC TSRMLS_DC);
/* no longer supported */
ZEND_API int add_assoc_function(zval *arg, char *key,void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
ZEND_API int add_assoc_function(zval *arg, char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
ZEND_API int add_assoc_long_ex(zval *arg, char *key, uint key_len, long n);
ZEND_API int add_assoc_null_ex(zval *arg, char *key, uint key_len);
@ -240,7 +240,7 @@ ZEND_API int call_user_function_ex(HashTable *function_table, zval **object_pp,
ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
int is_ref, int num_symbol_tables, ...);
#define add_method(arg,key,method) add_assoc_function((arg),(key),(method))
#define add_method(arg, key, method) add_assoc_function((arg), (key), (method))
#if ZEND_DEBUG
#define CHECK_ZVAL_STRING(z) \
@ -252,12 +252,12 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
#define CHECK_ZVAL_STRING_REL(z)
#endif
#define ZVAL_RESOURCE(z,l) { \
#define ZVAL_RESOURCE(z, l) { \
(z)->type = IS_RESOURCE; \
(z)->value.lval = l; \
}
#define ZVAL_BOOL(z,b) { \
#define ZVAL_BOOL(z, b) { \
(z)->type = IS_BOOL; \
(z)->value.lval = b; \
}
@ -266,27 +266,27 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
(z)->type = IS_NULL; \
}
#define ZVAL_LONG(z,l) { \
#define ZVAL_LONG(z, l) { \
(z)->type = IS_LONG; \
(z)->value.lval = l; \
}
#define ZVAL_DOUBLE(z,d) { \
#define ZVAL_DOUBLE(z, d) { \
(z)->type = IS_DOUBLE; \
(z)->value.dval = d; \
}
#define ZVAL_STRING(z,s,duplicate) { \
#define ZVAL_STRING(z, s, duplicate) { \
char *__s=(s); \
(z)->value.str.len = strlen(__s); \
(z)->value.str.val = (duplicate?estrndup(__s,(z)->value.str.len):__s); \
(z)->value.str.val = (duplicate?estrndup(__s, (z)->value.str.len):__s); \
(z)->type = IS_STRING; \
}
#define ZVAL_STRINGL(z,s,l,duplicate) { \
#define ZVAL_STRINGL(z, s, l, duplicate) { \
char *__s=(s); int __l=l; \
(z)->value.str.len = __l; \
(z)->value.str.val = (duplicate?estrndup(__s,__l):__s); \
(z)->value.str.val = (duplicate?estrndup(__s, __l):__s); \
(z)->type = IS_STRING; \
}
@ -296,63 +296,63 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
(z)->type = IS_STRING; \
}
#define ZVAL_FALSE(z) ZVAL_BOOL(z,0)
#define ZVAL_TRUE(z) ZVAL_BOOL(z,1)
#define ZVAL_FALSE(z) ZVAL_BOOL(z, 0)
#define ZVAL_TRUE(z) ZVAL_BOOL(z, 1)
#define RETVAL_RESOURCE(l) ZVAL_RESOURCE(return_value,l)
#define RETVAL_BOOL(b) ZVAL_BOOL(return_value,b)
#define RETVAL_RESOURCE(l) ZVAL_RESOURCE(return_value, l)
#define RETVAL_BOOL(b) ZVAL_BOOL(return_value, b)
#define RETVAL_NULL() ZVAL_NULL(return_value)
#define RETVAL_LONG(l) ZVAL_LONG(return_value,l)
#define RETVAL_DOUBLE(d) ZVAL_DOUBLE(return_value,d)
#define RETVAL_STRING(s,duplicate) ZVAL_STRING(return_value,s,duplicate)
#define RETVAL_STRINGL(s,l,duplicate) ZVAL_STRINGL(return_value,s,l,duplicate)
#define RETVAL_LONG(l) ZVAL_LONG(return_value, l)
#define RETVAL_DOUBLE(d) ZVAL_DOUBLE(return_value, d)
#define RETVAL_STRING(s, duplicate) ZVAL_STRING(return_value, s, duplicate)
#define RETVAL_STRINGL(s, l, duplicate) ZVAL_STRINGL(return_value, s, l, duplicate)
#define RETVAL_EMPTY_STRING() ZVAL_EMPTY_STRING(return_value)
#define RETVAL_FALSE ZVAL_BOOL(return_value,0)
#define RETVAL_TRUE ZVAL_BOOL(return_value,1)
#define RETVAL_FALSE ZVAL_BOOL(return_value, 0)
#define RETVAL_TRUE ZVAL_BOOL(return_value, 1)
#define RETURN_RESOURCE(l) { RETVAL_RESOURCE(l); return; }
#define RETURN_BOOL(b) { RETVAL_BOOL(b); return; }
#define RETURN_NULL() { RETVAL_NULL(); return;}
#define RETURN_LONG(l) { RETVAL_LONG(l); return; }
#define RETURN_DOUBLE(d) { RETVAL_DOUBLE(d); return; }
#define RETURN_STRING(s,duplicate) { RETVAL_STRING(s,duplicate); return; }
#define RETURN_STRINGL(s,l,duplicate) { RETVAL_STRINGL(s,l,duplicate); return; }
#define RETURN_STRING(s, duplicate) { RETVAL_STRING(s, duplicate); return; }
#define RETURN_STRINGL(s, l, duplicate) { RETVAL_STRINGL(s, l, duplicate); return; }
#define RETURN_EMPTY_STRING() { RETVAL_EMPTY_STRING(); return; }
#define RETURN_FALSE { RETVAL_FALSE; return; }
#define RETURN_TRUE { RETVAL_TRUE; return; }
#define SET_VAR_STRING(n,v) { \
#define SET_VAR_STRING(n, v) { \
{ \
zval *var; \
ALLOC_ZVAL(var); \
ZVAL_STRING(var,v,0); \
ZVAL_STRING(var, v, 0); \
ZEND_SET_GLOBAL_VAR(n, var); \
} \
}
#define SET_VAR_STRINGL(n,v,l) { \
#define SET_VAR_STRINGL(n, v, l) { \
{ \
zval *var; \
ALLOC_ZVAL(var); \
ZVAL_STRINGL(var,v,l,0); \
ZVAL_STRINGL(var, v, l, 0); \
ZEND_SET_GLOBAL_VAR(n, var); \
} \
}
#define SET_VAR_LONG(n,v) { \
#define SET_VAR_LONG(n, v) { \
{ \
zval *var; \
ALLOC_ZVAL(var); \
ZVAL_LONG(var,v); \
ZVAL_LONG(var, v); \
ZEND_SET_GLOBAL_VAR(n, var); \
} \
}
#define SET_VAR_DOUBLE(n,v) { \
#define SET_VAR_DOUBLE(n, v) { \
{ \
zval *var; \
ALLOC_ZVAL(var); \
ZVAL_DOUBLE(var,v); \
ZVAL_DOUBLE(var, v); \
ZEND_SET_GLOBAL_VAR(n, var); \
} \
}

6
Zend/zend_alloc.c
View File

@ -61,7 +61,7 @@ static long mem_block_end_magic = MEM_BLOCK_END_MAGIC;
# if ZEND_DEBUG
#define CHECK_MEMORY_LIMIT(s, rs) _CHECK_MEMORY_LIMIT(s, rs, __zend_filename, __zend_lineno)
# else
#define CHECK_MEMORY_LIMIT(s, rs) _CHECK_MEMORY_LIMIT(s, rs, NULL,0)
#define CHECK_MEMORY_LIMIT(s, rs) _CHECK_MEMORY_LIMIT(s, rs, NULL, 0)
# endif
#define _CHECK_MEMORY_LIMIT(s, rs, file, lineno) { AG(allocated_memory) += rs;\
@ -72,7 +72,7 @@ static long mem_block_end_magic = MEM_BLOCK_END_MAGIC;
} \
if (!AG(memory_exhausted)) { \
if (!file) { \
zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted (tried to allocate %d bytes)", AG(memory_limit),s); \
zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted (tried to allocate %d bytes)", AG(memory_limit), s); \
} else { \
zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted at %s:%d (tried to allocate %d bytes)", AG(memory_limit), file, lineno, s); \
} \
@ -295,7 +295,7 @@ ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LIN
HANDLE_BLOCK_INTERRUPTIONS();
REMOVE_POINTER_FROM_LIST(p);
p = (zend_mem_header *) ZEND_DO_REALLOC(p,sizeof(zend_mem_header)+MEM_HEADER_PADDING+SIZE+END_MAGIC_SIZE);
p = (zend_mem_header *) ZEND_DO_REALLOC(p, sizeof(zend_mem_header)+MEM_HEADER_PADDING+SIZE+END_MAGIC_SIZE);
if (!p) {
if (!allow_failure) {
fprintf(stderr,"FATAL: erealloc(): Unable to allocate %ld bytes\n", (long) size);

22
Zend/zend_alloc.h
View File

@ -84,11 +84,11 @@ ZEND_API int _persist_alloc(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
/* Standard wrapper macros */
#define emalloc(size) _emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define efree(ptr) _efree((ptr) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define ecalloc(nmemb,size) _ecalloc((nmemb), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc(ptr,size) _erealloc((ptr), (size),0 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc_recoverable(ptr,size) _erealloc((ptr), (size),1 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define ecalloc(nmemb, size) _ecalloc((nmemb), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc(ptr, size) _erealloc((ptr), (size), 0 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc_recoverable(ptr, size) _erealloc((ptr), (size), 1 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define estrdup(s) _estrdup((s) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define estrndup(s,length) _estrndup((s), (length) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define estrndup(s, length) _estrndup((s), (length) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define persist_alloc(p) _persist_alloc((p) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
/* Relay wrapper macros */
@ -102,15 +102,15 @@ ZEND_API int _persist_alloc(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
#define persist_alloc_rel(p) _persist_alloc((p) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
/* Selective persistent/non persistent allocation macros */
#define pemalloc(size,persistent) ((persistent)?malloc(size):emalloc(size))
#define pefree(ptr,persistent) ((persistent)?free(ptr):efree(ptr))
#define pecalloc(nmemb,size,persistent) ((persistent)?calloc((nmemb),(size)):ecalloc((nmemb),(size)))
#define perealloc(ptr,size,persistent) ((persistent)?realloc((ptr),(size)):erealloc((ptr),(size)))
#define perealloc_recoverable(ptr,size,persistent) ((persistent)?realloc((ptr),(size)):erealloc_recoverable((ptr),(size)))
#define pestrdup(s,persistent) ((persistent)?strdup(s):estrdup(s))
#define pemalloc(size, persistent) ((persistent)?malloc(size):emalloc(size))
#define pefree(ptr, persistent) ((persistent)?free(ptr):efree(ptr))
#define pecalloc(nmemb, size, persistent) ((persistent)?calloc((nmemb), (size)):ecalloc((nmemb), (size)))
#define perealloc(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc((ptr), (size)))
#define perealloc_recoverable(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_recoverable((ptr), (size)))
#define pestrdup(s, persistent) ((persistent)?strdup(s):estrdup(s))
#define safe_estrdup(ptr) ((ptr)?(estrdup(ptr)):(empty_string))
#define safe_estrndup(ptr,len) ((ptr)?(estrndup((ptr),(len))):(empty_string))
#define safe_estrndup(ptr, len) ((ptr)?(estrndup((ptr), (len))):(empty_string))
ZEND_API int zend_set_memory_limit(unsigned int memory_limit);

14
Zend/zend_builtin_functions.c
View File

@ -251,7 +251,7 @@ ZEND_FUNCTION(strcmp)
}
convert_to_string_ex(s1);
convert_to_string_ex(s2);
RETURN_LONG(zend_binary_zval_strcmp(*s1,*s2));
RETURN_LONG(zend_binary_zval_strcmp(*s1, *s2));
}
/* }}} */
@ -267,7 +267,7 @@ ZEND_FUNCTION(strncmp)
convert_to_string_ex(s1);
convert_to_string_ex(s2);
convert_to_long_ex(s3);
RETURN_LONG(zend_binary_zval_strncmp(*s1,*s2,*s3));
RETURN_LONG(zend_binary_zval_strncmp(*s1, *s2, *s3));
}
/* }}} */
@ -298,13 +298,13 @@ ZEND_FUNCTION(strncasecmp)
convert_to_string_ex(s1);
convert_to_string_ex(s2);
convert_to_long_ex(s3);
RETURN_LONG(zend_binary_zval_strncasecmp(*s1,*s2,*s3));
RETURN_LONG(zend_binary_zval_strncasecmp(*s1, *s2, *s3));
}
/* }}} */
ZEND_FUNCTION(each)
{
zval **array,*entry,**entry_ptr, *tmp;
zval **array, *entry, **entry_ptr, *tmp;
char *string_key;
ulong num_key;
zval **inserted_pointer;
@ -342,10 +342,10 @@ ZEND_FUNCTION(each)
/* add the key elements */
switch (zend_hash_get_current_key(target_hash, &string_key, &num_key, 1)) {
case HASH_KEY_IS_STRING:
add_get_index_string(return_value,0,string_key,(void **) &inserted_pointer,0);
add_get_index_string(return_value, 0, string_key, (void **) &inserted_pointer, 0);
break;
case HASH_KEY_IS_LONG:
add_get_index_long(return_value,0,num_key, (void **) &inserted_pointer);
add_get_index_long(return_value, 0, num_key, (void **) &inserted_pointer);
break;
}
zend_hash_update(return_value->value.ht, "key", sizeof("key"), inserted_pointer, sizeof(zval *), NULL);
@ -363,7 +363,7 @@ ZEND_FUNCTION(error_reporting)
case 0:
break;
case 1:
if (zend_get_parameters_ex(1,&arg) == FAILURE) {
if (zend_get_parameters_ex(1, &arg) == FAILURE) {
RETURN_FALSE;
}
convert_to_long_ex(arg);

4
Zend/zend_compile.c
View File

@ -810,7 +810,7 @@ int zend_do_begin_function_call(znode *function_name TSRMLS_DC)
zend_function *function;
zend_str_tolower(function_name->u.constant.value.str.val, function_name->u.constant.value.str.len);
if (zend_hash_find(CG(function_table), function_name->u.constant.value.str.val,function_name->u.constant.value.str.len+1, (void **) &function)==FAILURE) {
if (zend_hash_find(CG(function_table), function_name->u.constant.value.str.val, function_name->u.constant.value.str.len+1, (void **) &function)==FAILURE) {
znode tmp = *function_name;
zval_copy_ctor(&tmp.u.constant);
@ -1772,7 +1772,7 @@ void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC)
opline->opcode = ZEND_DO_FCALL;
opline->result.u.var = get_temporary_variable(CG(active_op_array));
opline->result.op_type = IS_VAR;
opline->op1.u.constant.value.str.val = estrndup("shell_exec",sizeof("shell_exec")-1);
opline->op1.u.constant.value.str.val = estrndup("shell_exec", sizeof("shell_exec")-1);
opline->op1.u.constant.value.str.len = sizeof("shell_exec")-1;
INIT_PZVAL(&opline->op1.u.constant);
opline->op1.u.constant.type = IS_STRING;

12
Zend/zend_constants.c
View File

@ -167,7 +167,7 @@ ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval,
c.value.type = IS_LONG;
c.value.value.lval = lval;
c.flags = flags;
c.name = zend_strndup(name,name_len);
c.name = zend_strndup(name, name_len);
c.name_len = name_len;
c.module_number = module_number;
zend_register_constant(&c TSRMLS_CC);
@ -181,7 +181,7 @@ ZEND_API void zend_register_double_constant(char *name, uint name_len, double dv
c.value.type = IS_DOUBLE;
c.value.value.dval = dval;
c.flags = flags;
c.name = zend_strndup(name,name_len);
c.name = zend_strndup(name, name_len);
c.name_len = name_len;
c.module_number = module_number;
zend_register_constant(&c TSRMLS_CC);
@ -196,7 +196,7 @@ ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *st
c.value.value.str.val = strval;
c.value.value.str.len = strlen;
c.flags = flags;
c.name = zend_strndup(name,name_len);
c.name = zend_strndup(name, name_len);
c.name_len = name_len;
c.module_number = module_number;
zend_register_constant(&c TSRMLS_CC);
@ -212,7 +212,7 @@ ZEND_API void zend_register_string_constant(char *name, uint name_len, char *str
ZEND_API int zend_get_constant(char *name, uint name_len, zval *result TSRMLS_DC)
{
zend_constant *c;
char *lookup_name = estrndup(name,name_len);
char *lookup_name = estrndup(name, name_len);
int retval;
zend_str_tolower(lookup_name, name_len);
@ -240,14 +240,14 @@ ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC)
int ret = SUCCESS;
#if 0
printf("Registering constant for module %d\n",c->module_number);
printf("Registering constant for module %d\n", c->module_number);
#endif
zend_str_tolower(lowercase_name, c->name_len);
if (zend_hash_add(EG(zend_constants), lowercase_name, c->name_len, (void *) c, sizeof(zend_constant), NULL)==FAILURE) {
free(c->name);
zval_dtor(&c->value);
zend_error(E_NOTICE,"Constant %s already defined",lowercase_name);
zend_error(E_NOTICE,"Constant %s already defined", lowercase_name);
ret = FAILURE;
}
free(lowercase_name);

16
Zend/zend_constants.h
View File

@ -34,15 +34,15 @@ typedef struct _zend_constant {
int module_number;
} zend_constant;
#define REGISTER_LONG_CONSTANT(name,lval,flags) zend_register_long_constant((name),sizeof(name),(lval),(flags),module_number TSRMLS_CC)
#define REGISTER_DOUBLE_CONSTANT(name,dval,flags) zend_register_double_constant((name),sizeof(name),(dval),(flags),module_number TSRMLS_CC)
#define REGISTER_STRING_CONSTANT(name,str,flags) zend_register_string_constant((name),sizeof(name),(str),(flags),module_number TSRMLS_CC)
#define REGISTER_STRINGL_CONSTANT(name,str,len,flags) zend_register_stringl_constant((name),sizeof(name),(str),(len),(flags),module_number TSRMLS_CC)
#define REGISTER_LONG_CONSTANT(name, lval, flags) zend_register_long_constant((name), sizeof(name), (lval), (flags), module_number TSRMLS_CC)
#define REGISTER_DOUBLE_CONSTANT(name, dval, flags) zend_register_double_constant((name), sizeof(name), (dval), (flags), module_number TSRMLS_CC)
#define REGISTER_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name), (str), (flags), module_number TSRMLS_CC)
#define REGISTER_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name), (str), (len), (flags), module_number TSRMLS_CC)
#define REGISTER_MAIN_LONG_CONSTANT(name,lval,flags) zend_register_long_constant((name),sizeof(name),(lval),(flags),0 TSRMLS_CC)
#define REGISTER_MAIN_DOUBLE_CONSTANT(name,dval,flags) zend_register_double_constant((name),sizeof(name),(dval),(flags),0 TSRMLS_CC)
#define REGISTER_MAIN_STRING_CONSTANT(name,str,flags) zend_register_string_constant((name),sizeof(name),(str),(flags),0 TSRMLS_CC)
#define REGISTER_MAIN_STRINGL_CONSTANT(name,str,len,flags) zend_register_stringl_constant((name),sizeof(name),(str),(len),(flags),0 TSRMLS_CC)
#define REGISTER_MAIN_LONG_CONSTANT(name, lval, flags) zend_register_long_constant((name), sizeof(name), (lval), (flags), 0 TSRMLS_CC)
#define REGISTER_MAIN_DOUBLE_CONSTANT(name, dval, flags) zend_register_double_constant((name), sizeof(name), (dval), (flags), 0 TSRMLS_CC)
#define REGISTER_MAIN_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name), (str), (flags), 0 TSRMLS_CC)
#define REGISTER_MAIN_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name), (str), (len), (flags), 0 TSRMLS_CC)
void clean_module_constants(int module_number TSRMLS_DC);
void free_zend_constant(zend_constant *c);

4
Zend/zend_execute_API.c
View File

@ -692,7 +692,7 @@ static LRESULT CALLBACK zend_timeout_WndProc(HWND hWnd, UINT message, WPARAM wPa
}
break;
default:
return DefWindowProc(hWnd,message,wParam,lParam);
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
@ -779,7 +779,7 @@ void zend_set_timeout(long seconds)
signal(SIGPROF, zend_timeout);
sigemptyset(&sigset);
sigaddset(&sigset, SIGPROF);
sigprocmask(SIG_UNBLOCK,&sigset,NULL);
sigprocmask(SIG_UNBLOCK, &sigset, NULL);
}
# endif
#endif

8
Zend/zend_hash.c
View File

@ -97,7 +97,7 @@ static void _zend_is_inconsistent(HashTable *ht, char *file, int line)
}
zend_bailout();
}
#define IS_CONSISTENT(a) _zend_is_inconsistent(a,__FILE__,__LINE__);
#define IS_CONSISTENT(a) _zend_is_inconsistent(a, __FILE__, __LINE__);
#define SET_INCONSISTENT(n) ht->inconsistent = n;
#else
#define IS_CONSISTENT(a)
@ -1232,7 +1232,7 @@ ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t co
ZEND_API int zend_hash_minmax(HashTable *ht, int (*compar) (const void *, const void *), int flag, void **pData)
{
Bucket *p,*res;
Bucket *p, *res;
IS_CONSISTENT(ht);
@ -1244,11 +1244,11 @@ ZEND_API int zend_hash_minmax(HashTable *ht, int (*compar) (const void *, const
res = p = ht->pListHead;
while ((p = p->pListNext)) {
if (flag) {
if (compar(&res,&p) < 0) { /* max */
if (compar(&res, &p) < 0) { /* max */
res = p;
}
} else {
if (compar(&res,&p) > 0) { /* min */
if (compar(&res, &p) > 0) { /* min */
res = p;
}
}

38
Zend/zend_hash.h
View File

@ -82,23 +82,23 @@ ZEND_API void zend_hash_destroy(HashTable *ht);
ZEND_API void zend_hash_clean(HashTable *ht);
/* additions/updates/changes */
ZEND_API int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest,int flag);
#define zend_hash_update(ht,arKey,nKeyLength,pData,nDataSize,pDest) \
zend_hash_add_or_update(ht,arKey,nKeyLength,pData,nDataSize,pDest,HASH_UPDATE)
#define zend_hash_add(ht,arKey,nKeyLength,pData,nDataSize,pDest) \
zend_hash_add_or_update(ht,arKey,nKeyLength,pData,nDataSize,pDest,HASH_ADD)
ZEND_API int zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest,int flag);
#define zend_hash_quick_update(ht,arKey,nKeyLength,h,pData,nDataSize,pDest) \
zend_hash_quick_add_or_update(ht,arKey,nKeyLength,h,pData,nDataSize,pDest,HASH_UPDATE)
#define zend_hash_quick_add(ht,arKey,nKeyLength,h,pData,nDataSize,pDest) \
zend_hash_quick_add_or_update(ht,arKey,nKeyLength,h,pData,nDataSize,pDest,HASH_ADD)
ZEND_API int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag);
#define zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE)
#define zend_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD)
ZEND_API int zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag);
#define zend_hash_quick_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE)
#define zend_hash_quick_add(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_ADD)
ZEND_API int zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag);
#define zend_hash_index_update(ht,h,pData,nDataSize,pDest) \
zend_hash_index_update_or_next_insert(ht,h,pData,nDataSize,pDest,HASH_UPDATE)
#define zend_hash_next_index_insert(ht,pData,nDataSize,pDest) \
zend_hash_index_update_or_next_insert(ht,0,pData,nDataSize,pDest,HASH_NEXT_INSERT)
#define zend_hash_index_update(ht, h, pData, nDataSize, pDest) \
zend_hash_index_update_or_next_insert(ht, h, pData, nDataSize, pDest, HASH_UPDATE)
#define zend_hash_next_index_insert(ht, pData, nDataSize, pDest) \
zend_hash_index_update_or_next_insert(ht, 0, pData, nDataSize, pDest, HASH_NEXT_INSERT)
ZEND_API int zend_hash_add_empty_element(HashTable *ht, char *arKey, uint nKeyLength);
@ -134,10 +134,10 @@ ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSR
/* Deletes */
ZEND_API int zend_hash_del_key_or_index(HashTable *ht, char *arKey, uint nKeyLength, ulong h, int flag);
#define zend_hash_del(ht,arKey,nKeyLength) \
zend_hash_del_key_or_index(ht,arKey,nKeyLength,0,HASH_DEL_KEY)
#define zend_hash_index_del(ht,h) \
zend_hash_del_key_or_index(ht,NULL,0,h,HASH_DEL_INDEX)
#define zend_hash_del(ht, arKey, nKeyLength) \
zend_hash_del_key_or_index(ht, arKey, nKeyLength, 0, HASH_DEL_KEY)
#define zend_hash_index_del(ht, h) \
zend_hash_del_key_or_index(ht, NULL, 0, h, HASH_DEL_INDEX)
ZEND_API ulong zend_get_hash_value(HashTable *ht, char *arKey, uint nKeyLength);

12
Zend/zend_ini.h
View File

@ -29,29 +29,29 @@
#ifndef XtOffsetOf
# if defined(CRAY) || (defined(__arm) && !defined(LINUX))
# ifdef __STDC__
# define XtOffset(p_type,field) _Offsetof(p_type,field)
# define XtOffset(p_type, field) _Offsetof(p_type, field)
# else
# ifdef CRAY2
# define XtOffset(p_type,field) \
# define XtOffset(p_type, field) \
(sizeof(int)*((unsigned int)&(((p_type)NULL)->field)))
# else /* !CRAY2 */
# define XtOffset(p_type,field) ((unsigned int)&(((p_type)NULL)->field))
# define XtOffset(p_type, field) ((unsigned int)&(((p_type)NULL)->field))
# endif /* !CRAY2 */
# endif /* __STDC__ */
# else /* ! (CRAY || __arm) */
# define XtOffset(p_type,field) \
# define XtOffset(p_type, field) \
((long) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL)))
# endif /* !CRAY */
# ifdef offsetof
# define XtOffsetOf(s_type,field) offsetof(s_type,field)
# define XtOffsetOf(s_type, field) offsetof(s_type, field)
# else
# define XtOffsetOf(s_type,field) XtOffset(s_type*,field)
# define XtOffsetOf(s_type, field) XtOffset(s_type*, field)
# endif
#endif

10
Zend/zend_ini_scanner.l
View File

@ -172,7 +172,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
<INITIAL>[ ]*("true"|"on"|"yes")[ ]* {
ini_lval->value.str.val = zend_strndup("1",1);
ini_lval->value.str.val = zend_strndup("1", 1);
ini_lval->value.str.len = 1;
ini_lval->type = IS_STRING;
return CFG_TRUE;
@ -180,7 +180,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
<INITIAL>[ ]*("false"|"off"|"no"|"none")[ ]* {
ini_lval->value.str.val = zend_strndup("",0);
ini_lval->value.str.val = zend_strndup("", 0);
ini_lval->value.str.len = 0;
ini_lval->type = IS_STRING;
return CFG_FALSE;
@ -199,7 +199,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
yytext++;
yyleng--;
ini_lval->value.str.val = zend_strndup(yytext,yyleng);
ini_lval->value.str.val = zend_strndup(yytext, yyleng);
ini_lval->value.str.len = yyleng;
ini_lval->type = IS_STRING;
return SECTION;
@ -249,7 +249,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
}
}
if (yyleng!=0) {
ini_lval->value.str.val = zend_strndup(yytext,yyleng);
ini_lval->value.str.val = zend_strndup(yytext, yyleng);
ini_lval->value.str.len = yyleng;
ini_lval->type = IS_STRING;
return TC_STRING;
@ -279,7 +279,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
<INITIAL>. {
#if DEBUG
php_error(E_NOTICE,"Unexpected character on line %d: '%s' (ASCII %d)\n",yylineno,yytext,yytext[0]);
php_error(E_NOTICE,"Unexpected character on line %d: '%s' (ASCII %d)\n", yylineno, yytext, yytext[0]);
#endif
}

12
Zend/zend_language_parser.y
View File

@ -445,12 +445,12 @@ expr_without_variable:
| expr '|' expr { zend_do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 TSRMLS_CC); }
| expr '&' expr { zend_do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 TSRMLS_CC); }
| expr '^' expr { zend_do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); }
| expr '.' expr { zend_do_binary_op(ZEND_CONCAT,&$$,&$1,&$3 TSRMLS_CC); }
| expr '+' expr { zend_do_binary_op(ZEND_ADD,&$$,&$1,&$3 TSRMLS_CC); }
| expr '-' expr { zend_do_binary_op(ZEND_SUB,&$$,&$1,&$3 TSRMLS_CC); }
| expr '*' expr { zend_do_binary_op(ZEND_MUL,&$$,&$1,&$3 TSRMLS_CC); }
| expr '/' expr { zend_do_binary_op(ZEND_DIV,&$$,&$1,&$3 TSRMLS_CC); }
| expr '%' expr { zend_do_binary_op(ZEND_MOD,&$$,&$1,&$3 TSRMLS_CC); }
| expr '.' expr { zend_do_binary_op(ZEND_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
| expr '+' expr { zend_do_binary_op(ZEND_ADD, &$$, &$1, &$3 TSRMLS_CC); }
| expr '-' expr { zend_do_binary_op(ZEND_SUB, &$$, &$1, &$3 TSRMLS_CC); }
| expr '*' expr { zend_do_binary_op(ZEND_MUL, &$$, &$1, &$3 TSRMLS_CC); }
| expr '/' expr { zend_do_binary_op(ZEND_DIV, &$$, &$1, &$3 TSRMLS_CC); }
| expr '%' expr { zend_do_binary_op(ZEND_MOD, &$$, &$1, &$3 TSRMLS_CC); }
| expr T_SL expr { zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 TSRMLS_CC); }
| expr T_SR expr { zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 TSRMLS_CC); }
| '+' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); }

28
Zend/zend_language_scanner.l
View File

@ -98,9 +98,9 @@ ZEND_API zend_scanner_globals language_scanner_globals;
#define YY_FATAL_ERROR zend_fatal_scanner_error
#define HANDLE_NEWLINES(s,l) \
#define HANDLE_NEWLINES(s, l) \
do { \
char *p = (s),*boundary = p+(l); \
char *p = (s), *boundary = p+(l); \
\
while (p<boundary) { \
if (*p == '\n') { \
@ -150,7 +150,7 @@ END_EXTERN_C()
static inline void save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
{
#ifndef __cplusplus
memcpy(&lex_state->buffer_state,&YY_CURRENT_BUFFER,sizeof(YY_BUFFER_STATE));
memcpy(&lex_state->buffer_state, &YY_CURRENT_BUFFER, sizeof(YY_BUFFER_STATE));
lex_state->in = yyin;
lex_state->state = YYSTATE;
#else
@ -1008,7 +1008,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
errno = 0;
zendlval->value.lval = strtol(yytext, NULL, 0);
if (errno == ERANGE) { /* overflow */
zendlval->value.dval = strtod(yytext,NULL);
zendlval->value.dval = strtod(yytext, NULL);
zendlval->type = IS_DOUBLE;
return T_DNUMBER;
} else {
@ -1023,7 +1023,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
if (errno == ERANGE) { /* overflow */
/* not trying strtod - it returns trash on 0x-es */
zendlval->value.lval = LONG_MAX; /* maximal long */
zend_error(E_NOTICE,"Hex number is too big: %s",yytext);
zend_error(E_NOTICE,"Hex number is too big: %s", yytext);
} else {
if (zendlval->value.lval < 0) {
/* maintain consistency with the old way */
@ -1045,7 +1045,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
}
<ST_IN_SCRIPTING>{DNUM}|{EXPONENT_DNUM} {
zendlval->value.dval = strtod(yytext,NULL);
zendlval->value.dval = strtod(yytext, NULL);
zendlval->type = IS_DOUBLE;
return T_DNUMBER;
}
@ -1078,7 +1078,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
}
<INITIAL>"<?"|"<script"{WHITESPACE}+"language"{WHITESPACE}*"="{WHITESPACE}*("php"|"\"php\""|"\'php\'"){WHITESPACE}*">" {
HANDLE_NEWLINES(yytext,yyleng);
HANDLE_NEWLINES(yytext, yyleng);
if (CG(short_tags) || yyleng>2) { /* yyleng>2 means it's not <? but <script> */
zendlval->value.str.val = yytext; /* no copying - intentional */
zendlval->value.str.len = yyleng;
@ -1173,7 +1173,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
zendlval->value.str.val = yytext; /* no copying - intentional */
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext,yyleng);
HANDLE_NEWLINES(yytext, yyleng);
return T_WHITESPACE;
}
@ -1264,7 +1264,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
zendlval->value.str.val = estrndup(yytext+1, yyleng-2);
zendlval->value.str.len = yyleng-2;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext,yyleng);
HANDLE_NEWLINES(yytext, yyleng);
/* convert escape sequences */
s = t = zendlval->value.str.val;
@ -1346,7 +1346,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
zendlval->value.str.val = estrndup(yytext+1, yyleng-2);
zendlval->value.str.len = yyleng-2;
zendlval->type = IS_STRING;
HANDLE_NEWLINES(yytext,yyleng);
HANDLE_NEWLINES(yytext, yyleng);
/* convert escape sequences */
s = t = zendlval->value.str.val;
@ -1451,7 +1451,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
<ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>{ESCAPED_AND_WHITESPACE} {
HANDLE_NEWLINES(yytext,yyleng);
HANDLE_NEWLINES(yytext, yyleng);
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
@ -1459,7 +1459,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
}
<ST_SINGLE_QUOTE>([^'\\]|\\[^'\\])+ {
HANDLE_NEWLINES(yytext,yyleng);
HANDLE_NEWLINES(yytext, yyleng);
zendlval->value.str.val = (char *) estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
@ -1556,7 +1556,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
zendlval->value.lval = (long) yytext[1];
break;
default:
zendlval->value.str.val = estrndup(yytext,yyleng);
zendlval->value.str.val = estrndup(yytext, yyleng);
zendlval->value.str.len = yyleng;
zendlval->type = IS_STRING;
return T_BAD_CHARACTER;
@ -1604,5 +1604,5 @@ NEWLINE ("\r"|"\n"|"\r\n")
<ST_IN_SCRIPTING,INITIAL,ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_SINGLE_QUOTE,ST_HEREDOC>{ANY_CHAR} {
zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d",yytext[0],yytext[0],YYSTATE);
zend_error(E_COMPILE_WARNING,"Unexpected character in input: '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
}

12
Zend/zend_list.c
View File

@ -165,7 +165,7 @@ void list_entry_destructor(void *ptr)
zend_rsrc_list_dtors_entry *ld;
TSRMLS_FETCH();
if (zend_hash_index_find(&list_destructors, le->type,(void **) &ld)==SUCCESS) {
if (zend_hash_index_find(&list_destructors, le->type, (void **) &ld)==SUCCESS) {
switch (ld->type) {
case ZEND_RESOURCE_LIST_TYPE_STD:
if (ld->list_dtor) {
@ -180,7 +180,7 @@ void list_entry_destructor(void *ptr)
EMPTY_SWITCH_DEFAULT_CASE()
}
} else {
zend_error(E_WARNING,"Unknown list entry type in request shutdown (%d)",le->type);
zend_error(E_WARNING,"Unknown list entry type in request shutdown (%d)", le->type);
}
}
@ -191,7 +191,7 @@ void plist_entry_destructor(void *ptr)
zend_rsrc_list_dtors_entry *ld;
TSRMLS_FETCH();
if (zend_hash_index_find(&list_destructors, le->type,(void **) &ld)==SUCCESS) {
if (zend_hash_index_find(&list_destructors, le->type, (void **) &ld)==SUCCESS) {
switch (ld->type) {
case ZEND_RESOURCE_LIST_TYPE_STD:
if (ld->plist_dtor) {
@ -206,7 +206,7 @@ void plist_entry_destructor(void *ptr)
EMPTY_SWITCH_DEFAULT_CASE()
}
} else {
zend_error(E_WARNING,"Unknown persistent list entry type in module shutdown (%d)",le->type);
zend_error(E_WARNING,"Unknown persistent list entry type in module shutdown (%d)", le->type);
}
}
@ -325,7 +325,7 @@ ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_fu
lde.type = ZEND_RESOURCE_LIST_TYPE_EX;
lde.type_name = type_name;
if (zend_hash_next_index_insert(&list_destructors,(void *) &lde, sizeof(zend_rsrc_list_dtors_entry),NULL)==FAILURE) {
if (zend_hash_next_index_insert(&list_destructors, (void *) &lde, sizeof(zend_rsrc_list_dtors_entry), NULL)==FAILURE) {
return FAILURE;
}
return list_destructors.nNextFreeElement-1;
@ -340,7 +340,7 @@ ZEND_API int zend_fetch_list_dtor_id(char *type_name)
while(zend_hash_get_current_data_ex(&list_destructors, (void **)&lde, &pos) == SUCCESS) {
if(strcmp(type_name, lde->type_name) == 0) {
#if 0
printf("Found resource id %d for resource type %s\n",(*lde).resource_id,type_name);
printf("Found resource id %d for resource type %s\n", (*lde).resource_id, type_name);
#endif
return lde->resource_id;
}

2
Zend/zend_list.h
View File

@ -98,7 +98,7 @@ extern ZEND_API int le_index_ptr; /* list entry type for index pointers */
rsrc = (rsrc_type) zend_fetch_resource(passed_id TSRMLS_CC, default_id, resource_type_name, NULL, 1, resource_type); \
ZEND_VERIFY_RESOURCE(rsrc);
#define ZEND_FETCH_RESOURCE2(rsrc, rsrc_type, passed_id, default_id, resource_type_name, resource_type1,resource_type2) \
#define ZEND_FETCH_RESOURCE2(rsrc, rsrc_type, passed_id, default_id, resource_type_name, resource_type1, resource_type2) \
rsrc = (rsrc_type) zend_fetch_resource(passed_id TSRMLS_CC, default_id, resource_type_name, NULL, 2, resource_type1, resource_type2); \
ZEND_VERIFY_RESOURCE(rsrc);

6
Zend/zend_llist.c
View File

@ -63,7 +63,7 @@ ZEND_API void zend_llist_prepend_element(zend_llist *l, void *element)
}
#define DEL_LLIST_ELEMENT(current,l) \
#define DEL_LLIST_ELEMENT(current, l) \
if (current->prev) {\
current->prev->next = current->next;\
} else {\
@ -86,7 +86,7 @@ ZEND_API void zend_llist_del_element(zend_llist *l, void *element, int (*compare
while (current) {
if (compare(current->data, element)) {
DEL_LLIST_ELEMENT(current,l);
DEL_LLIST_ELEMENT(current, l);
break;
}
current = current->next;
@ -151,7 +151,7 @@ ZEND_API void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data))
while (element) {
next = element->next;
if (func(element->data)) {
DEL_LLIST_ELEMENT(element,l);
DEL_LLIST_ELEMENT(element, l);
}
element = next;
}

Write Preview
Loading…
Cancel
Save