Annotation of embedaddon/php/Zend/zend_execute.h, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | Zend Engine |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1998-2012 Zend Technologies Ltd. (http://www.zend.com) |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 2.00 of the Zend license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.zend.com/license/2_00.txt. |
! 11: | If you did not receive a copy of the Zend license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@zend.com so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Andi Gutmans <andi@zend.com> |
! 16: | Zeev Suraski <zeev@zend.com> |
! 17: +----------------------------------------------------------------------+
! 18: */
! 19:
! 20: /* $Id: zend_execute.h 321634 2012-01-01 13:15:04Z felipe $ */
! 21:
! 22: #ifndef ZEND_EXECUTE_H
! 23: #define ZEND_EXECUTE_H
! 24:
! 25: #include "zend_compile.h"
! 26: #include "zend_hash.h"
! 27: #include "zend_operators.h"
! 28: #include "zend_variables.h"
! 29:
! 30: typedef union _temp_variable {
! 31: zval tmp_var;
! 32: struct {
! 33: zval **ptr_ptr;
! 34: zval *ptr;
! 35: zend_bool fcall_returned_reference;
! 36: } var;
! 37: struct {
! 38: zval **ptr_ptr;
! 39: zval *ptr;
! 40: zend_bool fcall_returned_reference;
! 41: zval *str;
! 42: zend_uint offset;
! 43: } str_offset;
! 44: struct {
! 45: zval **ptr_ptr;
! 46: zval *ptr;
! 47: zend_bool fcall_returned_reference;
! 48: HashPointer fe_pos;
! 49: } fe;
! 50: zend_class_entry *class_entry;
! 51: } temp_variable;
! 52:
! 53:
! 54: BEGIN_EXTERN_C()
! 55: ZEND_API extern void (*zend_execute)(zend_op_array *op_array TSRMLS_DC);
! 56: ZEND_API extern void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, int return_value_used TSRMLS_DC);
! 57:
! 58: void init_executor(TSRMLS_D);
! 59: void shutdown_executor(TSRMLS_D);
! 60: void shutdown_destructors(TSRMLS_D);
! 61: ZEND_API void execute(zend_op_array *op_array TSRMLS_DC);
! 62: ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, int return_value_used TSRMLS_DC);
! 63: ZEND_API int zend_is_true(zval *op);
! 64: #define safe_free_zval_ptr(p) safe_free_zval_ptr_rel(p ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
! 65: static inline void safe_free_zval_ptr_rel(zval *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
! 66: {
! 67: TSRMLS_FETCH();
! 68:
! 69: if (p!=EG(uninitialized_zval_ptr)) {
! 70: FREE_ZVAL_REL(p);
! 71: }
! 72: }
! 73: ZEND_API int zend_lookup_class(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC);
! 74: ZEND_API int zend_lookup_class_ex(const char *name, int name_length, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
! 75: ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
! 76: ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *string_name TSRMLS_DC);
! 77: ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
! 78: ZEND_API int zend_eval_stringl_ex(char *str, int str_len, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
! 79:
! 80: static inline int i_zend_is_true(zval *op)
! 81: {
! 82: int result;
! 83:
! 84: switch (Z_TYPE_P(op)) {
! 85: case IS_NULL:
! 86: result = 0;
! 87: break;
! 88: case IS_LONG:
! 89: case IS_BOOL:
! 90: case IS_RESOURCE:
! 91: result = (Z_LVAL_P(op)?1:0);
! 92: break;
! 93: case IS_DOUBLE:
! 94: result = (Z_DVAL_P(op) ? 1 : 0);
! 95: break;
! 96: case IS_STRING:
! 97: if (Z_STRLEN_P(op) == 0
! 98: || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) {
! 99: result = 0;
! 100: } else {
! 101: result = 1;
! 102: }
! 103: break;
! 104: case IS_ARRAY:
! 105: result = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
! 106: break;
! 107: case IS_OBJECT:
! 108: if(IS_ZEND_STD_OBJECT(*op)) {
! 109: TSRMLS_FETCH();
! 110:
! 111: if (Z_OBJ_HT_P(op)->cast_object) {
! 112: zval tmp;
! 113: if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_BOOL TSRMLS_CC) == SUCCESS) {
! 114: result = Z_LVAL(tmp);
! 115: break;
! 116: }
! 117: } else if (Z_OBJ_HT_P(op)->get) {
! 118: zval *tmp = Z_OBJ_HT_P(op)->get(op TSRMLS_CC);
! 119: if(Z_TYPE_P(tmp) != IS_OBJECT) {
! 120: /* for safety - avoid loop */
! 121: convert_to_boolean(tmp);
! 122: result = Z_LVAL_P(tmp);
! 123: zval_ptr_dtor(&tmp);
! 124: break;
! 125: }
! 126: }
! 127: }
! 128: result = 1;
! 129: break;
! 130: default:
! 131: result = 0;
! 132: break;
! 133: }
! 134: return result;
! 135: }
! 136:
! 137: ZEND_API int zval_update_constant(zval **pp, void *arg TSRMLS_DC);
! 138: ZEND_API int zval_update_constant_inline_change(zval **pp, void *arg TSRMLS_DC);
! 139: ZEND_API int zval_update_constant_no_inline_change(zval **pp, void *arg TSRMLS_DC);
! 140: ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *scope TSRMLS_DC);
! 141:
! 142: /* dedicated Zend executor functions - do not use! */
! 143: #define ZEND_VM_STACK_PAGE_SIZE ((64 * 1024) - 64)
! 144:
! 145: struct _zend_vm_stack {
! 146: void **top;
! 147: void **end;
! 148: zend_vm_stack prev;
! 149: };
! 150:
! 151: #define ZEND_VM_STACK_ELEMETS(stack) \
! 152: ((void**)(((char*)(stack)) + ZEND_MM_ALIGNED_SIZE(sizeof(struct _zend_vm_stack))))
! 153:
! 154: #define ZEND_VM_STACK_GROW_IF_NEEDED(count) \
! 155: do { \
! 156: if (UNEXPECTED((count) > \
! 157: EG(argument_stack)->end - EG(argument_stack)->top)) { \
! 158: zend_vm_stack_extend((count) TSRMLS_CC); \
! 159: } \
! 160: } while (0)
! 161:
! 162: static inline zend_vm_stack zend_vm_stack_new_page(int count) {
! 163: zend_vm_stack page = (zend_vm_stack)emalloc(ZEND_MM_ALIGNED_SIZE(sizeof(*page)) + sizeof(void*) * count);
! 164:
! 165: page->top = ZEND_VM_STACK_ELEMETS(page);
! 166: page->end = page->top + count;
! 167: page->prev = NULL;
! 168: return page;
! 169: }
! 170:
! 171: static inline void zend_vm_stack_init(TSRMLS_D)
! 172: {
! 173: EG(argument_stack) = zend_vm_stack_new_page(ZEND_VM_STACK_PAGE_SIZE);
! 174: }
! 175:
! 176: static inline void zend_vm_stack_destroy(TSRMLS_D)
! 177: {
! 178: zend_vm_stack stack = EG(argument_stack);
! 179:
! 180: while (stack != NULL) {
! 181: zend_vm_stack p = stack->prev;
! 182: efree(stack);
! 183: stack = p;
! 184: }
! 185: }
! 186:
! 187: static inline void zend_vm_stack_extend(int count TSRMLS_DC)
! 188: {
! 189: zend_vm_stack p = zend_vm_stack_new_page(count >= ZEND_VM_STACK_PAGE_SIZE ? count : ZEND_VM_STACK_PAGE_SIZE);
! 190: p->prev = EG(argument_stack);
! 191: EG(argument_stack) = p;
! 192: }
! 193:
! 194: static inline void **zend_vm_stack_top(TSRMLS_D)
! 195: {
! 196: return EG(argument_stack)->top;
! 197: }
! 198:
! 199: static inline void zend_vm_stack_push(void *ptr TSRMLS_DC)
! 200: {
! 201: ZEND_VM_STACK_GROW_IF_NEEDED(1);
! 202: *(EG(argument_stack)->top++) = ptr;
! 203: }
! 204:
! 205: static inline void zend_vm_stack_push_nocheck(void *ptr TSRMLS_DC)
! 206: {
! 207: *(EG(argument_stack)->top++) = ptr;
! 208: }
! 209:
! 210: static inline void *zend_vm_stack_pop(TSRMLS_D)
! 211: {
! 212: void *el = *(--EG(argument_stack)->top);
! 213:
! 214: if (UNEXPECTED(EG(argument_stack)->top == ZEND_VM_STACK_ELEMETS(EG(argument_stack)))) {
! 215: zend_vm_stack p = EG(argument_stack);
! 216: EG(argument_stack) = p->prev;
! 217: efree(p);
! 218: }
! 219: return el;
! 220: }
! 221:
! 222: static inline void *zend_vm_stack_alloc(size_t size TSRMLS_DC)
! 223: {
! 224: void *ret;
! 225:
! 226: size = (size + (sizeof(void*) - 1)) / sizeof(void*);
! 227:
! 228: /* the following comparison must be optimized out at compile time */
! 229: if (ZEND_MM_ALIGNMENT > sizeof(void*)) {
! 230: int extra = (ZEND_MM_ALIGNMENT - ((zend_uintptr_t)EG(argument_stack)->top & (ZEND_MM_ALIGNMENT - 1))) / sizeof(void*);
! 231:
! 232: if (UNEXPECTED(size + extra + ZEND_MM_ALIGNED_SIZE(sizeof(void*)) / sizeof(void*) >
! 233: (zend_uintptr_t)(EG(argument_stack)->end - EG(argument_stack)->top))) {
! 234: zend_vm_stack_extend(size TSRMLS_CC);
! 235: } else {
! 236: void **old_top = EG(argument_stack)->top;
! 237:
! 238: EG(argument_stack)->top += extra;
! 239: /* store old top on the stack */
! 240: *EG(argument_stack)->top = (void*)old_top;
! 241: EG(argument_stack)->top += ZEND_MM_ALIGNED_SIZE(sizeof(void*)) / sizeof(void*);
! 242: }
! 243: } else {
! 244: ZEND_VM_STACK_GROW_IF_NEEDED((int)size);
! 245: }
! 246: ret = (void*)EG(argument_stack)->top;
! 247: EG(argument_stack)->top += size;
! 248: return ret;
! 249: }
! 250:
! 251: static inline void zend_vm_stack_free_int(void *ptr TSRMLS_DC)
! 252: {
! 253: if (UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (void**)ptr)) {
! 254: zend_vm_stack p = EG(argument_stack);
! 255:
! 256: EG(argument_stack) = p->prev;
! 257: efree(p);
! 258: } else {
! 259: EG(argument_stack)->top = (void**)ptr;
! 260: }
! 261: }
! 262:
! 263: static inline void zend_vm_stack_free(void *ptr TSRMLS_DC)
! 264: {
! 265: if (UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (void**)ptr)) {
! 266: zend_vm_stack p = EG(argument_stack);
! 267:
! 268: EG(argument_stack) = p->prev;
! 269: efree(p);
! 270: } else {
! 271: /* the following comparison must be optimized out at compile time */
! 272: if (ZEND_MM_ALIGNMENT > sizeof(void*)) {
! 273: ptr = (void*)(((char*)ptr) - ZEND_MM_ALIGNED_SIZE(sizeof(void*)));
! 274: EG(argument_stack)->top = *(void***)ptr;
! 275: } else {
! 276: EG(argument_stack)->top = (void**)ptr;
! 277: }
! 278: }
! 279: }
! 280:
! 281: static inline void** zend_vm_stack_push_args(int count TSRMLS_DC)
! 282: {
! 283:
! 284: if (UNEXPECTED(EG(argument_stack)->top - ZEND_VM_STACK_ELEMETS(EG(argument_stack)) < count) ||
! 285: UNEXPECTED(EG(argument_stack)->top == EG(argument_stack)->end)) {
! 286: zend_vm_stack p = EG(argument_stack);
! 287:
! 288: zend_vm_stack_extend(count + 1 TSRMLS_CC);
! 289:
! 290: EG(argument_stack)->top += count;
! 291: *(EG(argument_stack)->top) = (void*)(zend_uintptr_t)count;
! 292: while (count-- > 0) {
! 293: void *data = *(--p->top);
! 294:
! 295: if (UNEXPECTED(p->top == ZEND_VM_STACK_ELEMETS(p))) {
! 296: zend_vm_stack r = p;
! 297:
! 298: EG(argument_stack)->prev = p->prev;
! 299: p = p->prev;
! 300: efree(r);
! 301: }
! 302: *(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + count) = data;
! 303: }
! 304: return EG(argument_stack)->top++;
! 305: }
! 306: *(EG(argument_stack)->top) = (void*)(zend_uintptr_t)count;
! 307: return EG(argument_stack)->top++;
! 308: }
! 309:
! 310: static inline void zend_vm_stack_clear_multiple(TSRMLS_D)
! 311: {
! 312: void **p = EG(argument_stack)->top - 1;
! 313: int delete_count = (int)(zend_uintptr_t) *p;
! 314:
! 315: while (--delete_count>=0) {
! 316: zval *q = *(zval **)(--p);
! 317: *p = NULL;
! 318: zval_ptr_dtor(&q);
! 319: }
! 320: zend_vm_stack_free_int(p TSRMLS_CC);
! 321: }
! 322:
! 323: static inline zval** zend_vm_stack_get_arg(int requested_arg TSRMLS_DC)
! 324: {
! 325: void **p = EG(current_execute_data)->prev_execute_data->function_state.arguments;
! 326: int arg_count = (int)(zend_uintptr_t) *p;
! 327:
! 328: if (UNEXPECTED(requested_arg > arg_count)) {
! 329: return NULL;
! 330: }
! 331: return (zval**)p - arg_count + requested_arg - 1;
! 332: }
! 333:
! 334: static inline void zend_arg_types_stack_2_pop(zend_ptr_stack *stack, zval **object, zend_function **fbc)
! 335: {
! 336: void *a, *b;
! 337:
! 338: zend_ptr_stack_2_pop(stack, &a, &b);
! 339:
! 340: *object = (zval *) a;
! 341: *fbc = (zend_function *) b;
! 342: }
! 343:
! 344: static inline void zend_arg_types_stack_3_pop(zend_ptr_stack *stack, zend_class_entry **called_scope, zval **object, zend_function **fbc)
! 345: {
! 346: void *a, *b, *c;
! 347:
! 348: zend_ptr_stack_3_pop(stack, &a, &b, &c);
! 349:
! 350: *called_scope = (zend_class_entry *) a;
! 351: *object = (zval *) b;
! 352: *fbc = (zend_function *) c;
! 353: }
! 354:
! 355: void execute_new_code(TSRMLS_D);
! 356:
! 357:
! 358: /* services */
! 359: ZEND_API char *get_active_class_name(char **space TSRMLS_DC);
! 360: ZEND_API char *get_active_function_name(TSRMLS_D);
! 361: ZEND_API char *zend_get_executed_filename(TSRMLS_D);
! 362: ZEND_API uint zend_get_executed_lineno(TSRMLS_D);
! 363: ZEND_API zend_bool zend_is_executing(TSRMLS_D);
! 364:
! 365: ZEND_API void zend_set_timeout(long seconds, int reset_signals);
! 366: ZEND_API void zend_unset_timeout(TSRMLS_D);
! 367: ZEND_API void zend_timeout(int dummy);
! 368: ZEND_API zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len, int fetch_type TSRMLS_DC);
! 369: void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC);
! 370:
! 371: #ifdef ZEND_WIN32
! 372: void zend_init_timeout_thread(void);
! 373: void zend_shutdown_timeout_thread(void);
! 374: #define WM_REGISTER_ZEND_TIMEOUT (WM_USER+1)
! 375: #define WM_UNREGISTER_ZEND_TIMEOUT (WM_USER+2)
! 376: #endif
! 377:
! 378: #define zendi_zval_copy_ctor(p) zval_copy_ctor(&(p))
! 379: #define zendi_zval_dtor(p) zval_dtor(&(p))
! 380:
! 381: #define active_opline (*EG(opline_ptr))
! 382:
! 383: /* The following tries to resolve the classname of a zval of type object.
! 384: * Since it is slow it should be only used in error messages.
! 385: */
! 386: #define Z_OBJ_CLASS_NAME_P(zval) ((zval) && Z_TYPE_P(zval) == IS_OBJECT && Z_OBJ_HT_P(zval)->get_class_entry != NULL && Z_OBJ_HT_P(zval)->get_class_entry(zval TSRMLS_CC) ? Z_OBJ_HT_P(zval)->get_class_entry(zval TSRMLS_CC)->name : "")
! 387:
! 388: ZEND_API zval** zend_get_compiled_variable_value(const zend_execute_data *execute_data_ptr, zend_uint var);
! 389:
! 390: #define ZEND_USER_OPCODE_CONTINUE 0 /* execute next opcode */
! 391: #define ZEND_USER_OPCODE_RETURN 1 /* exit from executor (return from function) */
! 392: #define ZEND_USER_OPCODE_DISPATCH 2 /* call original opcode handler */
! 393: #define ZEND_USER_OPCODE_ENTER 3 /* enter into new op_array without recursion */
! 394: #define ZEND_USER_OPCODE_LEAVE 4 /* return to calling op_array within the same executor */
! 395:
! 396: #define ZEND_USER_OPCODE_DISPATCH_TO 0x100 /* call original handler of returned opcode */
! 397:
! 398: ZEND_API int zend_set_user_opcode_handler(zend_uchar opcode, user_opcode_handler_t handler);
! 399: ZEND_API user_opcode_handler_t zend_get_user_opcode_handler(zend_uchar opcode);
! 400:
! 401: /* former zend_execute_locks.h */
! 402: typedef struct _zend_free_op {
! 403: zval* var;
! 404: /* int is_var; */
! 405: } zend_free_op;
! 406:
! 407: ZEND_API zval *zend_get_zval_ptr(znode *node, const temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC);
! 408: ZEND_API zval **zend_get_zval_ptr_ptr(const znode *node, const temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC);
! 409:
! 410: ZEND_API int zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS);
! 411:
! 412: END_EXTERN_C()
! 413:
! 414: #endif /* ZEND_EXECUTE_H */
! 415:
! 416: /*
! 417: * Local variables:
! 418: * tab-width: 4
! 419: * c-basic-offset: 4
! 420: * indent-tabs-mode: t
! 421: * End:
! 422: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zend_execute.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend