mirrors/php-src
0
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-11-23 09:54:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

WIN64 support

Browse Source
This commit is contained in:
Dmitry Stogov 2007-04-16 08:09:56 +00:00
parent f088268f91
commit e1814f0dbe
22 changed files with 78 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
TSRM/TSRM.h
View File

@ -30,6 +30,14 @@
# define TSRM_API
#endif
#ifdef _WIN64
typedef unsigned __int64 tsrm_intptr_t;
typedef __int64 tsrm_uintptr_t;
#else
typedef long tsrm_intptr_t;
typedef unsigned long tsrm_uintptr_t;
#endif
/* Only compile multi-threading functions if we're in ZTS mode */
#ifdef ZTS

4
TSRM/tsrm_win32.c
View File

@ -228,10 +228,10 @@ TSRM_API FILE *popen_ex(const char *command, const char *type, const char *cwd,
proc = process_get(NULL TSRMLS_CC);
if (read) {
fno = _open_osfhandle((long)in, _O_RDONLY | mode);
fno = _open_osfhandle((tsrm_intptr_t)in, _O_RDONLY | mode);
CloseHandle(out);
} else {
fno = _open_osfhandle((long)out, _O_WRONLY | mode);
fno = _open_osfhandle((tsrm_intptr_t)out, _O_WRONLY | mode);
CloseHandle(in);
}

14
Zend/zend_API.c
View File

@ -44,7 +44,7 @@ ZEND_API int zend_get_parameters(int ht, int param_count, ...)
TSRMLS_FETCH();
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
arg_count = (int)(zend_uintptr_t) *p;
if (param_count>arg_count) {
return FAILURE;
@ -82,7 +82,7 @@ ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval **argument
zval *param_ptr;
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
arg_count = (int)(zend_uintptr_t) *p;
if (param_count>arg_count) {
return FAILURE;
@ -122,7 +122,7 @@ ZEND_API int zend_get_parameters_ex(int param_count, ...)
TSRMLS_FETCH();
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
arg_count = (int)(zend_uintptr_t) *p;
if (param_count>arg_count) {
return FAILURE;
@ -145,7 +145,7 @@ ZEND_API int _zend_get_parameters_array_ex(int param_count, zval ***argument_arr
int arg_count;
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
arg_count = (int)(zend_uintptr_t) *p;
if (param_count>arg_count) {
return FAILURE;
@ -187,7 +187,7 @@ ZEND_API int zend_copy_parameters_array(int param_count, zval *argument_array TS
int arg_count;
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
arg_count = (int)(zend_uintptr_t) *p;
if (param_count>arg_count) {
return FAILURE;
@ -698,7 +698,7 @@ static int zend_parse_va_args(int num_args, char *type_spec, va_list *va, int fl
}
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
arg_count = (int)(zend_uintptr_t) *p;
if (num_args > arg_count) {
zend_error(E_WARNING, "%s(): could not obtain parameters for parsing",
@ -878,7 +878,7 @@ ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC
zend_update_class_constants(class_type->parent TSRMLS_CC);
}
#if ZTS
ALLOC_HASHTABLE(CG(static_members)[(long)(class_type->static_members)]);
ALLOC_HASHTABLE(CG(static_members)[(zend_intptr_t)(class_type->static_members)]);
#else
ALLOC_HASHTABLE(class_type->static_members);
#endif

2
Zend/zend_API.h
View File

@ -160,7 +160,7 @@ typedef struct _zend_function_entry {
INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, functions, handle_fcall, handle_propget, handle_propset, NULL, NULL)
#ifdef ZTS
# define CE_STATIC_MEMBERS(ce) (((ce)->type==ZEND_USER_CLASS)?(ce)->static_members:CG(static_members)[(long)(ce)->static_members])
# define CE_STATIC_MEMBERS(ce) (((ce)->type==ZEND_USER_CLASS)?(ce)->static_members:CG(static_members)[(zend_intptr_t)(ce)->static_members])
#else
# define CE_STATIC_MEMBERS(ce) ((ce)->static_members)
#endif

18
Zend/zend_alloc.c
View File

@ -50,6 +50,16 @@
# define ZEND_MM_COOKIES ZEND_DEBUG
#endif
#ifdef _WIN64
# define PTR_FMT "0x%0.16I64x"
/*
#elif sizeof(long) == 8
# define PTR_FMT "0x%0.16lx"
*/
#else
# define PTR_FMT "0x%0.8lx"
#endif
#if ZEND_DEBUG
void zend_debug_alloc_output(char *format, ...)
{
@ -1180,7 +1190,7 @@ static void zend_mm_check_leaks(zend_mm_heap *heap)
repeated = zend_mm_find_leaks(segment, p);
total += 1 + repeated;
if (repeated) {
zend_message_dispatcher(ZMSG_MEMORY_LEAK_REPEATED, (void *)repeated);
zend_message_dispatcher(ZMSG_MEMORY_LEAK_REPEATED, (void *)(zend_uintptr_t)repeated);
}
#if ZEND_MM_CACHE
} else if (p->magic == MEM_BLOCK_CACHED) {
@ -1221,7 +1231,7 @@ static int zend_mm_check_ptr(zend_mm_heap *heap, void *ptr, int silent ZEND_FILE
if (!silent) {
zend_message_dispatcher(ZMSG_LOG_SCRIPT_NAME, NULL);
zend_debug_alloc_output("---------------------------------------\n");
zend_debug_alloc_output("%s(%d) : Block 0x%0.8lX status:\n" ZEND_FILE_LINE_RELAY_CC, (long) ptr);
zend_debug_alloc_output("%s(%d) : Block "PTR_FMT" status:\n" ZEND_FILE_LINE_RELAY_CC, ptr);
if (__zend_orig_filename) {
zend_debug_alloc_output("%s(%d) : Actual location (location was relayed)\n" ZEND_FILE_LINE_ORIG_RELAY_CC);
}
@ -1253,7 +1263,7 @@ static int zend_mm_check_ptr(zend_mm_heap *heap, void *ptr, int silent ZEND_FILE
if (p->info._size != ZEND_MM_NEXT_BLOCK(p)->info._prev) {
if (!silent) {
zend_debug_alloc_output("Invalid pointer: ((size=0x%0.8X) != (next.prev=0x%0.8X))\n", p->info._size, ZEND_MM_NEXT_BLOCK(p)->info._prev);
zend_debug_alloc_output("Invalid pointer: ((size="PTR_FMT") != (next.prev="PTR_FMT"))\n", p->info._size, ZEND_MM_NEXT_BLOCK(p)->info._prev);
had_problems = 1;
} else {
return zend_mm_check_ptr(heap, ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
@ -1262,7 +1272,7 @@ static int zend_mm_check_ptr(zend_mm_heap *heap, void *ptr, int silent ZEND_FILE
if (p->info._prev != ZEND_MM_GUARD_BLOCK &&
ZEND_MM_PREV_BLOCK(p)->info._size != p->info._prev) {
if (!silent) {
zend_debug_alloc_output("Invalid pointer: ((prev=0x%0.8X) != (prev.size=0x%0.8X))\n", p->info._prev, ZEND_MM_PREV_BLOCK(p)->info._size);
zend_debug_alloc_output("Invalid pointer: ((prev="PTR_FMT") != (prev.size="PTR_FMT"))\n", p->info._prev, ZEND_MM_PREV_BLOCK(p)->info._size);
had_problems = 1;
} else {
return zend_mm_check_ptr(heap, ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);

14
Zend/zend_builtin_functions.c
View File

@ -172,14 +172,14 @@ ZEND_FUNCTION(func_num_args)
int arg_count;
p = EG(argument_stack).top_element-1-1;
arg_count = (ulong) *p; /* this is the amount of arguments passed to func_num_args(); */
arg_count = (int)(zend_uintptr_t) *p; /* this is the amount of arguments passed to func_num_args(); */
p -= 1+arg_count;
if (*p) {
zend_error(E_ERROR, "func_num_args(): Can't be used as a function parameter");
}
--p;
if (p>=EG(argument_stack).elements) {
RETURN_LONG((ulong) *p);
RETURN_LONG((long)(zend_uintptr_t) *p);
} else {
zend_error(E_WARNING, "func_num_args(): Called from the global scope - no function context");
RETURN_LONG(-1);
@ -210,7 +210,7 @@ ZEND_FUNCTION(func_get_arg)
}
p = EG(argument_stack).top_element-1-1;
arg_count = (ulong) *p; /* this is the amount of arguments passed to func_get_arg(); */
arg_count = (int)(zend_uintptr_t) *p; /* this is the amount of arguments passed to func_get_arg(); */
p -= 1+arg_count;
if (*p) {
zend_error(E_ERROR, "func_get_arg(): Can't be used as a function parameter");
@ -220,7 +220,7 @@ ZEND_FUNCTION(func_get_arg)
zend_error(E_WARNING, "func_get_arg(): Called from the global scope - no function context");
RETURN_FALSE;
}
arg_count = (ulong) *p;
arg_count = (int)(zend_uintptr_t) *p;
if (requested_offset>=arg_count) {
zend_error(E_WARNING, "func_get_arg(): Argument %ld not passed to function", requested_offset);
@ -244,7 +244,7 @@ ZEND_FUNCTION(func_get_args)
int i;
p = EG(argument_stack).top_element-1-1;
arg_count = (ulong) *p; /* this is the amount of arguments passed to func_get_args(); */
arg_count = (int)(zend_uintptr_t) *p; /* this is the amount of arguments passed to func_get_args(); */
p -= 1+arg_count;
if (*p) {
zend_error(E_ERROR, "func_get_args(): Can't be used as a function parameter");
@ -255,7 +255,7 @@ ZEND_FUNCTION(func_get_args)
zend_error(E_WARNING, "func_get_args(): Called from the global scope - no function context");
RETURN_FALSE;
}
arg_count = (ulong) *p;
arg_count = (int)(zend_uintptr_t) *p;
array_init(return_value);
@ -1655,7 +1655,7 @@ static zval *debug_backtrace_get_args(void ***curpos TSRMLS_DC)
{
void **p = *curpos - 2;
zval *arg_array, **arg;
int arg_count = (ulong) *p;
int arg_count = (int)(zend_uintptr_t) *p;
*curpos -= (arg_count+2);

2
Zend/zend_compile.c
View File

@ -4189,7 +4189,7 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify
CG(static_members) = realloc(CG(static_members), (n+1)*sizeof(HashTable*));
CG(static_members)[n] = NULL;
}
ce->static_members = (HashTable*)n;
ce->static_members = (HashTable*)(zend_intptr_t)n;
#else
ce->static_members = NULL;
#endif

10
Zend/zend_execute.c
View File

@ -104,15 +104,15 @@ static inline void zend_pzval_unlock_free_func(zval *z)
#define FREE_OP(should_free) \
if (should_free.var) { \
if ((long)should_free.var & 1L) { \
zval_dtor((zval*)((long)should_free.var & ~1L)); \
if ((zend_uintptr_t)should_free.var & 1L) { \
zval_dtor((zval*)((zend_uintptr_t)should_free.var & ~1L)); \
} else { \
zval_ptr_dtor(&should_free.var); \
} \
}
#define FREE_OP_IF_VAR(should_free) \
if (should_free.var != NULL && (((long)should_free.var & 1L) == 0)) { \
if (should_free.var != NULL && (((zend_uintptr_t)should_free.var & 1L) == 0)) { \
zval_ptr_dtor(&should_free.var); \
}
@ -121,9 +121,9 @@ static inline void zend_pzval_unlock_free_func(zval *z)
zval_ptr_dtor(&should_free.var); \
}
#define TMP_FREE(z) (zval*)(((long)(z)) | 1L)
#define TMP_FREE(z) (zval*)(((zend_uintptr_t)(z)) | 1L)
#define IS_TMP_FREE(should_free) ((long)should_free.var & 1L)
#define IS_TMP_FREE(should_free) ((zend_uintptr_t)should_free.var & 1L)
#define INIT_PZVAL_COPY(z,v) \
(z)->value = (v)->value; \

4
Zend/zend_execute.h
View File

@ -146,7 +146,7 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
static inline void zend_ptr_stack_clear_multiple(TSRMLS_D)
{
void **p = EG(argument_stack).top_element-2;
int delete_count = (ulong) *p;
int delete_count = (int)(zend_uintptr_t) *p;
EG(argument_stack).top -= (delete_count+2);
while (--delete_count>=0) {
@ -160,7 +160,7 @@ static inline void zend_ptr_stack_clear_multiple(TSRMLS_D)
static inline int zend_ptr_stack_get_arg(int requested_arg, void **data TSRMLS_DC)
{
void **p = EG(argument_stack).top_element-2;
int arg_count = (ulong) *p;
int arg_count = (int)(zend_uintptr_t) *p;
if (requested_arg>arg_count) {
return FAILURE;

6
Zend/zend_execute_API.c
View File

@ -451,7 +451,7 @@ ZEND_API int zend_is_true(zval *op)
ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *scope TSRMLS_DC)
{
zval *p = *pp;
zend_bool inline_change = (zend_bool) (unsigned long) arg;
zend_bool inline_change = (zend_bool) (zend_uintptr_t) arg;
zval const_value;
if (Z_TYPE_P(p) == IS_CONSTANT) {
@ -867,7 +867,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
if (fci->no_separation) {
if(i) {
/* hack to clean up the stack */
zend_ptr_stack_n_push(&EG(argument_stack), 2, (void *) (long) i, NULL);
zend_ptr_stack_n_push(&EG(argument_stack), 2, (void *) (zend_uintptr_t) i, NULL);
zend_ptr_stack_clear_multiple(TSRMLS_C);
}
@ -908,7 +908,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
fci->param_count = 2;
}
zend_ptr_stack_2_push(&EG(argument_stack), (void *) (long) fci->param_count, NULL);
zend_ptr_stack_2_push(&EG(argument_stack), (void *) (zend_uintptr_t) fci->param_count, NULL);
original_function_state_ptr = EG(function_state_ptr);
EG(function_state_ptr) = &EX(function_state);

2
Zend/zend_ini.c
View File

@ -225,7 +225,7 @@ static int zend_ini_refresh_cache(zend_ini_entry *p, int stage TSRMLS_DC)
ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC)
{
zend_hash_apply_with_argument(EG(ini_directives), (apply_func_arg_t) zend_ini_refresh_cache, (void *)(long) stage TSRMLS_CC);
zend_hash_apply_with_argument(EG(ini_directives), (apply_func_arg_t) zend_ini_refresh_cache, (void *)(zend_intptr_t) stage TSRMLS_CC);
}
#endif

2
Zend/zend_opcode.c
View File

@ -160,7 +160,7 @@ ZEND_API int zend_cleanup_class_data(zend_class_entry **pce TSRMLS_DC)
zend_hash_destroy(CE_STATIC_MEMBERS(*pce));
FREE_HASHTABLE(CE_STATIC_MEMBERS(*pce));
#ifdef ZTS
CG(static_members)[(long)((*pce)->static_members)] = NULL;
CG(static_members)[(zend_intptr_t)((*pce)->static_members)] = NULL;
#else
(*pce)->static_members = NULL;
#endif

8
Zend/zend_types.h
View File

@ -28,6 +28,14 @@ typedef unsigned int zend_uint;
typedef unsigned long zend_ulong;
typedef unsigned short zend_ushort;
#ifdef _WIN64
typedef unsigned __int64 zend_intptr_t;
typedef __int64 zend_uintptr_t;
#else
typedef long zend_intptr_t;
typedef unsigned long zend_uintptr_t;
#endif
typedef unsigned int zend_object_handle;
typedef struct _zend_object_handlers zend_object_handlers;

4
Zend/zend_vm_def.h
View File

@ -1857,7 +1857,7 @@ ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
}
}
zend_ptr_stack_2_push(&EG(argument_stack), (void *) opline->extended_value, NULL);
zend_ptr_stack_2_push(&EG(argument_stack), (void *)(zend_uintptr_t)opline->extended_value, NULL);
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
@ -1900,7 +1900,7 @@ ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
ulong arg_count;
p = (zval **) EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
arg_count = (ulong)(zend_uintptr_t) *p;
while (arg_count>0) {
zend_verify_arg_type(EX(function_state).function, ++i, *(p-arg_count) TSRMLS_CC);

4
Zend/zend_vm_execute.h
View File

@ -145,7 +145,7 @@ static int zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
}
}
zend_ptr_stack_2_push(&EG(argument_stack), (void *) opline->extended_value, NULL);
zend_ptr_stack_2_push(&EG(argument_stack), (void *)(zend_uintptr_t)opline->extended_value, NULL);
EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
@ -188,7 +188,7 @@ static int zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
ulong arg_count;
p = (zval **) EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
arg_count = (ulong)(zend_uintptr_t) *p;
while (arg_count>0) {
zend_verify_arg_type(EX(function_state).function, ++i, *(p-arg_count) TSRMLS_CC);

2
ext/standard/proc_open.c
View File

@ -946,7 +946,7 @@ PHP_FUNCTION(proc_open)
break;
}
#ifdef PHP_WIN32
stream = php_stream_fopen_from_fd(_open_osfhandle((long)descriptors[i].parentend,
stream = php_stream_fopen_from_fd(_open_osfhandle((zend_intptr_t)descriptors[i].parentend,
descriptors[i].mode_flags), mode_string, NULL);
#else
stream = php_stream_fopen_from_fd(descriptors[i].parentend, mode_string, NULL);

2
main/SAPI.c
View File

@ -541,7 +541,7 @@ SAPI_API int sapi_header_op(sapi_header_op_enum op, void *arg TSRMLS_DC)
switch (op) {
case SAPI_HEADER_SET_STATUS:
sapi_update_response_code((long) arg TSRMLS_CC);
sapi_update_response_code((int)(zend_intptr_t) arg TSRMLS_CC);
return SUCCESS;
case SAPI_HEADER_REPLACE:

4
main/main.c
View File

@ -974,7 +974,7 @@ static void php_message_handler_for_zend(long message, void *data)
if (message==ZMSG_MEMORY_LEAK_DETECTED) {
zend_leak_info *t = (zend_leak_info *) data;
snprintf(memory_leak_buf, 512, "%s(%d) : Freeing 0x%.8lX (%zu bytes), script=%s\n", t->filename, t->lineno, (unsigned long)t->addr, t->size, SAFE_FILENAME(SG(request_info).path_translated));
snprintf(memory_leak_buf, 512, "%s(%d) : Freeing 0x%.8lX (%zu bytes), script=%s\n", t->filename, t->lineno, (zend_uintptr_t)t->addr, t->size, SAFE_FILENAME(SG(request_info).path_translated));
if (t->orig_filename) {
char relay_buf[512];
@ -982,7 +982,7 @@ static void php_message_handler_for_zend(long message, void *data)
strlcat(memory_leak_buf, relay_buf, sizeof(memory_leak_buf));
}
} else {
unsigned long leak_count = (unsigned long) data;
unsigned long leak_count = (zend_uintptr_t) data;
snprintf(memory_leak_buf, 512, "Last leak repeated %ld time%s\n", leak_count, (leak_count>1?"s":""));
}

4
main/php_ini.c
View File

@ -142,7 +142,7 @@ PHPAPI void display_ini_entries(zend_module_entry *module)
}
php_info_print_table_start();
php_info_print_table_header(3, "Directive", "Local Value", "Master Value");
zend_hash_apply_with_argument(EG(ini_directives), (apply_func_arg_t) php_ini_displayer, (void *) (long) module_number TSRMLS_CC);
zend_hash_apply_with_argument(EG(ini_directives), (apply_func_arg_t) php_ini_displayer, (void *) (zend_intptr_t) module_number TSRMLS_CC);
php_info_print_table_end();
}
/* }}} */
@ -590,7 +590,7 @@ PHPAPI int cfg_get_long(char *varname, long *result)
zval *tmp, var;
if (zend_hash_find(&configuration_hash, varname, strlen(varname) + 1, (void **) &tmp) == FAILURE) {
*result = (long) NULL;
*result = 0;
return FAILURE;
}
var = *tmp;

10
main/streams/plain_wrapper.c
View File

@ -223,9 +223,9 @@ PHPAPI php_stream *_php_stream_fopen_from_fd(int fd, const char *mode, const cha
}
#elif defined(PHP_WIN32)
{
long handle = _get_osfhandle(self->fd);
zend_uintptr_t handle = _get_osfhandle(self->fd);
if (handle != 0xFFFFFFFF) {
if (handle != (zend_uintptr_t)INVALID_HANDLE_VALUE) {
self->is_pipe = GetFileType((HANDLE)handle) == FILE_TYPE_PIPE;
}
}
@ -261,9 +261,9 @@ PHPAPI php_stream *_php_stream_fopen_from_file(FILE *file, const char *mode STRE
}
#elif defined(PHP_WIN32)
{
long handle = _get_osfhandle(self->fd);
zend_uintptr_t handle = _get_osfhandle(self->fd);
if (handle != 0xFFFFFFFF) {
if (handle != (zend_uintptr_t)INVALID_HANDLE_VALUE) {
self->is_pipe = GetFileType((HANDLE)handle) == FILE_TYPE_PIPE;
}
}
@ -601,7 +601,7 @@ static int php_stdiop_set_option(php_stream *stream, int option, int value, void
return -1;
}
if ((long) ptrparam == PHP_STREAM_LOCK_SUPPORTED) {
if ((zend_uintptr_t) ptrparam == PHP_STREAM_LOCK_SUPPORTED) {
return 0;
}

3
win32/build/config.w32
View File

@ -126,8 +126,7 @@ if (VCVERS >= 14) {
// disable annoying warnings. In addition, time_t defaults
// to 64-bit. Ask for 32-bit.
if (X64) {
ADD_FLAG('CFLAGS', ' /wd4996 ');
// ADD_FLAG('CFLAGS', ' /wd4996 /Wp64 ');
ADD_FLAG('CFLAGS', ' /wd4996 /Wp64 ');
} else {
ADD_FLAG('CFLAGS', ' /wd4996 /D_USE_32BIT_TIME_T=1 ');
}

4
win32/select.c
View File

@ -63,8 +63,8 @@ PHPAPI int php_select(int max_fd, fd_set *rfds, fd_set *wfds, fd_set *efds, stru
/* build an array of handles for non-sockets */
for (i = 0; i < max_fd; i++) {
if (SAFE_FD_ISSET(i, rfds) || SAFE_FD_ISSET(i, wfds) || SAFE_FD_ISSET(i, efds)) {
handles[n_handles] = (HANDLE)_get_osfhandle(i);
if ((DWORD)handles[n_handles] == 0xffffffff) {
handles[n_handles] = (HANDLE)(zend_uintptr_t)_get_osfhandle(i);
if (handles[n_handles] == INVALID_HANDLE_VALUE) {
/* socket */
if (SAFE_FD_ISSET(i, rfds)) {
FD_SET((uint)i, &sock_read);