Merge remote-tracking branch 'php-src/master' into ast

Conflicts:
	Zend/zend_compile.c
	Zend/zend_compile.h
	Zend/zend_globals.h
	Zend/zend_language_parser.y
	Zend/zend_language_scanner.c
	Zend/zend_language_scanner.l
	Zend/zend_types.h

diff --cc Zend/zend.c
Simple merge

diff --cc Zend/zend.h
index 52cc923e7485f0d99970046cdc0fe8748f99ba3d,e3770052889dbd9e40b96131062b78502ec29ccf..52adbd267ed391411804cafd9c9afe9d842d68d9
--- 1/Zend/zend.h
--- 2/Zend/zend.h
+++ b/Zend/zend.h
@@@ -400,9 -401,8 +400,9 @@@ void zend_error_noreturn(int type, cons
  #endif
  
  #include "zend_string.h"
 +#include "zend_ast.h"
  
- static zend_always_inline zend_uint zval_refcount_p(zval* pz) {
+ static zend_always_inline uint32_t zval_refcount_p(zval* pz) {
        ZEND_ASSERT(Z_REFCOUNTED_P(pz) || Z_IMMUTABLE_P(pz));
        return GC_REFCOUNT(Z_COUNTED_P(pz));
  }

diff --cc Zend/zend_ast.c
index 822698a354a15125dee986f7662916d3a2589778,810b9b1fe81956e8017f6997bbedd7be4fc2d321..25320182741e5552648d058e22a99a1d68b206e4
--- 1/Zend/zend_ast.c
--- 2/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@@ -23,88 -23,31 +23,88 @@@
  #include "zend_API.h"
  #include "zend_operators.h"
  
 -ZEND_API zend_ast *zend_ast_create_constant(zval *zv)
 -{
 -      zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zval));
 -      ast->kind = ZEND_CONST;
 -      ast->children = 0;
 -      ZVAL_COPY_VALUE(&ast->u.val, zv);
 -      return ast;
 +static inline void *zend_ast_alloc(size_t size TSRMLS_DC) {
 +      return zend_arena_alloc(&CG(ast_arena), size);
  }
  
 -ZEND_API zend_ast* zend_ast_create_unary(uint kind, zend_ast *op0)
 -{
 -      zend_ast *ast = emalloc(sizeof(zend_ast));
 +static inline void *zend_ast_realloc(void *old, size_t old_size, size_t new_size TSRMLS_DC) {
 +      void *new = zend_ast_alloc(new_size TSRMLS_CC);
 +      memcpy(new, old, old_size);
 +      return new;
 +}
 +
- size_t zend_ast_size(zend_uint children) {
++static inline size_t zend_ast_size(uint32_t children) {
 +      return sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children;
 +}
 +
- size_t zend_ast_list_size(zend_uint children) {
++static inline size_t zend_ast_list_size(uint32_t children) {
 +      return sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * children;
 +}
 +
 +ZEND_API zend_ast *zend_ast_create_znode(znode *node) {
 +      TSRMLS_FETCH();
 +      zend_ast_znode *ast = zend_ast_alloc(sizeof(zend_ast_znode) TSRMLS_CC);
 +      ast->kind = ZEND_AST_ZNODE;
 +      ast->attr = 0;
 +      ast->lineno = CG(zend_lineno);
 +      ast->node = *node;
 +      return (zend_ast *) ast;
 +}
 +
 +ZEND_API zend_ast *zend_ast_create_zval_ex(zval *zv, zend_ast_attr attr) {
 +      TSRMLS_FETCH();
 +      zend_ast_zval *ast = zend_ast_alloc(sizeof(zend_ast_zval) TSRMLS_CC);
 +      ast->kind = ZEND_AST_ZVAL;
 +      ast->attr = attr;
 +      ZVAL_COPY_VALUE(&ast->val, zv);
 +      ast->val.u2.lineno = CG(zend_lineno);
 +      return (zend_ast *) ast;
 +}
 +
 +ZEND_API zend_ast *zend_ast_create_decl(
-       zend_ast_kind kind, zend_uint flags, zend_uint start_lineno, zend_string *doc_comment,
++      zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment,
 +      zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2
 +) {
 +      TSRMLS_FETCH();
 +      zend_ast_decl *ast = zend_ast_alloc(sizeof(zend_ast_decl) TSRMLS_CC);
 +
        ast->kind = kind;
 -      ast->children = 1;
 -      (&ast->u.child)[0] = op0;
 -      return ast;
 +      ast->attr = 0;
 +      ast->start_lineno = start_lineno;
 +      ast->end_lineno = CG(zend_lineno);
 +      ast->flags = flags;
 +      ast->lex_pos = LANG_SCNG(yy_text);
 +      ast->doc_comment = doc_comment;
 +      ast->name = name;
 +      ast->child[0] = child0;
 +      ast->child[1] = child1;
 +      ast->child[2] = child2;
 +
 +      return (zend_ast *) ast;
  }
  
 -ZEND_API zend_ast* zend_ast_create_binary(uint kind, zend_ast *op0, zend_ast *op1)
 -{
 -      zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*));
 +static zend_ast *zend_ast_create_from_va_list(zend_ast_kind kind, zend_ast_attr attr, va_list va) {
 +      TSRMLS_FETCH();
-       zend_uint i, children = kind >> ZEND_AST_NUM_CHILDREN_SHIFT;
++      uint32_t i, children = kind >> ZEND_AST_NUM_CHILDREN_SHIFT;
 +      zend_ast *ast = zend_ast_alloc(zend_ast_size(children) TSRMLS_CC);
        ast->kind = kind;
 -      ast->children = 2;
 -      (&ast->u.child)[0] = op0;
 -      (&ast->u.child)[1] = op1;
 +      ast->attr = attr;
-       ast->lineno = UINT_MAX;
++      ast->lineno = (uint32_t) -1;
 +
 +      for (i = 0; i < children; ++i) {
 +              ast->child[i] = va_arg(va, zend_ast *);
 +              if (ast->child[i] != NULL) {
-                       zend_uint lineno = zend_ast_get_lineno(ast->child[i]);
++                      uint32_t lineno = zend_ast_get_lineno(ast->child[i]);
 +                      if (lineno < ast->lineno) {
 +                              ast->lineno = lineno;
 +                      }
 +              }
 +      }
 +
 +      if (ast->lineno == UINT_MAX) {
 +              ast->lineno = CG(zend_lineno);
 +      }
 +
        return ast;
  }
  
@@@ -130,39 -70,35 +130,39 @@@ ZEND_API zend_ast *zend_ast_create(zend
        return ast;
  }
  
- ZEND_API zend_ast_list *zend_ast_create_list(zend_uint init_children, zend_ast_kind kind, ...) {
 -ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op)
 -{
 -      if ((*ast)->children >= 4 && (*ast)->children == ((*ast)->children & -(*ast)->children)) {
 -              *ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children * 2 + 1));
++ZEND_API zend_ast_list *zend_ast_create_list(uint32_t init_children, zend_ast_kind kind, ...) {
 +      TSRMLS_FETCH();
 +      zend_ast_list *list = zend_ast_alloc(zend_ast_list_size(4) TSRMLS_CC);
 +      list->kind = kind;
 +      list->attr = 0;
 +      list->lineno = CG(zend_lineno);
 +      list->children = 0;
 +
 +      {
 +              va_list va;
-               zend_uint i;
++              uint32_t i;
 +              va_start(va, kind);
 +              for (i = 0; i < init_children; ++i) {
 +                      list = zend_ast_list_add(list, va_arg(va, zend_ast *));
 +              }
 +              va_end(va);
        }
 -      (&(*ast)->u.child)[(*ast)->children++] = op;
 -}
  
 -ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast)
 -{
 -      *ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children - 1));
 +      return list;
  }
  
- static inline zend_bool is_power_of_two(unsigned short n) {
 -ZEND_API int zend_ast_is_ct_constant(zend_ast *ast)
 -{
 -      int i;
++static inline zend_bool is_power_of_two(uint32_t n) {
 +      return n == (n & -n);
 +}
  
 -      if (ast->kind == ZEND_CONST) {
 -              return !Z_CONSTANT(ast->u.val);
 -      } else {
 -              for (i = 0; i < ast->children; i++) {
 -                      if ((&ast->u.child)[i]) {
 -                              if (!zend_ast_is_ct_constant((&ast->u.child)[i])) {
 -                                      return 0;
 -                              }
 -                      }
 -              }
 -              return 1;
 +ZEND_API zend_ast_list *zend_ast_list_add(zend_ast_list *list, zend_ast *op) {
 +      if (list->children >= 4 && is_power_of_two(list->children)) {
 +              TSRMLS_FETCH();
 +              list = zend_ast_realloc(list,
 +                      zend_ast_list_size(list->children), zend_ast_list_size(list->children * 2) TSRMLS_CC);
        }
 +      list->child[list->children++] = op;
 +      return list;
  }
  
  static void zend_ast_add_array_element(zval *result, zval *offset, zval *expr TSRMLS_DC)
@@@ -297,15 -342,13 +297,15 @@@ ZEND_API void zend_ast_evaluate(zval *r
                        sub_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op2);
                        break;
 -              case ZEND_INIT_ARRAY:
 +              case ZEND_AST_ARRAY:
                        array_init(result);
                        {
-                               zend_uint i;
 -                              int i;
 -                              for (i = 0; i < ast->children; i+=2) {
 -                                      if ((&ast->u.child)[i]) {
 -                                              zend_ast_evaluate(&op1, (&ast->u.child)[i], scope TSRMLS_CC);
++                              uint32_t i;
 +                              zend_ast_list *list = zend_ast_get_list(ast);
 +                              for (i = 0; i < list->children; i++) {
 +                                      zend_ast *elem = list->child[i];
 +                                      if (elem->child[1]) {
 +                                              zend_ast_evaluate(&op1, elem->child[1], scope TSRMLS_CC);
                                        } else {
                                                ZVAL_UNDEF(&op1);
                                        }
@@@ -334,105 -377,35 +334,105 @@@ ZEND_API zend_ast *zend_ast_copy(zend_a
  {
        if (ast == NULL) {
                return NULL;
 -      } else if (ast->kind == ZEND_CONST) {
 -              zend_ast *copy = zend_ast_create_constant(&ast->u.val);
 -              zval_copy_ctor(&copy->u.val);
 -              return copy;
 -      } else if (ast->children) {
 -              zend_ast *new = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
 -              int i;
 +      } else if (ast->kind == ZEND_AST_ZVAL) {
 +              zend_ast_zval *new = emalloc(sizeof(zend_ast_zval));
 +              new->kind = ZEND_AST_ZVAL;
 +              new->attr = ast->attr;
 +              ZVAL_COPY(&new->val, zend_ast_get_zval(ast));
 +              return (zend_ast *) new;
 +      } else if (zend_ast_is_list(ast)) {
 +              zend_ast_list *list = zend_ast_get_list(ast);
 +              zend_ast_list *new = emalloc(zend_ast_list_size(list->children));
-               zend_uint i;
++              uint32_t i;
 +              new->kind = list->kind;
 +              new->attr = list->attr;
 +              new->children = list->children;
 +              for (i = 0; i < list->children; i++) {
 +                      new->child[i] = zend_ast_copy(list->child[i]);
 +              }
 +              return (zend_ast *) new;
 +      } else {
-               zend_uint i, children = zend_ast_get_num_children(ast);
++              uint32_t i, children = zend_ast_get_num_children(ast);
 +              zend_ast *new = emalloc(zend_ast_size(children));
                new->kind = ast->kind;
 -              new->children = ast->children;
 -              for (i = 0; i < ast->children; i++) {
 -                      (&new->u.child)[i] = zend_ast_copy((&ast->u.child)[i]);
 +              new->attr = ast->attr;
 +              for (i = 0; i < children; i++) {
 +                      new->child[i] = zend_ast_copy(ast->child[i]);
                }
                return new;
        }
 -      return zend_ast_create_dynamic(ast->kind);
  }
  
 -ZEND_API void zend_ast_destroy(zend_ast *ast)
 -{
 -      int i;
 +static void zend_ast_destroy_ex(zend_ast *ast, zend_bool free) {
 +      if (!ast) {
 +              return;
 +      }
  
 -      if (ast->kind == ZEND_CONST) {
 -              zval_dtor(&ast->u.val);
 -      } else {
 -              for (i = 0; i < ast->children; i++) {
 -                      if ((&ast->u.child)[i]) {
 -                              zend_ast_destroy((&ast->u.child)[i]);
 +      switch (ast->kind) {
 +              case ZEND_AST_ZVAL:
 +              {
 +                      /* Destroy value without using GC: When opcache moves arrays into SHM it will
 +                       * free the zend_array structure, so references to it from outside the op array
 +                       * become invalid. GC would cause such a reference in the root buffer. */
 +                      zval *zv = zend_ast_get_zval(ast);
 +                      if (Z_REFCOUNTED_P(zv) && !Z_DELREF_P(zv)) {
 +                              _zval_dtor_func_for_ptr(Z_COUNTED_P(zv) ZEND_FILE_LINE_CC);
 +                      }
 +                      break;
 +              }
 +              case ZEND_AST_FUNC_DECL:
 +              case ZEND_AST_CLOSURE:
 +              case ZEND_AST_METHOD:
 +              case ZEND_AST_CLASS:
 +              {
 +                      zend_ast_decl *decl = (zend_ast_decl *) ast;
-                       STR_RELEASE(decl->name);
++                      zend_string_release(decl->name);
 +                      if (decl->doc_comment) {
-                               STR_RELEASE(decl->doc_comment);
++                              zend_string_release(decl->doc_comment);
 +                      }
 +                      zend_ast_destroy_ex(decl->child[0], free);
 +                      zend_ast_destroy_ex(decl->child[1], free);
 +                      zend_ast_destroy_ex(decl->child[2], free);
 +                      break;
 +              }
 +              default:
 +                      if (zend_ast_is_list(ast)) {
 +                              zend_ast_list *list = zend_ast_get_list(ast);
-                               zend_uint i;
++                              uint32_t i;
 +                              for (i = 0; i < list->children; i++) {
 +                                      zend_ast_destroy_ex(list->child[i], free);
 +                              }
 +                      } else {
-                               zend_uint i, children = zend_ast_get_num_children(ast);
++                              uint32_t i, children = zend_ast_get_num_children(ast);
 +                              for (i = 0; i < children; i++) {
 +                                      zend_ast_destroy_ex(ast->child[i], free);
 +                              }
                        }
-               zend_uint i;
 +      }
 +
 +      if (free) {
 +              efree(ast);
 +      }
 +}
 +
 +ZEND_API void zend_ast_destroy(zend_ast *ast) {
 +      zend_ast_destroy_ex(ast, 0);
 +}
 +ZEND_API void zend_ast_destroy_and_free(zend_ast *ast) {
 +      zend_ast_destroy_ex(ast, 1);
 +}
 +
 +ZEND_API void zend_ast_apply(zend_ast *ast, zend_ast_apply_func fn TSRMLS_DC) {
 +      if (zend_ast_is_list(ast)) {
 +              zend_ast_list *list = zend_ast_get_list(ast);
-               zend_uint i, children = zend_ast_get_num_children(ast);
++              uint32_t i;
 +              for (i = 0; i < list->children; ++i) {
 +                      fn(&list->child[i] TSRMLS_CC);
 +              }
 +      } else {
++              uint32_t i, children = zend_ast_get_num_children(ast);
 +              for (i = 0; i < children; ++i) {
 +                      fn(&ast->child[i] TSRMLS_CC);
                }
        }
 -      efree(ast);
  }

diff --cc Zend/zend_ast.h
index c8cac17cef73fb25cf89e2362da2b364d015e35e,8678299f0fabdf35bf49ab2242413fcfc9a90fec..24d2aa6308856b542ec653b1007263fcf32adad4
--- 1/Zend/zend_ast.h
--- 2/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@@ -25,239 -24,39 +25,239 @@@
  
  #include "zend.h"
  
 -typedef enum _zend_ast_kind {
 -      /* first 256 kinds are reserved for opcodes */
 -      ZEND_CONST = 256,
 -      ZEND_BOOL_AND,
 -      ZEND_BOOL_OR,
 -      ZEND_SELECT,
 -      ZEND_UNARY_PLUS,
 -      ZEND_UNARY_MINUS,
 -} zend_ast_kind;
 +#define ZEND_AST_SPECIAL_SHIFT      6
 +#define ZEND_AST_IS_LIST_SHIFT      7
 +#define ZEND_AST_NUM_CHILDREN_SHIFT 8
 +
 +enum _zend_ast_kind {
 +      /* special nodes */
 +      ZEND_AST_ZVAL = 1 << ZEND_AST_SPECIAL_SHIFT,
 +      ZEND_AST_ZNODE,
 +
 +      /* declaration nodes */
 +      ZEND_AST_FUNC_DECL,
 +      ZEND_AST_CLOSURE,
 +      ZEND_AST_METHOD,
 +      ZEND_AST_CLASS,
 +
 +      /* list nodes */
 +      ZEND_AST_ARG_LIST = 1 << ZEND_AST_IS_LIST_SHIFT,
 +      ZEND_AST_LIST,
 +      ZEND_AST_ARRAY,
 +      ZEND_AST_ENCAPS_LIST,
 +      ZEND_AST_EXPR_LIST,
 +      ZEND_AST_STMT_LIST,
 +      ZEND_AST_IF,
 +      ZEND_AST_SWITCH_LIST,
 +      ZEND_AST_CATCH_LIST,
 +      ZEND_AST_PARAM_LIST,
 +      ZEND_AST_CLOSURE_USES,
 +      ZEND_AST_PROP_DECL,
 +      ZEND_AST_CONST_DECL,
 +      ZEND_AST_CLASS_CONST_DECL,
 +      ZEND_AST_NAME_LIST,
 +      ZEND_AST_TRAIT_ADAPTATIONS,
 +      ZEND_AST_USE,
 +
 +      /* 0 child nodes */
 +      ZEND_AST_MAGIC_CONST = 0 << ZEND_AST_NUM_CHILDREN_SHIFT,
 +      ZEND_AST_TYPE,
 +
 +      /* 1 child node */
 +      ZEND_AST_VAR = 1 << ZEND_AST_NUM_CHILDREN_SHIFT,
 +      ZEND_AST_CONST,
 +      ZEND_AST_RESOLVE_CLASS_NAME,
 +      ZEND_AST_UNPACK,
 +      ZEND_AST_UNARY_PLUS,
 +      ZEND_AST_UNARY_MINUS,
 +      ZEND_AST_CAST,
 +      ZEND_AST_EMPTY,
 +      ZEND_AST_ISSET,
 +      ZEND_AST_SILENCE,
 +      ZEND_AST_SHELL_EXEC,
 +      ZEND_AST_CLONE,
 +      ZEND_AST_EXIT,
 +      ZEND_AST_PRINT,
 +      ZEND_AST_INCLUDE_OR_EVAL,
 +      ZEND_AST_UNARY_OP,
 +      ZEND_AST_PRE_INC,
 +      ZEND_AST_PRE_DEC,
 +      ZEND_AST_POST_INC,
 +      ZEND_AST_POST_DEC,
 +
 +      ZEND_AST_GLOBAL,
 +      ZEND_AST_UNSET,
 +      ZEND_AST_RETURN,
 +      ZEND_AST_LABEL,
 +      ZEND_AST_REF,
 +      ZEND_AST_HALT_COMPILER,
 +      ZEND_AST_ECHO,
 +      ZEND_AST_THROW,
 +      ZEND_AST_GOTO,
 +      ZEND_AST_BREAK,
 +      ZEND_AST_CONTINUE,
 +
 +      /* 2 child nodes */
 +      ZEND_AST_DIM = 2 << ZEND_AST_NUM_CHILDREN_SHIFT,
 +      ZEND_AST_PROP,
 +      ZEND_AST_STATIC_PROP,
 +      ZEND_AST_CALL,
 +      ZEND_AST_CLASS_CONST,
 +      ZEND_AST_ASSIGN,
 +      ZEND_AST_ASSIGN_REF,
 +      ZEND_AST_ASSIGN_OP,
 +      ZEND_AST_BINARY_OP,
 +      ZEND_AST_GREATER,
 +      ZEND_AST_GREATER_EQUAL,
 +      ZEND_AST_AND,
 +      ZEND_AST_OR,
 +      ZEND_AST_ARRAY_ELEM,
 +      ZEND_AST_NEW,
 +      ZEND_AST_INSTANCEOF,
 +      ZEND_AST_YIELD,
 +
 +      ZEND_AST_STATIC,
 +      ZEND_AST_WHILE,
 +      ZEND_AST_DO_WHILE,
 +      ZEND_AST_IF_ELEM,
 +      ZEND_AST_SWITCH,
 +      ZEND_AST_SWITCH_CASE,
 +      ZEND_AST_DECLARE,
 +      ZEND_AST_PROP_ELEM,
 +      ZEND_AST_CONST_ELEM,
 +      ZEND_AST_USE_TRAIT,
 +      ZEND_AST_TRAIT_PRECEDENCE,
 +      ZEND_AST_METHOD_REFERENCE,
 +      ZEND_AST_NAMESPACE,
 +      ZEND_AST_USE_ELEM,
 +      ZEND_AST_TRAIT_ALIAS,
 +
 +      /* 3 child nodes */
 +      ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT,
 +      ZEND_AST_STATIC_CALL,
 +      ZEND_AST_CONDITIONAL,
 +
 +      ZEND_AST_TRY,
 +      ZEND_AST_CATCH,
 +      ZEND_AST_PARAM,
 +
 +      /* 4 child nodes */
 +      ZEND_AST_FOR = 4 << ZEND_AST_NUM_CHILDREN_SHIFT,
 +      ZEND_AST_FOREACH,
 +};
 +
- typedef unsigned short zend_ast_kind;
- typedef unsigned short zend_ast_attr;
++typedef uint16_t zend_ast_kind;
++typedef uint16_t zend_ast_attr;
  
  struct _zend_ast {
 -      unsigned short kind;
 -      unsigned short children;
 -      union {
 -              zval      val;
 -              zend_ast *child;
 -      } u;
 +      zend_ast_kind kind; /* Type of the node (ZEND_AST_* enum constant) */
 +      zend_ast_attr attr; /* Additional attribute, use depending on node type */
-       zend_uint lineno;   /* Line number */
++      uint32_t lineno;    /* Line number */
 +      zend_ast *child[1]; /* Array of children (using struct hack) */
  };
  
 -ZEND_API zend_ast *zend_ast_create_constant(zval *zv);
 +/* Same as zend_ast, but with children count, which is updated dynamically */
 +typedef struct _zend_ast_list {
 +      zend_ast_kind kind;
 +      zend_ast_attr attr;
-       zend_uint lineno;
-       zend_uint children;
++      uint32_t lineno;
++      uint32_t children;
 +      zend_ast *child[1];
 +} zend_ast_list;
 +
 +/* Lineno is stored in val.u2.lineno */
 +typedef struct _zend_ast_zval {
 +      zend_ast_kind kind;
 +      zend_ast_attr attr;
 +      zval val;
 +} zend_ast_zval;
 +
 +/* Separate structure for function and class declaration, as they need extra information. */
 +typedef struct _zend_ast_decl {
 +      zend_ast_kind kind;
 +      zend_ast_attr attr; /* Unused - for structure compatibility */
-       zend_uint start_lineno;
-       zend_uint end_lineno;
-       zend_uint flags;
++      uint32_t start_lineno;
++      uint32_t end_lineno;
++      uint32_t flags;
 +      unsigned char *lex_pos;
 +      zend_string *doc_comment;
 +      zend_string *name;
 +      zend_ast *child[3];
 +} zend_ast_decl;
  
 -ZEND_API zend_ast *zend_ast_create_unary(uint kind, zend_ast *op0);
 -ZEND_API zend_ast *zend_ast_create_binary(uint kind, zend_ast *op0, zend_ast *op1);
 -ZEND_API zend_ast *zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *op1, zend_ast *op2);
 -ZEND_API zend_ast* zend_ast_create_dynamic(uint kind);
 -ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op);
 -ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast);
 +ZEND_API zend_ast *zend_ast_create_zval_ex(zval *zv, zend_ast_attr attr);
  
 -ZEND_API int zend_ast_is_ct_constant(zend_ast *ast);
 +ZEND_API zend_ast *zend_ast_create_ex(zend_ast_kind kind, zend_ast_attr attr, ...);
 +ZEND_API zend_ast *zend_ast_create(zend_ast_kind kind, ...);
 +
 +ZEND_API zend_ast *zend_ast_create_decl(
-       zend_ast_kind kind, zend_uint flags, zend_uint start_lineno, zend_string *doc_comment,
++      zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment,
 +      zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2
 +);
 +
- ZEND_API zend_ast_list *zend_ast_create_list(zend_uint init_children, zend_ast_kind kind, ...);
++ZEND_API zend_ast_list *zend_ast_create_list(uint32_t init_children, zend_ast_kind kind, ...);
 +ZEND_API zend_ast_list *zend_ast_list_add(zend_ast_list *list, zend_ast *op);
  
  ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *scope TSRMLS_DC);
  
  ZEND_API zend_ast *zend_ast_copy(zend_ast *ast);
  ZEND_API void zend_ast_destroy(zend_ast *ast);
- static inline zend_uint zend_ast_get_num_children(zend_ast *ast) {
 +ZEND_API void zend_ast_destroy_and_free(zend_ast *ast);
 +
 +typedef void (*zend_ast_apply_func)(zend_ast **ast_ptr TSRMLS_DC);
 +ZEND_API void zend_ast_apply(zend_ast *ast, zend_ast_apply_func fn TSRMLS_DC);
 +
 +static inline zend_bool zend_ast_is_list(zend_ast *ast) {
 +      return (ast->kind >> ZEND_AST_IS_LIST_SHIFT) & 1;
 +}
 +static inline zend_ast_list *zend_ast_get_list(zend_ast *ast) {
 +      ZEND_ASSERT(zend_ast_is_list(ast));
 +      return (zend_ast_list *) ast;
 +}
 +
 +static inline zval *zend_ast_get_zval(zend_ast *ast) {
 +      ZEND_ASSERT(ast->kind == ZEND_AST_ZVAL);
 +      return &((zend_ast_zval *) ast)->val;
 +}
 +static inline zend_string *zend_ast_get_str(zend_ast *ast) {
 +      return Z_STR_P(zend_ast_get_zval(ast));
 +}
 +
- static inline zend_uint zend_ast_get_lineno(zend_ast *ast) {
++static inline uint32_t zend_ast_get_num_children(zend_ast *ast) {
 +      ZEND_ASSERT(!zend_ast_is_list(ast));
 +      return ast->kind >> ZEND_AST_NUM_CHILDREN_SHIFT;
 +}
- static inline zend_ast *zend_ast_create_zval_from_long(long lval) {
++static inline uint32_t zend_ast_get_lineno(zend_ast *ast) {
 +      if (ast->kind == ZEND_AST_ZVAL) {
 +              zval *zv = zend_ast_get_zval(ast);
 +              return zv->u2.lineno;
 +      } else {
 +              return ast->lineno;
 +      }
 +}
 +
 +static inline zend_ast *zend_ast_create_zval(zval *zv) {
 +      return zend_ast_create_zval_ex(zv, 0);
 +}
 +static inline zend_ast *zend_ast_create_zval_from_str(zend_string *str) {
 +      zval zv;
 +      ZVAL_STR(&zv, str);
 +      return zend_ast_create_zval(&zv);
 +}
- static inline zend_ast *zend_ast_create_binary_op(zend_uint opcode, zend_ast *op0, zend_ast *op1) {
++static inline zend_ast *zend_ast_create_zval_from_long(zend_long lval) {
 +      zval zv;
 +      ZVAL_LONG(&zv, lval);
 +      return zend_ast_create_zval(&zv);
 +}
 +
- static inline zend_ast *zend_ast_create_assign_op(zend_uint opcode, zend_ast *op0, zend_ast *op1) {
++static inline zend_ast *zend_ast_create_binary_op(uint32_t opcode, zend_ast *op0, zend_ast *op1) {
 +      return zend_ast_create_ex(ZEND_AST_BINARY_OP, opcode, op0, op1);
 +}
- static inline zend_ast *zend_ast_create_cast(zend_uint type, zend_ast *op0) {
++static inline zend_ast *zend_ast_create_assign_op(uint32_t opcode, zend_ast *op0, zend_ast *op1) {
 +      return zend_ast_create_ex(ZEND_AST_ASSIGN_OP, opcode, op0, op1);
 +}
++static inline zend_ast *zend_ast_create_cast(uint32_t type, zend_ast *op0) {
 +      return zend_ast_create_ex(ZEND_AST_CAST, type, op0);
 +}
  
  #endif

diff --cc Zend/zend_compile.c
index 4b292d5bef46d00dee389dfbe32df36acd30277b,7595e1addefdbc8576856e86a8befc06d8308faa..346ba66e3f9dda95dbc8d2c442beaea82a0b1c01
--- 1/Zend/zend_compile.c
--- 2/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@@ -60,29 -60,34 +60,29 @@@
                target = src; \
        } while (0)
  
- static inline void zend_alloc_cache_slot(zend_uint literal TSRMLS_DC) {
 -#define GET_CACHE_SLOT(literal) do { \
 -              Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot++; \
 -              if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
 -                      CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
 -                      CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \
 -              } \
 -      } while (0)
++static inline void zend_alloc_cache_slot(uint32_t literal TSRMLS_DC) {
 +      zend_op_array *op_array = CG(active_op_array);
 +      Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot++;
 +      if ((op_array->fn_flags & ZEND_ACC_INTERACTIVE) && op_array->run_time_cache) {
 +              op_array->run_time_cache = erealloc(op_array->run_time_cache,
 +                      op_array->last_cache_slot * sizeof(void*));
 +              op_array->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL;
 +      }
 +}
  
  #define POLYMORPHIC_CACHE_SLOT_SIZE 2
  
- static inline void zend_alloc_polymorphic_cache_slot(zend_uint literal TSRMLS_DC) {
 -#define GET_POLYMORPHIC_CACHE_SLOT(literal) do { \
 -              Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot; \
 -              CG(active_op_array)->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE; \
 -              if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
 -                      CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
 -                      CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \
 -                      CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 2] = NULL; \
 -              } \
 -      } while (0)
 -
 -#define FREE_POLYMORPHIC_CACHE_SLOT(literal) do { \
 -              if (Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) != -1 && \
 -                  Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) == \
 -                  CG(active_op_array)->last_cache_slot - POLYMORPHIC_CACHE_SLOT_SIZE) { \
 -                      Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = -1; \
 -                      CG(active_op_array)->last_cache_slot -= POLYMORPHIC_CACHE_SLOT_SIZE; \
 -              } \
 -      } while (0)
++static inline void zend_alloc_polymorphic_cache_slot(uint32_t literal TSRMLS_DC) {
 +      zend_op_array *op_array = CG(active_op_array);
 +      Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot;
 +      op_array->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE;
 +      if ((op_array->fn_flags & ZEND_ACC_INTERACTIVE) && op_array->run_time_cache) {
 +              op_array->run_time_cache = erealloc(
 +                      op_array->run_time_cache, op_array->last_cache_slot * sizeof(void *));
 +              op_array->run_time_cache[op_array->last_cache_slot - 1] = NULL;
 +              op_array->run_time_cache[op_array->last_cache_slot - 2] = NULL;
 +      }
 +}
  
  ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
  ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename TSRMLS_DC);
@@@ -135,27 -147,13 +135,27 @@@ static void zend_destroy_property_info_
  }
  /* }}} */
  
 -static void build_runtime_defined_function_key(zval *result, const char *name, int name_length TSRMLS_DC) /* {{{ */
 -{
 +static zend_string *zend_new_interned_string_safe(zend_string *str TSRMLS_DC) {
 +      zend_string *interned_str;
 +
-       STR_ADDREF(str);
++      zend_string_addref(str);
 +      interned_str = zend_new_interned_string(str TSRMLS_CC);
 +      if (str != interned_str) {
 +              return interned_str;
 +      } else {
-               STR_RELEASE(str);
++              zend_string_release(str);
 +              return str;
 +      }
 +}
 +
 +static zend_string *zend_build_runtime_definition_key(
 +      zend_string *name, unsigned char *lex_pos TSRMLS_DC
 +) {
 +      zend_string *result;
        char char_pos_buf[32];
 -      uint char_pos_len;
 -      const char *filename;
 +      size_t char_pos_len = zend_sprintf(char_pos_buf, "%p", lex_pos);
  
 -      char_pos_len = zend_sprintf(char_pos_buf, "%p", LANG_SCNG(yy_text));
 +      const char *filename;
        if (CG(active_op_array)->filename) {
                filename = CG(active_op_array)->filename->val;
        } else {
@@@ -163,12 -161,13 +163,12 @@@
        }
  
        /* NULL, name length, filename length, last accepting char position length */
-       result = STR_ALLOC(1 + name->len + strlen(filename) + char_pos_len, 0);
 -      ZVAL_NEW_STR(result, zend_string_alloc(1+name_length+strlen(filename)+char_pos_len, 0));
++      result = zend_string_alloc(1 + name->len + strlen(filename) + char_pos_len, 0);
  
 -      /* must be binary safe */
 -      Z_STRVAL_P(result)[0] = '\0';
 -      sprintf(Z_STRVAL_P(result)+1, "%s%s%s", name, filename, char_pos_buf);
 +      result->val[0] = '\0';
 +      sprintf(result->val + 1, "%s%s%s", name->val, filename, char_pos_buf);
 +      return result;
  }
 -/* }}} */
  
  static void init_compiler_declarables(TSRMLS_D) /* {{{ */
  {
@@@ -420,23 -429,32 +420,23 @@@ static int zend_add_ns_func_name_litera
  }
  /* }}} */
  
 -static int zend_add_class_name_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
 -{
 +static int zend_add_class_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) {
        int ret;
        zend_string *lc_name;
 -      zval c;
  
 -      if (op_array->last_literal > 0 &&
 -          &op_array->literals[op_array->last_literal - 1] == zv &&
 -          Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
 -              /* we already have function name as last literal (do nothing) */
 -              ret = op_array->last_literal - 1;
 -      } else {
 -              ret = zend_add_literal(op_array, zv TSRMLS_CC);
 -      }
 +      zval zv;
 +      ZVAL_STR(&zv, name);
  
 -      if (Z_STRVAL_P(zv)[0] == '\\') {
 -              lc_name = zend_string_alloc(Z_STRLEN_P(zv) - 1, 0);
 -              zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv) + 1, Z_STRLEN_P(zv) - 1);
 -      } else {
 -              lc_name = zend_string_alloc(Z_STRLEN_P(zv), 0);
 -              zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
 -      }
 -      ZVAL_NEW_STR(&c, lc_name);
 -      zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 +      ret = zend_add_literal(op_array, &zv TSRMLS_CC);
 +      name = Z_STR(zv); /* Load new name string in case it was interned */
 +
-       lc_name = STR_ALLOC(name->len, 0);
++      lc_name = zend_string_alloc(name->len, 0);
 +      zend_str_tolower_copy(lc_name->val, name->val, name->len);
  
 -      GET_CACHE_SLOT(ret);
 +      ZVAL_NEW_STR(&zv, lc_name);
 +      zend_add_literal(CG(active_op_array), &zv TSRMLS_CC);
 +
 +      zend_alloc_cache_slot(ret TSRMLS_CC);
  
        return ret;
  }
@@@ -625,254 -605,512 +625,254 @@@ void zend_do_free(znode *op1 TSRMLS_DC
  }
  /* }}} */
  
- zend_uint zend_add_member_modifier(zend_uint flags, zend_uint new_flag) {
-       zend_uint new_flags = flags | new_flag;
 -void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
 -{
 -      int last_op_number = get_next_op_number(CG(active_op_array));
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      if (last_op_number > 0) {
 -              zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1];
++uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag) {
++      uint32_t new_flags = flags | new_flag;
 +      if ((flags & ZEND_ACC_PPP_MASK) && (new_flag & ZEND_ACC_PPP_MASK)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed");
 +      }
 +      if ((flags & ZEND_ACC_ABSTRACT) && (new_flag & ZEND_ACC_ABSTRACT)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed");
 +      }
 +      if ((flags & ZEND_ACC_STATIC) && (new_flag & ZEND_ACC_STATIC)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed");
 +      }
 +      if ((flags & ZEND_ACC_FINAL) && (new_flag & ZEND_ACC_FINAL)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed");
 +      }
 +      if ((new_flags & ZEND_ACC_ABSTRACT) && (new_flags & ZEND_ACC_FINAL)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member");
 +      }
 +      return new_flags;
 +}
  
 -              switch (last_op->opcode) {
 -                      case ZEND_FETCH_OBJ_RW:
 -                              last_op->opcode = op;
 -                              last_op->extended_value = ZEND_ASSIGN_OBJ;
 +zend_string *zend_concat3(
 +      char *str1, size_t str1_len, char *str2, size_t str2_len, char *str3, size_t str3_len
 +) {
 +      size_t len = str1_len + str2_len + str3_len;
-       zend_string *res = STR_ALLOC(len, 0);
++      zend_string *res = zend_string_alloc(len, 0);
  
 -                              zend_do_op_data(opline, op2 TSRMLS_CC);
 -                              SET_UNUSED(opline->result);
 -                              GET_NODE(result, last_op->result);
 -                              return;
 -                      case ZEND_FETCH_DIM_RW:
 -                              last_op->opcode = op;
 -                              last_op->extended_value = ZEND_ASSIGN_DIM;
 -
 -                              zend_do_op_data(opline, op2 TSRMLS_CC);
 -                              opline->op2.var = get_temporary_variable(CG(active_op_array));
 -                              opline->op2_type = IS_VAR;
 -                              SET_UNUSED(opline->result);
 -                              GET_NODE(result,last_op->result);
 -                              return;
 -                      default:
 -                              break;
 -              }
 -      }
 +      memcpy(res->val, str1, str1_len);
 +      memcpy(res->val + str1_len, str2, str2_len);
 +      memcpy(res->val + str1_len + str2_len, str3, str3_len);
 +      res->val[len] = '\0';
  
 -      opline->opcode = op;
 -      SET_NODE(opline->op1, op1);
 -      SET_NODE(opline->op2, op2);
 -      opline->result_type = IS_VAR;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      GET_NODE(result, opline->result);
 +      return res;
  }
 -/* }}} */
  
 -void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) /* {{{ */
 -{
 -      zend_op opline;
 -      zend_op *opline_ptr;
 -
 -      if (varname->op_type == IS_CONST) {
 -              if (Z_TYPE(varname->u.constant) != IS_STRING) {
 -                      convert_to_string(&varname->u.constant);
 -              }
 -
 -              if (!zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) &&
 -                  !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
 -                    !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1)) &&
 -                  (CG(active_op_array)->last == 0 ||
 -                   CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) {
 -                      result->op_type = IS_CV;
 -                      result->u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
 -                      Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)];
 -                      result->EA = 0;
 -                      return;
 -              }
 -      }
 +zend_string *zend_concat_names(char *name1, size_t name1_len, char *name2, size_t name2_len) {
 +      return zend_concat3(name1, name1_len, "\\", 1, name2, name2_len);
 +}
  
 -      if (bp) {
 -              opline_ptr = &opline;
 -              init_op(opline_ptr TSRMLS_CC);
 +zend_string *zend_prefix_with_ns(zend_string *name TSRMLS_DC) {
 +      if (CG(current_namespace)) {
 +              zend_string *ns = CG(current_namespace);
 +              return zend_concat_names(ns->val, ns->len, name->val, name->len);
        } else {
-               return STR_COPY(name);
 -              opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC);
++              return zend_string_copy(name);
        }
 +}
  
 -      opline_ptr->opcode = op;
 -      opline_ptr->result_type = IS_VAR;
 -      opline_ptr->result.var = get_temporary_variable(CG(active_op_array));
 -      SET_NODE(opline_ptr->op1, varname);
 -      GET_NODE(result, opline_ptr->result);
 -      SET_UNUSED(opline_ptr->op2);
 -      opline_ptr->extended_value = ZEND_FETCH_LOCAL;
 +void *zend_hash_find_ptr_lc(HashTable *ht, char *str, size_t len) {
 +      void *result;
-       zend_string *lcname = STR_ALLOC(len, 0);
++      zend_string *lcname = zend_string_alloc(len, 0);
 +      zend_str_tolower_copy(lcname->val, str, len);
 +      result = zend_hash_find_ptr(ht, lcname);
-       STR_FREE(lcname);
++      zend_string_free(lcname);
 +      return result;
 +}
  
 -      if (varname->op_type == IS_CONST) {
 -              if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) {
 -                      opline_ptr->extended_value = ZEND_FETCH_GLOBAL;
 -              }
 +zend_string *zend_resolve_non_class_name(
-       zend_string *name, zend_uint type, zend_bool *is_fully_qualified,
++      zend_string *name, uint32_t type, zend_bool *is_fully_qualified,
 +      zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC
 +) {
 +      char *compound;
 +      *is_fully_qualified = 0;
 +
 +      if (name->val[0] == '\\') {
 +              /* Remove \ prefix (only relevant if this is a string rather than a label) */
-               return STR_INIT(name->val + 1, name->len - 1, 0);
++              return zend_string_init(name->val + 1, name->len - 1, 0);
        }
  
 -      if (bp) {
 -              zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
 -              zend_llist_add_element(fetch_list_ptr, opline_ptr);
 +      if (type == ZEND_NAME_FQ) {
 +              *is_fully_qualified = 1;
-               return STR_COPY(name);
++              return zend_string_copy(name);
        }
 -}
 -/* }}} */
  
 -void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) /* {{{ */
 -{
 -      /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
 -      fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC);
 -}
 -/* }}} */
 +      if (type == ZEND_NAME_RELATIVE) {
 +              *is_fully_qualified = 1;
 +              return zend_prefix_with_ns(name TSRMLS_CC);
 +      }
  
 -void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
 -{
 -      znode class_node;
 -      zend_llist *fetch_list_ptr;
 -      zend_llist_element *le;
 -      zend_op *opline_ptr;
 -      zend_op opline;
 -
 -      if (class_name->op_type == IS_CONST &&
 -          ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
 -              zend_resolve_class_name(class_name TSRMLS_CC);
 -              class_node = *class_name;
 -      } else {
 -              zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
 -      }
 -      fetch_list_ptr = zend_stack_top(&CG(bp_stack));
 -      if (result->op_type == IS_CV) {
 -              init_op(&opline TSRMLS_CC);
 -
 -              opline.opcode = ZEND_FETCH_W;
 -              opline.result_type = IS_VAR;
 -              opline.result.var = get_temporary_variable(CG(active_op_array));
 -              opline.op1_type = IS_CONST;
 -              LITERAL_STR(opline.op1, zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)]));
 -              GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
 -              if (class_node.op_type == IS_CONST) {
 -                      opline.op2_type = IS_CONST;
 -                      opline.op2.constant =
 -                              zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
 +      if (current_import_sub) {
 +              /* If an unqualified name is a function/const alias, replace it. */
 +              zend_string *import_name;
 +              if (case_sensitive) {
 +                      import_name = zend_hash_find_ptr(current_import_sub, name);
                } else {
 -                      SET_NODE(opline.op2, &class_node);
 +                      import_name = zend_hash_find_ptr_lc(current_import_sub, name->val, name->len);
                }
 -              GET_NODE(result,opline.result);
 -              opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;
 -              opline_ptr = &opline;
  
 -              zend_llist_add_element(fetch_list_ptr, &opline);
 -      } else {
 -              le = fetch_list_ptr->head;
 -
 -              opline_ptr = (zend_op *)le->data;
 -              if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1_type == IS_CV) {
 -                      init_op(&opline TSRMLS_CC);
 -                      opline.opcode = ZEND_FETCH_W;
 -                      opline.result_type = IS_VAR;
 -                      opline.result.var = get_temporary_variable(CG(active_op_array));
 -                      opline.op1_type = IS_CONST;
 -                      LITERAL_STR(opline.op1, zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(opline_ptr->op1.var)]));
 -                      GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
 -                      if (class_node.op_type == IS_CONST) {
 -                              opline.op2_type = IS_CONST;
 -                              opline.op2.constant =
 -                                      zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
 -                      } else {
 -                              SET_NODE(opline.op2, &class_node);
 -                      }
 -                      opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;
 -                      COPY_NODE(opline_ptr->op1, opline.result);
 +              if (import_name) {
 +                      *is_fully_qualified = 1;
-                       return STR_COPY(import_name);
++                      return zend_string_copy(import_name);
 +              }
 +      }
  
 -                      zend_llist_prepend_element(fetch_list_ptr, &opline);
 -              } else {
 -                      if (opline_ptr->op1_type == IS_CONST) {
 -                              GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op1.constant);
 -                      }
 -                      if (class_node.op_type == IS_CONST) {
 -                              opline_ptr->op2_type = IS_CONST;
 -                              opline_ptr->op2.constant =
 -                                      zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
 -                      } else {
 -                              SET_NODE(opline_ptr->op2, &class_node);
 -                      }
 -                      opline_ptr->extended_value |= ZEND_FETCH_STATIC_MEMBER;
 +      compound = memchr(name->val, '\\', name->len);
 +      if (compound) {
 +              *is_fully_qualified = 1;
 +      }
 +
 +      if (compound && CG(current_import)) {
 +              /* If the first part of a qualified name is an alias, substitute it. */
 +              size_t len = compound - name->val;
 +              zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
 +
 +              if (import_name) {
 +                      return zend_concat_names(
 +                              import_name->val, import_name->len, name->val + len + 1, name->len - len - 1);
                }
        }
 +
 +      return zend_prefix_with_ns(name TSRMLS_CC);
  }
  /* }}} */
  
 -void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */
 -{
 -      fetch_simple_variable(result, varname, 1 TSRMLS_CC);
 +zend_string *zend_resolve_function_name(
-       zend_string *name, zend_uint type, zend_bool *is_fully_qualified TSRMLS_DC
++      zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC
 +) {
 +      return zend_resolve_non_class_name(
 +              name, type, is_fully_qualified, 0, CG(current_import_function) TSRMLS_CC);
 +}
  
 -      fetch_array_dim(result, result, first_dim TSRMLS_CC);
 +zend_string *zend_resolve_const_name(
-       zend_string *name, zend_uint type, zend_bool *is_fully_qualified TSRMLS_DC
++      zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC
 +) {
 +      return zend_resolve_non_class_name(
 +              name, type, is_fully_qualified, 1, CG(current_import_const) TSRMLS_CC);
  }
 -/* }}} */
  
 -void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC) /* {{{ */
 -{
 -      zend_op opline;
 -      zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
 -
 -      if (zend_is_function_or_method_call(parent)) {
 -              init_op(&opline TSRMLS_CC);
 -              opline.opcode = ZEND_SEPARATE;
 -              SET_NODE(opline.op1, parent);
 -              SET_UNUSED(opline.op2);
 -              opline.result_type = IS_VAR;
 -              opline.result.var = opline.op1.var;
 -              zend_llist_add_element(fetch_list_ptr, &opline);
 -      }
 -
 -      init_op(&opline TSRMLS_CC);
 -      opline.opcode = ZEND_FETCH_DIM_W;       /* the backpatching routine assumes W */
 -      opline.result_type = IS_VAR;
 -      opline.result.var = get_temporary_variable(CG(active_op_array));
 -      SET_NODE(opline.op1, parent);
 -      SET_NODE(opline.op2, dim);
 -      if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
 -              zend_ulong index;
 +zend_string *zend_resolve_class_name(
-       zend_string *name, zend_uint type TSRMLS_DC
++      zend_string *name, uint32_t type TSRMLS_DC
 +) {
 +      char *compound;
  
 -              if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline.op2.constant)), index)) {
 -                      zval_dtor(&CONSTANT(opline.op2.constant));
 -                      ZVAL_LONG(&CONSTANT(opline.op2.constant), index);
 +      if (type == ZEND_NAME_RELATIVE) {
 +              return zend_prefix_with_ns(name TSRMLS_CC);
 +      }
 +
 +      if (type == ZEND_NAME_FQ || name->val[0] == '\\') {
 +              /* Remove \ prefix (only relevant if this is a string rather than a label) */
 +              if (name->val[0] == '\\') {
-                       name = STR_INIT(name->val + 1, name->len - 1, 0);
++                      name = zend_string_init(name->val + 1, name->len - 1, 0);
 +              } else {
-                       STR_ADDREF(name);
++                      zend_string_addref(name);
 +              }
 +              /* Ensure that \self, \parent and \static are not used */
 +              if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", name->val);
                }
 +              return name;
        }
  
 -      GET_NODE(result, opline.result);
 +      if (CG(current_import)) {
 +              compound = memchr(name->val, '\\', name->len);
 +              if (compound) {
 +                      /* If the first part of a qualified name is an alias, substitute it. */
 +                      size_t len = compound - name->val;
 +                      zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
 +
 +                      if (import_name) {
 +                              return zend_concat_names(
 +                                      import_name->val, import_name->len, name->val + len + 1, name->len - len - 1);
 +                      }
 +              } else {
 +                      /* If an unqualified name is an alias, replace it. */
 +                      zend_string *import_name
 +                              = zend_hash_find_ptr_lc(CG(current_import), name->val, name->len);
 +
 +                      if (import_name) {
-                               return STR_COPY(import_name);
++                              return zend_string_copy(import_name);
 +                      }
 +              }
 +      }
  
 -      zend_llist_add_element(fetch_list_ptr, &opline);
 +      /* If not fully qualified and not an alias, prepend the current namespace */
 +      return zend_prefix_with_ns(name TSRMLS_CC);
  }
 -/* }}} */
  
 -void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC) /* {{{ */
 -{
 -      fetch_array_dim(result, parent, offset TSRMLS_CC);
 +zend_string *zend_resolve_class_name_ast(zend_ast *ast TSRMLS_DC) {
 +      zend_string *name = zend_ast_get_str(ast);
 +      return zend_resolve_class_name(name, ast->attr TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_print(znode *result, znode *arg TSRMLS_DC) /* {{{ */
 +static void ptr_dtor(zval *zv) /* {{{ */
  {
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      opline->result_type = IS_TMP_VAR;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      opline->opcode = ZEND_PRINT;
 -      SET_NODE(opline->op1, arg);
 -      SET_UNUSED(opline->op2);
 -      GET_NODE(result, opline->result);
 +      efree(Z_PTR_P(zv));
  }
  /* }}} */
  
 -void zend_do_echo(znode *arg TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      opline->opcode = ZEND_ECHO;
 -      SET_NODE(opline->op1, arg);
 -      SET_UNUSED(opline->op2);
 +static void str_dtor(zval *zv) {
-       STR_RELEASE(Z_STR_P(zv));
++      zend_string_release(Z_STR_P(zv));
  }
 -/* }}} */
  
 -void zend_do_abstract_method(const znode *function_name, znode *modifiers, const znode *body TSRMLS_DC) /* {{{ */
 +void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */
  {
 -      char *method_type;
 +      zend_label *dest;
-       long current, distance;
++      zend_long current, distance;
 +      zval *label;
  
 -      if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
 -              Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT;
 -              method_type = "Interface";
 +      if (pass2) {
 +              label = opline->op2.zv;
        } else {
 -              method_type = "Abstract";
 +              label = &CONSTANT_EX(op_array, opline->op2.constant);
        }
 +      if (CG(context).labels == NULL ||
 +          (dest = zend_hash_find_ptr(CG(context).labels, Z_STR_P(label))) == NULL) {
  
 -      if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) {
 -              if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
 -              }
 -              if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
 -                      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -                      opline->opcode = ZEND_RAISE_ABSTRACT_ERROR;
 -                      SET_UNUSED(opline->op1);
 -                      SET_UNUSED(opline->op2);
 +              if (pass2) {
 +                      CG(in_compilation) = 1;
 +                      CG(active_op_array) = op_array;
 +                      CG(zend_lineno) = opline->lineno;
 +                      zend_error_noreturn(E_COMPILE_ERROR, "'goto' to undefined label '%s'", Z_STRVAL_P(label));
                } else {
 -                      /* we had code in the function body */
 -                      zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
 -              }
 -      } else {
 -              if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
 +                      /* Label is not defined. Delay to pass 2. */
 +                      INC_BPC(op_array);
 +                      return;
                }
        }
 -}
 -/* }}} */
  
 -static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */
 -{
 -      if ((opline->opcode == ZEND_FETCH_W) && (opline->op1_type == IS_CONST)
 -              && (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING)
 -              && ((opline->extended_value & ZEND_FETCH_STATIC_MEMBER) != ZEND_FETCH_STATIC_MEMBER)
 -              && (Z_STRHASH(CONSTANT(opline->op1.constant)) == THIS_HASHVAL)
 -              && (Z_STRLEN(CONSTANT(opline->op1.constant)) == (sizeof("this")-1))
 -              && !memcmp(Z_STRVAL(CONSTANT(opline->op1.constant)), "this", sizeof("this") - 1)) {
 -              return 1;
 -      } else {
 -              return 0;
 -      }
 -}
 -/* }}} */
 -
 -void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC) /* {{{ */
 -{
 -      int last_op_number;
 -      zend_op *opline;
 -
 -      if (value->op_type == IS_CV) {
 -              zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
 -              if (fetch_list_ptr && fetch_list_ptr->head) {
 -                      opline = (zend_op *)fetch_list_ptr->head->data;
 -
 -                      if (opline->opcode == ZEND_FETCH_DIM_W &&
 -                          opline->op1_type == IS_CV &&
 -                          opline->op1.var == value->u.op.var) {
 -
 -                              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -                              opline->opcode = ZEND_FETCH_R;
 -                              opline->result_type = IS_VAR;
 -                              opline->result.var = get_temporary_variable(CG(active_op_array));
 -                              opline->op1_type = IS_CONST;
 -                              LITERAL_STR(opline->op1,
 -                                      zend_string_copy(CG(active_op_array)->vars[EX_VAR_TO_NUM(value->u.op.var)]));
 -                              SET_UNUSED(opline->op2);
 -                              opline->extended_value = ZEND_FETCH_LOCAL;
 -                              GET_NODE(value, opline->result);
 -                      }
 -              }
 -      }
 -
 -      zend_do_end_variable_parse(variable, BP_VAR_W, 0 TSRMLS_CC);
 -
 -      last_op_number = get_next_op_number(CG(active_op_array));
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opline->op1.opline_num = dest->opline_num;
 +      zval_dtor(label);
 +      ZVAL_NULL(label);
  
 -      if (variable->op_type == IS_CV) {
 -              if (variable->u.op.var == CG(active_op_array)->this_var) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 -              }
 -      } else if (variable->op_type == IS_VAR) {
 -              int n = 0;
 -
 -              while (last_op_number - n > 0) {
 -                      zend_op *last_op;
 -
 -                      last_op = &CG(active_op_array)->opcodes[last_op_number-n-1];
 -
 -                      if (last_op->result_type == IS_VAR &&
 -                          last_op->result.var == variable->u.op.var) {
 -                              if (last_op->opcode == ZEND_FETCH_OBJ_W) {
 -                                      if (n > 0) {
 -                                              int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
 -                                              *opline = *last_op;
 -                                              MAKE_NOP(last_op);
 -                                              /* last_op = opline; */
 -                                              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -                                              /* get_next_op can realloc, we need to move last_op */
 -                                              last_op = &CG(active_op_array)->opcodes[opline_no];
 -                                      }
 -                                      last_op->opcode = ZEND_ASSIGN_OBJ;
 -                                      zend_do_op_data(opline, value TSRMLS_CC);
 -                                      SET_UNUSED(opline->result);
 -                                      GET_NODE(result, last_op->result);
 -                                      return;
 -                              } else if (last_op->opcode == ZEND_FETCH_DIM_W) {
 -                                      if (n > 0) {
 -                                              int opline_no = (opline-CG(active_op_array)->opcodes)/sizeof(*opline);
 -                                              *opline = *last_op;
 -                                              MAKE_NOP(last_op);
 -                                              /* last_op = opline; */
 -                                              /* TBFixed: this can realloc opcodes, leaving last_op pointing wrong */
 -                                              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -                                              /* get_next_op can realloc, we need to move last_op */
 -                                              last_op = &CG(active_op_array)->opcodes[opline_no];
 -                                      }
 -                                      last_op->opcode = ZEND_ASSIGN_DIM;
 -                                      zend_do_op_data(opline, value TSRMLS_CC);
 -                                      opline->op2.var = get_temporary_variable(CG(active_op_array));
 -                                      opline->op2_type = IS_VAR;
 -                                      SET_UNUSED(opline->result);
 -                                      GET_NODE(result, last_op->result);
 -                                      return;
 -                              } else if (opline_is_fetch_this(last_op TSRMLS_CC)) {
 -                                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 -                              } else {
 -                                      break;
 -                              }
 +      /* Check that we are not moving into loop or switch */
 +      current = opline->extended_value;
 +      for (distance = 0; current != dest->brk_cont; distance++) {
 +              if (current == -1) {
 +                      if (pass2) {
 +                              CG(in_compilation) = 1;
 +                              CG(active_op_array) = op_array;
 +                              CG(zend_lineno) = opline->lineno;
                        }
 -                      n++;
 +                      zend_error_noreturn(E_COMPILE_ERROR, "'goto' into loop or switch statement is disallowed");
                }
 +              current = op_array->brk_cont_array[current].parent;
        }
  
 -      opline->opcode = ZEND_ASSIGN;
 -      SET_NODE(opline->op1, variable);
 -      SET_NODE(opline->op2, value);
 -      opline->result_type = IS_VAR;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      GET_NODE(result, opline->result);
 -}
 -/* }}} */
 -
 -void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline;
 -
 -      if (lvar->op_type == IS_CV) {
 -              if (lvar->u.op.var == CG(active_op_array)->this_var) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 -              }
 -      } else if (lvar->op_type == IS_VAR) {
 -              int last_op_number = get_next_op_number(CG(active_op_array));
 -
 -              if (last_op_number > 0) {
 -                      opline = &CG(active_op_array)->opcodes[last_op_number-1];
 -                      if (opline_is_fetch_this(opline TSRMLS_CC)) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 -                      }
 -              }
 -      }
 -
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_ASSIGN_REF;
 -      if (zend_is_function_or_method_call(rvar)) {
 -              opline->extended_value = ZEND_RETURNS_FUNCTION;
 -      } else if (rvar->EA & ZEND_PARSED_NEW) {
 -              opline->extended_value = ZEND_RETURNS_NEW;
 -      } else {
 +      if (distance == 0) {
 +              /* Nothing to break out of, optimize to ZEND_JMP */
 +              opline->opcode = ZEND_JMP;
                opline->extended_value = 0;
 -      }
 -      if (result) {
 -              opline->result_type = IS_VAR;
 -              opline->result.var = get_temporary_variable(CG(active_op_array));
 -              GET_NODE(result, opline->result);
 +              SET_UNUSED(opline->op2);
        } else {
 -              opline->result_type = IS_UNUSED | EXT_TYPE_UNUSED;
 +              /* Set real break distance */
 +              ZVAL_LONG(label, distance);
        }
 -      SET_NODE(opline->op1, lvar);
 -      SET_NODE(opline->op2, rvar);
 -}
 -/* }}} */
 -
 -static inline void do_begin_loop(TSRMLS_D) /* {{{ */
 -{
 -      zend_brk_cont_element *brk_cont_element;
 -      int parent;
 -
 -      parent = CG(context).current_brk_cont;
 -      CG(context).current_brk_cont = CG(active_op_array)->last_brk_cont;
 -      brk_cont_element = get_next_brk_cont_element(CG(active_op_array));
 -      brk_cont_element->start = get_next_op_number(CG(active_op_array));
 -      brk_cont_element->parent = parent;
 -}
 -/* }}} */
  
 -static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */
 -{
 -      if (!has_loop_var) {
 -              /* The start fileld is used to free temporary variables in case of exceptions.
 -               * We won't try to free something of we don't have loop variable.
 -               */
 -              CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].start = -1;
 +      if (pass2) {
 +              DEC_BPC(op_array);
        }
 -      CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = cont_addr;
 -      CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array));
 -      CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent;
 -}
 -/* }}} */
 -
 -void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */
 -{
 -      int while_cond_op_number = get_next_op_number(CG(active_op_array));
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      opline->opcode = ZEND_JMPZ;
 -      SET_NODE(opline->op1, expr);
 -      close_bracket_token->u.op.opline_num = while_cond_op_number;
 -      SET_UNUSED(opline->op2);
 -
 -      do_begin_loop(TSRMLS_C);
 -      INC_BPC(CG(active_op_array));
 -}
 -/* }}} */
 -
 -void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      /* add unconditional jump */
 -      opline->opcode = ZEND_JMP;
 -      opline->op1.opline_num = while_token->u.op.opline_num;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -
 -      /* update while's conditional jmp */
 -      CG(active_op_array)->opcodes[close_bracket_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
 -
 -      do_end_loop(while_token->u.op.opline_num, 0 TSRMLS_CC);
 -
 -      DEC_BPC(CG(active_op_array));
 -}
 -/* }}} */
 -
 -void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */
 -{
 -      int for_cond_op_number = get_next_op_number(CG(active_op_array));
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      opline->opcode = ZEND_JMPZNZ;
 -      SET_NODE(opline->op1, expr);  /* the conditional expression */
 -      second_semicolon_token->u.op.opline_num = for_cond_op_number;
 -      SET_UNUSED(opline->op2);
  }
  /* }}} */
  
@@@ -930,43 -1236,132 +930,43 @@@ static int generate_free_foreach_copy(c
  }
  /* }}} */
  
- static zend_uint zend_add_try_element(zend_uint try_op TSRMLS_DC) /* {{{ */
 -void zend_do_if_end(TSRMLS_D) /* {{{ */
++static uint32_t zend_add_try_element(uint32_t try_op TSRMLS_DC) /* {{{ */
  {
 -      int next_op_number = get_next_op_number(CG(active_op_array));
 -      zend_llist *jmp_list_ptr = zend_stack_top(&CG(bp_stack));
 -      zend_llist_element *le;
 +      zend_op_array *op_array = CG(active_op_array);
-       zend_uint try_catch_offset = op_array->last_try_catch++;
++      uint32_t try_catch_offset = op_array->last_try_catch++;
 +      zend_try_catch_element *elem;
  
 -      for (le=jmp_list_ptr->head; le; le = le->next) {
 -              CG(active_op_array)->opcodes[*((int *) le->data)].op1.opline_num = next_op_number;
 -      }
 -      zend_llist_destroy(jmp_list_ptr);
 -      zend_stack_del_top(&CG(bp_stack));
 -      DEC_BPC(CG(active_op_array));
 -}
 -/* }}} */
 +      op_array->try_catch_array = safe_erealloc(
 +              op_array->try_catch_array, sizeof(zend_try_catch_element), op_array->last_try_catch, 0);
  
 -void zend_check_writable_variable(const znode *variable) /* {{{ */
 -{
 -      uint32_t type = variable->EA;
 +      elem = &op_array->try_catch_array[try_catch_offset];
 +      elem->try_op = try_op;
 +      elem->catch_op = 0;
 +      elem->finally_op = 0;
 +      elem->finally_end = 0;
  
 -      if (type & ZEND_PARSED_METHOD_CALL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context");
 -      }
 -      if (type == ZEND_PARSED_FUNCTION_CALL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context");
 -      }
 +      return try_catch_offset;
  }
  /* }}} */
  
 -void zend_do_begin_variable_parse(TSRMLS_D) /* {{{ */
 +ZEND_API void function_add_ref(zend_function *function) /* {{{ */
  {
 -      zend_llist fetch_list;
 -
 -      zend_llist_init(&fetch_list, sizeof(zend_op), NULL, 0);
 -      zend_stack_push(&CG(bp_stack), (void *) &fetch_list);
 -}
 -/* }}} */
 +      if (function->type == ZEND_USER_FUNCTION) {
 +              zend_op_array *op_array = &function->op_array;
  
 -void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC) /* {{{ */
 -{
 -      zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
 -      zend_llist_element *le = fetch_list_ptr->head;
 -      zend_op *opline = NULL;
 -      zend_op *opline_ptr;
 -      uint32_t this_var = -1;
 -
 -      /* TODO: $foo->x->y->z = 1 should fetch "x" and "y" for R or RW, not just W */
 -
 -      if (le) {
 -              opline_ptr = (zend_op *)le->data;
 -              if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) {
 -                      /* convert to FETCH_?(this) into IS_CV */
 -                      if (CG(active_op_array)->last == 0 ||
 -                          CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE) {
 -
 -                              this_var = opline_ptr->result.var;
 -                              if (CG(active_op_array)->this_var == -1) {
 -                                      CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), Z_STR(CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC);
 -                                      ZVAL_UNDEF(&CONSTANT(opline_ptr->op1.constant));
 -                              } else {
 -                                      zend_del_literal(CG(active_op_array), opline_ptr->op1.constant);
 -                              }
 -                              le = le->next;
 -                              if (variable->op_type == IS_VAR &&
 -                                  variable->u.op.var == this_var) {
 -                                      variable->op_type = IS_CV;
 -                                      variable->u.op.var = CG(active_op_array)->this_var;
 -                              }
 -                      } else if (CG(active_op_array)->this_var == -1) {
 -                              CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), zend_string_init("this", sizeof("this")-1, 0) TSRMLS_CC);
 -                      }
 -              }
 +              (*op_array->refcount)++;
 +              if (op_array->static_variables) {
 +                      HashTable *static_variables = op_array->static_variables;
  
 -              while (le) {
 -                      opline_ptr = (zend_op *)le->data;
 -                      if (opline_ptr->opcode == ZEND_SEPARATE) {
 -                              if (type != BP_VAR_R && type != BP_VAR_IS) {
 -                                      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -                                      memcpy(opline, opline_ptr, sizeof(zend_op));
 -                              }
 -                              le = le->next;
 -                              continue;
 -                      }
 -                      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -                      memcpy(opline, opline_ptr, sizeof(zend_op));
 -                      if (opline->op1_type == IS_VAR &&
 -                          opline->op1.var == this_var) {
 -                              opline->op1_type = IS_CV;
 -                              opline->op1.var = CG(active_op_array)->this_var;
 -                      }
 -                      switch (type) {
 -                              case BP_VAR_R:
 -                                      if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) {
 -                                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
 -                                      }
 -                                      opline->opcode -= 3;
 -                                      break;
 -                              case BP_VAR_W:
 -                                      break;
 -                              case BP_VAR_RW:
 -                                      opline->opcode += 3;
 -                                      break;
 -                              case BP_VAR_IS:
 -                                      if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) {
 -                                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
 -                                      }
 -                                      opline->opcode += 6; /* 3+3 */
 -                                      break;
 -                              case BP_VAR_FUNC_ARG:
 -                                      opline->opcode += 9; /* 3+3+3 */
 -                                      opline->extended_value |= arg_offset;
 -                                      break;
 -                              case BP_VAR_UNSET:
 -                                      if (opline->opcode == ZEND_FETCH_DIM_W && opline->op2_type == IS_UNUSED) {
 -                                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting");
 -                                      }
 -                                      opline->opcode += 12; /* 3+3+3+3 */
 -                                      break;
 -                      }
 -                      le = le->next;
 +                      ALLOC_HASHTABLE(op_array->static_variables);
 +                      zend_array_dup(op_array->static_variables, static_variables);
                }
 -              if (opline && type == BP_VAR_W && arg_offset) {
 -                      opline->extended_value |= ZEND_FETCH_MAKE_REF;
 +              op_array->run_time_cache = NULL;
 +      } else if (function->type == ZEND_INTERNAL_FUNCTION) {
 +              if (function->common.function_name) {
-                       STR_ADDREF(function->common.function_name);
++                      zend_string_addref(function->common.function_name);
                }
        }
 -      zend_llist_destroy(fetch_list_ptr);
 -      zend_stack_del_top(&CG(bp_stack));
  }
  /* }}} */
  
@@@ -978,489 -1385,564 +978,489 @@@ static void do_inherit_parent_construct
                return;
        }
  
 -      if (op1) {
 -              SET_NODE(opline->op1, op1);
 -              SET_NODE(opline->result, op1);
 -      } else {
 -              SET_UNUSED(opline->op1);
 -              opline->result_type = IS_TMP_VAR;
 -              opline->result.var = get_temporary_variable(CG(active_op_array));
 -      }
 -      SET_NODE(opline->op2, op2);
 -      GET_NODE(result, opline->result);
 -}
 -/* }}} */
 -
 -void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      opline->opcode = ZEND_ADD_VAR;
 +      /* You cannot change create_object */
 +      ce->create_object = ce->parent->create_object;
  
 -      if (op1) {
 -              SET_NODE(opline->op1, op1);
 -              SET_NODE(opline->result, op1);
 -      } else {
 -              SET_UNUSED(opline->op1);
 -              opline->result_type = IS_TMP_VAR;
 -              opline->result.var = get_temporary_variable(CG(active_op_array));
 +      /* Inherit special functions if needed */
 +      if (!ce->get_iterator) {
 +              ce->get_iterator = ce->parent->get_iterator;
        }
 -      SET_NODE(opline->op2, op2);
 -      GET_NODE(result, opline->result);
 -}
 -/* }}} */
 -
 -void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
 -{
 -      if (op1->op_type==IS_TMP_VAR) {
 -              zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -              opline->opcode = ZEND_FREE;
 -              SET_NODE(opline->op1, op1);
 -              SET_UNUSED(opline->op2);
 -      } else if (op1->op_type==IS_VAR) {
 -              zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
 -
 -              while (opline->opcode == ZEND_END_SILENCE || opline->opcode == ZEND_EXT_FCALL_END || opline->opcode == ZEND_OP_DATA) {
 -                      opline--;
 +      if (!ce->iterator_funcs.funcs) {
 +              ce->iterator_funcs.funcs = ce->parent->iterator_funcs.funcs;
 +      }
 +      if (!ce->__get) {
 +              ce->__get   = ce->parent->__get;
 +      }
 +      if (!ce->__set) {
 +              ce->__set = ce->parent->__set;
 +      }
 +      if (!ce->__unset) {
 +              ce->__unset = ce->parent->__unset;
 +      }
 +      if (!ce->__isset) {
 +              ce->__isset = ce->parent->__isset;
 +      }
 +      if (!ce->__call) {
 +              ce->__call = ce->parent->__call;
 +      }
 +      if (!ce->__callstatic) {
 +              ce->__callstatic = ce->parent->__callstatic;
 +      }
 +      if (!ce->__tostring) {
 +              ce->__tostring = ce->parent->__tostring;
 +      }
 +      if (!ce->clone) {
 +              ce->clone = ce->parent->clone;
 +      }
 +      if(!ce->serialize) {
 +              ce->serialize = ce->parent->serialize;
 +      }
 +      if(!ce->unserialize) {
 +              ce->unserialize = ce->parent->unserialize;
 +      }
 +      if (!ce->destructor) {
 +              ce->destructor   = ce->parent->destructor;
 +      }
 +      if (!ce->__debugInfo) {
 +              ce->__debugInfo = ce->parent->__debugInfo;
 +      }
 +      if (ce->constructor) {
 +              if (ce->parent->constructor && ce->parent->constructor->common.fn_flags & ZEND_ACC_FINAL) {
 +                      zend_error(E_ERROR, "Cannot override final %s::%s() with %s::%s()",
 +                              ce->parent->name->val, ce->parent->constructor->common.function_name->val,
 +                              ce->name->val, ce->constructor->common.function_name->val
 +                              );
                }
 -              if (opline->result_type == IS_VAR
 -                      && opline->result.var == op1->u.op.var) {
 -                      if (opline->opcode == ZEND_FETCH_R ||
 -                          opline->opcode == ZEND_FETCH_DIM_R ||
 -                          opline->opcode == ZEND_FETCH_OBJ_R ||
 -                          opline->opcode == ZEND_QM_ASSIGN_VAR) {
 -                              /* It's very rare and useless case. It's better to use
 -                                 additional FREE opcode and simplify the FETCH handlers
 -                                 their selves */
 -                              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -                              opline->opcode = ZEND_FREE;
 -                              SET_NODE(opline->op1, op1);
 -                              SET_UNUSED(opline->op2);
 -                      } else {
 -                              opline->result_type |= EXT_TYPE_UNUSED;
 -                      }
 +              return;
 +      }
 +
 +      if ((function = zend_hash_str_find_ptr(&ce->parent->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1)) != NULL) {
 +              /* inherit parent's constructor */
 +              if (function->type == ZEND_INTERNAL_FUNCTION) {
 +                      new_function = pemalloc(sizeof(zend_internal_function), 1);
 +                      memcpy(new_function, function, sizeof(zend_internal_function));
                } else {
 -                      while (opline>CG(active_op_array)->opcodes) {
 -                              if (opline->opcode == ZEND_FETCH_DIM_R
 -                                  && opline->op1_type == IS_VAR
 -                                  && opline->op1.var == op1->u.op.var) {
 -                                      /* This should the end of a list() construct
 -                                       * Mark its result as unused
 -                                       */
 -                                      opline->extended_value = ZEND_FETCH_STANDARD;
 -                                      break;
 -                              } else if (opline->result_type==IS_VAR
 -                                      && opline->result.var == op1->u.op.var) {
 -                                      if (opline->opcode == ZEND_NEW) {
 -                                              opline->result_type |= EXT_TYPE_UNUSED;
 -                                              opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
 -                                              while (opline->opcode != ZEND_DO_FCALL || opline->op1.num != ZEND_CALL_CTOR) {
 -                                                      opline--;
 -                                              }
 -                                              opline->op1.num |= ZEND_CALL_CTOR_RESULT_UNUSED;
 -                                      }
 -                                      break;
 +                      new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
 +                      memcpy(new_function, function, sizeof(zend_op_array));
 +              }
 +              zend_hash_str_update_ptr(&ce->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1, new_function);
 +              function_add_ref(new_function);
 +      } else {
 +              /* Don't inherit the old style constructor if we already have the new style constructor */
 +              zend_string *lc_class_name;
 +              zend_string *lc_parent_class_name;
 +
-               lc_class_name = STR_ALLOC(ce->name->len, 0);
++              lc_class_name = zend_string_alloc(ce->name->len, 0);
 +              zend_str_tolower_copy(lc_class_name->val, ce->name->val, ce->name->len);
 +              if (!zend_hash_exists(&ce->function_table, lc_class_name)) {
-                       lc_parent_class_name = STR_ALLOC(ce->parent->name->len, 0);
++                      lc_parent_class_name = zend_string_alloc(ce->parent->name->len, 0);
 +                      zend_str_tolower_copy(lc_parent_class_name->val, ce->parent->name->val, ce->parent->name->len);
 +                      if (!zend_hash_exists(&ce->function_table, lc_parent_class_name) &&
 +                                      (function = zend_hash_find_ptr(&ce->parent->function_table, lc_parent_class_name)) != NULL) {
 +                              if (function->common.fn_flags & ZEND_ACC_CTOR) {
 +                                      /* inherit parent's constructor */
 +                                      new_function = pemalloc(sizeof(zend_function), function->type == ZEND_INTERNAL_FUNCTION);
 +                                      memcpy(new_function, function, sizeof(zend_function));
 +                                      zend_hash_update_ptr(&ce->function_table, lc_parent_class_name, new_function);
 +                                      function_add_ref(new_function);
                                }
 -                              opline--;
                        }
-                       STR_RELEASE(lc_parent_class_name);
++                      zend_string_release(lc_parent_class_name);
                }
-               STR_FREE(lc_class_name);
 -      } else if (op1->op_type == IS_CONST) {
 -              zval_dtor(&op1->u.constant);
++              zend_string_free(lc_class_name);
        }
 +      ce->constructor = ce->parent->constructor;
  }
  /* }}} */
  
- char *zend_visibility_string(zend_uint fn_flags) /* {{{ */
 -int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */
++char *zend_visibility_string(uint32_t fn_flags) /* {{{ */
  {
 -      if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK)
 -              && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed");
 -      }
 -      if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT)
 -              && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed");
 -      }
 -      if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC)
 -              && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed");
 +      if (fn_flags & ZEND_ACC_PRIVATE) {
 +              return "private";
        }
 -      if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL)
 -              && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed");
 +      if (fn_flags & ZEND_ACC_PROTECTED) {
 +              return "protected";
        }
 -      if (((Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member");
 +      if (fn_flags & ZEND_ACC_PUBLIC) {
 +              return "public";
        }
 -      return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant));
 +      return "";
  }
  /* }}} */
  
 -void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */
 +static zend_function *do_inherit_method(zend_function *old_function TSRMLS_DC) /* {{{ */
  {
 -      zend_op_array op_array;
 -      zend_string *name = Z_STR(function_name->u.constant);
 -      int function_begin_line = function_token->u.op.opline_num;
 -      uint32_t fn_flags;
 -      zend_string *lcname;
 -      zend_bool orig_interactive;
 -      ALLOCA_FLAG(use_heap)
 +      zend_function *new_function;
  
 -      if (is_method) {
 -              if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
 -                      if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
 -                      }
 -                      Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
 -              }
 -              fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */
 +      if (old_function->type == ZEND_INTERNAL_FUNCTION) {
 +              new_function = pemalloc(sizeof(zend_internal_function), 1);
 +              memcpy(new_function, old_function, sizeof(zend_internal_function));
        } else {
 -              fn_flags = 0;
 +              new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
 +              memcpy(new_function, old_function, sizeof(zend_op_array));
        }
 -      if ((fn_flags & ZEND_ACC_STATIC) && (fn_flags & ZEND_ACC_ABSTRACT) && !(CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
 -              zend_error(E_STRICT, "Static function %s%s%s() should not be abstract", is_method ? CG(active_class_entry)->name->val : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant));
 +      /* The class entry of the derived function intentionally remains the same
 +       * as that of the parent class.  That allows us to know in which context
 +       * we're running, and handle private method calls properly.
 +       */
 +      function_add_ref(new_function);
 +      return new_function;
 +}
 +/* }}} */
 +
 +static zend_bool zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto TSRMLS_DC) /* {{{ */
 +{
-       zend_uint i, num_args;
++      uint32_t i, num_args;
 +
 +      /* If it's a user function then arg_info == NULL means we don't have any parameters but
 +       * we still need to do the arg number checks.  We are only willing to ignore this for internal
 +       * functions because extensions don't always define arg_info.
 +       */
 +      if (!proto || (!proto->common.arg_info && proto->common.type != ZEND_USER_FUNCTION)) {
 +              return 1;
        }
  
 -      function_token->u.op_array = CG(active_op_array);
 +      /* Checks for constructors only if they are declared in an interface,
 +       * or explicitly marked as abstract
 +       */
 +      if ((fe->common.fn_flags & ZEND_ACC_CTOR)
 +              && ((proto->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
 +                      && (proto->common.fn_flags & ZEND_ACC_ABSTRACT) == 0)) {
 +              return 1;
 +      }
  
 -      orig_interactive = CG(interactive);
 -      CG(interactive) = 0;
 -      init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
 -      CG(interactive) = orig_interactive;
 +      /* If both methods are private do not enforce a signature */
 +    if ((fe->common.fn_flags & ZEND_ACC_PRIVATE) && (proto->common.fn_flags & ZEND_ACC_PRIVATE)) {
 +              return 1;
 +      }
  
 -      op_array.function_name = name;
 -      if (return_reference) {
 -              op_array.fn_flags |= ZEND_ACC_RETURN_REFERENCE;
 +      /* check number of arguments */
 +      if (proto->common.required_num_args < fe->common.required_num_args
 +              || proto->common.num_args > fe->common.num_args) {
 +              return 0;
        }
 -      op_array.fn_flags |= fn_flags;
  
 -      op_array.scope = is_method?CG(active_class_entry):NULL;
 -      op_array.prototype = NULL;
 +      /* by-ref constraints on return values are covariant */
 +      if ((proto->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
 +              && !(fe->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
 +              return 0;
 +      }
  
 -      op_array.line_start = zend_get_compiled_lineno(TSRMLS_C);
 +      if ((proto->common.fn_flags & ZEND_ACC_VARIADIC)
 +              && !(fe->common.fn_flags & ZEND_ACC_VARIADIC)) {
 +              return 0;
 +      }
  
 -      if (is_method) {
 -              lcname = zend_string_alloc(name->len, 0);
 -              zend_str_tolower_copy(lcname->val, name->val, name->len);
 -              lcname = zend_new_interned_string(lcname TSRMLS_CC);
 -              CG(active_op_array) = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
 -              memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array));
 -              if (zend_hash_add_ptr(&CG(active_class_entry)->function_table, lcname, CG(active_op_array)) == NULL) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name->val, name->val);
 -              }
 +      /* For variadic functions any additional (optional) arguments that were added must be
 +       * checked against the signature of the variadic argument, so in this case we have to
 +       * go through all the parameters of the function and not just those present in the
 +       * prototype. */
 +      num_args = proto->common.num_args;
 +      if ((fe->common.fn_flags & ZEND_ACC_VARIADIC)
 +              && fe->common.num_args > proto->common.num_args) {
 +              num_args = fe->common.num_args;
 +      }
  
 -              zend_stack_push(&CG(context_stack), (void *) &CG(context));
 -              zend_init_compiler_context(TSRMLS_C);
 +      for (i = 0; i < num_args; i++) {
 +              zend_arg_info *fe_arg_info = &fe->common.arg_info[i];
  
 -              if (fn_flags & ZEND_ACC_ABSTRACT) {
 -                      CG(active_class_entry)->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
 +              zend_arg_info *proto_arg_info;
 +              if (i < proto->common.num_args) {
 +                      proto_arg_info = &proto->common.arg_info[i];
 +              } else {
 +                      proto_arg_info = &proto->common.arg_info[proto->common.num_args-1];
                }
  
 -              if (!(fn_flags & ZEND_ACC_PPP_MASK)) {
 -                      fn_flags |= ZEND_ACC_PUBLIC;
 +              if (ZEND_LOG_XOR(fe_arg_info->class_name, proto_arg_info->class_name)) {
 +                      /* Only one has a type hint and the other one doesn't */
 +                      return 0;
                }
  
 -              if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
 -                      if ((name->len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
 -                              }
 -                      } else if ((name->len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
 -                              if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
 -                                      zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
 -                              }
 -                      } else if ((name->len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
 -                              }
 -                      } else if ((name->len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
 -                              }
 -                      } else if ((name->len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
 -                              }
 -                      } else if ((name->len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
 -                              }
 -                      } else if ((name->len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
 -                              }
 -                      } else if ((name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static");
 -                              }
 +              if (fe_arg_info->class_name) {
 +                      zend_string *fe_class_name, *proto_class_name;
  
 -                      } else if ((name->len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static");
 -                              }
 +                      if (!strcasecmp(fe_arg_info->class_name, "parent") && proto->common.scope) {
-                               fe_class_name = STR_COPY(proto->common.scope->name);
++                              fe_class_name = zend_string_copy(proto->common.scope->name);
 +                      } else if (!strcasecmp(fe_arg_info->class_name, "self") && fe->common.scope) {
-                               fe_class_name = STR_COPY(fe->common.scope->name);
++                              fe_class_name = zend_string_copy(fe->common.scope->name);
 +                      } else {
-                               fe_class_name = STR_INIT(
++                              fe_class_name = zend_string_init(
 +                                      fe_arg_info->class_name,
 +                                      fe_arg_info->class_name_len, 0);
                        }
 -              } else {
 -                      char *class_lcname;
 -
 -                      class_lcname = do_alloca(CG(active_class_entry)->name->len + 1, use_heap);
 -                      zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name->val, CG(active_class_entry)->name->len);
 -                      /* Improve after RC: cache the lowercase class name */
  
 -                      if ((CG(active_class_entry)->name->len == name->len) && ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) && (!memcmp(class_lcname, lcname->val, name->len))) {
 -                              if (!CG(active_class_entry)->constructor) {
 -                                      CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
 -                              }
 -                      } else if ((name->len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1))) {
 -                              if (CG(active_class_entry)->constructor) {
 -                                      zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name->val);
 -                              }
 -                              CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1))) {
 -                              CG(active_class_entry)->destructor = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1))) {
 -                              CG(active_class_entry)->clone = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
 -                              }
 -                              CG(active_class_entry)->__call = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
 -                              if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
 -                                      zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
 -                              }
 -                              CG(active_class_entry)->__callstatic = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
 -                              }
 -                              CG(active_class_entry)->__get = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
 -                              }
 -                              CG(active_class_entry)->__set = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
 -                              }
 -                              CG(active_class_entry)->__unset = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
 -                              }
 -                              CG(active_class_entry)->__isset = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
 -                              }
 -                              CG(active_class_entry)->__tostring = (zend_function *) CG(active_op_array);
 -                      } else if ((name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static");
 -                              }
 -                      } else if ((name->len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) {
 -                              if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 -                                      zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static");
 -                              }
 -                              CG(active_class_entry)->__debugInfo = (zend_function *) CG(active_op_array);
 -                      } else if (!(fn_flags & ZEND_ACC_STATIC)) {
 -                              CG(active_op_array)->fn_flags |= ZEND_ACC_ALLOW_STATIC;
 +                      if (!strcasecmp(proto_arg_info->class_name, "parent") && proto->common.scope && proto->common.scope->parent) {
-                               proto_class_name = STR_COPY(proto->common.scope->parent->name);
++                              proto_class_name = zend_string_copy(proto->common.scope->parent->name);
 +                      } else if (!strcasecmp(proto_arg_info->class_name, "self") && proto->common.scope) {
-                               proto_class_name = STR_COPY(proto->common.scope->name);
++                              proto_class_name = zend_string_copy(proto->common.scope->name);
 +                      } else {
-                               proto_class_name = STR_INIT(
++                              proto_class_name = zend_string_init(
 +                                      proto_arg_info->class_name,
 +                                      proto_arg_info->class_name_len, 0);
                        }
 -                      free_alloca(class_lcname, use_heap);
 -              }
  
 -              zend_string_release(lcname);
 -      } else {
 -              zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -              zval key;
 -              zval *ns_name;
 -
 -              if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -                      /* Prefix function name with current namespace name */
 -                      znode tmp;
 -
 -                      ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
 -                      zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC);
 -                      op_array.function_name = Z_STR(tmp.u.constant);
 -                      lcname = zend_string_alloc(Z_STRLEN(tmp.u.constant), 0);
 -                      zend_str_tolower_copy(lcname->val, Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant));
 -              } else {
 -                      lcname = zend_string_alloc(name->len, 0);
 -                      zend_str_tolower_copy(lcname->val, name->val, name->len);
 -              }
 +                      if (strcasecmp(fe_class_name->val, proto_class_name->val)!=0) {
 +                              const char *colon;
  
 -              /* Function name must not conflict with import names */
 -              if (CG(current_import_function) &&
 -                  (ns_name = zend_hash_find(CG(current_import_function), lcname)) != NULL) {
 +                              if (fe->common.type != ZEND_USER_FUNCTION) {
-                                       STR_RELEASE(proto_class_name);
-                                       STR_RELEASE(fe_class_name);
++                                      zend_string_release(proto_class_name);
++                                      zend_string_release(fe_class_name);
 +                                      return 0;
 +                          } else if (strchr(proto_class_name->val, '\\') != NULL ||
 +                                              (colon = zend_memrchr(fe_class_name->val, '\\', fe_class_name->len)) == NULL ||
 +                                              strcasecmp(colon+1, proto_class_name->val) != 0) {
 +                                      zend_class_entry *fe_ce, *proto_ce;
  
 -                      char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
 +                                      fe_ce = zend_lookup_class(fe_class_name TSRMLS_CC);
 +                                      proto_ce = zend_lookup_class(proto_class_name TSRMLS_CC);
  
 -                      if (Z_STRLEN_P(ns_name) != Z_STRLEN(function_name->u.constant) ||
 -                              memcmp(tmp, lcname->val, Z_STRLEN(function_name->u.constant))) {
 -                              zend_error(E_COMPILE_ERROR, "Cannot declare function %s because the name is already in use", Z_STRVAL(function_name->u.constant));
 +                                      /* Check for class alias */
 +                                      if (!fe_ce || !proto_ce ||
 +                                                      fe_ce->type == ZEND_INTERNAL_CLASS ||
 +                                                      proto_ce->type == ZEND_INTERNAL_CLASS ||
 +                                                      fe_ce != proto_ce) {
-                                               STR_RELEASE(proto_class_name);
-                                               STR_RELEASE(fe_class_name);
++                                              zend_string_release(proto_class_name);
++                                              zend_string_release(fe_class_name);
 +                                              return 0;
 +                                      }
 +                              }
                        }
-                       STR_RELEASE(proto_class_name);
-                       STR_RELEASE(fe_class_name);
 -                      efree(tmp);
++                      zend_string_release(proto_class_name);
++                      zend_string_release(fe_class_name);
 +              }
 +              if (fe_arg_info->type_hint != proto_arg_info->type_hint) {
 +                      /* Incompatible type hint */
 +                      return 0;
                }
  
 -              opline->opcode = ZEND_DECLARE_FUNCTION;
 -              opline->op1_type = IS_CONST;
 -              build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC);
 -              opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
 -              opline->op2_type = IS_CONST;
 -              LITERAL_STR(opline->op2, zend_string_copy(lcname));
 -              opline->extended_value = ZEND_DECLARE_FUNCTION;
 -              CG(active_op_array) = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
 -              memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array));
 -              zend_hash_update_ptr(CG(function_table), Z_STR(key), CG(active_op_array));
 -              zend_stack_push(&CG(context_stack), (void *) &CG(context));
 -              zend_init_compiler_context(TSRMLS_C);
 -              zend_string_release(lcname);
 +              /* by-ref constraints on arguments are invariant */
 +              if (fe_arg_info->pass_by_reference != proto_arg_info->pass_by_reference) {
 +                      return 0;
 +              }
        }
  
 -      if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
 -              zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      return 1;
 +}
 +/* }}} */
  
 -              opline->opcode = ZEND_EXT_NOP;
 -              opline->lineno = function_begin_line;
 -              SET_UNUSED(opline->op1);
 -              SET_UNUSED(opline->op2);
 +#define REALLOC_BUF_IF_EXCEED(buf, offset, length, size) \
 +      if (UNEXPECTED(offset - buf + size >= length)) {        \
 +              length += size + 1;                             \
 +              buf = erealloc(buf, length);            \
        }
  
 -      {
 -              /* Push a separator to the switch stack */
 -              zend_switch_entry switch_entry;
 -
 -              switch_entry.cond.op_type = IS_UNUSED;
 -              switch_entry.default_case = 0;
 -              switch_entry.control_var = 0;
 +static char *zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */
 +{
 +      char *offset, *buf;
-       zend_uint length = 1024;
++      uint32_t length = 1024;
  
 -              zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry);
 +      offset = buf = (char *)emalloc(length * sizeof(char));
 +      if (fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
 +              *(offset++) = '&';
 +              *(offset++) = ' ';
        }
  
 -      {
 -              /* Push a separator to the foreach stack */
 -              zend_op dummy_opline;
 -
 -              dummy_opline.result_type = IS_UNUSED;
 -
 -              zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline);
 +      if (fptr->common.scope) {
 +              memcpy(offset, fptr->common.scope->name->val, fptr->common.scope->name->len);
 +              offset += fptr->common.scope->name->len;
 +              *(offset++) = ':';
 +              *(offset++) = ':';
        }
  
 -      if (CG(doc_comment)) {
 -              CG(active_op_array)->doc_comment = CG(doc_comment);
 -              CG(doc_comment) = NULL;
 +      {
 +              size_t name_len = fptr->common.function_name->len;
 +              REALLOC_BUF_IF_EXCEED(buf, offset, length, name_len);
 +              memcpy(offset, fptr->common.function_name->val, name_len);
 +              offset += name_len;
        }
 -}
 -/* }}} */
 -
 -void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC) /* {{{ */
 -{
 -      znode          function_name;
 -      zend_op_array *current_op_array = CG(active_op_array);
 -      int            current_op_number = get_next_op_number(CG(active_op_array));
 -      zend_op       *current_op;
 -
 -      function_name.op_type = IS_CONST;
 -      ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1);
  
 -      zend_do_begin_function_declaration(function_token, &function_name, 0, return_reference, NULL TSRMLS_CC);
 +      *(offset++) = '(';
 +      if (fptr->common.arg_info) {
-               zend_uint i, required;
++              uint32_t i, required;
 +              zend_arg_info *arg_info = fptr->common.arg_info;
  
 -      result->op_type = IS_TMP_VAR;
 -      result->u.op.var = get_temporary_variable(current_op_array);
 +              required = fptr->common.required_num_args;
 +              for (i = 0; i < fptr->common.num_args;) {
 +                      if (arg_info->class_name) {
 +                              const char *class_name;
-                               zend_uint class_name_len;
++                              uint32_t class_name_len;
 +                              if (!strcasecmp(arg_info->class_name, "self") && fptr->common.scope ) {
 +                                      class_name = fptr->common.scope->name->val;
 +                                      class_name_len = fptr->common.scope->name->len;
 +                              } else if (!strcasecmp(arg_info->class_name, "parent") && fptr->common.scope->parent) {
 +                                      class_name = fptr->common.scope->parent->name->val;
 +                                      class_name_len = fptr->common.scope->parent->name->len;
 +                              } else {
 +                                      class_name = arg_info->class_name;
 +                                      class_name_len = arg_info->class_name_len;
 +                              }
 +                              REALLOC_BUF_IF_EXCEED(buf, offset, length, class_name_len);
 +                              memcpy(offset, class_name, class_name_len);
 +                              offset += class_name_len;
 +                              *(offset++) = ' ';
 +                      } else if (arg_info->type_hint) {
-                               zend_uint type_name_len;
++                              uint32_t type_name_len;
 +                              char *type_name = zend_get_type_by_const(arg_info->type_hint);
 +                              type_name_len = strlen(type_name);
 +                              REALLOC_BUF_IF_EXCEED(buf, offset, length, type_name_len);
 +                              memcpy(offset, type_name, type_name_len);
 +                              offset += type_name_len;
 +                              *(offset++) = ' ';
 +                      }
  
 -      current_op = &current_op_array->opcodes[current_op_number];
 -      current_op->opcode = ZEND_DECLARE_LAMBDA_FUNCTION;
 -      zend_del_literal(current_op_array, current_op->op2.constant);
 -      SET_UNUSED(current_op->op2);
 -      SET_NODE(current_op->result, result);
 -      if (is_static) {
 -              CG(active_op_array)->fn_flags |= ZEND_ACC_STATIC;
 -      }
 -      CG(active_op_array)->fn_flags |= ZEND_ACC_CLOSURE;
 -}
 -/* }}} */
 +                      if (arg_info->pass_by_reference) {
 +                              *(offset++) = '&';
 +                      }
  
 -void zend_do_handle_exception(TSRMLS_D) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +                      if (arg_info->is_variadic) {
 +                              *(offset++) = '.';
 +                              *(offset++) = '.';
 +                              *(offset++) = '.';
 +                      }
  
 -      opline->opcode = ZEND_HANDLE_EXCEPTION;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -}
 -/* }}} */
 +                      *(offset++) = '$';
  
 -void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC) /* {{{ */
 -{
 -      char lcname[16];
 -      int name_len;
 +                      if (arg_info->name) {
 +                              REALLOC_BUF_IF_EXCEED(buf, offset, length, arg_info->name_len);
 +                              memcpy(offset, arg_info->name, arg_info->name_len);
 +                              offset += arg_info->name_len;
 +                      } else {
-                               zend_uint idx = i;
++                              uint32_t idx = i;
 +                              memcpy(offset, "param", 5);
 +                              offset += 5;
 +                              do {
 +                                      *(offset++) = (char) (idx % 10) + '0';
 +                                      idx /= 10;
 +                              } while (idx > 0);
 +                      }
 +                      if (i >= required && !arg_info->is_variadic) {
 +                              *(offset++) = ' ';
 +                              *(offset++) = '=';
 +                              *(offset++) = ' ';
 +                              if (fptr->type == ZEND_USER_FUNCTION) {
 +                                      zend_op *precv = NULL;
 +                                      {
-                                               zend_uint idx  = i;
++                                              uint32_t idx  = i;
 +                                              zend_op *op = ((zend_op_array *)fptr)->opcodes;
 +                                              zend_op *end = op + ((zend_op_array *)fptr)->last;
  
 -      zend_do_extended_info(TSRMLS_C);
 -      zend_do_return(NULL, 0 TSRMLS_CC);
 +                                              ++idx;
 +                                              while (op < end) {
 +                                                      if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT)
 +                                                                      && op->op1.num == (long)idx)
 +                                                      {
 +                                                              precv = op;
 +                                                      }
 +                                                      ++op;
 +                                              }
 +                                      }
 +                                      if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) {
 +                                              zval *zv = precv->op2.zv;
  
 -      pass_two(CG(active_op_array) TSRMLS_CC);
 -      zend_release_labels(0 TSRMLS_CC);
 +                                              if (Z_TYPE_P(zv) == IS_CONSTANT) {
 +                                                      REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN_P(zv));
 +                                                      memcpy(offset, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
 +                                                      offset += Z_STRLEN_P(zv);
 +                                              } else if (Z_TYPE_P(zv) == IS_FALSE) {
 +                                                      memcpy(offset, "false", 5);
 +                                                      offset += 5;
 +                                              } else if (Z_TYPE_P(zv) == IS_TRUE) {
 +                                                      memcpy(offset, "true", 4);
 +                                                      offset += 4;
 +                                              } else if (Z_TYPE_P(zv) == IS_NULL) {
 +                                                      memcpy(offset, "NULL", 4);
 +                                                      offset += 4;
 +                                              } else if (Z_TYPE_P(zv) == IS_STRING) {
 +                                                      *(offset++) = '\'';
 +                                                      REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRLEN_P(zv), 10));
 +                                                      memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10));
 +                                                      offset += MIN(Z_STRLEN_P(zv), 10);
 +                                                      if (Z_STRLEN_P(zv) > 10) {
 +                                                              *(offset++) = '.';
 +                                                              *(offset++) = '.';
 +                                                              *(offset++) = '.';
 +                                                      }
 +                                                      *(offset++) = '\'';
 +                                              } else if (Z_TYPE_P(zv) == IS_ARRAY) {
 +                                                      memcpy(offset, "Array", 5);
 +                                                      offset += 5;
 +                                              } else if (Z_TYPE_P(zv) == IS_CONSTANT_AST) {
 +                                                      memcpy(offset, "<expression>", 12);
 +                                                      offset += 12;
 +                                              } else {
 +                                                      zend_string *str = zval_get_string(zv);
 +                                                      REALLOC_BUF_IF_EXCEED(buf, offset, length, str->len);
 +                                                      memcpy(offset, str->val, str->len);
 +                                                      offset += str->len;
-                                                       STR_RELEASE(str);
++                                                      zend_string_release(str);
 +                                              }
 +                                      }
 +                              } else {
 +                                      memcpy(offset, "NULL", 4);
 +                                      offset += 4;
 +                              }
 +                      }
  
 -      if (CG(active_class_entry)) {
 -              zend_check_magic_method_implementation(CG(active_class_entry), (zend_function*)CG(active_op_array), E_COMPILE_ERROR TSRMLS_CC);
 -      } else {
 -              /* we don't care if the function name is longer, in fact lowercasing only
 -               * the beginning of the name speeds up the check process */
 -              name_len = CG(active_op_array)->function_name->len;
 -              zend_str_tolower_copy(lcname, CG(active_op_array)->function_name->val, MIN(name_len, sizeof(lcname)-1));
 -              lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
 -              if (name_len == sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)) && CG(active_op_array)->num_args != 1) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument", ZEND_AUTOLOAD_FUNC_NAME);
 +                      if (++i < fptr->common.num_args) {
 +                              *(offset++) = ',';
 +                              *(offset++) = ' ';
 +                      }
 +                      arg_info++;
 +                      REALLOC_BUF_IF_EXCEED(buf, offset, length, 32);
                }
        }
 +      *(offset++) = ')';
 +      *offset = '\0';
  
 -      CG(active_op_array)->line_end = zend_get_compiled_lineno(TSRMLS_C);
 -      CG(active_op_array) = function_token->u.op_array;
 -
 -
 -      /* Pop the switch and foreach separators */
 -      zend_stack_del_top(&CG(switch_cond_stack));
 -      zend_stack_del_top(&CG(foreach_copy_stack));
 +      return buf;
  }
  /* }}} */
  
 -void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_uchar pass_by_reference, zend_bool is_variadic TSRMLS_DC) /* {{{ */
 +static void do_inheritance_check_on_method(zend_function *child, zend_function *parent TSRMLS_DC) /* {{{ */
  {
-       zend_uint child_flags;
-       zend_uint parent_flags = parent->common.fn_flags;
 -      zend_op *opline;
 -      zend_arg_info *cur_arg_info;
 -      znode var;
++      uint32_t child_flags;
++      uint32_t parent_flags = parent->common.fn_flags;
  
 -      if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant));
 -      } else {
 -              var.op_type = IS_CV;
 -              var.u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
 -              Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(var.u.op.var)];
 -              var.EA = 0;
 -              if (EX_VAR_TO_NUM(var.u.op.var) != CG(active_op_array)->num_args) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s", Z_STRVAL(varname->u.constant));
 -              } else if (Z_STRHASH(varname->u.constant) == THIS_HASHVAL &&
 -                      Z_STRLEN(varname->u.constant) == sizeof("this")-1 &&
 -                  !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) {
 -                      if (CG(active_op_array)->scope &&
 -                          (CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) == 0) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 -                      }
 -                      CG(active_op_array)->this_var = var.u.op.var;
 -              }
 +      if ((parent->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
 +              && parent->common.fn_flags & ZEND_ACC_ABSTRACT
 +              && parent->common.scope != (child->common.prototype ? child->common.prototype->common.scope : child->common.scope)
 +              && child->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_IMPLEMENTED_ABSTRACT)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Can't inherit abstract function %s::%s() (previously declared abstract in %s)",
 +                      parent->common.scope->name->val,
 +                      child->common.function_name->val,
 +                      child->common.prototype ? child->common.prototype->common.scope->name->val : child->common.scope->name->val);
        }
  
 -      if (CG(active_op_array)->fn_flags & ZEND_ACC_VARIADIC) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic");
 +      if (parent_flags & ZEND_ACC_FINAL) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot override final method %s::%s()", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val);
        }
  
 -      if (is_variadic) {
 -              if (op == ZEND_RECV_INIT) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Variadic parameter cannot have a default value");
 +      child_flags     = child->common.fn_flags;
 +      /* You cannot change from static to non static and vice versa.
 +       */
 +      if ((child_flags & ZEND_ACC_STATIC) != (parent_flags & ZEND_ACC_STATIC)) {
 +              if (child->common.fn_flags & ZEND_ACC_STATIC) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non static method %s::%s() static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
 +              } else {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot make static method %s::%s() non static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
                }
 +      }
  
 -              op = ZEND_RECV_VARIADIC;
 -              CG(active_op_array)->fn_flags |= ZEND_ACC_VARIADIC;
 +      /* Disallow making an inherited method abstract. */
 +      if ((child_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_ABSTRACT)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non abstract method %s::%s() abstract in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
        }
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      CG(active_op_array)->num_args++;
 -      opline->opcode = op;
 -      SET_NODE(opline->result, &var);
 -      opline->op1_type = IS_UNUSED;
 -      opline->op1.num = CG(active_op_array)->num_args;
 -      if (op == ZEND_RECV_INIT) {
 -              SET_NODE(opline->op2, initialization);
 +      if (parent_flags & ZEND_ACC_CHANGED) {
 +              child->common.fn_flags |= ZEND_ACC_CHANGED;
        } else {
 -              SET_UNUSED(opline->op2);
 -              if (!is_variadic) {
 -                      CG(active_op_array)->required_num_args = CG(active_op_array)->num_args;
 -              }
 -      }
 -      CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args));
 -      cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1];
 -      cur_arg_info->name = estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant));
 -      cur_arg_info->name_len = Z_STRLEN(varname->u.constant);
 -      cur_arg_info->type_hint = 0;
 -      cur_arg_info->pass_by_reference = pass_by_reference;
 -      cur_arg_info->allow_null = 1;
 -      cur_arg_info->is_variadic = is_variadic;
 -      cur_arg_info->class_name = NULL;
 -      cur_arg_info->class_name_len = 0;
 -
 -      if (class_type->op_type != IS_UNUSED) {
 -              cur_arg_info->allow_null = 0;
 -
 -              if (Z_TYPE(class_type->u.constant) != IS_NULL) {
 -                      if (Z_TYPE(class_type->u.constant) == IS_ARRAY) {
 -                              cur_arg_info->type_hint = IS_ARRAY;
 -                              if (op == ZEND_RECV_INIT) {
 -                                      if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
 -                                              cur_arg_info->allow_null = 1;
 -                                      } else if (Z_TYPE(initialization->u.constant) != IS_ARRAY) {
 -                                              zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with array type hint can only be an array or NULL");
 -                                      }
 -                              }
 -                      } else if (Z_TYPE(class_type->u.constant) == IS_CALLABLE) {
 -                              cur_arg_info->type_hint = IS_CALLABLE;
 -                              if (op == ZEND_RECV_INIT) {
 -                                      if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
 -                                              cur_arg_info->allow_null = 1;
 -                                      } else {
 -                                              zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with callable type hint can only be NULL");
 -                                      }
 -                              }
 -                      } else {
 -                              cur_arg_info->type_hint = IS_OBJECT;
 -                              if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) {
 -                                      zend_resolve_class_name(class_type TSRMLS_CC);
 -                              }
 -                              Z_STR(class_type->u.constant) = zend_new_interned_string(Z_STR(class_type->u.constant) TSRMLS_CC);
 -                              if (IS_INTERNED(Z_STR(class_type->u.constant))) {
 -                                      Z_TYPE_FLAGS(class_type->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
 -                              }
 -// TODO: for now we have to copy it ???
 -#if 1
 -                              cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant));
 -                              cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
 -                              zend_string_release(Z_STR(class_type->u.constant));
 -#else
 -                              cur_arg_info->class_name = Z_STRVAL(class_type->u.constant);
 -                              cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
 -#endif
 -                              if (op == ZEND_RECV_INIT) {
 -                                      if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
 -                                              cur_arg_info->allow_null = 1;
 -                                      } else {
 -                                              zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with a class type hint can only be NULL");
 -                                      }
 -                              }
 -                      }
 +              /* Prevent derived classes from restricting access that was available in parent classes
 +               */
 +              if ((child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
 +              } else if (((child_flags & ZEND_ACC_PPP_MASK) < (parent_flags & ZEND_ACC_PPP_MASK))
 +                      && ((parent_flags & ZEND_ACC_PPP_MASK) & ZEND_ACC_PRIVATE)) {
 +                      child->common.fn_flags |= ZEND_ACC_CHANGED;
                }
        }
  
@@@ -1488,21 -1952,47 +1488,21 @@@
  }
  /* }}} */
  
 -int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */
 +static zend_bool do_inherit_method_check(HashTable *child_function_table, zend_function *parent, zend_string *key, zend_class_entry *child_ce) /* {{{ */
  {
-       zend_uint parent_flags = parent->common.fn_flags;
 -      zend_op *opline;
 -      uint32_t op_number;
 -      zend_function *function;
 -      zend_string *lcname;
 -      char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
 -
 -      zend_resolve_function_name(function_name, &check_namespace TSRMLS_CC);
 -
 -      if (check_namespace && Z_TYPE(CG(current_namespace)) != IS_UNDEF && !is_compound) {
 -                      /* We assume we call function from the current namespace
 -                      if it is not prefixed. */
++      uint32_t parent_flags = parent->common.fn_flags;
 +      zend_function *child;
 +      TSRMLS_FETCH();
  
 -                      /* In run-time PHP will check for function with full name and
 -                      internal function with short name */
 -                      zend_do_begin_dynamic_function_call(function_name, 1 TSRMLS_CC);
 -                      return 1;
 +      if ((child = zend_hash_find_ptr(child_function_table, key)) == NULL) {
 +              if (parent_flags & (ZEND_ACC_ABSTRACT)) {
 +                      child_ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
 +              }
 +              return 1; /* method doesn't exist in child, copy from parent */
        }
  
 -      lcname = zend_string_alloc(Z_STRLEN(function_name->u.constant), 0);
 -      zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant));
 -      if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) ||
 -              ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
 -              (function->type == ZEND_INTERNAL_FUNCTION))) {
 -                      zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC);
 -                      efree(lcname);
 -                      return 1; /* Dynamic */
 -      }
 -      zend_string_release(Z_STR(function_name->u.constant));
 -      Z_STR(function_name->u.constant) = lcname;
 -
 -      op_number = get_next_op_number(CG(active_op_array));
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_INIT_FCALL;
 -      SET_UNUSED(opline->op1);
 -      SET_NODE(opline->op2, function_name);
 -      GET_CACHE_SLOT(opline->op2.constant);
 +      do_inheritance_check_on_method(child, parent TSRMLS_CC);
  
 -      zend_push_function_call_entry(function, op_number TSRMLS_CC);
 -      zend_do_extended_fcall_begin(TSRMLS_C);
        return 0;
  }
  /* }}} */
@@@ -1566,39 -2089,78 +1566,39 @@@ static inline void do_implement_interfa
  }
  /* }}} */
  
 -void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC) /* {{{ */
 +ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface TSRMLS_DC) /* {{{ */
  {
 -      znode tmp;
 -      int len;
 -      zval *ns;
 -      zend_string *lookup_name;
 -      char *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
 -
 -      if (Z_STRVAL(element_name->u.constant)[0] == '\\') {
 -              /* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */
 -              memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant));
 -              --Z_STRLEN(element_name->u.constant);
 -              return;
 -      }
 +      /* expects interface to be contained in ce's interface list already */
-       zend_uint i, ce_num, if_num = iface->num_interfaces;
++      uint32_t i, ce_num, if_num = iface->num_interfaces;
 +      zend_class_entry *entry;
  
 -      if(!*check_namespace) {
 +      if (if_num==0) {
                return;
        }
 +      ce_num = ce->num_interfaces;
  
 -      if (current_import_sub) {
 -              len = Z_STRLEN(element_name->u.constant);
 -              if (case_sensitive) {
 -                      lookup_name = zend_string_init(Z_STRVAL(element_name->u.constant), len, 0);
 -              } else {
 -                      lookup_name = zend_string_alloc(len, 0);
 -                      zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len);
 -              }
 -              /* Check if function/const matches imported name */
 -              if ((ns = zend_hash_find(current_import_sub, lookup_name)) != NULL) {
 -                      zval_dtor(&element_name->u.constant);
 -                      ZVAL_DUP(&element_name->u.constant, ns);
 -                      zend_string_free(lookup_name);
 -                      *check_namespace = 0;
 -                      return;
 -              }
 -              zend_string_free(lookup_name);
 +      if (ce->type == ZEND_INTERNAL_CLASS) {
 +              ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
 +      } else {
 +              ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
        }
  
 -      if (compound && CG(current_import)) {
 -              len = compound - Z_STRVAL(element_name->u.constant);
 -              /* namespace is always lowercase */
 -              lookup_name = zend_string_alloc(len, 0);
 -              zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len);
 -              /* Check if first part of compound name is an import name */
 -              if ((ns = zend_hash_find(CG(current_import), lookup_name)) != NULL) {
 -                      /* Substitute import name */
 -                      tmp.op_type = IS_CONST;
 -                      ZVAL_DUP(&tmp.u.constant, ns);
 -                      len += 1;
 -                      Z_STRLEN(element_name->u.constant) -= len;
 -                      memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1);
 -                      zend_do_build_namespace_name(&tmp, &tmp, element_name TSRMLS_CC);
 -                      *element_name = tmp;
 -                      zend_string_free(lookup_name);
 -                      *check_namespace = 0;
 -                      return;
 +      /* Inherit the interfaces, only if they're not already inherited by the class */
 +      while (if_num--) {
 +              entry = iface->interfaces[if_num];
 +              for (i = 0; i < ce_num; i++) {
 +                      if (ce->interfaces[i] == entry) {
 +                              break;
 +                      }
 +              }
 +              if (i == ce_num) {
 +                      ce->interfaces[ce->num_interfaces++] = entry;
                }
 -              zend_string_free(lookup_name);
        }
  
 -      if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -              tmp = *element_name;
 -              Z_STR(tmp.u.constant) = zend_string_alloc(sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN(CG(current_namespace)), 0);
 -              Z_TYPE_FLAGS(tmp.u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
 -              memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
 -              memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace))]), "\\", sizeof("\\")-1);
 -              memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
 -              zend_string_release(Z_STR(element_name->u.constant));
 -              *element_name = tmp;
 +      /* and now call the implementing handlers */
 +      while (ce_num < ce->num_interfaces) {
 +              do_implement_interface(ce, ce->interfaces[ce_num++] TSRMLS_CC);
        }
  }
  /* }}} */
@@@ -1806,140 -2481,225 +1806,140 @@@ static void do_inherit_iface_constant(z
  }
  /* }}} */
  
 -int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */
 +ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
  {
-       zend_uint i, ignore = 0;
-       zend_uint current_iface_num = ce->num_interfaces;
-       zend_uint parent_iface_num  = ce->parent ? ce->parent->num_interfaces : 0;
 -      znode class_node;
 -      uint32_t op_number;
 -      zend_op *opline;
++      uint32_t i, ignore = 0;
++      uint32_t current_iface_num = ce->num_interfaces;
++      uint32_t parent_iface_num  = ce->parent ? ce->parent->num_interfaces : 0;
 +      zend_function *func;
 +      zend_string *key;
 +      zval *zv;
  
 -      if (method_name->op_type == IS_CONST) {
 -              char *lcname;
 -              if (Z_TYPE(method_name->u.constant) != IS_STRING) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
 -              }
 -              lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant));
 -              if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) &&
 -                  memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == 0) {
 -                      zval_dtor(&method_name->u.constant);
 -                      method_name->op_type = IS_UNUSED;
 -              }
 -              efree(lcname);
 -      }
 -
 -      if (class_name->op_type == IS_CONST &&
 -          ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
 -              zend_resolve_class_name(class_name TSRMLS_CC);
 -              class_node = *class_name;
 -              op_number = get_next_op_number(CG(active_op_array));
 -              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      } else {
 -              zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
 -              op_number = get_next_op_number(CG(active_op_array));
 -              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      for (i = 0; i < ce->num_interfaces; i++) {
 +              if (ce->interfaces[i] == NULL) {
 +                      memmove(ce->interfaces + i, ce->interfaces + i + 1, sizeof(zend_class_entry*) * (--ce->num_interfaces - i));
 +                      i--;
 +              } else if (ce->interfaces[i] == iface) {
 +                      if (i < parent_iface_num) {
 +                              ignore = 1;
 +                      } else {
 +                              zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ce->name->val, iface->name->val);
 +                      }
 +              }
        }
 -      opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
 -      if (class_node.op_type == IS_CONST) {
 -              opline->op1_type = IS_CONST;
 -              opline->op1.constant =
 -                      zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
 +      if (ignore) {
 +              /* Check for attempt to redeclare interface constants */
 +              ZEND_HASH_FOREACH_STR_KEY_VAL(&ce->constants_table, key, zv) {
 +                      do_inherit_constant_check(&iface->constants_table, zv, key, iface);
 +              } ZEND_HASH_FOREACH_END();
        } else {
 -              SET_NODE(opline->op1, &class_node);
 -      }
 -      if (method_name->op_type == IS_CONST) {
 -              opline->op2_type = IS_CONST;
 -              opline->op2.constant =
 -                      zend_add_func_name_literal(CG(active_op_array), &method_name->u.constant TSRMLS_CC);
 -              if (opline->op1_type == IS_CONST) {
 -                      GET_CACHE_SLOT(opline->op2.constant);
 -              } else {
 -                      GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant);
 +              if (ce->num_interfaces >= current_iface_num) {
 +                      if (ce->type == ZEND_INTERNAL_CLASS) {
 +                              ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
 +                      } else {
 +                              ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
 +                      }
                }
 -      } else {
 -              SET_NODE(opline->op2, method_name);
 -      }
 +              ce->interfaces[ce->num_interfaces++] = iface;
  
 -      zend_push_function_call_entry(NULL, op_number TSRMLS_CC);
 -      zend_do_extended_fcall_begin(TSRMLS_C);
 -      return 1; /* Dynamic */
 +              ZEND_HASH_FOREACH_STR_KEY_VAL(&iface->constants_table, key, zv) {
 +                      do_inherit_iface_constant(key, zv, ce, iface TSRMLS_CC);
 +              } ZEND_HASH_FOREACH_END();
 +
 +              ZEND_HASH_FOREACH_STR_KEY_PTR(&iface->function_table, key, func) {
 +                      if (do_inherit_method_check(&ce->function_table, func, key, ce)) {
 +                              zend_function *new_func = do_inherit_method(func TSRMLS_CC);
 +                              zend_hash_add_new_ptr(&ce->function_table, key, new_func);
 +                      }
 +              } ZEND_HASH_FOREACH_END();
 +
 +              do_implement_interface(ce, iface TSRMLS_CC);
 +              zend_do_inherit_interfaces(ce, iface TSRMLS_CC);
 +      }
  }
  /* }}} */
  
 -static int zend_do_convert_call(zend_op *init_opline, zend_op *opline, zend_long num_args, zend_function **func_ptr TSRMLS_DC)  /* {{{ */
 +ZEND_API void zend_do_implement_trait(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */
  {
-       zend_uint i, ignore = 0;
-       zend_uint current_trait_num = ce->num_traits;
-       zend_uint parent_trait_num  = ce->parent ? ce->parent->num_traits : 0;
 -      zval *function_name;
 -      zend_string *lcname;
 -      zend_function *function;
 -
 -      *func_ptr = NULL;
 -      if (opline->op1_type == IS_CONST && Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING) {
 -              function_name = &CONSTANT(opline->op1.constant);
 -              lcname = zend_string_alloc(Z_STRLEN_P(function_name), 0);
 -              zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
 -              if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) ||
 -                      ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
 -                      (function->type == ZEND_INTERNAL_FUNCTION))) {
 -                      function = NULL;
 -                      zend_string_release(lcname);
 -                      opline->opcode = ZEND_INIT_USER_CALL;
 -                      opline->extended_value = num_args;
 -                      opline->op2_type = opline->op1_type;
 -                      opline->op2 = opline->op1;
 -                      opline->op1_type = IS_CONST;
 -                      opline->op1 = init_opline->op2;
 -                      SET_UNUSED(opline->result);
 -                      MAKE_NOP(init_opline);
 -                      return 1;
 -              } else {
 -                      zend_string_release(Z_STR_P(function_name));
 -                      Z_STR_P(function_name) = zend_new_interned_string(lcname TSRMLS_CC);
 -                      opline->opcode = ZEND_INIT_FCALL;
 -                      opline->extended_value = num_args;
 -                      opline->op2_type = IS_CONST;
 -                      opline->op2.constant = opline->op1.constant;
 -                      GET_CACHE_SLOT(opline->op2.constant);
 -                      SET_UNUSED(opline->op1);
 -                      SET_UNUSED(opline->result);                                                             
 -                      MAKE_NOP(init_opline);
 -                      *func_ptr = function;
 -                      return 1;
++      uint32_t i, ignore = 0;
++      uint32_t current_trait_num = ce->num_traits;
++      uint32_t parent_trait_num  = ce->parent ? ce->parent->num_traits : 0;
 +
 +      for (i = 0; i < ce->num_traits; i++) {
 +              if (ce->traits[i] == NULL) {
 +                      memmove(ce->traits + i, ce->traits + i + 1, sizeof(zend_class_entry*) * (--ce->num_traits - i));
 +                      i--;
 +              } else if (ce->traits[i] == trait) {
 +                      if (i < parent_trait_num) {
 +                              ignore = 1;
 +                      }
                }
 -      } else {
 -              opline->opcode = ZEND_INIT_USER_CALL;
 -              opline->extended_value = num_args;
 -              opline->op2_type = opline->op1_type;
 -              opline->op2 = opline->op1;
 -              opline->op1_type = IS_CONST;
 -              opline->op1 = init_opline->op2;
 -              SET_UNUSED(opline->result);
 -              MAKE_NOP(init_opline);
 -              return 1;
        }
 -      return 0;
 +      if (!ignore) {
 +              if (ce->num_traits >= current_trait_num) {
 +                      if (ce->type == ZEND_INTERNAL_CLASS) {
 +                              ce->traits = (zend_class_entry **) realloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
 +                      } else {
 +                              ce->traits = (zend_class_entry **) erealloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
 +                      }
 +              }
 +              ce->traits[ce->num_traits++] = trait;
 +      }
  }
  /* }}} */
  
 -static int zend_do_convert_call_user_func(zend_op *init_opline, uint32_t num_args TSRMLS_DC) /* {{{ */
 +static zend_bool zend_traits_method_compatibility_check(zend_function *fn, zend_function *other_fn TSRMLS_DC) /* {{{ */
  {
-       zend_uint    fn_flags = fn->common.scope->ce_flags;
-       zend_uint other_flags = other_fn->common.scope->ce_flags;
 -      zend_op *opline = init_opline + 1;
 -      int level = 0;
 -      int converted = 0;
 -      uint32_t arg_num = 0;
 -      zend_function *func = NULL;
 -
 -      while (1) {
 -              switch (opline->opcode) {
 -                      case ZEND_SEND_VAL:
 -                      case ZEND_SEND_VAL_EX:
 -                      case ZEND_SEND_VAR:
 -                      case ZEND_SEND_VAR_EX:
 -                      case ZEND_SEND_VAR_NO_REF:
 -                      case ZEND_SEND_REF:
 -                      case ZEND_SEND_UNPACK:
 -                              if (level == 0) {
 -                                      if (!converted) {
 -                                              if (opline->opcode == ZEND_SEND_UNPACK) {
 -                                                      return 0;
 -                                              }
 -                                              if (!zend_do_convert_call(init_opline, opline, init_opline->extended_value - 1, &func TSRMLS_CC)) {
 -                                                      return 0;
 -                                              }
 -                                              converted = 1;
 -                                      } else {
 -                                              /* Use ZEND_SEND_USER instruction for parameters that may pass by reference */
 -                                              if (opline->opcode != ZEND_SEND_VAL &&
 -                                                  (func == NULL || 
 -                                                   ARG_SHOULD_BE_SENT_BY_REF(func, opline->op2.num-1))) {
 -                                                      opline->opcode = ZEND_SEND_USER;
 -                                              }
 -                                              opline->op2.num--;
 -                                      }
 -                                      if (++arg_num == num_args) {
 -                                              return 1;
 -                                      }
 -                              }
 -                              break;
 -                      case ZEND_INIT_FCALL_BY_NAME:
 -                      case ZEND_INIT_NS_FCALL_BY_NAME:
 -                      case ZEND_NEW:
 -                      case ZEND_INIT_METHOD_CALL:
 -                      case ZEND_INIT_STATIC_METHOD_CALL:
 -                      case ZEND_INIT_FCALL:
 -                              level++;
 -                              break;
 -                      case ZEND_DO_FCALL:
 -                              level--;
 -                              break;
 -              }
 -              opline++;
 -      }
++      uint32_t    fn_flags = fn->common.scope->ce_flags;
++      uint32_t other_flags = other_fn->common.scope->ce_flags;
 +
 +      return zend_do_perform_implementation_check(fn, other_fn TSRMLS_CC)
 +              && ((other_fn->common.scope->ce_flags & ZEND_ACC_INTERFACE) || zend_do_perform_implementation_check(other_fn, fn TSRMLS_CC))
 +              && ((fn_flags & (ZEND_ACC_FINAL|ZEND_ACC_STATIC)) ==
 +                  (other_flags & (ZEND_ACC_FINAL|ZEND_ACC_STATIC))); /* equal final and static qualifier */
  }
  /* }}} */
  
 -static int zend_do_convert_call_user_func_array(zend_op *init_opline TSRMLS_DC) /* {{{ */
 +static void zend_add_magic_methods(zend_class_entry* ce, zend_string* mname, zend_function* fe TSRMLS_DC) /* {{{ */
  {
 -      zend_op *opline = init_opline + 1;
 -      zend_op *send1 = NULL, *send2 = NULL;
 -      int level = 0;
 -      zend_function *func;
 -
 -      do {
 -              switch (opline->opcode) {
 -                      case ZEND_SEND_VAL:
 -                      case ZEND_SEND_VAL_EX:
 -                      case ZEND_SEND_VAR:
 -                      case ZEND_SEND_VAR_EX:
 -                      case ZEND_SEND_VAR_NO_REF:
 -                      case ZEND_SEND_REF:
 -                      case ZEND_SEND_UNPACK:
 -                              if (level == 0) {
 -                                      if (opline->opcode == ZEND_SEND_UNPACK) {
 -                                              return 0;
 -                                      }
 -                                      if (send1 == NULL) {
 -                                              send1 = opline;
 -                                      } else {
 -                                              send2 = opline;
 -                                      }
 -                              }
 -                              break;
 -                      case ZEND_INIT_FCALL_BY_NAME:
 -                      case ZEND_INIT_NS_FCALL_BY_NAME:
 -                      case ZEND_NEW:
 -                      case ZEND_INIT_METHOD_CALL:
 -                      case ZEND_INIT_STATIC_METHOD_CALL:
 -                      case ZEND_INIT_FCALL:
 -                              level++;
 -                              break;
 -                      case ZEND_DO_FCALL:
 -                              level--;
 -                              break;
 +      if (!strncmp(mname->val, ZEND_CLONE_FUNC_NAME, mname->len)) {
 +              ce->clone = fe; fe->common.fn_flags |= ZEND_ACC_CLONE;
 +      } else if (!strncmp(mname->val, ZEND_CONSTRUCTOR_FUNC_NAME, mname->len)) {
 +              if (ce->constructor) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name->val);
                }
 -              opline++;
 -      } while (send2 == NULL);
 -
 -      if (!zend_do_convert_call(init_opline, send1, 0, &func TSRMLS_CC)) {
 -              return 0;
 +              ce->constructor = fe; fe->common.fn_flags |= ZEND_ACC_CTOR;
 +      } else if (!strncmp(mname->val, ZEND_DESTRUCTOR_FUNC_NAME,  mname->len)) {
 +              ce->destructor = fe; fe->common.fn_flags |= ZEND_ACC_DTOR;
 +      } else if (!strncmp(mname->val, ZEND_GET_FUNC_NAME, mname->len)) {
 +              ce->__get = fe;
 +      } else if (!strncmp(mname->val, ZEND_SET_FUNC_NAME, mname->len)) {
 +              ce->__set = fe;
 +      } else if (!strncmp(mname->val, ZEND_CALL_FUNC_NAME, mname->len)) {
 +              ce->__call = fe;
 +      } else if (!strncmp(mname->val, ZEND_UNSET_FUNC_NAME, mname->len)) {
 +              ce->__unset = fe;
 +      } else if (!strncmp(mname->val, ZEND_ISSET_FUNC_NAME, mname->len)) {
 +              ce->__isset = fe;
 +      } else if (!strncmp(mname->val, ZEND_CALLSTATIC_FUNC_NAME, mname->len)) {
 +              ce->__callstatic = fe;
 +      } else if (!strncmp(mname->val, ZEND_TOSTRING_FUNC_NAME, mname->len)) {
 +              ce->__tostring = fe;
 +      } else if (!strncmp(mname->val, ZEND_DEBUGINFO_FUNC_NAME, mname->len)) {
 +              ce->__debugInfo = fe;
 +      } else if (ce->name->len == mname->len) {
-               zend_string *lowercase_name = STR_ALLOC(ce->name->len, 0);
++              zend_string *lowercase_name = zend_string_alloc(ce->name->len, 0);
 +              zend_str_tolower_copy(lowercase_name->val, ce->name->val, ce->name->len);
 +              lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC);
 +              if (!memcmp(mname->val, lowercase_name->val, mname->len)) {
 +                      if (ce->constructor) {
 +                              zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name->val);
 +                      }
 +                      ce->constructor = fe;
 +                      fe->common.fn_flags |= ZEND_ACC_CTOR;
 +              }
-               STR_RELEASE(lowercase_name);
++              zend_string_release(lowercase_name);
        }
 -
 -      send2->opcode = ZEND_SEND_ARRAY;
 -      send2->extended_value = 0;
 -      send2->op2.num--;
 -      return 1;
  }
  /* }}} */
  
@@@ -2034,68 -2799,155 +2034,68 @@@ static void zend_fixup_trait_method(zen
  }
  /* }}} */
  
 -static int zend_do_convert_defined(zend_op *init_opline, znode *result TSRMLS_DC) /* {{{ */
 +static int zend_traits_copy_functions(zend_string *fnname, zend_function *fn, zend_class_entry *ce, HashTable **overriden, HashTable *exclude_table TSRMLS_DC) /* {{{ */
  {
 -      zval c;
 -      zend_string *lc_name;
 -      zend_op *opline = init_opline + 1;
 +      zend_trait_alias  *alias, **alias_ptr;
 +      zend_string       *lcname;
 +      zend_function      fn_copy;
  
 -      if (opline->opcode != ZEND_SEND_VAL ||
 -              opline->op1_type != IS_CONST ||
 -              Z_TYPE(CONSTANT(opline->op1.constant)) != IS_STRING
 -              || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), '\\', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL
 -              || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), ':', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL) {
 -              return 0;
 -      }
 +      /* apply aliases which are qualified with a class name, there should not be any ambiguity */
 +      if (ce->trait_aliases) {
 +              alias_ptr = ce->trait_aliases;
 +              alias = *alias_ptr;
 +              while (alias) {
 +                      /* Scope unset or equal to the function we compare to, and the alias applies to fn */
 +                      if (alias->alias != NULL
 +                              && (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
 +                              && alias->trait_method->method_name->len == fnname->len
 +                              && (zend_binary_strcasecmp(alias->trait_method->method_name->val, alias->trait_method->method_name->len, fnname->val, fnname->len) == 0)) {
 +                              fn_copy = *fn;
  
 -      MAKE_NOP(init_opline);
 -      opline->opcode = ZEND_DEFINED;
 -      opline->extended_value = 0;
 -      GET_CACHE_SLOT(opline->op1.constant);
 -      /* lowcase constant name */
 -      lc_name = zend_string_alloc(Z_STRLEN(CONSTANT(opline->op1.constant)), 0);
 -      zend_str_tolower_copy(lc_name->val, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));
 -      ZVAL_NEW_STR(&c, lc_name);
 -      zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      opline->result_type = IS_TMP_VAR;
 -      GET_NODE(result, opline->result);
 -      return 1;
 -}
 -/* }}} */
 +                              /* if it is 0, no modifieres has been changed */
 +                              if (alias->modifiers) {
 +                                      fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
 +                              }
  
-                               lcname = STR_ALLOC(alias->alias->len, 0);
 -void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline;
 -      zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack));
++                              lcname = zend_string_alloc(alias->alias->len, 0);
 +                              zend_str_tolower_copy(lcname->val, alias->alias->val, alias->alias->len);
 +                              zend_add_trait_method(ce, alias->alias->val, lcname, &fn_copy, overriden TSRMLS_CC);
-                               STR_RELEASE(lcname);
++                              zend_string_release(lcname);
  
 -      if (is_method && function_name && function_name->op_type == IS_UNUSED) {
 -              /* clone */
 -              if (fcall->arg_num != 0) {
 -                      zend_error(E_WARNING, "Clone method does not require arguments");
 +                              /* Record the trait from which this alias was resolved. */
 +                              if (!alias->trait_method->ce) {
 +                                      alias->trait_method->ce = fn->common.scope;
 +                              }
 +                      }
 +                      alias_ptr++;
 +                      alias = *alias_ptr;
                }
 -              opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)];
 -      } else {
 -              uint32_t call_flags = 0;
 +      }
  
 -              opline = &CG(active_op_array)->opcodes[fcall->op_number];
 -              opline->extended_value = fcall->arg_num;
 +      if (exclude_table == NULL || zend_hash_find(exclude_table, fnname) == NULL) {
 +              /* is not in hashtable, thus, function is not to be excluded */
 +              fn_copy = *fn;
  
 -              if (opline->opcode == ZEND_NEW) {
 -                      call_flags = ZEND_CALL_CTOR;
 -              } else {
 -                      zend_function *func = fcall->fbc;
 -                      if (func && func->type == ZEND_INTERNAL_FUNCTION) {
 -                              /* Convert calls to some internal functions into built-ins */
 -                              if (func->common.function_name->len == sizeof("call_user_func")-1 &&
 -                                  memcmp(func->common.function_name->val, "call_user_func", sizeof("call_user_func")-1) == 0) {
 -                                      if (fcall->arg_num > 0) {
 -                                              if (zend_do_convert_call_user_func(opline, fcall->arg_num TSRMLS_CC)) {
 -                                                      fcall->arg_num--;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("call_user_func_array")-1 &&
 -                                         memcmp(func->common.function_name->val, "call_user_func_array", sizeof("call_user_func_array")-1) == 0) {
 -                                      if (fcall->arg_num == 2) {
 -                                              if (zend_do_convert_call_user_func_array(opline TSRMLS_CC)) {
 -                                                      fcall->arg_num = 0;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("defined")-1 &&
 -                                         memcmp(func->common.function_name->val, "defined", sizeof("defined")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_defined(opline, result TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 -                                      }
 -                              } else if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN) == 0 &&
 -                                         func->common.function_name->len == sizeof("strlen")-1 &&
 -                                         memcmp(func->common.function_name->val, "strlen", sizeof("strlen")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_strlen(opline, result TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("is_null")-1 &&
 -                                              memcmp(func->common.function_name->val, "is_null", sizeof("is_null")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_type_check(opline, result, IS_NULL TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("is_bool")-1 &&
 -                                              memcmp(func->common.function_name->val, "is_bool", sizeof("is_bool")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_type_check(opline, result, _IS_BOOL TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("is_long")-1 &&
 -                                              memcmp(func->common.function_name->val, "is_long", sizeof("is_long")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_type_check(opline, result, IS_LONG TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("is_float")-1 &&
 -                                              memcmp(func->common.function_name->val, "is_float", sizeof("is_float")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_type_check(opline, result, IS_DOUBLE TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("is_string")-1 &&
 -                                              memcmp(func->common.function_name->val, "is_string", sizeof("is_string")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_type_check(opline, result, IS_STRING TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("is_array")-1 &&
 -                                              memcmp(func->common.function_name->val, "is_array", sizeof("is_array")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_type_check(opline, result, IS_ARRAY TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("is_object")-1 &&
 -                                              memcmp(func->common.function_name->val, "is_object", sizeof("is_object")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_type_check(opline, result, IS_OBJECT TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 -                                      }
 -                              } else if (func->common.function_name->len == sizeof("is_resouce")-1 &&
 -                                              memcmp(func->common.function_name->val, "is_resource", sizeof("is_resource")-1) == 0) {
 -                                      if (fcall->arg_num == 1) {
 -                                              if (zend_do_convert_type_check(opline, result, IS_RESOURCE TSRMLS_CC)) {
 -                                                      zend_stack_del_top(&CG(function_call_stack));
 -                                                      return;
 -                                              }
 +              /* apply aliases which have not alias name, just setting visibility */
 +              if (ce->trait_aliases) {
 +                      alias_ptr = ce->trait_aliases;
 +                      alias = *alias_ptr;
 +                      while (alias) {
 +                              /* Scope unset or equal to the function we compare to, and the alias applies to fn */
 +                              if (alias->alias == NULL && alias->modifiers != 0
 +                                      && (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
 +                                      && (alias->trait_method->method_name->len == fnname->len)
 +                                      && (zend_binary_strcasecmp(alias->trait_method->method_name->val, alias->trait_method->method_name->len, fnname->val, fnname->len) == 0)) {
 +
 +                                      fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
 +
 +                                      /** Record the trait from which this alias was resolved. */
 +                                      if (!alias->trait_method->ce) {
 +                                              alias->trait_method->ce = fn->common.scope;
                                        }
                                }
 +                              alias_ptr++;
 +                              alias = *alias_ptr;
                        }
                }
  
@@@ -2106,191 -2967,158 +2106,191 @@@
  }
  /* }}} */
  
 -void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC) /* {{{ */
 +static void zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */
  {
-       zend_uint i;
 -      zend_op *opline;
 -      int original_op = op;
 -      zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack));
 -      zend_function *function_ptr = fcall->fbc;
 -      int send_by_reference = 0;
 -      int send_function = 0;
 -
 -      fcall->arg_num++;
 -
 -      if (fcall->uses_argument_unpacking) {
 -              zend_error_noreturn(E_COMPILE_ERROR,
 -                      "Cannot use positional argument after argument unpacking");
 -      }
++      uint32_t i;
  
 -      if (op == ZEND_SEND_VAR && (param->op_type & (IS_CONST|IS_TMP_VAR))) {
 -              /* Function call was converted into builtin instruction */
 -              zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
 -              zend_llist_destroy(fetch_list_ptr);
 -              zend_stack_del_top(&CG(bp_stack));
 -              original_op = op = ZEND_SEND_VAL;
 +      if ((trait->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", trait->name->val);
        }
  
 -      if (original_op == ZEND_SEND_REF) {
 -              if (function_ptr &&
 -                  function_ptr->common.function_name &&
 -                  function_ptr->common.type == ZEND_USER_FUNCTION &&
 -                  !ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) {
 -                      zend_error_noreturn(E_COMPILE_ERROR,
 -                                              "Call-time pass-by-reference has been removed; "
 -                                              "If you would like to pass argument by reference, modify the declaration of %s().",
 -                                              function_ptr->common.function_name->val);
 -              } else {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Call-time pass-by-reference has been removed");
 +      for (i = 0; i < ce->num_traits; i++) {
 +              if (ce->traits[i] == trait) {
 +                      return;
                }
 -              return;
        }
 +      zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", trait->name->val, ce->name->val);
 +}
 +/* }}} */
 +
 +static void zend_traits_init_trait_structures(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 +{
 +      size_t i, j = 0;
 +      zend_trait_precedence *cur_precedence;
 +      zend_trait_method_reference *cur_method_ref;
 +      zend_string *lcname;
 +      zend_bool method_exists;
 +
 +      /* resolve class references */
 +      if (ce->trait_precedences) {
 +              i = 0;
 +              while ((cur_precedence = ce->trait_precedences[i])) {
 +                      /** Resolve classes for all precedence operations. */
 +                      if (cur_precedence->exclude_from_classes) {
 +                              cur_method_ref = cur_precedence->trait_method;
 +                              if (!(cur_precedence->trait_method->ce = zend_fetch_class(cur_method_ref->class_name,
 +                                                              ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
 +                                      zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name->val);
 +                              }
 +                              zend_check_trait_usage(ce, cur_precedence->trait_method->ce TSRMLS_CC);
  
 -      if (function_ptr) {
 -              if (ARG_MAY_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) {
 -                      if (op == ZEND_SEND_VAR && param->op_type & (IS_VAR|IS_CV)) {
 -                              send_by_reference = ZEND_ARG_SEND_BY_REF;
 -                              if (zend_is_function_or_method_call(param)) {
 -                                      /* Method call */
 -                                      op = ZEND_SEND_VAR_NO_REF;
 -                                      send_function = ZEND_ARG_SEND_FUNCTION | ZEND_ARG_SEND_SILENT;
 +                              /** Ensure that the prefered method is actually available. */
-                               lcname = STR_ALLOC(cur_method_ref->method_name->len, 0);
++                              lcname = zend_string_alloc(cur_method_ref->method_name->len, 0);
 +                              zend_str_tolower_copy(lcname->val, 
 +                                      cur_method_ref->method_name->val,
 +                                      cur_method_ref->method_name->len);
 +                              method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
 +                                                                                               lcname);
-                               STR_FREE(lcname);
++                              zend_string_free(lcname);
 +                              if (!method_exists) {
 +                                      zend_error_noreturn(E_COMPILE_ERROR,
 +                                                         "A precedence rule was defined for %s::%s but this method does not exist",
 +                                                         cur_method_ref->ce->name->val,
 +                                                         cur_method_ref->method_name->val);
                                }
 -                      } else {
 -                              op = ZEND_SEND_VAL;
 -                      }
 -              } else if (ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) {
 -                      send_by_reference = ZEND_ARG_SEND_BY_REF;
 -              }
 -      }
  
 -      if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) {
 -              /* Method call */
 -              op = ZEND_SEND_VAR_NO_REF;
 -              send_function = ZEND_ARG_SEND_FUNCTION;
 -      } else if (op == ZEND_SEND_VAL && (param->op_type & (IS_VAR|IS_CV))) {
 -              op = ZEND_SEND_VAR_NO_REF;
 -      }
 +                              /** With the other traits, we are more permissive.
 +                                      We do not give errors for those. This allows to be more
 +                                      defensive in such definitions.
 +                                      However, we want to make sure that the insteadof declaration
 +                                      is consistent in itself.
 +                               */
 +                              j = 0;
 +                              while (cur_precedence->exclude_from_classes[j].class_name) {
 +                                      zend_string* class_name = cur_precedence->exclude_from_classes[j].class_name;
  
 -      if (op!=ZEND_SEND_VAR_NO_REF && send_by_reference==ZEND_ARG_SEND_BY_REF) {
 -              /* change to passing by reference */
 -              switch (param->op_type) {
 -                      case IS_VAR:
 -                      case IS_CV:
 -                              op = ZEND_SEND_REF;
 -                              break;
 -                      default:
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference");
 -                              break;
 -              }
 -      }
 +                                      if (!(cur_precedence->exclude_from_classes[j].ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_TRAIT |ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
 +                                              zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", class_name->val);
 +                                      }
 +                                      zend_check_trait_usage(ce, cur_precedence->exclude_from_classes[j].ce TSRMLS_CC);
  
 -      if (original_op == ZEND_SEND_VAR) {
 -              switch (op) {
 -                      case ZEND_SEND_VAR_NO_REF:
 -                              zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC);
 -                              break;
 -                      case ZEND_SEND_VAR:
 -                              if (function_ptr) {
 -                                      zend_do_end_variable_parse(param, BP_VAR_R, 0 TSRMLS_CC);
 -                              } else {
 -                                      zend_do_end_variable_parse(param, BP_VAR_FUNC_ARG, fcall->arg_num TSRMLS_CC);
 +                                      /* make sure that the trait method is not from a class mentioned in
 +                                       exclude_from_classes, for consistency */
 +                                      if (cur_precedence->trait_method->ce == cur_precedence->exclude_from_classes[i].ce) {
 +                                              zend_error_noreturn(E_COMPILE_ERROR,
 +                                                                 "Inconsistent insteadof definition. "
 +                                                                 "The method %s is to be used from %s, but %s is also on the exclude list",
 +                                                                 cur_method_ref->method_name->val,
 +                                                                 cur_precedence->trait_method->ce->name->val,
 +                                                                 cur_precedence->trait_method->ce->name->val);
 +                                      }
 +
-                                       STR_RELEASE(class_name);
++                                      zend_string_release(class_name);
 +                                      j++;
                                }
 -                              break;
 -                      case ZEND_SEND_REF:
 -                              zend_do_end_variable_parse(param, BP_VAR_W, 0 TSRMLS_CC);
 -                              break;
 +                      }
 +                      i++;
                }
        }
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      if (ce->trait_aliases) {
 +              i = 0;
 +              while (ce->trait_aliases[i]) {
 +                      /** For all aliases with an explicit class name, resolve the class now. */
 +                      if (ce->trait_aliases[i]->trait_method->class_name) {
 +                              cur_method_ref = ce->trait_aliases[i]->trait_method;
 +                              if (!(cur_method_ref->ce = zend_fetch_class(cur_method_ref->class_name, ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
 +                                      zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name->val);
 +                              }
 +                              zend_check_trait_usage(ce, cur_method_ref->ce TSRMLS_CC);
  
 -      if (op == ZEND_SEND_VAR_NO_REF) {
 -              if (function_ptr) {
 -                      opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND | send_by_reference | send_function;
 -              } else {
 -                      opline->extended_value = send_function;
 -              }
 -      } else {
 -              if (!function_ptr) {
 -                      switch (op) {
 -                              case ZEND_SEND_VAL:
 -                                      op = ZEND_SEND_VAL_EX;
 -                                      break;
 -                              case ZEND_SEND_VAR:
 -                                      op = ZEND_SEND_VAR_EX;
 -                                      break;
 +                              /** And, ensure that the referenced method is resolvable, too. */
-                               lcname = STR_ALLOC(cur_method_ref->method_name->len, 0);
++                              lcname = zend_string_alloc(cur_method_ref->method_name->len, 0);
 +                              zend_str_tolower_copy(lcname->val,
 +                                      cur_method_ref->method_name->val,
 +                                      cur_method_ref->method_name->len);
 +                              method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
 +                                              lcname);
-                               STR_FREE(lcname);
++                              zend_string_free(lcname);
 +
 +                              if (!method_exists) {
 +                                      zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", cur_method_ref->ce->name->val, cur_method_ref->method_name->val);
 +                              }
                        }
 +                      i++;
                }
        }
 -      opline->opcode = op;
 -      SET_NODE(opline->op1, param);
 -      opline->op2.opline_num = fcall->arg_num;
 -      SET_UNUSED(opline->op2);
  }
  /* }}} */
  
 -void zend_do_unpack_params(znode *params TSRMLS_DC) /* {{{ */
 +static void zend_traits_compile_exclude_table(HashTable* exclude_table, zend_trait_precedence **precedences, zend_class_entry *trait) /* {{{ */
  {
 -      zend_op *opline;
 -      zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack));
 -
 -      fcall->uses_argument_unpacking = 1;
 +      size_t i = 0, j;
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_SEND_UNPACK;
 -      SET_NODE(opline->op1, params);
 -      SET_UNUSED(opline->op2);
 -      opline->op2.num = fcall->arg_num;
 +      if (!precedences) {
 +              return;
 +      }
 +      while (precedences[i]) {
 +              if (precedences[i]->exclude_from_classes) {
 +                      j = 0;
 +                      while (precedences[i]->exclude_from_classes[j].ce) {
 +                              if (precedences[i]->exclude_from_classes[j].ce == trait) {
-                                       zend_string *lcname = STR_ALLOC(precedences[i]->trait_method->method_name->len, 0);
++                                      zend_string *lcname = zend_string_alloc(precedences[i]->trait_method->method_name->len, 0);
 +                                                                              
 +                                      zend_str_tolower_copy(lcname->val,
 +                                              precedences[i]->trait_method->method_name->val,
 +                                              precedences[i]->trait_method->method_name->len);
 +                                      if (zend_hash_add_empty_element(exclude_table, lcname) == NULL) {
-                                               STR_RELEASE(lcname);
++                                              zend_string_release(lcname);
 +                                              zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", precedences[i]->trait_method->method_name->val, trait->name->val);
 +                                      }
-                                       STR_RELEASE(lcname);
++                                      zend_string_release(lcname);
 +                              }
 +                              ++j;
 +                      }
 +              }
 +              ++i;
 +      }
  }
  /* }}} */
  
 -static int generate_free_switch_expr(zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */
 +static void zend_do_traits_method_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */
  {
-       zend_uint i;
 -      zend_op *opline;
++      uint32_t i;
 +      HashTable *overriden = NULL;
 +      zend_string *key;
 +      zend_function *fn;
  
 -      if (switch_entry->cond.op_type != IS_VAR && switch_entry->cond.op_type != IS_TMP_VAR) {
 -              return (switch_entry->cond.op_type == IS_UNUSED);
 -      }
 +      for (i = 0; i < ce->num_traits; i++) {
 +              if (ce->trait_precedences) {
 +                      HashTable exclude_table;
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +                      /* TODO: revisit this start size, may be its not optimal */
 +                      zend_hash_init_ex(&exclude_table, 8, NULL, NULL, 0, 0);
  
 -      opline->opcode = (switch_entry->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
 -      SET_NODE(opline->op1, &switch_entry->cond);
 -      SET_UNUSED(opline->op2);
 +                      zend_traits_compile_exclude_table(&exclude_table, ce->trait_precedences, ce->traits[i]);
  
 -      return 0;
 +                      /* copies functions, applies defined aliasing, and excludes unused trait methods */
 +                      ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
 +                              zend_traits_copy_functions(key, fn, ce, &overriden, &exclude_table TSRMLS_CC);
 +                      } ZEND_HASH_FOREACH_END();
 +
 +                      zend_hash_destroy(&exclude_table);
 +              } else {
 +                      ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
 +                              zend_traits_copy_functions(key, fn, ce, &overriden, NULL TSRMLS_CC);
 +                      } ZEND_HASH_FOREACH_END();
 +              }
 +      }
 +
 +      ZEND_HASH_FOREACH_PTR(&ce->function_table, fn) {
 +              zend_fixup_trait_method(fn, ce);
 +      } ZEND_HASH_FOREACH_END();
 +
 +      if (overriden) {
 +              zend_hash_destroy(overriden);
 +              FREE_HASHTABLE(overriden);
 +      }
  }
  /* }}} */
  
@@@ -2310,155 -3141,63 +2310,155 @@@ static zend_class_entry* find_first_def
  }
  /* }}} */
  
 -void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */
 +static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */
  {
 -      zend_op *opline;
 -      int start_op_number, end_op_number;
 -      zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
 +      size_t i;
 +      zend_property_info *property_info;
 +      zend_property_info *coliding_prop;
 +      zval compare_result;
 +      zend_string* prop_name;
 +      const char* class_name_unused;
 +      zend_bool not_compatible;
 +      zval* prop_value;
-       zend_uint flags;
++      uint32_t flags;
 +      zend_string *doc_comment;
  
 -      /* The error for use of return inside a generator is thrown in pass_two. */
 +      /* In the following steps the properties are inserted into the property table
 +       * for that, a very strict approach is applied:
 +       * - check for compatibility, if not compatible with any property in class -> fatal
 +       * - if compatible, then strict notice
 +       */
 +      for (i = 0; i < ce->num_traits; i++) {
 +              ZEND_HASH_FOREACH_PTR(&ce->traits[i]->properties_info, property_info) {
 +                      /* first get the unmangeld name if necessary,
 +                       * then check whether the property is already there
 +                       */
 +                      flags = property_info->flags;
 +                      if ((flags & ZEND_ACC_PPP_MASK) == ZEND_ACC_PUBLIC) {
-                               prop_name = STR_COPY(property_info->name);
++                              prop_name = zend_string_copy(property_info->name);
 +                      } else {
 +                              const char *pname;
 +                              int pname_len;
  
 -      if (do_end_vparse) {
 -              if (returns_reference && !zend_is_function_or_method_call(expr)) {
 -                      zend_do_end_variable_parse(expr, BP_VAR_W, 1 TSRMLS_CC);
 -              } else {
 -                      zend_do_end_variable_parse(expr, BP_VAR_R, 0 TSRMLS_CC);
 -              }
 -      }
 +                              /* for private and protected we need to unmangle the names */
 +                              zend_unmangle_property_name_ex(property_info->name->val, property_info->name->len,
 +                                                                                      &class_name_unused, &pname, &pname_len);
-                               prop_name = STR_INIT(pname, pname_len, 0);
++                              prop_name = zend_string_init(pname, pname_len, 0);
 +                      }
  
 -      start_op_number = get_next_op_number(CG(active_op_array));
 +                      /* next: check for conflicts with current class */
 +                      if ((coliding_prop = zend_hash_find_ptr(&ce->properties_info, prop_name)) != NULL) {
 +                              if (coliding_prop->flags & ZEND_ACC_SHADOW) {
 +                                      zend_hash_del(&ce->properties_info, prop_name);
 +                                      flags |= ZEND_ACC_CHANGED;
 +                              } else {
 +                                      if ((coliding_prop->flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))
 +                                              == (flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))) {
 +                                              /* flags are identical, now the value needs to be checked */
 +                                              if (flags & ZEND_ACC_STATIC) {
 +                                                      not_compatible = (FAILURE == compare_function(&compare_result,
 +                                                                                        &ce->default_static_members_table[coliding_prop->offset],
 +                                                                                        &ce->traits[i]->default_static_members_table[property_info->offset] TSRMLS_CC))
 +                                                                || (Z_LVAL(compare_result) != 0);
 +                                              } else {
 +                                                      not_compatible = (FAILURE == compare_function(&compare_result,
 +                                                                                        &ce->default_properties_table[coliding_prop->offset],
 +                                                                                        &ce->traits[i]->default_properties_table[property_info->offset] TSRMLS_CC))
 +                                                                || (Z_LVAL(compare_result) != 0);
 +                                              }
 +                                      } else {
 +                                              /* the flags are not identical, thus, we assume properties are not compatible */
 +                                              not_compatible = 1;
 +                                      }
  
 -#ifdef ZTS
 -      zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC);
 -      zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC);
 -#else
 -      zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr);
 -      zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy);
 -#endif
 +                                      if (not_compatible) {
 +                                              zend_error_noreturn(E_COMPILE_ERROR,
 +                                                         "%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed",
 +                                                              find_first_definition(ce, i, prop_name, coliding_prop->ce)->name->val,
 +                                                              property_info->ce->name->val,
 +                                                              prop_name->val,
 +                                                              ce->name->val);
 +                                      } else {
 +                                              zend_error(E_STRICT,
 +                                                         "%s and %s define the same property ($%s) in the composition of %s. This might be incompatible, to improve maintainability consider using accessor methods in traits instead. Class was composed",
 +                                                              find_first_definition(ce, i, prop_name, coliding_prop->ce)->name->val,
 +                                                              property_info->ce->name->val,
 +                                                              prop_name->val,
 +                                                              ce->name->val);
-                                               STR_RELEASE(prop_name);
++                                              zend_string_release(prop_name);
 +                                              continue;
 +                                      }
 +                              }
 +                      }
  
 -      end_op_number = get_next_op_number(CG(active_op_array));
 -      while (start_op_number < end_op_number) {
 -              CG(active_op_array)->opcodes[start_op_number].extended_value |= EXT_TYPE_FREE_ON_RETURN;
 -              start_op_number++;
 -      }
 +                      /* property not found, so lets add it */
 +                      if (flags & ZEND_ACC_STATIC) {
 +                              prop_value = &ce->traits[i]->default_static_members_table[property_info->offset];
 +                      } else {
 +                              prop_value = &ce->traits[i]->default_properties_table[property_info->offset];
 +                      }
 +                      if (Z_REFCOUNTED_P(prop_value)) Z_ADDREF_P(prop_value);
  
-                       doc_comment = property_info->doc_comment ? STR_COPY(property_info->doc_comment) : NULL;
 -      if (CG(context).in_finally) {
 -              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -              opline->opcode = ZEND_DISCARD_EXCEPTION;
 -              SET_UNUSED(opline->op1);
 -              SET_UNUSED(opline->op2);
++                      doc_comment = property_info->doc_comment ? zend_string_copy(property_info->doc_comment) : NULL;
 +                      zend_declare_property_ex(ce, prop_name,
 +                                                                       prop_value, flags,
 +                                                                   doc_comment TSRMLS_CC);
-                       STR_RELEASE(prop_name);
++                      zend_string_release(prop_name);
 +              } ZEND_HASH_FOREACH_END();
        }
 +}
 +/* }}} */
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 +{
 +      int i = 0;
 +      zend_trait_alias* cur_alias;
 +      zend_string* lc_method_name;
  
 -      opline->opcode = returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN;
 +      if (ce->trait_aliases) {
 +              while (ce->trait_aliases[i]) {
 +                      cur_alias = ce->trait_aliases[i];
 +                      /** The trait for this alias has not been resolved, this means, this
 +                              alias was not applied. Abort with an error. */
 +                      if (!cur_alias->trait_method->ce) {
 +                              if (cur_alias->alias) {
 +                                      /** Plain old inconsistency/typo/bug */
 +                                      zend_error_noreturn(E_COMPILE_ERROR,
 +                                                         "An alias (%s) was defined for method %s(), but this method does not exist",
 +                                                         cur_alias->alias->val,
 +                                                         cur_alias->trait_method->method_name->val);
 +                              } else {
 +                                      /** Here are two possible cases:
 +                                              1) this is an attempt to modifiy the visibility
 +                                                 of a method introduce as part of another alias.
 +                                                 Since that seems to violate the DRY principle,
 +                                                 we check against it and abort.
 +                                              2) it is just a plain old inconsitency/typo/bug
 +                                                 as in the case where alias is set. */
  
-                                       lc_method_name = STR_ALLOC(cur_alias->trait_method->method_name->len, 0);
 -      if (expr) {
 -              SET_NODE(opline->op1, expr);
++                                      lc_method_name = zend_string_alloc(cur_alias->trait_method->method_name->len, 0);
 +                                      zend_str_tolower_copy(
 +                                              lc_method_name->val,
 +                                              cur_alias->trait_method->method_name->val,
 +                                              cur_alias->trait_method->method_name->len);
 +                                      if (zend_hash_exists(&ce->function_table,
 +                                                                               lc_method_name)) {
-                                               STR_FREE(lc_method_name);
++                                              zend_string_free(lc_method_name);
 +                                              zend_error_noreturn(E_COMPILE_ERROR,
 +                                                                 "The modifiers for the trait alias %s() need to be changed in the same statment in which the alias is defined. Error",
 +                                                                 cur_alias->trait_method->method_name->val);
 +                                      } else {
-                                               STR_FREE(lc_method_name);
++                                              zend_string_free(lc_method_name);
 +                                              zend_error_noreturn(E_COMPILE_ERROR,
 +                                                                 "The modifiers of the trait method %s() are changed, but this method does not exist. Error",
 +                                                                 cur_alias->trait_method->method_name->val);
  
 -              if (!do_end_vparse) {
 -                      opline->extended_value = ZEND_RETURNS_VALUE;
 -              } else if (zend_is_function_or_method_call(expr)) {
 -                      opline->extended_value = ZEND_RETURNS_FUNCTION;
 +                                      }
 +                              }
 +                      }
 +                      i++;
                }
 -      } else {
 -              opline->op1_type = IS_CONST;
 -              LITERAL_NULL(opline->op1);
        }
 -
 -      SET_UNUSED(opline->op2);
  }
  /* }}} */
  
@@@ -2613,118 -3392,59 +2613,118 @@@ ZEND_API zend_class_entry *do_bind_inhe
  }
  /* }}} */
  
 -void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC) /* {{{ */
 +void zend_do_early_binding(TSRMLS_D) /* {{{ */
  {
 -      if (catch_token->op_type == IS_UNUSED && finally_token->op_type == IS_UNUSED) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally");
 +      zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
 +      HashTable *table;
 +
 +      while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
 +              opline--;
        }
 -      if (finally_token->op_type != IS_UNUSED) {
 -              zend_op *opline;
  
 -              CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_op = finally_token->u.op.opline_num + 1;
 -              CG(active_op_array)->try_catch_array[try_token->u.op.opline_num].finally_end = get_next_op_number(CG(active_op_array));
 -              CG(active_op_array)->has_finally_block = 1;
 +      switch (opline->opcode) {
 +              case ZEND_DECLARE_FUNCTION:
 +                      if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1 TSRMLS_CC) == FAILURE) {
 +                              return;
 +                      }
 +                      table = CG(function_table);
 +                      break;
 +              case ZEND_DECLARE_CLASS:
 +                      if (do_bind_class(CG(active_op_array), opline, CG(class_table), 1 TSRMLS_CC) == NULL) {
 +                              return;
 +                      }
 +                      table = CG(class_table);
 +                      break;
 +              case ZEND_DECLARE_INHERITED_CLASS:
 +                      {
 +                              zend_op *fetch_class_opline = opline-1;
 +                              zval *parent_name;
 +                              zend_class_entry *ce;
  
 -              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -              opline->opcode = ZEND_FAST_RET;
 -              SET_UNUSED(opline->op1);
 -              SET_UNUSED(opline->op2);
 +                              parent_name = &CONSTANT(fetch_class_opline->op2.constant);
 +                              if (((ce = zend_lookup_class(Z_STR_P(parent_name) TSRMLS_CC)) == NULL) ||
 +                                  ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
 +                                   (ce->type == ZEND_INTERNAL_CLASS))) {
 +                                  if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
-                                               zend_uint *opline_num = &CG(active_op_array)->early_binding;
++                                              uint32_t *opline_num = &CG(active_op_array)->early_binding;
  
 -              CG(active_op_array)->opcodes[finally_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
 +                                              while (*opline_num != -1) {
 +                                                      opline_num = &CG(active_op_array)->opcodes[*opline_num].result.opline_num;
 +                                              }
 +                                              *opline_num = opline - CG(active_op_array)->opcodes;
 +                                              opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED;
 +                                              opline->result_type = IS_UNUSED;
 +                                              opline->result.opline_num = -1;
 +                                      }
 +                                      return;
 +                              }
 +                              if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), ce, 1 TSRMLS_CC) == NULL) {
 +                                      return;
 +                              }
 +                              /* clear unnecessary ZEND_FETCH_CLASS opcode */
 +                              zend_del_literal(CG(active_op_array), fetch_class_opline->op2.constant);
 +                              MAKE_NOP(fetch_class_opline);
  
 -              CG(context).in_finally--;
 +                              table = CG(class_table);
 +                              break;
 +                      }
 +              case ZEND_VERIFY_ABSTRACT_CLASS:
 +              case ZEND_ADD_INTERFACE:
 +              case ZEND_ADD_TRAIT:
 +              case ZEND_BIND_TRAITS:
 +                      /* We currently don't early-bind classes that implement interfaces */
 +                      /* Classes with traits are handled exactly the same, no early-bind here */
 +                      return;
 +              default:
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Invalid binding type");
 +                      return;
        }
 +
 +      zend_hash_del(table, Z_STR(CONSTANT(opline->op1.constant)));
 +      zend_del_literal(CG(active_op_array), opline->op1.constant);
 +      zend_del_literal(CG(active_op_array), opline->op2.constant);
 +      MAKE_NOP(opline);
  }
  /* }}} */
  
 -void zend_do_throw(znode *expr TSRMLS_DC) /* {{{ */
 +ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC) /* {{{ */
  {
 -      zend_op *opline;
 +      if (op_array->early_binding != -1) {
 +              zend_bool orig_in_compilation = CG(in_compilation);
-               zend_uint opline_num = op_array->early_binding;
++              uint32_t opline_num = op_array->early_binding;
 +              zend_class_entry *ce;
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_THROW;
 -      SET_NODE(opline->op1, expr);
 -      SET_UNUSED(opline->op2);
 +              CG(in_compilation) = 1;
 +              while (opline_num != -1) {
 +                      if ((ce = zend_lookup_class(Z_STR_P(op_array->opcodes[opline_num-1].op2.zv) TSRMLS_CC)) != NULL) {
 +                              do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0 TSRMLS_CC);
 +                      }
 +                      opline_num = op_array->opcodes[opline_num].result.opline_num;
 +              }
 +              CG(in_compilation) = orig_in_compilation;
 +      }
  }
  /* }}} */
  
 -ZEND_API void function_add_ref(zend_function *function) /* {{{ */
 +ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */
  {
 -      if (function->type == ZEND_USER_FUNCTION) {
 -              zend_op_array *op_array = &function->op_array;
 +      zend_string *prop_name;
 +      int prop_name_length;
  
 -              (*op_array->refcount)++;
 -              if (op_array->static_variables) {
 -                      HashTable *static_variables = op_array->static_variables;
 +      prop_name_length = 1 + src1_length + 1 + src2_length;
-       prop_name = STR_ALLOC(prop_name_length, internal);
++      prop_name = zend_string_alloc(prop_name_length, internal);
 +      prop_name->val[0] = '\0';
 +      memcpy(prop_name->val + 1, src1, src1_length+1);
 +      memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1);
 +      return prop_name;
 +}
 +/* }}} */
  
 -                      ALLOC_HASHTABLE(op_array->static_variables);
 -                      zend_array_dup(op_array->static_variables, static_variables);
 -              }
 -              op_array->run_time_cache = NULL;
 -      } else if (function->type == ZEND_INTERNAL_FUNCTION) {
 -              if (function->common.function_name) {
 -                      zend_string_addref(function->common.function_name);
 -              }
 -      }
 +static int zend_strnlen(const char* s, int maxlen) /* {{{ */
 +{
 +      int len = 0;
 +      while (*s++ && maxlen--) len++;
 +      return len;
  }
  /* }}} */
  
@@@ -2824,3173 -3586,2987 +2824,3173 @@@ static int zend_constant_ct_subst(znod
  }
  /* }}} */
  
 -static zend_bool zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto TSRMLS_DC) /* {{{ */
 +void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */
  {
 -      uint32_t i, num_args;
 +      void** list = emalloc(sizeof(void*) * 2);
  
 -      /* If it's a user function then arg_info == NULL means we don't have any parameters but
 -       * we still need to do the arg number checks.  We are only willing to ignore this for internal
 -       * functions because extensions don't always define arg_info.
 -       */
 -      if (!proto || (!proto->common.arg_info && proto->common.type != ZEND_USER_FUNCTION)) {
 -              return 1;
 -      }
 +      list[0] = item;
 +      list[1] = NULL;
  
 -      /* Checks for constructors only if they are declared in an interface,
 -       * or explicitly marked as abstract
 -       */
 -      if ((fe->common.fn_flags & ZEND_ACC_CTOR)
 -              && ((proto->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
 -                      && (proto->common.fn_flags & ZEND_ACC_ABSTRACT) == 0)) {
 -              return 1;
 -      }
 +      *(void**)result = list;
 +}
 +/* }}} */
  
 -      /* If both methods are private do not enforce a signature */
 -    if ((fe->common.fn_flags & ZEND_ACC_PRIVATE) && (proto->common.fn_flags & ZEND_ACC_PRIVATE)) {
 -              return 1;
 -      }
 +void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */
 +{
 +      void** list = *(void**)result;
 +      size_t n = 0;
  
 -      /* check number of arguments */
 -      if (proto->common.required_num_args < fe->common.required_num_args
 -              || proto->common.num_args > fe->common.num_args) {
 -              return 0;
 +      if (list) {
 +              while (list[n]) {
 +                      n++;
 +              }
        }
  
 -      /* by-ref constraints on return values are covariant */
 -      if ((proto->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
 -              && !(fe->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
 -              return 0;
 -      }
 +      list = erealloc(list, sizeof(void*) * (n+2));
  
 -      if ((proto->common.fn_flags & ZEND_ACC_VARIADIC)
 -              && !(fe->common.fn_flags & ZEND_ACC_VARIADIC)) {
 -              return 0;
 -      }
 +      list[n]   = item;
 +      list[n+1] = NULL;
  
 -      /* For variadic functions any additional (optional) arguments that were added must be
 -       * checked against the signature of the variadic argument, so in this case we have to
 -       * go through all the parameters of the function and not just those present in the
 -       * prototype. */
 -      num_args = proto->common.num_args;
 -      if ((fe->common.fn_flags & ZEND_ACC_VARIADIC)
 -              && fe->common.num_args > proto->common.num_args) {
 -              num_args = fe->common.num_args;
 -      }
 +      *(void**)result = list;
 +}
 +/* }}} */
  
 -      for (i = 0; i < num_args; i++) {
 -              zend_arg_info *fe_arg_info = &fe->common.arg_info[i];
 +void zend_do_extended_info(TSRMLS_D) /* {{{ */
 +{
 +      zend_op *opline;
  
 -              zend_arg_info *proto_arg_info;
 -              if (i < proto->common.num_args) {
 -                      proto_arg_info = &proto->common.arg_info[i];
 -              } else {
 -                      proto_arg_info = &proto->common.arg_info[proto->common.num_args-1];
 -              }
 +      if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
 +              return;
 +      }
  
 -              if (ZEND_LOG_XOR(fe_arg_info->class_name, proto_arg_info->class_name)) {
 -                      /* Only one has a type hint and the other one doesn't */
 -                      return 0;
 -              }
 +      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
  
 -              if (fe_arg_info->class_name) {
 -                      zend_string *fe_class_name, *proto_class_name;
 +      opline->opcode = ZEND_EXT_STMT;
 +      SET_UNUSED(opline->op1);
 +      SET_UNUSED(opline->op2);
 +}
 +/* }}} */
  
 -                      if (!strcasecmp(fe_arg_info->class_name, "parent") && proto->common.scope) {
 -                              fe_class_name = zend_string_copy(proto->common.scope->name);
 -                      } else if (!strcasecmp(fe_arg_info->class_name, "self") && fe->common.scope) {
 -                              fe_class_name = zend_string_copy(fe->common.scope->name);
 -                      } else {
 -                              fe_class_name = zend_string_init(
 -                                      fe_arg_info->class_name,
 -                                      fe_arg_info->class_name_len, 0);
 -                      }
 +void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */
 +{
 +      zend_op *opline;
  
 -                      if (!strcasecmp(proto_arg_info->class_name, "parent") && proto->common.scope && proto->common.scope->parent) {
 -                              proto_class_name = zend_string_copy(proto->common.scope->parent->name);
 -                      } else if (!strcasecmp(proto_arg_info->class_name, "self") && proto->common.scope) {
 -                              proto_class_name = zend_string_copy(proto->common.scope->name);
 -                      } else {
 -                              proto_class_name = zend_string_init(
 -                                      proto_arg_info->class_name,
 -                                      proto_arg_info->class_name_len, 0);
 -                      }
 +      if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
 +              return;
 +      }
  
 -                      if (strcasecmp(fe_class_name->val, proto_class_name->val)!=0) {
 -                              const char *colon;
 +      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
  
 -                              if (fe->common.type != ZEND_USER_FUNCTION) {
 -                                      zend_string_release(proto_class_name);
 -                                      zend_string_release(fe_class_name);
 -                                      return 0;
 -                          } else if (strchr(proto_class_name->val, '\\') != NULL ||
 -                                              (colon = zend_memrchr(fe_class_name->val, '\\', fe_class_name->len)) == NULL ||
 -                                              strcasecmp(colon+1, proto_class_name->val) != 0) {
 -                                      zend_class_entry *fe_ce, *proto_ce;
 +      opline->opcode = ZEND_EXT_FCALL_BEGIN;
 +      SET_UNUSED(opline->op1);
 +      SET_UNUSED(opline->op2);
 +}
 +/* }}} */
  
 -                                      fe_ce = zend_lookup_class(fe_class_name TSRMLS_CC);
 -                                      proto_ce = zend_lookup_class(proto_class_name TSRMLS_CC);
 +void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */
 +{
 +      zend_op *opline;
  
 -                                      /* Check for class alias */
 -                                      if (!fe_ce || !proto_ce ||
 -                                                      fe_ce->type == ZEND_INTERNAL_CLASS ||
 -                                                      proto_ce->type == ZEND_INTERNAL_CLASS ||
 -                                                      fe_ce != proto_ce) {
 -                                              zend_string_release(proto_class_name);
 -                                              zend_string_release(fe_class_name);
 -                                              return 0;
 -                                      }
 -                              }
 -                      }
 -                      zend_string_release(proto_class_name);
 -                      zend_string_release(fe_class_name);
 +      if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
 +              return;
 +      }
 +
 +      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +
 +      opline->opcode = ZEND_EXT_FCALL_END;
 +      SET_UNUSED(opline->op1);
 +      SET_UNUSED(opline->op2);
 +}
 +/* }}} */
 +
 +zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */
 +{
 +      zend_auto_global *auto_global;
 +
 +      if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) {
 +              if (auto_global->armed) {
 +                      auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
                }
 -              if (fe_arg_info->type_hint != proto_arg_info->type_hint) {
 -                      /* Incompatible type hint */
 -                      return 0;
 +              return 1;
 +      }
 +      return 0;
 +}
 +/* }}} */
 +
 +int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
 +{
 +      zend_auto_global auto_global;
 +      int retval;
 +
 +      auto_global.name = zend_new_interned_string(name TSRMLS_CC);
 +      auto_global.auto_global_callback = auto_global_callback;
 +      auto_global.jit = jit;
 +
 +      retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE;
 +
-       STR_RELEASE(auto_global.name);
++      zend_string_release(auto_global.name);
 +      return retval;
 +}
 +/* }}} */
 +
 +ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */
 +{
 +      zend_auto_global *auto_global;
 +
 +      ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) {
 +              if (auto_global->jit) {
 +                      auto_global->armed = 1;
 +              } else if (auto_global->auto_global_callback) {
 +                      auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
 +              } else {
 +                      auto_global->armed = 0;
                }
 +      } ZEND_HASH_FOREACH_END();
 +}
 +/* }}} */
  
 -              /* by-ref constraints on arguments are invariant */
 -              if (fe_arg_info->pass_by_reference != proto_arg_info->pass_by_reference) {
 -                      return 0;
 +int zendlex(zend_parser_stack_elem *elem TSRMLS_DC) /* {{{ */
 +{
 +      zval zv;
 +      int retval;
 +
 +      if (CG(increment_lineno)) {
 +              CG(zend_lineno)++;
 +              CG(increment_lineno) = 0;
 +      }
 +
 +again:
 +      ZVAL_UNDEF(&zv);
 +      retval = lex_scan(&zv TSRMLS_CC);
 +      switch (retval) {
 +              case T_COMMENT:
 +              case T_DOC_COMMENT:
 +              case T_OPEN_TAG:
 +              case T_WHITESPACE:
 +                      goto again;
 +
 +              case T_CLOSE_TAG:
 +                      if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
 +                              CG(increment_lineno) = 1;
 +                      }
 +                      if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
 +                              goto again;
 +                      }
 +                      retval = ';'; /* implicit ; */
 +                      break;
 +              case T_OPEN_TAG_WITH_ECHO:
 +                      retval = T_ECHO;
 +                      break;
 +      }
 +      if (Z_TYPE(zv) != IS_UNDEF) {
 +              elem->ast = zend_ast_create_zval(&zv);
 +      }
 +
 +      return retval;
 +}
 +/* }}} */
 +
 +ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */
 +{
 +      zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0;
 +      dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR);
 +
 +      ce->refcount = 1;
 +      ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED;
 +
 +      ce->default_properties_table = NULL;
 +      ce->default_static_members_table = NULL;
 +      zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
 +      zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
 +      zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
 +
 +      if (ce->type == ZEND_INTERNAL_CLASS) {
 +#ifdef ZTS
 +              int n = zend_hash_num_elements(CG(class_table));
 +
 +              if (CG(static_members_table) && n >= CG(last_static_member)) {
 +                      /* Support for run-time declaration: dl() */
 +                      CG(last_static_member) = n+1;
 +                      CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*));
 +                      CG(static_members_table)[n] = NULL;
                }
 +              ce->static_members_table = (zval*)(zend_intptr_t)n;
 +#else
 +              ce->static_members_table = NULL;
 +#endif
 +      } else {
 +              ce->static_members_table = ce->default_static_members_table;
 +              ce->info.user.doc_comment = NULL;
        }
  
 -      return 1;
 +      ce->default_properties_count = 0;
 +      ce->default_static_members_count = 0;
 +
 +      if (nullify_handlers) {
 +              ce->constructor = NULL;
 +              ce->destructor = NULL;
 +              ce->clone = NULL;
 +              ce->__get = NULL;
 +              ce->__set = NULL;
 +              ce->__unset = NULL;
 +              ce->__isset = NULL;
 +              ce->__call = NULL;
 +              ce->__callstatic = NULL;
 +              ce->__tostring = NULL;
 +              ce->create_object = NULL;
 +              ce->get_iterator = NULL;
 +              ce->iterator_funcs.funcs = NULL;
 +              ce->interface_gets_implemented = NULL;
 +              ce->get_static_method = NULL;
 +              ce->parent = NULL;
 +              ce->num_interfaces = 0;
 +              ce->interfaces = NULL;
 +              ce->num_traits = 0;
 +              ce->traits = NULL;
 +              ce->trait_aliases = NULL;
 +              ce->trait_precedences = NULL;
 +              ce->serialize = NULL;
 +              ce->unserialize = NULL;
 +              ce->serialize_func = NULL;
 +              ce->unserialize_func = NULL;
 +              ce->__debugInfo = NULL;
 +              if (ce->type == ZEND_INTERNAL_CLASS) {
 +                      ce->info.internal.module = NULL;
 +                      ce->info.internal.builtin_functions = NULL;
 +              }
 +      }
  }
  /* }}} */
  
- zend_uint zend_get_class_fetch_type(zend_string *name) {
 -#define REALLOC_BUF_IF_EXCEED(buf, offset, length, size) \
 -      if (UNEXPECTED(offset - buf + size >= length)) {        \
 -              length += size + 1;                             \
 -              buf = erealloc(buf, length);            \
++uint32_t zend_get_class_fetch_type(zend_string *name) {
 +      if (name->len == sizeof("self") - 1 &&
 +              !strncasecmp(name->val, "self", sizeof("self") - 1)) {
 +              return ZEND_FETCH_CLASS_SELF;
 +      } else if (name->len == sizeof("parent") - 1 &&
 +              !strncasecmp(name->val, "parent", sizeof("parent") - 1)) {
 +              return ZEND_FETCH_CLASS_PARENT;
 +      } else if (name->len == sizeof("static") - 1 &&
 +              !strncasecmp(name->val, "static", sizeof("static") - 1)) {
 +              return ZEND_FETCH_CLASS_STATIC;
 +      } else {
 +              return ZEND_FETCH_CLASS_DEFAULT;
        }
 +}
  
- ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var) /* {{{ */
 -static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{{ */
++ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */
  {
 -      char *offset, *buf;
 -      uint32_t length = 1024;
 +      return op_array->vars[EX_VAR_TO_NUM(var)];
 +}
 +/* }}} */
  
 -      offset = buf = (char *)emalloc(length * sizeof(char));
 -      if (fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
 -              *(offset++) = '&';
 -              *(offset++) = ' ';
 +zend_ast *zend_ast_append_str(zend_ast *left_ast, zend_ast *right_ast) {
 +      zval *left_zv = zend_ast_get_zval(left_ast);
 +      zend_string *left = Z_STR_P(left_zv);
 +      zend_string *right = zend_ast_get_str(right_ast);
 +
 +      zend_string *result;
 +      size_t left_len = left->len;
 +      size_t len = left_len + right->len + 1; /* left\right */
 +
-       result = STR_REALLOC(left, len, 0);
++      result = zend_string_realloc(left, len, 0);
 +      result->val[left_len] = '\\';
 +      memcpy(&result->val[left_len + 1], right->val, right->len);
 +      result->val[len] = '\0';
-       STR_RELEASE(right);
++      zend_string_release(right);
 +
 +      ZVAL_STR(left_zv, result);
 +      return left_ast;
 +}
 +
 +/* A hacky way that is used to store the doc comment for properties */
 +zend_ast_list *zend_ast_append_doc_comment(zend_ast_list *list TSRMLS_DC) {
 +      if (CG(doc_comment)) {
 +              list = zend_ast_list_add(list, zend_ast_create_zval_from_str(CG(doc_comment)));
 +              CG(doc_comment) = NULL;
        }
  
 -      if (fptr->common.scope) {
 -              memcpy(offset, fptr->common.scope->name->val, fptr->common.scope->name->len);
 -              offset += fptr->common.scope->name->len;
 -              *(offset++) = ':';
 -              *(offset++) = ':';
 +      return list;
 +}
 +
 +void zend_verify_namespace(TSRMLS_D) /* {{{ */
 +{
 +      if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}");
        }
 +}
 +/* }}} */
  
 -      {
 -              size_t name_len = fptr->common.function_name->len;
 -              REALLOC_BUF_IF_EXCEED(buf, offset, length, name_len);
 -              memcpy(offset, fptr->common.function_name->val, name_len);
 -              offset += name_len;
 +static void zend_reset_import_tables(TSRMLS_D) {
 +      if (CG(current_import)) {
 +              zend_hash_destroy(CG(current_import));
 +              efree(CG(current_import));
 +              CG(current_import) = NULL;
        }
  
 -      *(offset++) = '(';
 -      if (fptr->common.arg_info) {
 -              uint32_t i, required;
 -              zend_arg_info *arg_info = fptr->common.arg_info;
 +      if (CG(current_import_function)) {
 +              zend_hash_destroy(CG(current_import_function));
 +              efree(CG(current_import_function));
 +              CG(current_import_function) = NULL;
 +      }
  
 -              required = fptr->common.required_num_args;
 -              for (i = 0; i < fptr->common.num_args;) {
 -                      if (arg_info->class_name) {
 -                              const char *class_name;
 -                              uint32_t class_name_len;
 -                              if (!strcasecmp(arg_info->class_name, "self") && fptr->common.scope ) {
 -                                      class_name = fptr->common.scope->name->val;
 -                                      class_name_len = fptr->common.scope->name->len;
 -                              } else if (!strcasecmp(arg_info->class_name, "parent") && fptr->common.scope->parent) {
 -                                      class_name = fptr->common.scope->parent->name->val;
 -                                      class_name_len = fptr->common.scope->parent->name->len;
 -                              } else {
 -                                      class_name = arg_info->class_name;
 -                                      class_name_len = arg_info->class_name_len;
 -                              }
 -                              REALLOC_BUF_IF_EXCEED(buf, offset, length, class_name_len);
 -                              memcpy(offset, class_name, class_name_len);
 -                              offset += class_name_len;
 -                              *(offset++) = ' ';
 -                      } else if (arg_info->type_hint) {
 -                              uint32_t type_name_len;
 -                              char *type_name = zend_get_type_by_const(arg_info->type_hint);
 -                              type_name_len = strlen(type_name);
 -                              REALLOC_BUF_IF_EXCEED(buf, offset, length, type_name_len);
 -                              memcpy(offset, type_name, type_name_len);
 -                              offset += type_name_len;
 -                              *(offset++) = ' ';
 -                      }
 +      if (CG(current_import_const)) {
 +              zend_hash_destroy(CG(current_import_const));
 +              efree(CG(current_import_const));
 +              CG(current_import_const) = NULL;
 +      }
 +}
  
 -                      if (arg_info->pass_by_reference) {
 -                              *(offset++) = '&';
 -                      }
 +static void zend_end_namespace(TSRMLS_D) {
 +      CG(in_namespace) = 0;
 +      zend_reset_import_tables(TSRMLS_C);
 +      if (CG(current_namespace)) {
-               STR_RELEASE(CG(current_namespace));
++              zend_string_release(CG(current_namespace));
 +              CG(current_namespace) = NULL;
 +      }
 +}
  
 -                      if (arg_info->is_variadic) {
 -                              *(offset++) = '.';
 -                              *(offset++) = '.';
 -                              *(offset++) = '.';
 -                      }
 +void zend_do_end_compilation(TSRMLS_D) /* {{{ */
 +{
 +      CG(has_bracketed_namespaces) = 0;
 +      zend_end_namespace(TSRMLS_C);
 +}
 +/* }}} */
  
 -                      *(offset++) = '$';
 +/* {{{ zend_dirname
 +   Returns directory name component of path */
 +ZEND_API size_t zend_dirname(char *path, size_t len)
 +{
 +      register char *end = path + len - 1;
 +      unsigned int len_adjust = 0;
  
 -                      if (arg_info->name) {
 -                              REALLOC_BUF_IF_EXCEED(buf, offset, length, arg_info->name_len);
 -                              memcpy(offset, arg_info->name, arg_info->name_len);
 -                              offset += arg_info->name_len;
 -                      } else {
 -                              uint32_t idx = i;
 -                              memcpy(offset, "param", 5);
 -                              offset += 5;
 -                              do {
 -                                      *(offset++) = (char) (idx % 10) + '0';
 -                                      idx /= 10;
 -                              } while (idx > 0);
 -                      }
 -                      if (i >= required && !arg_info->is_variadic) {
 -                              *(offset++) = ' ';
 -                              *(offset++) = '=';
 -                              *(offset++) = ' ';
 -                              if (fptr->type == ZEND_USER_FUNCTION) {
 -                                      zend_op *precv = NULL;
 -                                      {
 -                                              uint32_t idx  = i;
 -                                              zend_op *op = ((zend_op_array *)fptr)->opcodes;
 -                                              zend_op *end = op + ((zend_op_array *)fptr)->last;
 +#ifdef PHP_WIN32
 +      /* Note that on Win32 CWD is per drive (heritage from CP/M).
 +       * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive.
 +       */
 +      if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) {
 +              /* Skip over the drive spec (if any) so as not to change */
 +              path += 2;
 +              len_adjust += 2;
 +              if (2 == len) {
 +                      /* Return "c:" on Win32 for dirname("c:").
 +                       * It would be more consistent to return "c:."
 +                       * but that would require making the string *longer*.
 +                       */
 +                      return len;
 +              }
 +      }
 +#elif defined(NETWARE)
 +      /*
 +       * Find the first occurrence of : from the left
 +       * move the path pointer to the position just after :
 +       * increment the len_adjust to the length of path till colon character(inclusive)
 +       * If there is no character beyond : simple return len
 +       */
 +      char *colonpos = NULL;
 +      colonpos = strchr(path, ':');
 +      if (colonpos != NULL) {
 +              len_adjust = ((colonpos - path) + 1);
 +              path += len_adjust;
 +              if (len_adjust == len) {
 +                      return len;
 +              }
 +      }
 +#endif
 +
 +      if (len == 0) {
 +              /* Illegal use of this function */
 +              return 0;
 +      }
 +
 +      /* Strip trailing slashes */
 +      while (end >= path && IS_SLASH_P(end)) {
 +              end--;
 +      }
 +      if (end < path) {
 +              /* The path only contained slashes */
 +              path[0] = DEFAULT_SLASH;
 +              path[1] = '\0';
 +              return 1 + len_adjust;
 +      }
 +
 +      /* Strip filename */
 +      while (end >= path && !IS_SLASH_P(end)) {
 +              end--;
 +      }
 +      if (end < path) {
 +              /* No slash found, therefore return '.' */
 +#ifdef NETWARE
 +              if (len_adjust == 0) {
 +                      path[0] = '.';
 +                      path[1] = '\0';
 +                      return 1; /* only one character */
 +              } else {
 +                      path[0] = '\0';
 +                      return len_adjust;
 +              }
 +#else
 +              path[0] = '.';
 +              path[1] = '\0';
 +              return 1 + len_adjust;
 +#endif
 +      }
 +
 +      /* Strip slashes which came before the file name */
 +      while (end >= path && IS_SLASH_P(end)) {
 +              end--;
 +      }
 +      if (end < path) {
 +              path[0] = DEFAULT_SLASH;
 +              path[1] = '\0';
 +              return 1 + len_adjust;
 +      }
 +      *(end+1) = '\0';
 +
 +      return (size_t)(end + 1 - path) + len_adjust;
 +}
 +/* }}} */
 +
 +static inline zend_bool zend_str_equals_str(zend_string *str1, zend_string *str2) {
 +      return str1->len == str2->len && !memcmp(str1->val, str2->val, str2->len);
 +}
 +static inline zend_bool zend_str_equals_str_ci(zend_string *str1, zend_string *str2) {
 +      return str1->len == str2->len
 +              && !zend_binary_strcasecmp(str1->val, str1->len, str2->val, str2->len);
 +}
 +
 +#define zend_str_equals_literal(str, c) \
 +      ((str)->len == sizeof(c) - 1 && !memcmp((str)->val, (c), sizeof(c) - 1))
 +#define zend_str_equals_literal_ci(str, c) \
 +      ((str)->len == sizeof(c) - 1 \
 +       && !zend_binary_strcasecmp((str)->val, (str)->len, (c), sizeof(c) - 1))
 +
- static void zend_adjust_for_fetch_type(zend_op *opline, zend_uint type) {
++static void zend_adjust_for_fetch_type(zend_op *opline, uint32_t type) {
 +      switch (type & BP_VAR_MASK) {
 +              case BP_VAR_R:
 +                      return;
 +              case BP_VAR_W:
 +                      opline->opcode += 3;
 +                      return;
 +              case BP_VAR_REF:
 +                      opline->opcode += 3;
 +                      opline->extended_value |= ZEND_FETCH_MAKE_REF;
 +                      return;
 +              case BP_VAR_RW:
 +                      opline->opcode += 6;
 +                      return;
 +              case BP_VAR_IS:
 +                      opline->opcode += 9;
 +                      return;
 +              case BP_VAR_FUNC_ARG:
 +                      opline->opcode += 12;
 +                      opline->extended_value |= type >> BP_VAR_SHIFT;
 +                      return;
 +              case BP_VAR_UNSET:
 +                      opline->opcode += 15;
 +                      return;
 +              EMPTY_SWITCH_DEFAULT_CASE()
 +      }
 +}
 +
 +static inline void zend_make_var_result(znode *result, zend_op *opline TSRMLS_DC) {
 +      opline->result_type = IS_VAR;
 +      opline->result.var = get_temporary_variable(CG(active_op_array));
 +      GET_NODE(result, opline->result);
 +}
 +
 +static inline void zend_make_tmp_result(znode *result, zend_op *opline TSRMLS_DC) {
 +      opline->result_type = IS_TMP_VAR;
 +      opline->result.var = get_temporary_variable(CG(active_op_array));
 +      GET_NODE(result, opline->result);
 +}
  
 -                                              ++idx;
 -                                              while (op < end) {
 -                                                      if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT)
 -                                                                      && op->op1.num == (zend_long)idx)
 -                                                      {
 -                                                              precv = op;
 -                                                      }
 -                                                      ++op;
 -                                              }
 -                                      }
 -                                      if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) {
 -                                              zval *zv = precv->op2.zv;
 +static zend_op *zend_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) {
 +      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opline->opcode = opcode;
  
 -                                              if (Z_TYPE_P(zv) == IS_CONSTANT) {
 -                                                      REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN_P(zv));
 -                                                      memcpy(offset, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
 -                                                      offset += Z_STRLEN_P(zv);
 -                                              } else if (Z_TYPE_P(zv) == IS_FALSE) {
 -                                                      memcpy(offset, "false", 5);
 -                                                      offset += 5;
 -                                              } else if (Z_TYPE_P(zv) == IS_TRUE) {
 -                                                      memcpy(offset, "true", 4);
 -                                                      offset += 4;
 -                                              } else if (Z_TYPE_P(zv) == IS_NULL) {
 -                                                      memcpy(offset, "NULL", 4);
 -                                                      offset += 4;
 -                                              } else if (Z_TYPE_P(zv) == IS_STRING) {
 -                                                      *(offset++) = '\'';
 -                                                      REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRLEN_P(zv), 10));
 -                                                      memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10));
 -                                                      offset += MIN(Z_STRLEN_P(zv), 10);
 -                                                      if (Z_STRLEN_P(zv) > 10) {
 -                                                              *(offset++) = '.';
 -                                                              *(offset++) = '.';
 -                                                              *(offset++) = '.';
 -                                                      }
 -                                                      *(offset++) = '\'';
 -                                              } else if (Z_TYPE_P(zv) == IS_ARRAY) {
 -                                                      memcpy(offset, "Array", 5);
 -                                                      offset += 5;
 -                                              } else if (Z_TYPE_P(zv) == IS_CONSTANT_AST) {
 -                                                      memcpy(offset, "<expression>", 12);
 -                                                      offset += 12;
 -                                              } else {
 -                                                      zend_string *str = zval_get_string(zv);
 -                                                      REALLOC_BUF_IF_EXCEED(buf, offset, length, str->len);
 -                                                      memcpy(offset, str->val, str->len);
 -                                                      offset += str->len;
 -                                                      zend_string_release(str);
 -                                              }
 -                                      }
 -                              } else {
 -                                      memcpy(offset, "NULL", 4);
 -                                      offset += 4;
 -                              }
 -                      }
 +      if (op1 == NULL) {
 +              SET_UNUSED(opline->op1);
 +      } else {
 +              SET_NODE(opline->op1, op1);
 +      }
  
 -                      if (++i < fptr->common.num_args) {
 -                              *(offset++) = ',';
 -                              *(offset++) = ' ';
 -                      }
 -                      arg_info++;
 -                      REALLOC_BUF_IF_EXCEED(buf, offset, length, 32);
 -              }
 +      if (op2 == NULL) {
 +              SET_UNUSED(opline->op2);
 +      } else {
 +              SET_NODE(opline->op2, op2);
        }
 -      *(offset++) = ')';
 -      *offset = '\0';
  
 -      return buf;
 +      if (result) {
 +              zend_make_var_result(result, opline TSRMLS_CC);
 +      }
 +      return opline;
  }
 -/* }}} */
  
 -static void do_inheritance_check_on_method(zend_function *child, zend_function *parent TSRMLS_DC) /* {{{ */
 -{
 -      uint32_t child_flags;
 -      uint32_t parent_flags = parent->common.fn_flags;
 +static zend_op *zend_emit_op_tmp(
 +      znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC
 +) {
 +      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opline->opcode = opcode;
  
 -      if ((parent->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
 -              && parent->common.fn_flags & ZEND_ACC_ABSTRACT
 -              && parent->common.scope != (child->common.prototype ? child->common.prototype->common.scope : child->common.scope)
 -              && child->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_IMPLEMENTED_ABSTRACT)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Can't inherit abstract function %s::%s() (previously declared abstract in %s)",
 -                      parent->common.scope->name->val,
 -                      child->common.function_name->val,
 -                      child->common.prototype ? child->common.prototype->common.scope->name->val : child->common.scope->name->val);
 +      if (op1 == NULL) {
 +              SET_UNUSED(opline->op1);
 +      } else {
 +              SET_NODE(opline->op1, op1);
        }
  
 -      if (parent_flags & ZEND_ACC_FINAL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot override final method %s::%s()", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val);
 +      if (op2 == NULL) {
 +              SET_UNUSED(opline->op2);
 +      } else {
 +              SET_NODE(opline->op2, op2);
        }
  
 -      child_flags     = child->common.fn_flags;
 -      /* You cannot change from static to non static and vice versa.
 -       */
 -      if ((child_flags & ZEND_ACC_STATIC) != (parent_flags & ZEND_ACC_STATIC)) {
 -              if (child->common.fn_flags & ZEND_ACC_STATIC) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non static method %s::%s() static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
 -              } else {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot make static method %s::%s() non static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
 -              }
 +      zend_make_tmp_result(result, opline TSRMLS_CC);
 +
 +      return opline;
 +}
 +
 +static void zend_emit_tick(TSRMLS_D) {
 +      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +
 +      opline->opcode = ZEND_TICKS;
 +      SET_UNUSED(opline->op1);
 +      SET_UNUSED(opline->op2);
 +      opline->extended_value = Z_LVAL(CG(declarables).ticks);
 +}
 +
 +static inline zend_op *zend_emit_op_data(znode *value TSRMLS_DC) {
 +      return zend_emit_op(NULL, ZEND_OP_DATA, value, NULL TSRMLS_CC);
 +}
 +
- static inline zend_uint zend_emit_jump(zend_uint opnum_target TSRMLS_DC) {
-       zend_uint opnum = get_next_op_number(CG(active_op_array));
++static inline uint32_t zend_emit_jump(uint32_t opnum_target TSRMLS_DC) {
++      uint32_t opnum = get_next_op_number(CG(active_op_array));
 +      zend_op *opline = zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC);
 +      opline->op1.opline_num = opnum_target;
 +      return opnum;
 +}
 +
- static inline zend_uint zend_emit_cond_jump(
-       zend_uchar opcode, znode *cond, zend_uint opnum_target TSRMLS_DC
++static inline uint32_t zend_emit_cond_jump(
++      zend_uchar opcode, znode *cond, uint32_t opnum_target TSRMLS_DC
 +) {
-       zend_uint opnum = get_next_op_number(CG(active_op_array));
++      uint32_t opnum = get_next_op_number(CG(active_op_array));
 +      zend_op *opline = zend_emit_op(NULL, opcode, cond, NULL TSRMLS_CC);
 +      opline->op2.opline_num = opnum_target;
 +      return opnum;
 +}
 +
- static inline void zend_update_jump_target(zend_uint opnum_jump, zend_uint opnum_target TSRMLS_DC) {
++static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_target TSRMLS_DC) {
 +      zend_op *opline = &CG(active_op_array)->opcodes[opnum_jump];
 +      switch (opline->opcode) {
 +              case ZEND_JMP:
 +                      opline->op1.opline_num = opnum_target;
 +                      break;
 +              case ZEND_JMPZ:
 +              case ZEND_JMPNZ:
 +              case ZEND_JMPZ_EX:
 +              case ZEND_JMPNZ_EX:
 +                      opline->op2.opline_num = opnum_target;
 +                      break;
 +              EMPTY_SWITCH_DEFAULT_CASE()
 +      }
 +}
 +
- static inline void zend_update_jump_target_to_next(zend_uint opnum_jump TSRMLS_DC) {
++static inline void zend_update_jump_target_to_next(uint32_t opnum_jump TSRMLS_DC) {
 +      zend_update_jump_target(opnum_jump, get_next_op_number(CG(active_op_array)) TSRMLS_CC);
 +}
 +
 +static inline zend_op *zend_delayed_emit_op(
 +      znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC
 +) {
 +      zend_op tmp_opline;
 +      init_op(&tmp_opline TSRMLS_CC);
 +      tmp_opline.opcode = opcode;
 +      SET_NODE(tmp_opline.op1, op1);
 +      SET_NODE(tmp_opline.op2, op2);
 +      if (result) {
 +              zend_make_var_result(result, &tmp_opline TSRMLS_CC);
        }
  
 -      /* Disallow making an inherited method abstract. */
 -      if ((child_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_ABSTRACT)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non abstract method %s::%s() abstract in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
 +      zend_stack_push(&CG(delayed_oplines_stack), &tmp_opline);
 +      return zend_stack_top(&CG(delayed_oplines_stack));
 +}
 +
- static inline zend_uint zend_delayed_compile_begin(TSRMLS_D) {
++static inline uint32_t zend_delayed_compile_begin(TSRMLS_D) {
 +      return zend_stack_count(&CG(delayed_oplines_stack));
 +}
 +
- static zend_op *zend_delayed_compile_end(zend_uint offset TSRMLS_DC) {
++static zend_op *zend_delayed_compile_end(uint32_t offset TSRMLS_DC) {
 +      zend_op *opline, *oplines = zend_stack_base(&CG(delayed_oplines_stack));
-       zend_uint i, count = zend_stack_count(&CG(delayed_oplines_stack));
++      uint32_t i, count = zend_stack_count(&CG(delayed_oplines_stack));
 +
 +      ZEND_ASSERT(count > offset);
 +      for (i = offset; i < count; ++i) {
 +              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +              memcpy(opline, &oplines[i], sizeof(zend_op));
        }
 +      CG(delayed_oplines_stack).top = offset;
 +      return opline;
 +}
  
 -      if (parent_flags & ZEND_ACC_CHANGED) {
 -              child->common.fn_flags |= ZEND_ACC_CHANGED;
 +void zend_emit_final_return(zval *zv TSRMLS_DC) {
 +      znode zn;
 +      zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
 +
 +      zn.op_type = IS_CONST;
 +      if (zv) {
 +              ZVAL_COPY_VALUE(&zn.u.constant, zv);
        } else {
 -              /* Prevent derived classes from restricting access that was available in parent classes
 -               */
 -              if ((child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
 -              } else if (((child_flags & ZEND_ACC_PPP_MASK) < (parent_flags & ZEND_ACC_PPP_MASK))
 -                      && ((parent_flags & ZEND_ACC_PPP_MASK) & ZEND_ACC_PRIVATE)) {
 -                      child->common.fn_flags |= ZEND_ACC_CHANGED;
 -              }
 +              ZVAL_NULL(&zn.u.constant);
        }
  
 -      if (parent_flags & ZEND_ACC_PRIVATE) {
 -              child->common.prototype = NULL;
 -      } else if (parent_flags & ZEND_ACC_ABSTRACT) {
 -              child->common.fn_flags |= ZEND_ACC_IMPLEMENTED_ABSTRACT;
 -              child->common.prototype = parent;
 -      } else if (!(parent->common.fn_flags & ZEND_ACC_CTOR) || (parent->common.prototype && (parent->common.prototype->common.scope->ce_flags & ZEND_ACC_INTERFACE))) {
 -              /* ctors only have a prototype if it comes from an interface */
 -              child->common.prototype = parent->common.prototype ? parent->common.prototype : parent;
 +      zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL TSRMLS_CC);
 +}
 +
 +
 +static inline zend_bool zend_is_variable(zend_ast *ast) {
 +      return ast->kind == ZEND_AST_VAR || ast->kind == ZEND_AST_DIM
 +              || ast->kind == ZEND_AST_PROP || ast->kind == ZEND_AST_STATIC_PROP
 +              || ast->kind == ZEND_AST_CALL || ast->kind == ZEND_AST_METHOD_CALL
 +              || ast->kind == ZEND_AST_STATIC_CALL;
 +}
 +
 +static inline zend_bool zend_is_call(zend_ast *ast) {
 +      return ast->kind == ZEND_AST_CALL
 +              || ast->kind == ZEND_AST_METHOD_CALL
 +              || ast->kind == ZEND_AST_STATIC_CALL;
 +}
 +
 +static inline zend_bool zend_is_unticked_stmt(zend_ast *ast) {
 +      return ast->kind == ZEND_AST_STMT_LIST || ast->kind == ZEND_AST_LABEL;
 +}
 +
 +static inline zend_bool zend_can_write_to_variable(zend_ast *ast) {
 +      while (ast->kind == ZEND_AST_DIM || ast->kind == ZEND_AST_PROP) {
 +              ast = ast->child[0];
        }
  
 -      if (child->common.prototype && (child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT)) {
 -              if (!zend_do_perform_implementation_check(child, child->common.prototype TSRMLS_CC)) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s::%s() must be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, zend_get_function_declaration(child->common.prototype TSRMLS_CC));
 -              }
 -      } else if (EG(error_reporting) & E_STRICT || Z_TYPE(EG(user_error_handler)) != IS_UNDEF) { /* Check E_STRICT (or custom error handler) before the check so that we save some time */
 -              if (!zend_do_perform_implementation_check(child, parent TSRMLS_CC)) {
 -                      char *method_prototype = zend_get_function_declaration(parent TSRMLS_CC);
 -                      zend_error(E_STRICT, "Declaration of %s::%s() should be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, method_prototype);
 -                      efree(method_prototype);
 -              }
 +      return zend_is_variable(ast);
 +}
 +
 +static inline zend_bool zend_is_const_default_class_ref(zend_ast *name_ast) {
 +      zend_string *name;
 +
 +      if (name_ast->kind != ZEND_AST_ZVAL) {
 +              return 0;
 +      }
 +
 +      /* Fully qualified names are always default refs */
 +      if (!name_ast->attr) {
 +              return 1;
        }
 +
 +      name = zend_ast_get_str(name_ast);
 +      return ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(name);
  }
 -/* }}} */
  
 -static zend_bool do_inherit_method_check(HashTable *child_function_table, zend_function *parent, zend_string *key, zend_class_entry *child_ce) /* {{{ */
 -{
 -      uint32_t parent_flags = parent->common.fn_flags;
 -      zend_function *child;
 -      TSRMLS_FETCH();
 +static inline void zend_handle_numeric_op(znode *node TSRMLS_DC) {
 +      if (node->op_type == IS_CONST && Z_TYPE(node->u.constant) == IS_STRING) {
 +              zend_ulong index;
  
 -      if ((child = zend_hash_find_ptr(child_function_table, key)) == NULL) {
 -              if (parent_flags & (ZEND_ACC_ABSTRACT)) {
 -                      child_ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
 +              if (ZEND_HANDLE_NUMERIC(Z_STR(node->u.constant), index)) {
 +                      zval_ptr_dtor(&node->u.constant);
 +                      ZVAL_LONG(&node->u.constant, index);
                }
 -              return 1; /* method doesn't exist in child, copy from parent */
        }
 +}
  
 -      do_inheritance_check_on_method(child, parent TSRMLS_CC);
 -
 -      return 0;
 +static inline void zend_set_class_name_op1(zend_op *opline, znode *class_node TSRMLS_DC) {
 +      if (class_node->op_type == IS_CONST) {
 +              opline->op1_type = IS_CONST;
 +              opline->op1.constant = zend_add_class_name_literal(
 +                      CG(active_op_array), Z_STR(class_node->u.constant) TSRMLS_CC);
 +      } else {
 +              SET_NODE(opline->op1, class_node);
 +      }
  }
 -/* }}} */
  
 -static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_property_info *parent_info, zend_string *key, zend_class_entry *ce TSRMLS_DC) /* {{{ */
 -{
 -      zend_property_info *child_info;
 -      zend_class_entry *parent_ce = ce->parent;
 +static zend_op *zend_compile_class_ref(znode *result, zend_ast *name_ast TSRMLS_DC) {
 +      zend_op *opline;
 +      znode name_node;
 +      zend_compile_expr(&name_node, name_ast TSRMLS_CC);
  
 -      if (parent_info->flags & (ZEND_ACC_PRIVATE|ZEND_ACC_SHADOW)) {
 -              if ((child_info = zend_hash_find_ptr(&ce->properties_info, key)) != NULL) {
 -                      child_info->flags |= ZEND_ACC_CHANGED;
 -              } else {
 -                      if(ce->type & ZEND_INTERNAL_CLASS) {
 -                              child_info = zend_duplicate_property_info_internal(parent_info);
 -                      } else {
 -                              child_info = zend_duplicate_property_info(parent_info TSRMLS_CC);
 -                      }
 -                      zend_hash_update_ptr(&ce->properties_info, key, child_info);
 -                      child_info->flags &= ~ZEND_ACC_PRIVATE; /* it's not private anymore */
 -                      child_info->flags |= ZEND_ACC_SHADOW; /* but it's a shadow of private */
 +      if (name_node.op_type == IS_CONST) {
 +              zend_string *name = Z_STR(name_node.u.constant);
-               zend_uint fetch_type = zend_get_class_fetch_type(name);
++              uint32_t fetch_type = zend_get_class_fetch_type(name);
 +
 +              opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, NULL TSRMLS_CC);
 +              opline->extended_value = fetch_type;
 +
 +              if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) {
-                       zend_uint type = name_ast->kind == ZEND_AST_ZVAL ? name_ast->attr : ZEND_NAME_FQ;
++                      uint32_t type = name_ast->kind == ZEND_AST_ZVAL ? name_ast->attr : ZEND_NAME_FQ;
 +                      opline->op2_type = IS_CONST;
 +                      opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
 +                              zend_resolve_class_name(name, type TSRMLS_CC) TSRMLS_CC);
                }
 -              return 0; /* don't copy access information to child */
 +
-               STR_RELEASE(name);
++              zend_string_release(name);
 +      } else {
 +              opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node TSRMLS_CC);
 +              opline->extended_value = ZEND_FETCH_CLASS_DEFAULT;
        }
  
 -      if ((child_info = zend_hash_find_ptr(&ce->properties_info, key)) != NULL) {
 -              if ((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC)) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s",
 -                              (parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", parent_ce->name->val, key->val,
 -                              (child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ce->name->val, key->val);
 +      return opline;
 +}
  
-                       STR_RELEASE(name);
 +static int zend_try_compile_cv(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *name_ast = ast->child[0];
 +      if (name_ast->kind == ZEND_AST_ZVAL) {
 +              zend_string *name = zval_get_string(zend_ast_get_zval(name_ast));
 +
 +              if (zend_is_auto_global(name TSRMLS_CC)) {
++                      zend_string_release(name);
 +                      return FAILURE;
                }
  
 -              if(parent_info->flags & ZEND_ACC_CHANGED) {
 -                      child_info->flags |= ZEND_ACC_CHANGED;
 +              result->op_type = IS_CV;
 +              result->u.op.var = lookup_cv(CG(active_op_array), name TSRMLS_CC);
 +
 +              if (zend_str_equals_literal(name, "this")) {
 +                      CG(active_op_array)->this_var = result->u.op.var;
                }
-               zend_string *key = STR_INIT("this", sizeof("this") - 1, 0);
 +              return SUCCESS;
 +      }
 +
 +      return FAILURE;
 +}
 +
 +static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, int type TSRMLS_DC) {
 +      zend_ast *name_ast = ast->child[0];
 +      znode name_node;
 +      zend_op *opline;
 +
 +      /* there is a chance someone is accessing $this */
 +      if (ast->kind != ZEND_AST_ZVAL
 +              && CG(active_op_array)->scope && CG(active_op_array)->this_var == -1
 +      ) {
++              zend_string *key = zend_string_init("this", sizeof("this") - 1, 0);
 +              CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC);
 +      }
 +
 +      zend_compile_expr(&name_node, name_ast TSRMLS_CC);
  
 -              if ((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK)) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ce->name->val, key->val, zend_visibility_string(parent_info->flags), parent_ce->name->val, (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
 -              } else if ((child_info->flags & ZEND_ACC_STATIC) == 0) {
 -                      zval_ptr_dtor(&(ce->default_properties_table[parent_info->offset]));
 -                      ce->default_properties_table[parent_info->offset] = ce->default_properties_table[child_info->offset];
 -                      ZVAL_UNDEF(&ce->default_properties_table[child_info->offset]);
 -                      child_info->offset = parent_info->offset;
 +      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opline = zend_emit_op(result, ZEND_FETCH_R, &name_node, NULL TSRMLS_CC);
 +
 +      opline->extended_value = ZEND_FETCH_LOCAL;
 +      if (name_node.op_type == IS_CONST) {
 +              if (zend_is_auto_global(Z_STR(name_node.u.constant) TSRMLS_CC)) {
 +                      opline->extended_value = ZEND_FETCH_GLOBAL;
                }
 -              return 0;       /* Don't copy from parent */
 -      } else {
 -              return 1;       /* Copy from parent */
        }
 +
 +      return opline;
  }
 -/* }}} */
  
 -static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
 -{
 -      if (!(ce->ce_flags & ZEND_ACC_INTERFACE) && iface->interface_gets_implemented && iface->interface_gets_implemented(iface, ce TSRMLS_CC) == FAILURE) {
 -              zend_error(E_CORE_ERROR, "Class %s could not implement interface %s", ce->name->val, iface->name->val);
 +static void zend_compile_simple_var(znode *result, zend_ast *ast, int type TSRMLS_DC) {
 +      if (zend_try_compile_cv(result, ast TSRMLS_CC) == FAILURE) {
 +              zend_op *opline = zend_compile_simple_var_no_cv(result, ast, type TSRMLS_CC);
 +              zend_adjust_for_fetch_type(opline, type);
        }
 -      if (ce == iface) {
 -              zend_error(E_ERROR, "Interface %s cannot implement itself", ce->name->val);
 +}
 +
 +static void zend_separate_if_call_and_write(znode *node, zend_ast *ast, int type TSRMLS_DC) {
 +      if (type != BP_VAR_R && type != BP_VAR_IS && zend_is_call(ast)) {
 +              zend_op *opline = zend_emit_op(NULL, ZEND_SEPARATE, node, NULL TSRMLS_CC);
 +              opline->result_type = IS_VAR;
 +              opline->result.var = opline->op1.var;
        }
  }
 -/* }}} */
  
- void zend_delayed_compile_var(znode *result, zend_ast *ast, zend_uint type TSRMLS_DC);
 -ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface TSRMLS_DC) /* {{{ */
 -{
 -      /* expects interface to be contained in ce's interface list already */
 -      uint32_t i, ce_num, if_num = iface->num_interfaces;
 -      zend_class_entry *entry;
++void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC);
  
- static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, zend_uint type TSRMLS_DC) {
 -      if (if_num==0) {
 -              return;
 -      }
 -      ce_num = ce->num_interfaces;
++static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) {
 +      zend_ast *var_ast = ast->child[0];
 +      zend_ast *dim_ast = ast->child[1];
  
 -      if (ce->type == ZEND_INTERNAL_CLASS) {
 -              ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
 -      } else {
 -              ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
 -      }
 +      znode var_node, dim_node;
  
 -      /* Inherit the interfaces, only if they're not already inherited by the class */
 -      while (if_num--) {
 -              entry = iface->interfaces[if_num];
 -              for (i = 0; i < ce_num; i++) {
 -                      if (ce->interfaces[i] == entry) {
 -                              break;
 -                      }
 +      zend_delayed_compile_var(&var_node, var_ast, type TSRMLS_CC);
 +      zend_separate_if_call_and_write(&var_node, var_ast, type TSRMLS_CC);
 +
 +      if (dim_ast == NULL) {
 +              if (type == BP_VAR_R || type == BP_VAR_IS) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
                }
 -              if (i == ce_num) {
 -                      ce->interfaces[ce->num_interfaces++] = entry;
 +              if (type == BP_VAR_UNSET) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting");
                }
 +              dim_node.op_type = IS_UNUSED;
 +      } else {
 +              zend_compile_expr(&dim_node, dim_ast TSRMLS_CC);
 +              zend_handle_numeric_op(&dim_node TSRMLS_CC);
        }
  
 -      /* and now call the implementing handlers */
 -      while (ce_num < ce->num_interfaces) {
 -              do_implement_interface(ce, ce->interfaces[ce_num++] TSRMLS_CC);
 -      }
 +      return zend_delayed_emit_op(result, ZEND_FETCH_DIM_R, &var_node, &dim_node TSRMLS_CC);
  }
 -/* }}} */
  
 -#ifdef ZTS
 -# define zval_property_ctor(parent_ce, ce) \
 -      (((parent_ce)->type != (ce)->type) ? ZVAL_COPY_CTOR : zval_add_ref)
 -#else
 -# define zval_property_ctor(parent_ce, ce) \
 -      zval_add_ref
 -#endif
 +static inline zend_op *zend_compile_dim_common(
-       znode *result, zend_ast *ast, zend_uint type TSRMLS_DC
++      znode *result, zend_ast *ast, uint32_t type TSRMLS_DC
 +) {
-       zend_uint offset = zend_delayed_compile_begin(TSRMLS_C);
++      uint32_t offset = zend_delayed_compile_begin(TSRMLS_C);
 +      zend_delayed_compile_dim(result, ast, type TSRMLS_CC);
 +      return zend_delayed_compile_end(offset TSRMLS_CC);
 +}
  
 -static void do_inherit_class_constant(zend_string *name, zval *zv, zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC) /* {{{ */
 -{
 -      if (!Z_ISREF_P(zv)) {
 -              if (parent_ce->type == ZEND_INTERNAL_CLASS) {
 -                      ZVAL_NEW_PERSISTENT_REF(zv, zv);
 -              } else {
 -                      ZVAL_NEW_REF(zv, zv);
 -              }
 -      }
 -      if (Z_CONSTANT_P(Z_REFVAL_P(zv))) {
 -              ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
 -      }
 -      if (zend_hash_add(&ce->constants_table, name, zv)) {
 -              Z_ADDREF_P(zv);
 +void zend_compile_dim(znode *result, zend_ast *ast, int type TSRMLS_DC) {
 +      zend_op *opline = zend_compile_dim_common(result, ast, type TSRMLS_CC);
 +      zend_adjust_for_fetch_type(opline, type);
 +}
 +
 +static zend_bool is_this_fetch(zend_ast *ast) {
 +      if (ast->kind == ZEND_AST_VAR && ast->child[0]->kind == ZEND_AST_ZVAL) {
 +              zval *name = zend_ast_get_zval(ast->child[0]);
 +              return Z_TYPE_P(name) == IS_STRING && zend_str_equals_literal(Z_STR_P(name), "this");
        }
 +
 +      return 0;
  }
 -/* }}} */
  
 -ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC) /* {{{ */
 -{
 -      zend_property_info *property_info;
 -      zend_function *func;
 -      zend_string *key;
 -      zval *zv;
 +static zend_op *zend_delayed_compile_prop(
-       znode *result, zend_ast *ast, zend_uint type TSRMLS_DC
++      znode *result, zend_ast *ast, uint32_t type TSRMLS_DC
 +) {
 +      zend_ast *obj_ast = ast->child[0];
 +      zend_ast *prop_ast = ast->child[1];
  
 -      if ((ce->ce_flags & ZEND_ACC_INTERFACE)
 -              && !(parent_ce->ce_flags & ZEND_ACC_INTERFACE)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Interface %s may not inherit from class (%s)", ce->name->val, parent_ce->name->val);
 -      }
 -      if (parent_ce->ce_flags & ZEND_ACC_FINAL_CLASS) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Class %s may not inherit from final class (%s)", ce->name->val, parent_ce->name->val);
 -      }
 +      znode obj_node, prop_node;
 +      zend_op *opline;
  
 -      ce->parent = parent_ce;
 -      /* Copy serialize/unserialize callbacks */
 -      if (!ce->serialize) {
 -              ce->serialize   = parent_ce->serialize;
 +      if (is_this_fetch(obj_ast)) {
 +              obj_node.op_type = IS_UNUSED;
 +      } else {
 +              zend_delayed_compile_var(&obj_node, obj_ast, type TSRMLS_CC);
 +              zend_separate_if_call_and_write(&obj_node, obj_ast, type TSRMLS_CC);
        }
 -      if (!ce->unserialize) {
 -              ce->unserialize = parent_ce->unserialize;
 +      zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
 +
 +      opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node TSRMLS_CC);
 +      if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
 +              zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
        }
  
 -      /* Inherit interfaces */
 -      zend_do_inherit_interfaces(ce, parent_ce TSRMLS_CC);
 +      return opline;
 +}
  
- static zend_op *zend_compile_prop_common(znode *result, zend_ast *ast, zend_uint type TSRMLS_DC) {
-       zend_uint offset = zend_delayed_compile_begin(TSRMLS_C);
 -      /* Inherit properties */
 -      if (parent_ce->default_properties_count) {
 -              int i = ce->default_properties_count + parent_ce->default_properties_count;
++static zend_op *zend_compile_prop_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) {
++      uint32_t offset = zend_delayed_compile_begin(TSRMLS_C);
 +      zend_delayed_compile_prop(result, ast, type TSRMLS_CC);
 +      return zend_delayed_compile_end(offset TSRMLS_CC);
 +}
  
 -              ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(zval) * i, ce->type == ZEND_INTERNAL_CLASS);
 -              if (ce->default_properties_count) {
 -                      while (i-- > parent_ce->default_properties_count) {
 -                              ce->default_properties_table[i] = ce->default_properties_table[i - parent_ce->default_properties_count];
 -                      }
 -              }
 -              for (i = 0; i < parent_ce->default_properties_count; i++) {
 -#ifdef ZTS
 -                      if (parent_ce->type != ce->type) {
 -                              ZVAL_DUP(&ce->default_properties_table[i], &parent_ce->default_properties_table[i]);
 -                              if (Z_OPT_CONSTANT(ce->default_properties_table[i])) {
 -                                      ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
 -                              }
 -                              continue;
 -                      }
 -#endif
 +void zend_compile_prop(znode *result, zend_ast *ast, int type TSRMLS_DC) {
 +      zend_op *opline = zend_compile_prop_common(result, ast, type TSRMLS_CC);
 +      zend_adjust_for_fetch_type(opline, type);
 +}
  
 -                      ZVAL_COPY(&ce->default_properties_table[i], &parent_ce->default_properties_table[i]);
 -                      if (Z_OPT_CONSTANT(ce->default_properties_table[i])) {
 -                              ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
 -                      }
 -              }
 -              ce->default_properties_count += parent_ce->default_properties_count;
 -      }
 +zend_op *zend_compile_static_prop_common(znode *result, zend_ast *ast, int type TSRMLS_DC) {
 +      zend_ast *class_ast = ast->child[0];
 +      zend_ast *prop_ast = ast->child[1];
  
 -      if (parent_ce->type != ce->type) {
 -              /* User class extends internal class */
 -              zend_update_class_constants(parent_ce  TSRMLS_CC);
 -              if (parent_ce->default_static_members_count) {
 -                      int i = ce->default_static_members_count + parent_ce->default_static_members_count;
 +      znode class_node, prop_node;
 +      zend_op *opline;
  
 -                      ce->default_static_members_table = erealloc(ce->default_static_members_table, sizeof(zval) * i);
 -                      if (ce->default_static_members_count) {
 -                              while (i-- > parent_ce->default_static_members_count) {
 -                                      ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count];
 -                              }
 -                      }
 -                      for (i = 0; i < parent_ce->default_static_members_count; i++) {
 -                              ZVAL_MAKE_REF(&CE_STATIC_MEMBERS(parent_ce)[i]);
 -                              ce->default_static_members_table[i] = CE_STATIC_MEMBERS(parent_ce)[i];
 -                              Z_ADDREF(ce->default_static_members_table[i]);
 -                              if (Z_CONSTANT_P(Z_REFVAL(ce->default_static_members_table[i]))) {
 -                                      ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
 -                              }
 -                      }
 -                      ce->default_static_members_count += parent_ce->default_static_members_count;
 -                      ce->static_members_table = ce->default_static_members_table;
 -              }
 +      if (zend_is_const_default_class_ref(class_ast)) {
 +              class_node.op_type = IS_CONST;
 +              ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
        } else {
 -              if (parent_ce->default_static_members_count) {
 -                      int i = ce->default_static_members_count + parent_ce->default_static_members_count;
 -
 -                      ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(zval) * i, ce->type == ZEND_INTERNAL_CLASS);
 -                      if (ce->default_static_members_count) {
 -                              while (i-- > parent_ce->default_static_members_count) {
 -                                      ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count];
 -                              }
 -                      }
 -                      for (i = 0; i < parent_ce->default_static_members_count; i++) {
 -                              ZVAL_MAKE_REF(&parent_ce->default_static_members_table[i]);
 -                              ce->default_static_members_table[i] = parent_ce->default_static_members_table[i];
 -                              Z_ADDREF(ce->default_static_members_table[i]);
 -                              if (Z_CONSTANT_P(Z_REFVAL(ce->default_static_members_table[i]))) {
 -                                      ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
 -                              }
 -                      }
 -                      ce->default_static_members_count += parent_ce->default_static_members_count;
 -                      if (ce->type == ZEND_USER_CLASS) {
 -                              ce->static_members_table = ce->default_static_members_table;
 -                      }
 -              }
 +              zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
        }
  
 -      ZEND_HASH_FOREACH_PTR(&ce->properties_info, property_info) {
 -              if (property_info->ce == ce) {
 -                      if (property_info->flags & ZEND_ACC_STATIC) {
 -                              property_info->offset += parent_ce->default_static_members_count;
 -                      } else {
 -                              property_info->offset += parent_ce->default_properties_count;
 -                      }
 -              }
 -      } ZEND_HASH_FOREACH_END();
 -
 -      ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->properties_info, key, property_info) {
 -              if (do_inherit_property_access_check(&ce->properties_info, property_info, key, ce TSRMLS_CC)) {
 -                      if (ce->type & ZEND_INTERNAL_CLASS) {
 -                              property_info = zend_duplicate_property_info_internal(property_info);
 -                      } else {
 -                              property_info = zend_duplicate_property_info(property_info TSRMLS_CC);
 -                      }
 -                      zend_hash_add_new_ptr(&ce->properties_info, key, property_info);
 -              }
 -      } ZEND_HASH_FOREACH_END();
 +      zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
  
 -      ZEND_HASH_FOREACH_STR_KEY_VAL(&parent_ce->constants_table, key, zv) {
 -              do_inherit_class_constant(key, zv, ce, parent_ce TSRMLS_CC);
 -      } ZEND_HASH_FOREACH_END();
 +      opline = zend_emit_op(result, ZEND_FETCH_R, &prop_node, NULL TSRMLS_CC);
 +      if (opline->op1_type == IS_CONST) {
 +              zend_alloc_polymorphic_cache_slot(opline->op1.constant TSRMLS_CC);
 +      }
 +      if (class_node.op_type == IS_CONST) {
 +              opline->op2_type = IS_CONST;
 +              opline->op2.constant = zend_add_class_name_literal(
 +                      CG(active_op_array), Z_STR(class_node.u.constant) TSRMLS_CC);
 +      } else {
 +              SET_NODE(opline->op2, &class_node);
 +      }
 +      opline->extended_value |= ZEND_FETCH_STATIC_MEMBER;
  
 -      ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, func) {
 -              if (do_inherit_method_check(&ce->function_table, func, key, ce)) {
 -                      zend_function *new_func = do_inherit_method(func TSRMLS_CC);
 -                      zend_hash_add_new_ptr(&ce->function_table, key, new_func);
 -              }
 -      } ZEND_HASH_FOREACH_END();
 +      return opline;
 +}
  
- void zend_compile_static_prop(znode *result, zend_ast *ast, zend_uint type TSRMLS_DC) {
 -      do_inherit_parent_constructor(ce TSRMLS_CC);
++void zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) {
 +      zend_op *opline = zend_compile_static_prop_common(result, ast, type TSRMLS_CC);
 +      zend_adjust_for_fetch_type(opline, type);
 +}
  
 -      if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS && ce->type == ZEND_INTERNAL_CLASS) {
 -              ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
 -      } else if (!(ce->ce_flags & (ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
 -              /* The verification will be done in runtime by ZEND_VERIFY_ABSTRACT_CLASS */
 -              zend_verify_abstract_class(ce TSRMLS_CC);
 +static inline zend_uchar get_list_fetch_opcode(zend_uchar op_type) {
 +      switch (op_type) {
 +              case IS_VAR:
 +              case IS_CV:
 +                      return ZEND_FETCH_DIM_R;
 +              case IS_TMP_VAR:
 +              case IS_CONST:
 +                      return ZEND_FETCH_DIM_TMP_VAR;
 +              EMPTY_SWITCH_DEFAULT_CASE()
        }
 -      ce->ce_flags |= parent_ce->ce_flags & ZEND_HAS_STATIC_IN_METHODS;
  }
 -/* }}} */
  
 -static zend_bool do_inherit_constant_check(HashTable *child_constants_table, zval *parent_constant, zend_string *name, const zend_class_entry *iface) /* {{{ */
 -{
 -      zval *old_constant;
 +static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint i;
++      uint32_t i;
  
 -      if ((old_constant = zend_hash_find(child_constants_table, name)) != NULL) {
 -              if (!Z_ISREF_P(old_constant) ||
 -                  !Z_ISREF_P(parent_constant) ||
 -                  Z_REFVAL_P(old_constant) != Z_REFVAL_P(parent_constant)) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot inherit previously-inherited or override constant %s from interface %s", name->val, iface->name->val);
 -              }
 -              return 0;
 +      if (list->children == 1 && !list->child[0]) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list");
        }
 -      return 1;
 -}
 -/* }}} */
  
 -static void do_inherit_iface_constant(zend_string *name, zval *zv, zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
 -{
 -      if (do_inherit_constant_check(&ce->constants_table, zv, name, iface)) {
 -              ZVAL_MAKE_REF(zv);
 -              Z_ADDREF_P(zv);
 -              if (Z_CONSTANT_P(Z_REFVAL_P(zv))) {
 -                      ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *var_ast = list->child[i];
 +              znode fetch_result, dim_node, var_node, assign_result;
 +              zend_op *opline;
 +
 +              if (var_ast == NULL) {
 +                      continue;
 +              }
 +
 +              dim_node.op_type = IS_CONST;
 +              ZVAL_LONG(&dim_node.u.constant, i);
 +
 +              if (expr_node->op_type == IS_CONST) {
 +                      Z_TRY_ADDREF(expr_node->u.constant);
 +              }
 +
 +              opline = zend_emit_op(&fetch_result,
 +                      get_list_fetch_opcode(expr_node->op_type), expr_node, &dim_node TSRMLS_CC);
 +              opline->extended_value |= ZEND_FETCH_ADD_LOCK;
 +
 +              if (var_ast->kind != ZEND_AST_LIST) {
 +                      if (is_this_fetch(var_ast)) {
 +                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 +                      }
 +                      zend_compile_var(&var_node, var_ast, BP_VAR_W TSRMLS_CC);
 +                      zend_emit_op(&assign_result, ZEND_ASSIGN, &var_node, &fetch_result TSRMLS_CC);
 +                      zend_do_free(&assign_result TSRMLS_CC);
 +              } else {
 +                      zend_compile_list_assign(&assign_result, var_ast, &fetch_result TSRMLS_CC);
 +                      zend_do_free(&assign_result TSRMLS_CC);
                }
 -              zend_hash_update(&ce->constants_table, name, zv);
        }
 +      *result = *expr_node;
  }
 -/* }}} */
  
 -ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
 -{
 -      uint32_t i, ignore = 0;
 -      uint32_t current_iface_num = ce->num_interfaces;
 -      uint32_t parent_iface_num  = ce->parent ? ce->parent->num_interfaces : 0;
 -      zend_function *func;
 -      zend_string *key;
 -      zval *zv;
 +void zend_ensure_writable_variable(const zend_ast *ast) {
 +      if (ast->kind == ZEND_AST_CALL) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context");
 +      }
 +      if (ast->kind == ZEND_AST_METHOD_CALL || ast->kind == ZEND_AST_STATIC_CALL) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context");
 +      }
 +}
  
 -      for (i = 0; i < ce->num_interfaces; i++) {
 -              if (ce->interfaces[i] == NULL) {
 -                      memmove(ce->interfaces + i, ce->interfaces + i + 1, sizeof(zend_class_entry*) * (--ce->num_interfaces - i));
 -                      i--;
 -              } else if (ce->interfaces[i] == iface) {
 -                      if (i < parent_iface_num) {
 -                              ignore = 1;
 -                      } else {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ce->name->val, iface->name->val);
 -                      }
 -              }
 +/* Detects $a... = $a pattern */
 +zend_bool zend_is_assign_to_self(zend_ast *var_ast, zend_ast *expr_ast TSRMLS_DC) {
 +      if (expr_ast->kind != ZEND_AST_VAR || expr_ast->child[0]->kind != ZEND_AST_ZVAL) {
 +              return 0;
        }
 -      if (ignore) {
 -              /* Check for attempt to redeclare interface constants */
 -              ZEND_HASH_FOREACH_STR_KEY_VAL(&ce->constants_table, key, zv) {
 -                      do_inherit_constant_check(&iface->constants_table, zv, key, iface);
 -              } ZEND_HASH_FOREACH_END();
 -      } else {
 -              if (ce->num_interfaces >= current_iface_num) {
 -                      if (ce->type == ZEND_INTERNAL_CLASS) {
 -                              ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
 -                      } else {
 -                              ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
 -                      }
 -              }
 -              ce->interfaces[ce->num_interfaces++] = iface;
  
 -              ZEND_HASH_FOREACH_STR_KEY_VAL(&iface->constants_table, key, zv) {
 -                      do_inherit_iface_constant(key, zv, ce, iface TSRMLS_CC);
 -              } ZEND_HASH_FOREACH_END();
 +      while (zend_is_variable(var_ast) && var_ast->kind != ZEND_AST_VAR) {
 +              var_ast = var_ast->child[0];
 +      }
  
 -              ZEND_HASH_FOREACH_STR_KEY_PTR(&iface->function_table, key, func) {
 -                      if (do_inherit_method_check(&ce->function_table, func, key, ce)) {
 -                              zend_function *new_func = do_inherit_method(func TSRMLS_CC);
 -                              zend_hash_add_new_ptr(&ce->function_table, key, new_func);
 -                      }
 -              } ZEND_HASH_FOREACH_END();
 +      if (var_ast->kind != ZEND_AST_VAR || var_ast->child[0]->kind != ZEND_AST_ZVAL) {
 +              return 0;
 +      }
  
 -              do_implement_interface(ce, iface TSRMLS_CC);
 -              zend_do_inherit_interfaces(ce, iface TSRMLS_CC);
 +      {
 +              zend_string *name1 = zval_get_string(zend_ast_get_zval(var_ast->child[0]));
 +              zend_string *name2 = zval_get_string(zend_ast_get_zval(expr_ast->child[0]));
 +              zend_bool result = zend_str_equals_str(name1, name2);
-               STR_RELEASE(name1);
-               STR_RELEASE(name2);
++              zend_string_release(name1);
++              zend_string_release(name2);
 +              return result;
        }
  }
 -/* }}} */
  
 -ZEND_API void zend_do_implement_trait(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */
 -{
 -      uint32_t i, ignore = 0;
 -      uint32_t current_trait_num = ce->num_traits;
 -      uint32_t parent_trait_num  = ce->parent ? ce->parent->num_traits : 0;
 +void zend_compile_assign(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *var_ast = ast->child[0];
 +      zend_ast *expr_ast = ast->child[1];
  
 -      for (i = 0; i < ce->num_traits; i++) {
 -              if (ce->traits[i] == NULL) {
 -                      memmove(ce->traits + i, ce->traits + i + 1, sizeof(zend_class_entry*) * (--ce->num_traits - i));
 -                      i--;
 -              } else if (ce->traits[i] == trait) {
 -                      if (i < parent_trait_num) {
 -                              ignore = 1;
 -                      }
 -              }
 +      znode var_node, expr_node;
 +      zend_op *opline;
-       zend_uint offset;
++      uint32_t offset;
 +
 +      if (is_this_fetch(var_ast)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
        }
 -      if (!ignore) {
 -              if (ce->num_traits >= current_trait_num) {
 -                      if (ce->type == ZEND_INTERNAL_CLASS) {
 -                              ce->traits = (zend_class_entry **) realloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
 +
 +      zend_ensure_writable_variable(var_ast);
 +
 +      switch (var_ast->kind) {
 +              case ZEND_AST_VAR:
 +              case ZEND_AST_STATIC_PROP:
 +                      zend_compile_var(&var_node, var_ast, BP_VAR_W TSRMLS_CC);
 +                      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 +                      zend_emit_op(result, ZEND_ASSIGN, &var_node, &expr_node TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_DIM:
 +                      offset = zend_delayed_compile_begin(TSRMLS_C);
 +                      zend_delayed_compile_dim(result, var_ast, BP_VAR_W TSRMLS_CC);
 +
 +                      if (zend_is_assign_to_self(var_ast, expr_ast TSRMLS_CC)) {
 +                              /* $a[0] = $a should evaluate the right $a first */
 +                              zend_compile_simple_var_no_cv(&expr_node, expr_ast, BP_VAR_R TSRMLS_CC);
                        } else {
 -                              ce->traits = (zend_class_entry **) erealloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
 +                              zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
                        }
 -              }
 -              ce->traits[ce->num_traits++] = trait;
 +
 +                      opline = zend_delayed_compile_end(offset TSRMLS_CC);
 +                      opline->opcode = ZEND_ASSIGN_DIM;
 +
 +                      opline = zend_emit_op_data(&expr_node TSRMLS_CC);
 +                      opline->op2.var = get_temporary_variable(CG(active_op_array));
 +                      opline->op2_type = IS_VAR;
 +                      return;
 +              case ZEND_AST_PROP:
 +                      offset = zend_delayed_compile_begin(TSRMLS_C);
 +                      zend_delayed_compile_prop(result, var_ast, BP_VAR_W TSRMLS_CC);
 +                      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 +
 +                      opline = zend_delayed_compile_end(offset TSRMLS_CC);
 +                      opline->opcode = ZEND_ASSIGN_OBJ;
 +
 +                      zend_emit_op_data(&expr_node TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_LIST:
 +                      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 +                      zend_compile_list_assign(result, var_ast, &expr_node TSRMLS_CC);
 +                      return;
 +              EMPTY_SWITCH_DEFAULT_CASE();
        }
  }
 -/* }}} */
 -
 -static zend_bool zend_traits_method_compatibility_check(zend_function *fn, zend_function *other_fn TSRMLS_DC) /* {{{ */
 -{
 -      uint32_t    fn_flags = fn->common.scope->ce_flags;
 -      uint32_t other_flags = other_fn->common.scope->ce_flags;
  
 -      return zend_do_perform_implementation_check(fn, other_fn TSRMLS_CC)
 -              && ((other_fn->common.scope->ce_flags & ZEND_ACC_INTERFACE) || zend_do_perform_implementation_check(other_fn, fn TSRMLS_CC))
 -              && ((fn_flags & (ZEND_ACC_FINAL|ZEND_ACC_STATIC)) ==
 -                  (other_flags & (ZEND_ACC_FINAL|ZEND_ACC_STATIC))); /* equal final and static qualifier */
 +static inline void zend_emit_assign_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) {
 +      znode dummy_node;
 +      zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN, var_ast,
 +              zend_ast_create_znode(value_node));
 +      zend_compile_assign(&dummy_node, assign_ast TSRMLS_CC);
 +      zend_do_free(&dummy_node TSRMLS_CC);
  }
 -/* }}} */
  
 -static void zend_add_magic_methods(zend_class_entry* ce, zend_string* mname, zend_function* fe TSRMLS_DC) /* {{{ */
 -{
 -      if (!strncmp(mname->val, ZEND_CLONE_FUNC_NAME, mname->len)) {
 -              ce->clone = fe; fe->common.fn_flags |= ZEND_ACC_CLONE;
 -      } else if (!strncmp(mname->val, ZEND_CONSTRUCTOR_FUNC_NAME, mname->len)) {
 -              if (ce->constructor) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name->val);
 -              }
 -              ce->constructor = fe; fe->common.fn_flags |= ZEND_ACC_CTOR;
 -      } else if (!strncmp(mname->val, ZEND_DESTRUCTOR_FUNC_NAME,  mname->len)) {
 -              ce->destructor = fe; fe->common.fn_flags |= ZEND_ACC_DTOR;
 -      } else if (!strncmp(mname->val, ZEND_GET_FUNC_NAME, mname->len)) {
 -              ce->__get = fe;
 -      } else if (!strncmp(mname->val, ZEND_SET_FUNC_NAME, mname->len)) {
 -              ce->__set = fe;
 -      } else if (!strncmp(mname->val, ZEND_CALL_FUNC_NAME, mname->len)) {
 -              ce->__call = fe;
 -      } else if (!strncmp(mname->val, ZEND_UNSET_FUNC_NAME, mname->len)) {
 -              ce->__unset = fe;
 -      } else if (!strncmp(mname->val, ZEND_ISSET_FUNC_NAME, mname->len)) {
 -              ce->__isset = fe;
 -      } else if (!strncmp(mname->val, ZEND_CALLSTATIC_FUNC_NAME, mname->len)) {
 -              ce->__callstatic = fe;
 -      } else if (!strncmp(mname->val, ZEND_TOSTRING_FUNC_NAME, mname->len)) {
 -              ce->__tostring = fe;
 -      } else if (!strncmp(mname->val, ZEND_DEBUGINFO_FUNC_NAME, mname->len)) {
 -              ce->__debugInfo = fe;
 -      } else if (ce->name->len == mname->len) {
 -              zend_string *lowercase_name = zend_string_alloc(ce->name->len, 0);
 -              zend_str_tolower_copy(lowercase_name->val, ce->name->val, ce->name->len);
 -              lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC);
 -              if (!memcmp(mname->val, lowercase_name->val, mname->len)) {
 -                      if (ce->constructor) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name->val);
 -                      }
 -                      ce->constructor = fe;
 -                      fe->common.fn_flags |= ZEND_ACC_CTOR;
 -              }
 -              zend_string_release(lowercase_name);
 +void zend_compile_assign_ref(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *target_ast = ast->child[0];
 +      zend_ast *source_ast = ast->child[1];
 +
 +      znode target_node, source_node;
 +      zend_op *opline;
 +
 +      if (is_this_fetch(target_ast)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 +      }
 +      zend_ensure_writable_variable(target_ast);
 +
 +      zend_compile_var(&target_node, target_ast, BP_VAR_W TSRMLS_CC);
 +      zend_compile_var(&source_node, source_ast, BP_VAR_REF TSRMLS_CC);
 +
 +      opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node TSRMLS_CC);
 +      if (!result) {
 +              opline->result_type |= EXT_TYPE_UNUSED;
 +      }
 +
 +      if (zend_is_call(source_ast)) {
 +              opline->extended_value = ZEND_RETURNS_FUNCTION;
 +      } else if (source_ast->kind == ZEND_AST_NEW) {
 +              opline->extended_value = ZEND_RETURNS_NEW;
        }
  }
 -/* }}} */
  
 -static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_string *key, zend_function *fn, HashTable **overriden TSRMLS_DC) /* {{{ */
 -{
 -      zend_function *existing_fn = NULL;
 -      zend_function *new_fn;
 +static inline void zend_emit_assign_ref_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) {
 +      zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN_REF, var_ast,
 +              zend_ast_create_znode(value_node));
 +      zend_compile_assign_ref(NULL, assign_ast TSRMLS_CC);
 +}
  
 -      if ((existing_fn = zend_hash_find_ptr(&ce->function_table, key)) != NULL) {
 -              if (existing_fn->common.scope == ce) {
 -                      /* members from the current class override trait methods */
 -                      /* use temporary *overriden HashTable to detect hidden conflict */
 -                      if (*overriden) {
 -                              if ((existing_fn = zend_hash_find_ptr(*overriden, key)) != NULL) {
 -                                      if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
 -                                              /* Make sure the trait method is compatible with previosly declared abstract method */
 -                                              if (!zend_traits_method_compatibility_check(fn, existing_fn TSRMLS_CC)) {
 -                                                      zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
 -                                                              zend_get_function_declaration(fn TSRMLS_CC),
 -                                                              zend_get_function_declaration(existing_fn TSRMLS_CC));
 -                                              }
 -                                      } else if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
 -                                              /* Make sure the abstract declaration is compatible with previous declaration */
 -                                              if (!zend_traits_method_compatibility_check(existing_fn, fn TSRMLS_CC)) {
 -                                                      zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
 -                                                              zend_get_function_declaration(fn TSRMLS_CC),
 -                                                              zend_get_function_declaration(existing_fn TSRMLS_CC));
 -                                              }
 -                                              return;
 -                                      }
 -                              }
 -                      } else {
 -                              ALLOC_HASHTABLE(*overriden);
 -                              zend_hash_init_ex(*overriden, 8, NULL, ptr_dtor, 0, 0);
 -                      }
 -                      fn = zend_hash_update_mem(*overriden, key, fn, sizeof(zend_function));
 +void zend_compile_compound_assign(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *var_ast = ast->child[0];
 +      zend_ast *expr_ast = ast->child[1];
-       zend_uint opcode = ast->attr;
++      uint32_t opcode = ast->attr;
 +
 +      znode var_node, expr_node;
 +      zend_op *opline;
-       zend_uint offset;
++      uint32_t offset;
 +
 +      zend_ensure_writable_variable(var_ast);
 +
 +      switch (var_ast->kind) {
 +              case ZEND_AST_VAR:
 +              case ZEND_AST_STATIC_PROP:
 +                      zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
 +                      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 +                      zend_emit_op(result, opcode, &var_node, &expr_node TSRMLS_CC);
                        return;
 -              } else if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
 -                      /* Make sure the trait method is compatible with previosly declared abstract method */
 -                      if (!zend_traits_method_compatibility_check(fn, existing_fn TSRMLS_CC)) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
 -                                      zend_get_function_declaration(fn TSRMLS_CC),
 -                                      zend_get_function_declaration(existing_fn TSRMLS_CC));
 -                      }
 -              } else if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
 -                      /* Make sure the abstract declaration is compatible with previous declaration */
 -                      if (!zend_traits_method_compatibility_check(existing_fn, fn TSRMLS_CC)) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s",
 -                                      zend_get_function_declaration(fn TSRMLS_CC),
 -                                      zend_get_function_declaration(existing_fn TSRMLS_CC));
 -                      }
 +              case ZEND_AST_DIM:
 +                      offset = zend_delayed_compile_begin(TSRMLS_C);
 +                      zend_delayed_compile_dim(result, var_ast, BP_VAR_RW TSRMLS_CC);
 +                      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 +
 +                      opline = zend_delayed_compile_end(offset TSRMLS_CC);
 +                      opline->opcode = opcode;
 +                      opline->extended_value = ZEND_ASSIGN_DIM;
 +
 +                      opline = zend_emit_op_data(&expr_node TSRMLS_CC);
 +                      opline->op2.var = get_temporary_variable(CG(active_op_array));
 +                      opline->op2_type = IS_VAR;
                        return;
 -              } else if ((existing_fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
 -                      /* two traits can't define the same non-abstract method */
 -#if 1
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s has not been applied, because there are collisions with other trait methods on %s",
 -                              name, ce->name->val);
 -#else         /* TODO: better error message */
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s::%s has not been applied as %s::%s, because of collision with %s::%s",
 -                              fn->common.scope->name->val, fn->common.function_name->val,
 -                              ce->name->val, name,
 -                              existing_fn->common.scope->name->val, existing_fn->common.function_name->val);
 -#endif
 -              } else {
 -                      /* inherited members are overridden by members inserted by traits */
 -                      /* check whether the trait method fulfills the inheritance requirements */
 -                      do_inheritance_check_on_method(fn, existing_fn TSRMLS_CC);
 -              }
 -      }
 +              case ZEND_AST_PROP:
 +                      offset = zend_delayed_compile_begin(TSRMLS_C);
 +                      zend_delayed_compile_prop(result, var_ast, BP_VAR_RW TSRMLS_CC);
 +                      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
  
 -      function_add_ref(fn);
 -      new_fn = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
 -      memcpy(new_fn, fn, sizeof(zend_op_array));
 -      fn = zend_hash_update_ptr(&ce->function_table, key, new_fn);
 -      zend_add_magic_methods(ce, key, fn TSRMLS_CC);
 +                      opline = zend_delayed_compile_end(offset TSRMLS_CC);
 +                      opline->opcode = opcode;
 +                      opline->extended_value = ZEND_ASSIGN_OBJ;
 +
 +                      zend_emit_op_data(&expr_node TSRMLS_CC);
 +                      return;
 +              EMPTY_SWITCH_DEFAULT_CASE()
 +      }
  }
 -/* }}} */
  
- zend_uint zend_compile_args(zend_ast *ast, zend_function *fbc TSRMLS_DC) {
 -static void zend_fixup_trait_method(zend_function *fn, zend_class_entry *ce) /* {{{ */
 -{
 -      if ((fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
++uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc TSRMLS_DC) {
 +      // TODO.AST &var error
 +      zend_ast_list *args = zend_ast_get_list(ast);
-       zend_uint i;
++      uint32_t i;
 +      zend_bool uses_arg_unpack = 0;
-       zend_uint arg_count = 0; /* number of arguments not including unpacks */
++      uint32_t arg_count = 0; /* number of arguments not including unpacks */
  
 -              fn->common.scope = ce;
 +      for (i = 0; i < args->children; ++i) {
 +              zend_ast *arg = args->child[i];
-               zend_uint arg_num = i + 1;
++              uint32_t arg_num = i + 1;
  
 -              if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
 -                      ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
 +              znode arg_node;
 +              zend_op *opline;
 +              zend_uchar opcode;
 +              zend_ulong flags = 0;
 +
 +              if (arg->kind == ZEND_AST_UNPACK) {
 +                      uses_arg_unpack = 1;
 +                      fbc = NULL;
 +                      
 +                      zend_compile_expr(&arg_node, arg->child[0] TSRMLS_CC);
 +                      opline = zend_emit_op(NULL, ZEND_SEND_UNPACK, &arg_node, NULL TSRMLS_CC);
 +                      opline->op2.num = arg_count;
 +                      continue;
 +              }
 +
 +              if (uses_arg_unpack) {
 +                      zend_error_noreturn(E_COMPILE_ERROR,
 +                              "Cannot use positional argument after argument unpacking");
 +              }
 +
 +              arg_count++;
 +              if (zend_is_variable(arg)) {
 +                      if (zend_is_call(arg)) {
 +                              zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC);
 +                              opcode = ZEND_SEND_VAR_NO_REF;
 +                              flags |= ZEND_ARG_SEND_FUNCTION;
 +                              if (fbc && ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
 +                                      flags |= ZEND_ARG_SEND_BY_REF;
 +                                      if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) {
 +                                              flags |= ZEND_ARG_SEND_SILENT;
 +                                      }
 +                              }
 +                      } else if (fbc) {
 +                              if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
 +                                      zend_compile_var(&arg_node, arg, BP_VAR_W TSRMLS_CC);
 +                                      opcode = ZEND_SEND_REF;
 +                              } else {
 +                                      zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC);
 +                                      opcode = ZEND_SEND_VAR;
 +                              }
 +                      } else {
 +                              zend_compile_var(&arg_node, arg,
 +                                      BP_VAR_FUNC_ARG | (arg_num << BP_VAR_SHIFT) TSRMLS_CC);
 +                              opcode = ZEND_SEND_VAR_EX;
 +                      }
 +              } else {
 +                      zend_compile_expr(&arg_node, arg TSRMLS_CC);
 +                      if (arg_node.op_type & (IS_VAR|IS_CV)) {
 +                              opcode = ZEND_SEND_VAR_NO_REF;
 +                              if (fbc && ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) {
 +                                      flags |= ZEND_ARG_SEND_BY_REF;
 +                              }
 +                      } else {
 +                              if (fbc) {
 +                                      opcode = ZEND_SEND_VAL;
 +                                      if (ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) {
 +                                              zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference");
 +                                      }
 +                              } else {
 +                                      opcode = ZEND_SEND_VAL_EX;
 +                              }
 +                      }
                }
 -              if (fn->op_array.static_variables) {
 -                      ce->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
 +
 +              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +              opline->opcode = opcode;
 +              SET_NODE(opline->op1, &arg_node);
 +              SET_UNUSED(opline->op2);
 +              opline->op2.opline_num = arg_num;
 +
 +              if (opcode == ZEND_SEND_VAR_NO_REF) {
 +                      if (fbc) {
 +                              flags |= ZEND_ARG_COMPILE_TIME_BOUND;
 +                      }
 +                      opline->extended_value = flags;
 +              } else if (fbc) {
 +                      opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND;
                }
        }
 +
 +      return arg_count;
  }
 -/* }}} */
  
 -static int zend_traits_copy_functions(zend_string *fnname, zend_function *fn, zend_class_entry *ce, HashTable **overriden, HashTable *exclude_table TSRMLS_DC) /* {{{ */
 -{
 -      zend_trait_alias  *alias, **alias_ptr;
 -      zend_string       *lcname;
 -      zend_function      fn_copy;
 +void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *fbc TSRMLS_DC) {
 +      zend_op *opline;
-       zend_uint opnum_init = get_next_op_number(CG(active_op_array)) - 1;
-       zend_uint arg_count;
-       zend_uint call_flags;
++      uint32_t opnum_init = get_next_op_number(CG(active_op_array)) - 1;
++      uint32_t arg_count;
++      uint32_t call_flags;
  
 -      /* apply aliases which are qualified with a class name, there should not be any ambiguity */
 -      if (ce->trait_aliases) {
 -              alias_ptr = ce->trait_aliases;
 -              alias = *alias_ptr;
 -              while (alias) {
 -                      /* Scope unset or equal to the function we compare to, and the alias applies to fn */
 -                      if (alias->alias != NULL
 -                              && (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
 -                              && alias->trait_method->method_name->len == fnname->len
 -                              && (zend_binary_strcasecmp(alias->trait_method->method_name->val, alias->trait_method->method_name->len, fnname->val, fnname->len) == 0)) {
 -                              fn_copy = *fn;
 +      zend_do_extended_fcall_begin(TSRMLS_C);
  
 -                              /* if it is 0, no modifieres has been changed */
 -                              if (alias->modifiers) {
 -                                      fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
 -                              }
 +      arg_count = zend_compile_args(args_ast, fbc TSRMLS_CC);
  
 -                              lcname = zend_string_alloc(alias->alias->len, 0);
 -                              zend_str_tolower_copy(lcname->val, alias->alias->val, alias->alias->len);
 -                              zend_add_trait_method(ce, alias->alias->val, lcname, &fn_copy, overriden TSRMLS_CC);
 -                              zend_string_release(lcname);
 +      opline = &CG(active_op_array)->opcodes[opnum_init];
 +      opline->extended_value = arg_count;
  
 -                              /* Record the trait from which this alias was resolved. */
 -                              if (!alias->trait_method->ce) {
 -                                      alias->trait_method->ce = fn->common.scope;
 -                              }
 -                      }
 -                      alias_ptr++;
 -                      alias = *alias_ptr;
 -              }
 -      }
 +      call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0);
 +      opline = zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
 +      opline->op1.num = call_flags;
  
 -      if (exclude_table == NULL || zend_hash_find(exclude_table, fnname) == NULL) {
 -              /* is not in hashtable, thus, function is not to be excluded */
 -              fn_copy = *fn;
 +      zend_do_extended_fcall_end(TSRMLS_C);
 +}
  
 -              /* apply aliases which have not alias name, just setting visibility */
 -              if (ce->trait_aliases) {
 -                      alias_ptr = ce->trait_aliases;
 -                      alias = *alias_ptr;
 -                      while (alias) {
 -                              /* Scope unset or equal to the function we compare to, and the alias applies to fn */
 -                              if (alias->alias == NULL && alias->modifiers != 0
 -                                      && (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
 -                                      && (alias->trait_method->method_name->len == fnname->len)
 -                                      && (zend_binary_strcasecmp(alias->trait_method->method_name->val, alias->trait_method->method_name->len, fnname->val, fnname->len) == 0)) {
 +zend_bool zend_compile_function_name(znode *name_node, zend_ast *name_ast TSRMLS_DC) {
 +      zend_string *orig_name = zend_ast_get_str(name_ast);
 +      zend_bool is_fully_qualified;
  
 -                                      fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
 +      name_node->op_type = IS_CONST;
 +      ZVAL_STR(&name_node->u.constant, zend_resolve_function_name(
 +              orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC));
  
 -                                      /** Record the trait from which this alias was resolved. */
 -                                      if (!alias->trait_method->ce) {
 -                                              alias->trait_method->ce = fn->common.scope;
 -                                      }
 -                              }
 -                              alias_ptr++;
 -                              alias = *alias_ptr;
 -                      }
 -              }
 +      return !is_fully_qualified && CG(current_namespace);
 +}
  
 -              zend_add_trait_method(ce, fn->common.function_name->val, fnname, &fn_copy, overriden TSRMLS_CC);
 +void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) {
 +      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME;
 +      SET_UNUSED(opline->op1);
 +      opline->op2_type = IS_CONST;
 +      opline->op2.constant = zend_add_ns_func_name_literal(
 +              CG(active_op_array), &name_node->u.constant TSRMLS_CC);
 +      zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
 +
 +      zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
 +}
 +
 +void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) {
 +      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opline->opcode = ZEND_INIT_FCALL_BY_NAME;
 +      SET_UNUSED(opline->op1);
 +      if (name_node->op_type == IS_CONST && Z_TYPE(name_node->u.constant) == IS_STRING) {
 +              opline->op2_type = IS_CONST;
 +              opline->op2.constant
 +                      = zend_add_func_name_literal(CG(active_op_array), &name_node->u.constant TSRMLS_CC);
 +              zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
 +      } else {
 +              SET_NODE(opline->op2, name_node);
        }
  
 -      return ZEND_HASH_APPLY_KEEP;
 +      zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
  }
 -/* }}} */
  
 -static void zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait TSRMLS_DC) /* {{{ */
 -{
 +static zend_bool zend_args_contain_unpack(zend_ast_list *args) {
-       zend_uint i;
+       uint32_t i;
 -
 -      if ((trait->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", trait->name->val);
 +      for (i = 0; i < args->children; ++i) {
 +              if (args->child[i]->kind == ZEND_AST_UNPACK) {
 +                      return 1;
 +              }
        }
 +      return 0;
 +}
  
 -      for (i = 0; i < ce->num_traits; i++) {
 -              if (ce->traits[i] == trait) {
 -                      return;
 -              }
 +int zend_compile_func_strlen(znode *result, zend_ast_list *args TSRMLS_DC) {
 +      znode arg_node;
 +
 +      if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN)
 +              || args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK
 +      ) {
 +              return FAILURE;
        }
 -      zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", trait->name->val, ce->name->val);
 +
 +      zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC);
 +      zend_emit_op(result, ZEND_STRLEN, &arg_node, NULL TSRMLS_CC);
 +      return SUCCESS;
  }
 -/* }}} */
  
- int zend_compile_func_typecheck(znode *result, zend_ast_list *args, zend_uint type TSRMLS_DC) {
 -static void zend_traits_init_trait_structures(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 -{
 -      size_t i, j = 0;
 -      zend_trait_precedence *cur_precedence;
 -      zend_trait_method_reference *cur_method_ref;
 -      zend_string *lcname;
 -      zend_bool method_exists;
++int zend_compile_func_typecheck(znode *result, zend_ast_list *args, uint32_t type TSRMLS_DC) {
 +      znode arg_node;
 +      zend_op *opline;
  
 -      /* resolve class references */
 -      if (ce->trait_precedences) {
 -              i = 0;
 -              while ((cur_precedence = ce->trait_precedences[i])) {
 -                      /** Resolve classes for all precedence operations. */
 -                      if (cur_precedence->exclude_from_classes) {
 -                              cur_method_ref = cur_precedence->trait_method;
 -                              if (!(cur_precedence->trait_method->ce = zend_fetch_class(cur_method_ref->class_name,
 -                                                              ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
 -                                      zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name->val);
 -                              }
 -                              zend_check_trait_usage(ce, cur_precedence->trait_method->ce TSRMLS_CC);
 +      if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) {
 +              return FAILURE;
 +      }
 +      
 +      zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC);
 +      opline = zend_emit_op(result, ZEND_TYPE_CHECK, &arg_node, NULL TSRMLS_CC);
 +      opline->extended_value = type;
 +      return SUCCESS;
 +}
  
 -                              /** Ensure that the prefered method is actually available. */
 -                              lcname = zend_string_alloc(cur_method_ref->method_name->len, 0);
 -                              zend_str_tolower_copy(lcname->val, 
 -                                      cur_method_ref->method_name->val,
 -                                      cur_method_ref->method_name->len);
 -                              method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
 -                                                                                               lcname);
 -                              zend_string_free(lcname);
 -                              if (!method_exists) {
 -                                      zend_error_noreturn(E_COMPILE_ERROR,
 -                                                         "A precedence rule was defined for %s::%s but this method does not exist",
 -                                                         cur_method_ref->ce->name->val,
 -                                                         cur_method_ref->method_name->val);
 -                              }
 +int zend_compile_func_defined(znode *result, zend_ast_list *args TSRMLS_DC) {
 +      zend_string *name;
 +      zend_op *opline;
  
 -                              /** With the other traits, we are more permissive.
 -                                      We do not give errors for those. This allows to be more
 -                                      defensive in such definitions.
 -                                      However, we want to make sure that the insteadof declaration
 -                                      is consistent in itself.
 -                               */
 -                              j = 0;
 -                              while (cur_precedence->exclude_from_classes[j].class_name) {
 -                                      zend_string* class_name = cur_precedence->exclude_from_classes[j].class_name;
 +      if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) {
 +              return FAILURE;
 +      }
  
 -                                      if (!(cur_precedence->exclude_from_classes[j].ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_TRAIT |ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
 -                                              zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", class_name->val);
 -                                      }
 -                                      zend_check_trait_usage(ce, cur_precedence->exclude_from_classes[j].ce TSRMLS_CC);
 +      name = zval_get_string(zend_ast_get_zval(args->child[0]));
 +      if (zend_memrchr(name->val, '\\', name->len) || zend_memrchr(name->val, ':', name->len)) {
-               STR_RELEASE(name);
++              zend_string_release(name);
 +              return FAILURE;
 +      }
  
 -                                      /* make sure that the trait method is not from a class mentioned in
 -                                       exclude_from_classes, for consistency */
 -                                      if (cur_precedence->trait_method->ce == cur_precedence->exclude_from_classes[i].ce) {
 -                                              zend_error_noreturn(E_COMPILE_ERROR,
 -                                                                 "Inconsistent insteadof definition. "
 -                                                                 "The method %s is to be used from %s, but %s is also on the exclude list",
 -                                                                 cur_method_ref->method_name->val,
 -                                                                 cur_precedence->trait_method->ce->name->val,
 -                                                                 cur_precedence->trait_method->ce->name->val);
 -                                      }
 +      opline = zend_emit_op(result, ZEND_DEFINED, NULL, NULL TSRMLS_CC);
 +      opline->op1_type = IS_CONST;
 +      LITERAL_STR(opline->op1, name);
 +      zend_alloc_cache_slot(opline->op1.constant TSRMLS_CC);
  
 -                                      zend_string_release(class_name);
 -                                      j++;
 -                              }
 -                      }
 -                      i++;
 -              }
 +      /* Lowercase constant name in a separate literal */
 +      {
 +              zval c;
-               zend_string *lcname = STR_ALLOC(name->len, 0);
++              zend_string *lcname = zend_string_alloc(name->len, 0);
 +              zend_str_tolower_copy(lcname->val, name->val, name->len);
 +              ZVAL_NEW_STR(&c, lcname);
 +              zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
        }
 +      return SUCCESS;
 +}
  
 -      if (ce->trait_aliases) {
 -              i = 0;
 -              while (ce->trait_aliases[i]) {
 -                      /** For all aliases with an explicit class name, resolve the class now. */
 -                      if (ce->trait_aliases[i]->trait_method->class_name) {
 -                              cur_method_ref = ce->trait_aliases[i]->trait_method;
 -                              if (!(cur_method_ref->ce = zend_fetch_class(cur_method_ref->class_name, ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
 -                                      zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name->val);
 -                              }
 -                              zend_check_trait_usage(ce, cur_method_ref->ce TSRMLS_CC);
 +static int zend_try_compile_ct_bound_init_user_func(
-       znode *result, zend_ast *name_ast, zend_uint num_args TSRMLS_DC
++      znode *result, zend_ast *name_ast, uint32_t num_args TSRMLS_DC
 +) {
 +      zend_string *name, *lcname;
 +      zend_function *fbc;
 +      zend_op *opline;
  
 -                              /** And, ensure that the referenced method is resolvable, too. */
 -                              lcname = zend_string_alloc(cur_method_ref->method_name->len, 0);
 -                              zend_str_tolower_copy(lcname->val,
 -                                      cur_method_ref->method_name->val,
 -                                      cur_method_ref->method_name->len);
 -                              method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
 -                                              lcname);
 -                              zend_string_free(lcname);
 +      if (name_ast->kind != ZEND_AST_CONST || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
 +              return FAILURE;
 +      }
  
 -                              if (!method_exists) {
 -                                      zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", cur_method_ref->ce->name->val, cur_method_ref->method_name->val);
 -                              }
 -                      }
 -                      i++;
 -              }
 +      name = zend_ast_get_str(name_ast);
-       lcname = STR_ALLOC(name->len, 0);
++      lcname = zend_string_alloc(name->len, 0);
 +      zend_str_tolower_copy(lcname->val, name->val, name->len);
 +
 +      fbc = zend_hash_find_ptr(CG(function_table), lcname);
 +      if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION &&
 +              (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
 +      ) {
-               STR_FREE(lcname);
++              zend_string_free(lcname);
 +              return FAILURE;
        }
 +
 +      opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, NULL TSRMLS_CC);
 +      opline->op2_type = IS_CONST;
 +      LITERAL_STR(opline->op2, lcname);
 +      opline->extended_value = num_args;
 +
 +      return SUCCESS;
  }
 -/* }}} */
  
 -static void zend_traits_compile_exclude_table(HashTable* exclude_table, zend_trait_precedence **precedences, zend_class_entry *trait) /* {{{ */
 -{
 -      size_t i = 0, j;
 +static void zend_compile_init_user_func(
-       znode *result, zend_ast *name_ast, zend_uint num_args, zend_string *orig_func_name TSRMLS_DC
++      znode *result, zend_ast *name_ast, uint32_t num_args, zend_string *orig_func_name TSRMLS_DC
 +) {
 +      zend_op *opline;
 +      znode name_node;
  
 -      if (!precedences) {
 +      if (zend_try_compile_ct_bound_init_user_func(result, name_ast, num_args TSRMLS_CC) == SUCCESS) {
                return;
        }
 -      while (precedences[i]) {
 -              if (precedences[i]->exclude_from_classes) {
 -                      j = 0;
 -                      while (precedences[i]->exclude_from_classes[j].ce) {
 -                              if (precedences[i]->exclude_from_classes[j].ce == trait) {
 -                                      zend_string *lcname = zend_string_alloc(precedences[i]->trait_method->method_name->len, 0);
 -                                                                              
 -                                      zend_str_tolower_copy(lcname->val,
 -                                              precedences[i]->trait_method->method_name->val,
 -                                              precedences[i]->trait_method->method_name->len);
 -                                      if (zend_hash_add_empty_element(exclude_table, lcname) == NULL) {
 -                                              zend_string_release(lcname);
 -                                              zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", precedences[i]->trait_method->method_name->val, trait->name->val);
 -                                      }
 -                                      zend_string_release(lcname);
 -                              }
 -                              ++j;
 -                      }
 -              }
 -              ++i;
 +
 +      zend_compile_expr(&name_node, name_ast TSRMLS_CC);
 +
 +      opline = zend_emit_op(NULL, ZEND_INIT_USER_CALL, NULL, &name_node TSRMLS_CC);
 +      opline->op1_type = IS_CONST;
-       LITERAL_STR(opline->op1, STR_COPY(orig_func_name));
++      LITERAL_STR(opline->op1, zend_string_copy(orig_func_name));
 +      opline->extended_value = num_args;
 +}
 +
 +/* cufa = call_user_func_array */
 +int zend_compile_func_cufa(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) {
 +      znode arg_node;
 +
 +      if (args->children != 2 || zend_args_contain_unpack(args)) {
 +              return FAILURE;
        }
 +
 +      zend_compile_init_user_func(NULL, args->child[0], 1, lcname TSRMLS_CC);
 +      zend_compile_expr(&arg_node, args->child[1] TSRMLS_CC);
 +      zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL TSRMLS_CC);
 +      zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
 +
 +      return SUCCESS;
  }
 -/* }}} */
  
 -static void zend_do_traits_method_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 -{
 +/* cuf = call_user_func */
 +int zend_compile_func_cuf(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) {
-       zend_uint i;
+       uint32_t i;
 -      HashTable *overriden = NULL;
 -      zend_string *key;
 -      zend_function *fn;
 -
 -      for (i = 0; i < ce->num_traits; i++) {
 -              if (ce->trait_precedences) {
 -                      HashTable exclude_table;
  
 -                      /* TODO: revisit this start size, may be its not optimal */
 -                      zend_hash_init_ex(&exclude_table, 8, NULL, NULL, 0, 0);
 +      if (args->children < 1 || zend_args_contain_unpack(args)) {
 +              return FAILURE;
 +      }
  
 -                      zend_traits_compile_exclude_table(&exclude_table, ce->trait_precedences, ce->traits[i]);
 +      zend_compile_init_user_func(NULL, args->child[0], args->children - 1, lcname TSRMLS_CC);
 +      for (i = 1; i < args->children; ++i) {
 +              zend_ast *arg_ast = args->child[i];
 +              znode arg_node;
 +              zend_op *opline;
 +              zend_bool send_user = 0;
  
 -                      /* copies functions, applies defined aliasing, and excludes unused trait methods */
 -                      ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
 -                              zend_traits_copy_functions(key, fn, ce, &overriden, &exclude_table TSRMLS_CC);
 -                      } ZEND_HASH_FOREACH_END();
 +              if (zend_is_variable(arg_ast) && !zend_is_call(arg_ast)) {
 +                      zend_compile_var(&arg_node, arg_ast, BP_VAR_FUNC_ARG | (i << BP_VAR_SHIFT) TSRMLS_CC);
 +                      send_user = 1;
 +              } else {
 +                      zend_compile_expr(&arg_node, arg_ast TSRMLS_CC);
 +                      if (arg_node.op_type & (IS_VAR|IS_CV)) {
 +                              send_user = 1;
 +                      }
 +              }
  
 -                      zend_hash_destroy(&exclude_table);
 +              if (send_user) {
 +                      opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL TSRMLS_CC);
                } else {
 -                      ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
 -                              zend_traits_copy_functions(key, fn, ce, &overriden, NULL TSRMLS_CC);
 -                      } ZEND_HASH_FOREACH_END();
 +                      opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL TSRMLS_CC);
                }
 +
 +              opline->op2.opline_num = i;
        }
 +      zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
  
 -      ZEND_HASH_FOREACH_PTR(&ce->function_table, fn) {
 -              zend_fixup_trait_method(fn, ce);
 -      } ZEND_HASH_FOREACH_END();
 +      return SUCCESS;
 +}
  
 -      if (overriden) {
 -              zend_hash_destroy(overriden);
 -              FREE_HASHTABLE(overriden);
 +int zend_try_compile_special_func(
 +      znode *result, zend_string *lcname, zend_ast_list *args TSRMLS_DC
 +) {
 +      if (zend_str_equals_literal(lcname, "strlen")) {
 +              return zend_compile_func_strlen(result, args TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "is_null")) {
 +              return zend_compile_func_typecheck(result, args, IS_NULL TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "is_bool")) {
 +              return zend_compile_func_typecheck(result, args, _IS_BOOL TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "is_long")) {
 +              return zend_compile_func_typecheck(result, args, IS_LONG TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "is_float")) {
 +              return zend_compile_func_typecheck(result, args, IS_DOUBLE TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "is_string")) {
 +              return zend_compile_func_typecheck(result, args, IS_STRING TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "is_array")) {
 +              return zend_compile_func_typecheck(result, args, IS_ARRAY TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "is_object")) {
 +              return zend_compile_func_typecheck(result, args, IS_OBJECT TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "is_resource")) {
 +              return zend_compile_func_typecheck(result, args, IS_RESOURCE TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "defined")) {
 +              return zend_compile_func_defined(result, args TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "call_user_func_array")) {
 +              return zend_compile_func_cufa(result, args, lcname TSRMLS_CC);
 +      } else if (zend_str_equals_literal(lcname, "call_user_func")) {
 +              return zend_compile_func_cuf(result, args, lcname TSRMLS_CC);
 +      } else {
 +              return FAILURE;
        }
  }
 -/* }}} */
  
 -static zend_class_entry* find_first_definition(zend_class_entry *ce, size_t current_trait, zend_string *prop_name, zend_class_entry *coliding_ce) /* {{{ */
 -{
 -      size_t i;
 +void zend_compile_call(znode *result, zend_ast *ast, int type TSRMLS_DC) {
 +      zend_ast *name_ast = ast->child[0];
 +      zend_ast *args_ast = ast->child[1];
  
 -      if (coliding_ce == ce) {
 -              for (i = 0; i < current_trait; i++) {
 -                      if (zend_hash_exists(&ce->traits[i]->properties_info, prop_name)) {
 -                              return ce->traits[i];
 -                      }
 -              }
 +      znode name_node;
 +
 +      if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
 +              zend_compile_expr(&name_node, name_ast TSRMLS_CC);
 +              zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC);
 +              return;
        }
  
 -      return coliding_ce;
 -}
 -/* }}} */
 +      {
 +              zend_bool runtime_resolution = zend_compile_function_name(&name_node, name_ast TSRMLS_CC);
 +              if (runtime_resolution) {
 +                      zend_compile_ns_call(result, &name_node, args_ast TSRMLS_CC);
 +                      return;
 +              }
 +      }
  
 -static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 -{
 -      size_t i;
 -      zend_property_info *property_info;
 -      zend_property_info *coliding_prop;
 -      zval compare_result;
 -      zend_string* prop_name;
 -      const char* class_name_unused;
 -      zend_bool not_compatible;
 -      zval* prop_value;
 -      uint32_t flags;
 -      zend_string *doc_comment;
 +      {
 +              zval *name = &name_node.u.constant;
-               zend_string *lcname = STR_ALLOC(Z_STRLEN_P(name), 0);
++              zend_string *lcname = zend_string_alloc(Z_STRLEN_P(name), 0);
 +              zend_function *fbc;
 +              zend_op *opline;
  
 -      /* In the following steps the properties are inserted into the property table
 -       * for that, a very strict approach is applied:
 -       * - check for compatibility, if not compatible with any property in class -> fatal
 -       * - if compatible, then strict notice
 -       */
 -      for (i = 0; i < ce->num_traits; i++) {
 -              ZEND_HASH_FOREACH_PTR(&ce->traits[i]->properties_info, property_info) {
 -                      /* first get the unmangeld name if necessary,
 -                       * then check whether the property is already there
 -                       */
 -                      flags = property_info->flags;
 -                      if ((flags & ZEND_ACC_PPP_MASK) == ZEND_ACC_PUBLIC) {
 -                              prop_name = zend_string_copy(property_info->name);
 -                      } else {
 -                              const char *pname;
 -                              int pname_len;
 +              zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
  
 -                              /* for private and protected we need to unmangle the names */
 -                              zend_unmangle_property_name_ex(property_info->name->val, property_info->name->len,
 -                                                                                      &class_name_unused, &pname, &pname_len);
 -                              prop_name = zend_string_init(pname, pname_len, 0);
 -                      }
 +              fbc = zend_hash_find_ptr(CG(function_table), lcname);
 +              if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION &&
 +                      (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
 +              ) {
-                       STR_RELEASE(lcname);
++                      zend_string_release(lcname);
 +                      zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC);
 +                      return;
 +              }
  
 -                      /* next: check for conflicts with current class */
 -                      if ((coliding_prop = zend_hash_find_ptr(&ce->properties_info, prop_name)) != NULL) {
 -                              if (coliding_prop->flags & ZEND_ACC_SHADOW) {
 -                                      zend_hash_del(&ce->properties_info, prop_name);
 -                                      flags |= ZEND_ACC_CHANGED;
 -                              } else {
 -                                      if ((coliding_prop->flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))
 -                                              == (flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))) {
 -                                              /* flags are identical, now the value needs to be checked */
 -                                              if (flags & ZEND_ACC_STATIC) {
 -                                                      not_compatible = (FAILURE == compare_function(&compare_result,
 -                                                                                        &ce->default_static_members_table[coliding_prop->offset],
 -                                                                                        &ce->traits[i]->default_static_members_table[property_info->offset] TSRMLS_CC))
 -                                                                || (Z_LVAL(compare_result) != 0);
 -                                              } else {
 -                                                      not_compatible = (FAILURE == compare_function(&compare_result,
 -                                                                                        &ce->default_properties_table[coliding_prop->offset],
 -                                                                                        &ce->traits[i]->default_properties_table[property_info->offset] TSRMLS_CC))
 -                                                                || (Z_LVAL(compare_result) != 0);
 -                                              }
 -                                      } else {
 -                                              /* the flags are not identical, thus, we assume properties are not compatible */
 -                                              not_compatible = 1;
 -                                      }
 +              if (zend_try_compile_special_func(result, lcname,
 +                              zend_ast_get_list(args_ast) TSRMLS_CC) == SUCCESS
 +              ) {
-                       STR_RELEASE(lcname);
++                      zend_string_release(lcname);
 +                      zval_ptr_dtor(&name_node.u.constant);
 +                      return;
 +              }
  
 -                                      if (not_compatible) {
 -                                              zend_error_noreturn(E_COMPILE_ERROR,
 -                                                         "%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed",
 -                                                              find_first_definition(ce, i, prop_name, coliding_prop->ce)->name->val,
 -                                                              property_info->ce->name->val,
 -                                                              prop_name->val,
 -                                                              ce->name->val);
 -                                      } else {
 -                                              zend_error(E_STRICT,
 -                                                         "%s and %s define the same property ($%s) in the composition of %s. This might be incompatible, to improve maintainability consider using accessor methods in traits instead. Class was composed",
 -                                                              find_first_definition(ce, i, prop_name, coliding_prop->ce)->name->val,
 -                                                              property_info->ce->name->val,
 -                                                              prop_name->val,
 -                                                              ce->name->val);
 -                                              zend_string_release(prop_name);
 -                                              continue;
 -                                      }
 -                              }
 -                      }
 +              zval_ptr_dtor(&name_node.u.constant);
 +              ZVAL_NEW_STR(&name_node.u.constant, lcname);
  
 -                      /* property not found, so lets add it */
 -                      if (flags & ZEND_ACC_STATIC) {
 -                              prop_value = &ce->traits[i]->default_static_members_table[property_info->offset];
 -                      } else {
 -                              prop_value = &ce->traits[i]->default_properties_table[property_info->offset];
 -                      }
 -                      if (Z_REFCOUNTED_P(prop_value)) Z_ADDREF_P(prop_value);
 +              opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &name_node TSRMLS_CC);
 +              zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
  
 -                      doc_comment = property_info->doc_comment ? zend_string_copy(property_info->doc_comment) : NULL;
 -                      zend_declare_property_ex(ce, prop_name,
 -                                                                       prop_value, flags,
 -                                                                   doc_comment TSRMLS_CC);
 -                      zend_string_release(prop_name);
 -              } ZEND_HASH_FOREACH_END();
 +              zend_compile_call_common(result, args_ast, fbc TSRMLS_CC);
        }
  }
 -/* }}} */
 -
 -static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 -{
 -      int i = 0;
 -      zend_trait_alias* cur_alias;
 -      zend_string* lc_method_name;
  
 -      if (ce->trait_aliases) {
 -              while (ce->trait_aliases[i]) {
 -                      cur_alias = ce->trait_aliases[i];
 -                      /** The trait for this alias has not been resolved, this means, this
 -                              alias was not applied. Abort with an error. */
 -                      if (!cur_alias->trait_method->ce) {
 -                              if (cur_alias->alias) {
 -                                      /** Plain old inconsistency/typo/bug */
 -                                      zend_error_noreturn(E_COMPILE_ERROR,
 -                                                         "An alias (%s) was defined for method %s(), but this method does not exist",
 -                                                         cur_alias->alias->val,
 -                                                         cur_alias->trait_method->method_name->val);
 -                              } else {
 -                                      /** Here are two possible cases:
 -                                              1) this is an attempt to modifiy the visibility
 -                                                 of a method introduce as part of another alias.
 -                                                 Since that seems to violate the DRY principle,
 -                                                 we check against it and abort.
 -                                              2) it is just a plain old inconsitency/typo/bug
 -                                                 as in the case where alias is set. */
 +void zend_compile_method_call(znode *result, zend_ast *ast, int type TSRMLS_DC) {
 +      zend_ast *obj_ast = ast->child[0];
 +      zend_ast *method_ast = ast->child[1];
 +      zend_ast *args_ast = ast->child[2];
  
 -                                      lc_method_name = zend_string_alloc(cur_alias->trait_method->method_name->len, 0);
 -                                      zend_str_tolower_copy(
 -                                              lc_method_name->val,
 -                                              cur_alias->trait_method->method_name->val,
 -                                              cur_alias->trait_method->method_name->len);
 -                                      if (zend_hash_exists(&ce->function_table,
 -                                                                               lc_method_name)) {
 -                                              zend_string_free(lc_method_name);
 -                                              zend_error_noreturn(E_COMPILE_ERROR,
 -                                                                 "The modifiers for the trait alias %s() need to be changed in the same statment in which the alias is defined. Error",
 -                                                                 cur_alias->trait_method->method_name->val);
 -                                      } else {
 -                                              zend_string_free(lc_method_name);
 -                                              zend_error_noreturn(E_COMPILE_ERROR,
 -                                                                 "The modifiers of the trait method %s() are changed, but this method does not exist. Error",
 -                                                                 cur_alias->trait_method->method_name->val);
 +      znode obj_node, method_node;
 +      zend_op *opline;
  
 -                                      }
 -                              }
 -                      }
 -                      i++;
 -              }
 +      if (is_this_fetch(obj_ast)) {
 +              obj_node.op_type = IS_UNUSED;
 +      } else {
 +              zend_compile_var(&obj_node, obj_ast, type TSRMLS_CC);
        }
 -}
 -/* }}} */
  
 -ZEND_API void zend_do_bind_traits(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 -{
 +      zend_compile_expr(&method_node, method_ast TSRMLS_CC);
 +      opline = zend_emit_op(NULL, ZEND_INIT_METHOD_CALL, &obj_node, NULL TSRMLS_CC);
 +      
 +      if (method_node.op_type == IS_CONST) {
 +              if (Z_TYPE(method_node.u.constant) != IS_STRING) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
 +              }
  
 -      if (ce->num_traits <= 0) {
 -              return;
 +              opline->op2_type = IS_CONST;
 +              opline->op2.constant =
 +                      zend_add_func_name_literal(CG(active_op_array), &method_node.u.constant TSRMLS_CC);
 +              zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
 +      } else {
 +              SET_NODE(opline->op2, &method_node);
        }
  
 -      /* complete initialization of trait strutures in ce */
 -      zend_traits_init_trait_structures(ce TSRMLS_CC);
 -
 -      /* first care about all methods to be flattened into the class */
 -      zend_do_traits_method_binding(ce TSRMLS_CC);
 +      zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
 +}
  
 -      /* Aliases which have not been applied indicate typos/bugs. */
 -      zend_do_check_for_inconsistent_traits_aliasing(ce TSRMLS_CC);
 +zend_bool zend_is_constructor(zend_string *name) {
 +      return zend_str_equals_literal_ci(name, ZEND_CONSTRUCTOR_FUNC_NAME);
 +}
  
 -      /* then flatten the properties into it, to, mostly to notfiy developer about problems */
 -      zend_do_traits_property_binding(ce TSRMLS_CC);
 +void zend_compile_static_call(znode *result, zend_ast *ast, int type TSRMLS_DC) {
 +      zend_ast *class_ast = ast->child[0];
 +      zend_ast *method_ast = ast->child[1];
 +      zend_ast *args_ast = ast->child[2];
  
 -      /* verify that all abstract methods from traits have been implemented */
 -      zend_verify_abstract_class(ce TSRMLS_CC);
 +      znode class_node, method_node;
 +      zend_op *opline;
 +      zend_ulong extended_value = 0;
  
 -      /* now everything should be fine and an added ZEND_ACC_IMPLICIT_ABSTRACT_CLASS should be removed */
 -      if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
 -              ce->ce_flags -= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
 +      if (zend_is_const_default_class_ref(class_ast)) {
 +              class_node.op_type = IS_CONST;
 +              ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
 +      } else {
 +              opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
 +              extended_value = opline->extended_value;
        }
 -}
 -/* }}} */
 -
 -ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, HashTable *function_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
 -{
 -      zend_function *function, *new_function;
 -      zval *op1, *op2;
  
 -      if (compile_time) {
 -              op1 = &CONSTANT_EX(op_array, opline->op1.constant);
 -              op2 = &CONSTANT_EX(op_array, opline->op2.constant);
 -      } else {
 -              op1 = opline->op1.zv;
 -              op2 = opline->op2.zv;
 +      zend_compile_expr(&method_node, method_ast TSRMLS_CC);
 +      if (method_node.op_type == IS_CONST) {
 +              zval *name = &method_node.u.constant;
 +              if (Z_TYPE_P(name) != IS_STRING) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
 +              }
 +              if (zend_is_constructor(Z_STR_P(name))) {
 +                      zval_ptr_dtor(name);
 +                      method_node.op_type = IS_UNUSED;
 +              }
        }
  
 -      function = zend_hash_find_ptr(function_table, Z_STR_P(op1));
 -      new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
 -      memcpy(new_function, function, sizeof(zend_op_array));
 -      if (zend_hash_add_ptr(function_table, Z_STR_P(op2), new_function) == NULL) {
 -              int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR;
 -              zend_function *old_function;
 +      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
 +      opline->extended_value = extended_value;
  
 -              efree(new_function);
 -              if ((old_function = zend_hash_find_ptr(function_table, Z_STR_P(op2))) != NULL
 -                      && old_function->type == ZEND_USER_FUNCTION
 -                      && old_function->op_array.last > 0) {
 -                      zend_error(error_level, "Cannot redeclare %s() (previously declared in %s:%d)",
 -                                              function->common.function_name->val,
 -                                              old_function->op_array.filename->val,
 -                                              old_function->op_array.opcodes[0].lineno);
 +      zend_set_class_name_op1(opline, &class_node TSRMLS_CC);
 +
 +      if (method_node.op_type == IS_CONST) {
 +              opline->op2_type = IS_CONST;
 +              opline->op2.constant =
 +                      zend_add_func_name_literal(CG(active_op_array), &method_node.u.constant TSRMLS_CC);
 +              if (opline->op1_type == IS_CONST) {
 +                      zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
                } else {
 -                      zend_error(error_level, "Cannot redeclare %s()", function->common.function_name->val);
 +                      zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
                }
 -              return FAILURE;
        } else {
 -              (*function->op_array.refcount)++;
 -              function->op_array.static_variables = NULL; /* NULL out the unbound function */
 -              return SUCCESS;
 +              SET_NODE(opline->op2, &method_node);
        }
 +
 +      zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_prepare_reference(znode *result, znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */
 -{
 -      zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference));
 -      method_ref->ce = NULL;
 +void zend_compile_new(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *class_ast = ast->child[0];
 +      zend_ast *args_ast = ast->child[1];
  
 -      /* REM: There should not be a need for copying,
 -         zend_do_begin_class_declaration is also just using that string */
 -      if (class_name) {
 -              zend_resolve_class_name(class_name TSRMLS_CC);
 -              method_ref->class_name = Z_STR(class_name->u.constant);
 -      } else {
 -              method_ref->class_name = NULL;
 -      }
 +      znode class_node, ctor_result;
 +      zend_op *opline;
-       zend_uint opnum;
++      uint32_t opnum;
  
 -      method_ref->method_name = Z_STR(method_name->u.constant);
 +      zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
  
 -      result->u.op.ptr = method_ref;
 -      result->op_type = IS_TMP_VAR;
 +      opnum = get_next_op_number(CG(active_op_array));
 +      opline = zend_emit_op(result, ZEND_NEW, &class_node, NULL TSRMLS_CC);
 +
 +      zend_compile_call_common(&ctor_result, args_ast, NULL TSRMLS_CC);
 +      zend_do_free(&ctor_result TSRMLS_CC);
 +
 +      /* New jumps over ctor call if ctor does not exist */
 +      opline = &CG(active_op_array)->opcodes[opnum];
 +      opline->op2.opline_num = get_next_op_number(CG(active_op_array));
  }
 -/* }}} */
  
 -void zend_add_trait_alias(znode *method_reference, znode *modifiers, znode *alias TSRMLS_DC) /* {{{ */
 -{
 -      zend_class_entry *ce = CG(active_class_entry);
 -      zend_trait_alias *trait_alias;
 +void zend_compile_clone(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *obj_ast = ast->child[0];
  
 -      if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_STATIC) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier");
 -              return;
 -      } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier");
 -              return;
 -      } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_FINAL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier");
 -              return;
 +      znode obj_node;
 +      zend_compile_expr(&obj_node, obj_ast TSRMLS_CC);
 +
 +      zend_emit_op(result, ZEND_CLONE, &obj_node, NULL TSRMLS_CC);
 +}
 +
 +void zend_compile_global_var(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *var_ast = ast->child[0];
 +      zend_ast *name_ast = var_ast->child[0];
 +
 +      znode name_node, result;
 +
 +      zend_compile_expr(&name_node, name_ast TSRMLS_CC);
 +      if (name_node.op_type == IS_CONST) {
 +              if (Z_TYPE(name_node.u.constant) != IS_STRING) {
 +                      convert_to_string(&name_node.u.constant);
 +              }
        }
  
 -      trait_alias = emalloc(sizeof(zend_trait_alias));
 -      trait_alias->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
 -      trait_alias->modifiers = Z_LVAL(modifiers->u.constant);
 -      if (alias) {
 -              trait_alias->alias = Z_STR(alias->u.constant);
 +      if (zend_try_compile_cv(&result, var_ast TSRMLS_CC) == SUCCESS) {
 +              zend_emit_op(NULL, ZEND_BIND_GLOBAL, &result, &name_node TSRMLS_CC);
        } else {
 -              trait_alias->alias = NULL;
 +              zend_emit_op(&result, ZEND_FETCH_W, &name_node, NULL TSRMLS_CC);
 +
 +              // TODO.AST Avoid double fetch
 +              //opline->extended_value = ZEND_FETCH_GLOBAL_LOCK;
 +
 +              zend_emit_assign_ref_znode(var_ast, &result TSRMLS_CC);
        }
 -      zend_add_to_list(&ce->trait_aliases, trait_alias TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_add_trait_precedence(znode *method_reference, znode *trait_list TSRMLS_DC) /* {{{ */
 -{
 -      zend_class_entry *ce = CG(active_class_entry);
 -      zend_trait_precedence *trait_precedence = emalloc(sizeof(zend_trait_precedence));
 +static void zend_compile_static_var_common(
 +      zend_ast *var_ast, zval *value, zend_bool by_ref TSRMLS_DC
 +) {
 +      znode var_node, result;
 +      zend_op *opline;
 +
 +      zend_compile_expr(&var_node, var_ast TSRMLS_CC);
 +
 +      if (!CG(active_op_array)->static_variables) {
 +              if (CG(active_op_array)->scope) {
 +                      CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
 +              }
 +              ALLOC_HASHTABLE(CG(active_op_array)->static_variables);
 +              zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0);
 +      }
 +
 +      zend_hash_update(CG(active_op_array)->static_variables, Z_STR(var_node.u.constant), value);
  
 -      trait_precedence->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
 -      trait_precedence->exclude_from_classes = trait_list->u.op.ptr;
 +      opline = zend_emit_op(&result, by_ref ? ZEND_FETCH_W : ZEND_FETCH_R, &var_node, NULL TSRMLS_CC);
 +      opline->extended_value = ZEND_FETCH_STATIC;
  
 -      zend_add_to_list(&ce->trait_precedences, trait_precedence TSRMLS_CC);
 +      if (by_ref) {
 +              zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast);
 +              zend_emit_assign_ref_znode(fetch_ast, &result TSRMLS_CC);
 +      } else {
 +              zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast);
 +              zend_emit_assign_znode(fetch_ast, &result TSRMLS_CC);
 +      }
  }
 -/* }}} */
  
 -ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
 -{
 -      zend_class_entry *ce;
 -      zval *op1, *op2;
 +void zend_compile_static_var(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *var_ast = ast->child[0];
 +      zend_ast *value_ast = ast->child[1];
 +      zval value_zv;
  
 -      if (compile_time) {
 -              op1 = &CONSTANT_EX(op_array, opline->op1.constant);
 -              op2 = &CONSTANT_EX(op_array, opline->op2.constant);
 +      if (value_ast) {
 +              zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
        } else {
 -              op1 = opline->op1.zv;
 -              op2 = opline->op2.zv;
 +              ZVAL_NULL(&value_zv);
        }
 -      if ((ce = zend_hash_find_ptr(class_table, Z_STR_P(op1))) == NULL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1));
 -              return NULL;
 +
 +      zend_compile_static_var_common(var_ast, &value_zv, 1 TSRMLS_CC);
 +}
 +
 +void zend_compile_unset(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *var_ast = ast->child[0];
 +
 +      znode var_node;
 +      zend_op *opline;
 +      switch (var_ast->kind) {
 +              case ZEND_AST_VAR:
 +                      if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) {
 +                              opline = zend_emit_op(NULL, ZEND_UNSET_VAR, &var_node, NULL TSRMLS_CC);
 +                              opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
 +                      } else {
 +                              opline = zend_compile_simple_var_no_cv(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
 +                              opline->opcode = ZEND_UNSET_VAR;
 +                      }
 +                      return;
 +              case ZEND_AST_DIM:
 +                      opline = zend_compile_dim_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
 +                      opline->opcode = ZEND_UNSET_DIM;
 +                      return;
 +              case ZEND_AST_PROP:
 +                      opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
 +                      opline->opcode = ZEND_UNSET_OBJ;
 +                      return;
 +              case ZEND_AST_STATIC_PROP:
 +                      opline = zend_compile_static_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
 +                      opline->opcode = ZEND_UNSET_VAR;
 +                      return;
 +              EMPTY_SWITCH_DEFAULT_CASE()
        }
 -      ce->refcount++;
 -      if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
 -              ce->refcount--;
 -              if (!compile_time) {
 -                      /* If we're in compile time, in practice, it's quite possible
 -                       * that we'll never reach this class declaration at runtime,
 -                       * so we shut up about it.  This allows the if (!defined('FOO')) { return; }
 -                       * approach to work.
 -                       */
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name->val);
 -              }
 -              return NULL;
 -      } else {
 -              if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
 -                      zend_verify_abstract_class(ce TSRMLS_CC);
 -              }
 -              return ce;
 +}
 +
 +static void zend_free_foreach_and_switch_variables(TSRMLS_D) {
-       zend_uint opnum_start, opnum_end, i;
++      uint32_t opnum_start, opnum_end, i;
 +
 +      opnum_start = get_next_op_number(CG(active_op_array));
 +
 +#ifdef ZTS
 +      zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC);
 +      zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC);
 +#else
 +      zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr);
 +      zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy);
 +#endif
 +
 +      opnum_end = get_next_op_number(CG(active_op_array));
 +
 +      for (i = opnum_start; i < opnum_end; ++i) {
 +              CG(active_op_array)->opcodes[i].extended_value |= EXT_TYPE_FREE_ON_RETURN;
        }
  }
 -/* }}} */
  
 -ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC) /* {{{ */
 -{
 -      zend_class_entry *ce;
 -      zval *op1, *op2;
 +void zend_compile_return(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
 +      zend_bool by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
  
 -      if (compile_time) {
 -              op1 = &CONSTANT_EX(op_array, opline->op1.constant);
 -              op2 = &CONSTANT_EX(op_array, opline->op2.constant);
 +      znode expr_node;
 +      zend_op *opline;
 +
 +      if (!expr_ast) {
 +              expr_node.op_type = IS_CONST;
 +              ZVAL_NULL(&expr_node.u.constant);
 +      } else if (by_ref && zend_is_variable(expr_ast) && !zend_is_call(expr_ast)) {
 +              zend_compile_var(&expr_node, expr_ast, BP_VAR_REF TSRMLS_CC);
        } else {
 -              op1 = opline->op1.zv;
 -              op2 = opline->op2.zv;
 +              zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
        }
  
 -      ce = zend_hash_find_ptr(class_table, Z_STR_P(op1));
 +      zend_free_foreach_and_switch_variables(TSRMLS_C);
  
 -      if (!ce) {
 -              if (!compile_time) {
 -                      /* If we're in compile time, in practice, it's quite possible
 -                       * that we'll never reach this class declaration at runtime,
 -                       * so we shut up about it.  This allows the if (!defined('FOO')) { return; }
 -                       * approach to work.
 -                       */
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", Z_STRVAL_P(op2));
 -              }
 -              return NULL;
 +      if (CG(context).in_finally) {
 +              zend_emit_op(NULL, ZEND_DISCARD_EXCEPTION, NULL, NULL TSRMLS_CC);
        }
  
 -      if (parent_ce->ce_flags & ZEND_ACC_INTERFACE) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from interface %s", ce->name->val, parent_ce->name->val);
 -      } else if ((parent_ce->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from trait %s", ce->name->val, parent_ce->name->val);
 +      opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN,
 +              &expr_node, NULL TSRMLS_CC);
 +
 +      if (expr_ast) {
 +              if (zend_is_call(expr_ast)) {
 +                      opline->extended_value = ZEND_RETURNS_FUNCTION;
 +              } else if (!zend_is_variable(expr_ast)) {
 +                      opline->extended_value = ZEND_RETURNS_VALUE;
 +              }
        }
 +}
  
 -      zend_do_inheritance(ce, parent_ce TSRMLS_CC);
 +void zend_compile_echo(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
  
 -      ce->refcount++;
 +      znode expr_node;
 +      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
  
 -      /* Register the derived class */
 -      if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name->val);
 -      }
 -      return ce;
 +      zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_early_binding(TSRMLS_D) /* {{{ */
 -{
 -      zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
 -      HashTable *table;
 +void zend_compile_throw(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
  
 -      while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
 -              opline--;
 -      }
 +      znode expr_node;
 +      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
  
 -      switch (opline->opcode) {
 -              case ZEND_DECLARE_FUNCTION:
 -                      if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1 TSRMLS_CC) == FAILURE) {
 -                              return;
 -                      }
 -                      table = CG(function_table);
 -                      break;
 -              case ZEND_DECLARE_CLASS:
 -                      if (do_bind_class(CG(active_op_array), opline, CG(class_table), 1 TSRMLS_CC) == NULL) {
 -                              return;
 -                      }
 -                      table = CG(class_table);
 -                      break;
 -              case ZEND_DECLARE_INHERITED_CLASS:
 -                      {
 -                              zend_op *fetch_class_opline = opline-1;
 -                              zval *parent_name;
 -                              zend_class_entry *ce;
 +      zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL TSRMLS_CC);
 +}
  
 -                              parent_name = &CONSTANT(fetch_class_opline->op2.constant);
 -                              if (((ce = zend_lookup_class(Z_STR_P(parent_name) TSRMLS_CC)) == NULL) ||
 -                                  ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
 -                                   (ce->type == ZEND_INTERNAL_CLASS))) {
 -                                  if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
 -                                              uint32_t *opline_num = &CG(active_op_array)->early_binding;
 +void zend_compile_break_continue(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *depth_ast = ast->child[0];
  
 -                                              while (*opline_num != -1) {
 -                                                      opline_num = &CG(active_op_array)->opcodes[*opline_num].result.opline_num;
 -                                              }
 -                                              *opline_num = opline - CG(active_op_array)->opcodes;
 -                                              opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED;
 -                                              opline->result_type = IS_UNUSED;
 -                                              opline->result.opline_num = -1;
 -                                      }
 -                                      return;
 -                              }
 -                              if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), ce, 1 TSRMLS_CC) == NULL) {
 -                                      return;
 -                              }
 -                              /* clear unnecessary ZEND_FETCH_CLASS opcode */
 -                              zend_del_literal(CG(active_op_array), fetch_class_opline->op2.constant);
 -                              MAKE_NOP(fetch_class_opline);
 +      znode depth_node;
 +      zend_op *opline;
  
 -                              table = CG(class_table);
 -                              break;
 -                      }
 -              case ZEND_VERIFY_ABSTRACT_CLASS:
 -              case ZEND_ADD_INTERFACE:
 -              case ZEND_ADD_TRAIT:
 -              case ZEND_BIND_TRAITS:
 -                      /* We currently don't early-bind classes that implement interfaces */
 -                      /* Classes with traits are handled exactly the same, no early-bind here */
 -                      return;
 -              default:
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Invalid binding type");
 -                      return;
 +      ZEND_ASSERT(ast->kind == ZEND_AST_BREAK || ast->kind == ZEND_AST_CONTINUE);
 +
 +      if (depth_ast) {
 +              if (depth_ast->kind != ZEND_AST_ZVAL) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand "
 +                              "is no longer supported", ast->kind == ZEND_AST_BREAK ? "break" : "continue");
 +              }
 +
 +              zend_compile_expr(&depth_node, depth_ast TSRMLS_CC);
 +
 +              if (Z_TYPE(depth_node.u.constant) != IS_LONG || Z_LVAL(depth_node.u.constant) < 1) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers",
 +                              ast->kind == ZEND_AST_BREAK ? "break" : "continue");
 +              }
 +      } else {
 +              depth_node.op_type = IS_CONST;
 +              ZVAL_LONG(&depth_node.u.constant, 1);
        }
  
 -      zend_hash_del(table, Z_STR(CONSTANT(opline->op1.constant)));
 -      zend_del_literal(CG(active_op_array), opline->op1.constant);
 -      zend_del_literal(CG(active_op_array), opline->op2.constant);
 -      MAKE_NOP(opline);
 +      opline = zend_emit_op(NULL, ast->kind == ZEND_AST_BREAK ? ZEND_BRK : ZEND_CONT,
 +              NULL, &depth_node TSRMLS_CC);
 +      opline->op1.opline_num = CG(context).current_brk_cont;
  }
 -/* }}} */
  
 -ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC) /* {{{ */
 -{
 -      if (op_array->early_binding != -1) {
 -              zend_bool orig_in_compilation = CG(in_compilation);
 -              uint32_t opline_num = op_array->early_binding;
 -              zend_class_entry *ce;
 +void zend_compile_goto(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *label_ast = ast->child[0];
 +      znode label_node;
 +      zend_op *opline;
 +
 +      zend_compile_expr(&label_node, label_ast TSRMLS_CC);
 +      opline = zend_emit_op(NULL, ZEND_GOTO, NULL, &label_node TSRMLS_CC);
 +      opline->extended_value = CG(context).current_brk_cont;
 +      zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC);
 +}
 +
 +void zend_compile_label(zend_ast *ast TSRMLS_DC) {
 +      zval *label = zend_ast_get_zval(ast->child[0]);
 +      zend_label dest;
 +
 +      ZEND_ASSERT(Z_TYPE_P(label) == IS_STRING);
 +
 +      if (!CG(context).labels) {
 +              ALLOC_HASHTABLE(CG(context).labels);
 +              zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0);
 +      }
 +
 +      dest.brk_cont = CG(context).current_brk_cont;
 +      dest.opline_num = get_next_op_number(CG(active_op_array));
  
 -              CG(in_compilation) = 1;
 -              while (opline_num != -1) {
 -                      if ((ce = zend_lookup_class(Z_STR_P(op_array->opcodes[opline_num-1].op2.zv) TSRMLS_CC)) != NULL) {
 -                              do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0 TSRMLS_CC);
 -                      }
 -                      opline_num = op_array->opcodes[opline_num].result.opline_num;
 -              }
 -              CG(in_compilation) = orig_in_compilation;
 +      if (!zend_hash_add_mem(CG(context).labels, Z_STR_P(label), &dest, sizeof(zend_label))) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL_P(label));
        }
  }
 -/* }}} */
  
 -void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
 -{
 -      int next_op_number = get_next_op_number(CG(active_op_array));
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +void zend_compile_while(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *cond_ast = ast->child[0];
 +      zend_ast *stmt_ast = ast->child[1];
  
 -      opline->opcode = ZEND_JMPNZ_EX;
 -      if (expr1->op_type == IS_TMP_VAR) {
 -              SET_NODE(opline->result, expr1);
 -      } else {
 -              opline->result.var = get_temporary_variable(CG(active_op_array));
 -              opline->result_type = IS_TMP_VAR;
 -      }
 -      SET_NODE(opline->op1, expr1);
 -      SET_UNUSED(opline->op2);
 +      znode cond_node;
-       zend_uint opnum_start, opnum_jmpz;
++      uint32_t opnum_start, opnum_jmpz;
  
 -      op_token->u.op.opline_num = next_op_number;
 +      opnum_start = get_next_op_number(CG(active_op_array));
 +      zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
  
 -      GET_NODE(expr1, opline->result);
 -}
 -/* }}} */
 +      opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
 +      zend_begin_loop(TSRMLS_C);
  
 -void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      zend_compile_stmt(stmt_ast TSRMLS_CC);
  
 -      *result = *expr1; /* we saved the original result in expr1 */
 -      opline->opcode = ZEND_BOOL;
 -      SET_NODE(opline->result, result);
 -      SET_NODE(opline->op1, expr2);
 -      SET_UNUSED(opline->op2);
 +      zend_emit_jump(opnum_start TSRMLS_CC);
 +
 +      zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
  
 -      CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
 +      zend_end_loop(opnum_start, 0 TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
 -{
 -      int next_op_number = get_next_op_number(CG(active_op_array));
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +void zend_compile_do_while(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *stmt_ast = ast->child[0];
 +      zend_ast *cond_ast = ast->child[1];
  
 -      opline->opcode = ZEND_JMPZ_EX;
 -      if (expr1->op_type == IS_TMP_VAR) {
 -              SET_NODE(opline->result, expr1);
 -      } else {
 -              opline->result.var = get_temporary_variable(CG(active_op_array));
 -              opline->result_type = IS_TMP_VAR;
 -      }
 -      SET_NODE(opline->op1, expr1);
 -      SET_UNUSED(opline->op2);
 +      znode cond_node;
-       zend_uint opnum_start, opnum_cond;
++      uint32_t opnum_start, opnum_cond;
  
 -      op_token->u.op.opline_num = next_op_number;
 +      zend_begin_loop(TSRMLS_C);
  
 -      GET_NODE(expr1, opline->result);
 -}
 -/* }}} */
 +      opnum_start = get_next_op_number(CG(active_op_array));
 +      zend_compile_stmt(stmt_ast TSRMLS_CC);
  
 -void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opnum_cond = get_next_op_number(CG(active_op_array));
 +      zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
  
 -      *result = *expr1; /* we saved the original result in expr1 */
 -      opline->opcode = ZEND_BOOL;
 -      SET_NODE(opline->result, result);
 -      SET_NODE(opline->op1, expr2);
 -      SET_UNUSED(opline->op2);
 +      zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, opnum_start TSRMLS_CC);
  
 -      CG(active_op_array)->opcodes[op_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
 +      zend_end_loop(opnum_cond, 0 TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_do_while_begin(TSRMLS_D) /* {{{ */
 -{
 -      do_begin_loop(TSRMLS_C);
 -      INC_BPC(CG(active_op_array));
 -}
 -/* }}} */
 +void zend_compile_expr_list(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list;
-       zend_uint i;
++      uint32_t i;
  
 -void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      result->op_type = IS_CONST;
 +      ZVAL_TRUE(&result->u.constant);
  
 -      opline->opcode = ZEND_JMPNZ;
 -      SET_NODE(opline->op1, expr);
 -      opline->op2.opline_num = do_token->u.op.opline_num;
 -      SET_UNUSED(opline->op2);
 +      if (!ast) {
 +              return;
 +      }
  
 -      do_end_loop(expr_open_bracket->u.op.opline_num, 0 TSRMLS_CC);
 +      list = zend_ast_get_list(ast);
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *expr_ast = list->child[i];
  
 -      DEC_BPC(CG(active_op_array));
 +              zend_do_free(result TSRMLS_CC);
 +              zend_compile_expr(result, expr_ast TSRMLS_CC);
 +      }
  }
 -/* }}} */
  
 -void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +void zend_compile_for(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *init_ast = ast->child[0];
 +      zend_ast *cond_ast = ast->child[1];
 +      zend_ast *loop_ast = ast->child[2];
 +      zend_ast *stmt_ast = ast->child[3];
  
 -      opline->opcode = op;
 -      opline->op1.opline_num = CG(context).current_brk_cont;
 -      SET_UNUSED(opline->op1);
 -      if (expr) {
 -              if (expr->op_type != IS_CONST) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand is no longer supported", op == ZEND_BRK ? "break" : "continue");
 -              } else if (Z_TYPE(expr->u.constant) != IS_LONG || Z_LVAL(expr->u.constant) < 1) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", op == ZEND_BRK ? "break" : "continue");
 -              }
 -              SET_NODE(opline->op2, expr);
 -      } else {
 -              LITERAL_LONG(opline->op2, 1);
 -              opline->op2_type = IS_CONST;
 -      }
 -}
 -/* }}} */
 +      znode result;
-       zend_uint opnum_cond, opnum_jmpz, opnum_loop;
++      uint32_t opnum_cond, opnum_jmpz, opnum_loop;
  
 -void zend_do_switch_cond(const znode *cond TSRMLS_DC) /* {{{ */
 -{
 -      zend_switch_entry switch_entry;
 +      zend_compile_expr_list(&result, init_ast TSRMLS_CC);
 +      zend_do_free(&result TSRMLS_CC);
  
 -      switch_entry.cond = *cond;
 -      switch_entry.default_case = -1;
 -      switch_entry.control_var = -1;
 -      zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry);
 +      opnum_cond = get_next_op_number(CG(active_op_array));
 +      zend_compile_expr_list(&result, cond_ast TSRMLS_CC);
 +      zend_do_extended_info(TSRMLS_C);
 +
 +      opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &result, 0 TSRMLS_CC);
 +      zend_begin_loop(TSRMLS_C);
 +
 +      zend_compile_stmt(stmt_ast TSRMLS_CC);
  
 -      do_begin_loop(TSRMLS_C);
 +      opnum_loop = get_next_op_number(CG(active_op_array));
 +      zend_compile_expr_list(&result, loop_ast TSRMLS_CC);
 +      zend_do_free(&result TSRMLS_CC);
  
 -      INC_BPC(CG(active_op_array));
 +      zend_emit_jump(opnum_cond TSRMLS_CC);
 +
 +      zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
 +
 +      zend_end_loop(opnum_loop, 0 TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_switch_end(const znode *case_list TSRMLS_DC) /* {{{ */
 -{
 +void zend_compile_foreach(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
 +      zend_ast *value_ast = ast->child[1];
 +      zend_ast *key_ast = ast->child[2];
 +      zend_ast *stmt_ast = ast->child[3];
 +      zend_bool by_ref = value_ast->kind == ZEND_AST_REF;
 +      zend_bool is_variable = zend_is_variable(expr_ast) && !zend_is_call(expr_ast)
 +              && zend_can_write_to_variable(expr_ast);
 +
 +      znode expr_node, reset_node, value_node, key_node, dummy_node;
        zend_op *opline;
-       zend_uint opnum_reset, opnum_fetch;
 -      zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack));
++      uint32_t opnum_reset, opnum_fetch;
 +      zend_op foreach_stack_opline;
  
 -      /* add code to jmp to default case */
 -      if (switch_entry_ptr->default_case != -1) {
 -              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -              opline->opcode = ZEND_JMP;
 -              SET_UNUSED(opline->op1);
 -              SET_UNUSED(opline->op2);
 -              opline->op1.opline_num = switch_entry_ptr->default_case;
 +      if (key_ast) {
 +              if (key_ast->kind == ZEND_AST_REF) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference");
 +              }
 +              if (key_ast->kind == ZEND_AST_LIST) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element");
 +              }
        }
  
 -      if (case_list->op_type != IS_UNUSED) { /* non-empty switch */
 -              int next_op_number = get_next_op_number(CG(active_op_array));
 +      if (by_ref) {
 +              value_ast = value_ast->child[0];
 +      }
  
 -              CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
 +      if (by_ref && is_variable) {
 +              zend_compile_var(&expr_node, expr_ast, BP_VAR_W TSRMLS_CC);
 +      } else {
 +              zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
        }
  
 -      /* remember break/continue loop information */
 -      CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array));
 -      CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent;
 +      opnum_reset = get_next_op_number(CG(active_op_array));
 +      opline = zend_emit_op(&reset_node, ZEND_FE_RESET, &expr_node, NULL TSRMLS_CC);
 +      if (by_ref && is_variable) {
 +              opline->extended_value = ZEND_FE_RESET_VARIABLE | ZEND_FE_RESET_REFERENCE; // ???
 +      }
  
 -      if (switch_entry_ptr->cond.op_type==IS_VAR || switch_entry_ptr->cond.op_type==IS_TMP_VAR) {
 -              /* emit free for the switch condition*/
 -              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -              opline->opcode = (switch_entry_ptr->cond.op_type == IS_TMP_VAR) ? ZEND_FREE : ZEND_SWITCH_FREE;
 -              SET_NODE(opline->op1, &switch_entry_ptr->cond);
 -              SET_UNUSED(opline->op2);
 +      SET_NODE(foreach_stack_opline.result, &reset_node);
 +      zend_stack_push(&CG(foreach_copy_stack), &foreach_stack_opline);
 +
 +      opnum_fetch = get_next_op_number(CG(active_op_array));
 +      opline = zend_emit_op(&value_node, ZEND_FE_FETCH, &reset_node, NULL TSRMLS_CC);
 +      if (by_ref) {
 +              opline->extended_value |= ZEND_FE_FETCH_BYREF;
        }
 -      if (switch_entry_ptr->cond.op_type == IS_CONST) {
 -              zval_dtor(&switch_entry_ptr->cond.u.constant);
 +      if (key_ast) {
 +              opline->extended_value |= ZEND_FE_FETCH_WITH_KEY;
        }
  
 -      zend_stack_del_top(&CG(switch_cond_stack));
 +      opline = zend_emit_op(NULL, ZEND_OP_DATA, NULL, NULL TSRMLS_CC);
  
 -      DEC_BPC(CG(active_op_array));
 -}
 -/* }}} */
 +      /* Allocate enough space to keep HashPointer on VM stack */
 +      opline->op1_type = IS_TMP_VAR;
 +      opline->op1.var = get_temporary_variable(CG(active_op_array));
 +      if (sizeof(HashPointer) > sizeof(zval)) {
 +              /* Make sure 1 zval is enough for HashPointer (2 must be enough) */
 +              get_temporary_variable(CG(active_op_array));
 +      }
  
 -void zend_do_case_before_statement(const znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      int next_op_number;
 -      zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack));
 -      znode result;
 +      if (key_ast) {
 +              zend_make_tmp_result(&key_node, opline TSRMLS_CC);
 +      }
  
 -      if (switch_entry_ptr->control_var == -1) {
 -              switch_entry_ptr->control_var = get_temporary_variable(CG(active_op_array));
 +      if (value_ast->attr == ZEND_AST_LIST) {
 +              zend_compile_list_assign(&dummy_node, value_ast, &value_node TSRMLS_CC);
 +              zend_do_free(&dummy_node TSRMLS_CC);
 +      } else if (by_ref) {
 +              zend_emit_assign_ref_znode(value_ast, &value_node TSRMLS_CC);
 +      } else {
 +              zend_emit_assign_znode(value_ast, &value_node TSRMLS_CC);
        }
 -      opline->opcode = ZEND_CASE;
 -      opline->result.var = switch_entry_ptr->control_var;
 -      opline->result_type = IS_TMP_VAR;
 -      SET_NODE(opline->op1, &switch_entry_ptr->cond);
 -      SET_NODE(opline->op2, case_expr);
 -      if (opline->op1_type == IS_CONST) {
 -              zval_copy_ctor(&CONSTANT(opline->op1.constant));
 +
 +      if (key_ast) {
 +              zend_emit_assign_znode(key_ast, &key_node TSRMLS_CC);
        }
 -      GET_NODE(&result, opline->result);
  
 -      next_op_number = get_next_op_number(CG(active_op_array));
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_JMPZ;
 -      SET_NODE(opline->op1, &result);
 -      SET_UNUSED(opline->op2);
 -      case_token->u.op.opline_num = next_op_number;
 +      zend_begin_loop(TSRMLS_C);
  
 -      if (case_list->op_type==IS_UNUSED) {
 -              return;
 -      }
 -      next_op_number = get_next_op_number(CG(active_op_array));
 -      CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
 -}
 -/* }}} */
 +      zend_compile_stmt(stmt_ast TSRMLS_CC);
  
 -void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC) /* {{{ */
 -{
 -      int next_op_number = get_next_op_number(CG(active_op_array));
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      zend_emit_jump(opnum_fetch TSRMLS_CC);
  
 -      opline->opcode = ZEND_JMP;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -      result->u.op.opline_num = next_op_number;
 +      opline = &CG(active_op_array)->opcodes[opnum_reset];
 +      opline->op2.opline_num = get_next_op_number(CG(active_op_array));
  
 -      switch (CG(active_op_array)->opcodes[case_token->u.op.opline_num].opcode) {
 -              case ZEND_JMP:
 -                      CG(active_op_array)->opcodes[case_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
 -                      break;
 -              case ZEND_JMPZ:
 -                      CG(active_op_array)->opcodes[case_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
 -                      break;
 +      opline = &CG(active_op_array)->opcodes[opnum_fetch];
 +      opline->op2.opline_num = get_next_op_number(CG(active_op_array));
 +
 +      zend_end_loop(opnum_fetch, 1 TSRMLS_CC);
 +
 +      {
 +              zend_op *container_ptr = zend_stack_top(&CG(foreach_copy_stack));
 +              generate_free_foreach_copy(container_ptr TSRMLS_CC);
 +              zend_stack_del_top(&CG(foreach_copy_stack));
        }
  }
 -/* }}} */
  
 -void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC) /* {{{ */
 -{
 -      int next_op_number = get_next_op_number(CG(active_op_array));
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      zend_switch_entry *switch_entry_ptr = zend_stack_top(&CG(switch_cond_stack));
 +void zend_compile_if(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint i;
-       zend_uint *jmp_opnums = safe_emalloc(sizeof(zend_uint), list->children - 1, 0);
++      uint32_t i;
++      uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), list->children - 1, 0);
  
 -      opline->opcode = ZEND_JMP;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -      default_token->u.op.opline_num = next_op_number;
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *elem_ast = list->child[i];
 +              zend_ast *cond_ast = elem_ast->child[0];
 +              zend_ast *stmt_ast = elem_ast->child[1];
  
 -      next_op_number = get_next_op_number(CG(active_op_array));
 -      switch_entry_ptr->default_case = next_op_number;
 +              znode cond_node;
-               zend_uint opnum_jmpz;
++              uint32_t opnum_jmpz;
 +              if (cond_ast) {
 +                      zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
 +                      opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
 +              }
  
 -      if (case_list->op_type==IS_UNUSED) {
 -              return;
 +              zend_compile_stmt(stmt_ast TSRMLS_CC);
 +
 +              if (i != list->children - 1) {
 +                      jmp_opnums[i] = zend_emit_jump(0 TSRMLS_CC);
 +              }
 +
 +              if (cond_ast) {
 +                      zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
 +              }
        }
 -      CG(active_op_array)->opcodes[case_list->u.op.opline_num].op1.opline_num = next_op_number;
 +
 +      for (i = 0; i < list->children - 1; ++i) {
 +              zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC);
 +      }
 +
 +      efree(jmp_opnums);
  }
 -/* }}} */
  
 -void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline;
 -      int doing_inheritance = 0;
 -      zend_class_entry *new_class_entry;
 -      zend_string *lcname;
 -      int error = 0;
 -      zval *ns_name, key;
 +void zend_compile_switch(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
 +      zend_ast_list *cases = zend_ast_get_list(ast->child[1]);
  
-       zend_uint i;
 -      if (CG(active_class_entry)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested");
 -              return;
 -      }
++      uint32_t i;
 +      zend_bool has_default_case = 0;
 +      zend_switch_entry switch_entry;
  
 -      lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0);
 -      zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
 +      znode expr_node, case_node;
 +      zend_op *opline;
-       zend_uint *jmpnz_opnums = safe_emalloc(sizeof(zend_uint), cases->children, 0);
-       zend_uint opnum_default_jmp;
++      uint32_t *jmpnz_opnums = safe_emalloc(sizeof(uint32_t), cases->children, 0);
++      uint32_t opnum_default_jmp;
  
 -      if (!(strcmp(lcname->val, "self") && strcmp(lcname->val, "parent"))) {
 -              zend_string_free(lcname);
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant));
 -      }
 +      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
  
 -      /* Class name must not conflict with import names */
 -      if (CG(current_import) &&
 -          (ns_name = zend_hash_find(CG(current_import), lcname)) != NULL) {
 -              error = 1;
 -      }
 +      switch_entry.cond = expr_node;
 +      switch_entry.default_case = -1;
 +      switch_entry.control_var = -1;
 +      zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry);
  
 -      if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -              /* Prefix class name with name of current namespace */
 -              znode tmp;
 +      zend_begin_loop(TSRMLS_C);
  
 -              tmp.op_type = IS_CONST;
 -              ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
 -              zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
 -              *class_name = tmp;
 -              zend_string_free(lcname);
 -              lcname = zend_string_alloc(Z_STRLEN(class_name->u.constant), 0);
 -              zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
 -      }
 +      case_node.op_type = IS_TMP_VAR;
 +      case_node.u.op.var = get_temporary_variable(CG(active_op_array));
  
 -      if (error) {
 -              char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
 +      for (i = 0; i < cases->children; ++i) {
 +              zend_ast *case_ast = cases->child[i];
 +              zend_ast *cond_ast = case_ast->child[0];
 +              znode cond_node;
  
 -              if (Z_STRLEN_P(ns_name) != Z_STRLEN(class_name->u.constant) ||
 -                      memcmp(tmp, lcname->val, Z_STRLEN(class_name->u.constant))) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant));
 +              if (!cond_ast) {
 +                      has_default_case = 1;
 +                      continue;
                }
 -              efree(tmp);
 -      }
 -
 -      new_class_entry = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry));
 -      new_class_entry->type = ZEND_USER_CLASS;
 -      new_class_entry->name = zend_new_interned_string(Z_STR(class_name->u.constant) TSRMLS_CC);
  
 -      zend_initialize_class_data(new_class_entry, 1 TSRMLS_CC);
 -      new_class_entry->info.user.filename = zend_get_compiled_filename(TSRMLS_C);
 -      new_class_entry->info.user.line_start = class_token->u.op.opline_num;
 -      new_class_entry->ce_flags |= class_token->EA;
 +              zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
  
 -      if (parent_class_name && parent_class_name->op_type != IS_UNUSED) {
 -              switch (parent_class_name->EA) {
 -                      case ZEND_FETCH_CLASS_SELF:
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'self' as class name as it is reserved");
 -                              break;
 -                      case ZEND_FETCH_CLASS_PARENT:
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'parent' as class name as it is reserved");
 -                              break;
 -                      case ZEND_FETCH_CLASS_STATIC:
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as class name as it is reserved");
 -                              break;
 -                      default:
 -                              break;
 +              opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node TSRMLS_CC);
 +              SET_NODE(opline->result, &case_node);
 +              if (opline->op1_type == IS_CONST) {
 +                      zval_copy_ctor(&CONSTANT(opline->op1.constant));
                }
 -              doing_inheritance = 1;
 +
 +              jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0 TSRMLS_CC);
        }
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->op1_type = IS_CONST;
 -      build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC);
 -      opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
 +      opnum_default_jmp = zend_emit_jump(0 TSRMLS_CC);
  
 -      opline->op2_type = IS_CONST;
 +      for (i = 0; i < cases->children; ++i) {
 +              zend_ast *case_ast = cases->child[i];
 +              zend_ast *cond_ast = case_ast->child[0];
 +              zend_ast *stmt_ast = case_ast->child[1];
  
 -      if (doing_inheritance) {
 -              /* Make sure a trait does not try to extend a class */
 -              if ((new_class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. Traits can only be composed from other traits with the 'use' keyword. Error", new_class_entry->name->val);
 +              if (cond_ast) {
 +                      zend_update_jump_target_to_next(jmpnz_opnums[i] TSRMLS_CC);
 +              } else {
 +                      zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
                }
  
 -              opline->extended_value = parent_class_name->u.op.var;
 -              opline->opcode = ZEND_DECLARE_INHERITED_CLASS;
 -      } else {
 -              opline->opcode = ZEND_DECLARE_CLASS;
 +              zend_compile_stmt(stmt_ast TSRMLS_CC);
        }
  
 -      LITERAL_STR(opline->op2, lcname);
 -
 -      zend_hash_update_ptr(CG(class_table), Z_STR(key), new_class_entry);
 -      CG(active_class_entry) = new_class_entry;
 +      if (!has_default_case) {
 +              zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
 +      }
  
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      opline->result_type = IS_VAR;
 -      GET_NODE(&CG(implementing_class), opline->result);
 +      zend_end_loop(get_next_op_number(CG(active_op_array)), 1 TSRMLS_CC);
  
 -      if (CG(doc_comment)) {
 -              CG(active_class_entry)->info.user.doc_comment = CG(doc_comment);
 -              CG(doc_comment) = NULL;
 +      if (expr_node.op_type == IS_VAR || expr_node.op_type == IS_TMP_VAR) {
 +              zend_emit_op(NULL, expr_node.op_type == IS_TMP_VAR ? ZEND_FREE : ZEND_SWITCH_FREE,
 +                      &expr_node, NULL TSRMLS_CC);
 +      } else if (expr_node.op_type == IS_CONST) {
 +              zval_dtor(&expr_node.u.constant);
        }
 +
 +      zend_stack_del_top(&CG(switch_cond_stack));
 +      efree(jmpnz_opnums);
  }
 -/* }}} */
  
 -static void do_verify_abstract_class(TSRMLS_D) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +void zend_compile_try(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *try_ast = ast->child[0];
 +      zend_ast_list *catches = zend_ast_get_list(ast->child[1]);
 +      zend_ast *finally_ast = ast->child[2];
  
-       zend_uint i;
 -      opline->opcode = ZEND_VERIFY_ABSTRACT_CLASS;
 -      SET_NODE(opline->op1, &CG(implementing_class));
 -      SET_UNUSED(opline->op2);
 -}
 -/* }}} */
++      uint32_t i;
 +      zend_op *opline;
-       zend_uint try_catch_offset = zend_add_try_element(
++      uint32_t try_catch_offset = zend_add_try_element(
 +              get_next_op_number(CG(active_op_array)) TSRMLS_CC);
-       zend_uint *jmp_opnums = safe_emalloc(sizeof(zend_uint), catches->children, 0);
++      uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), catches->children, 0);
  
 -void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_class_entry *ce = CG(active_class_entry);
 +      if (catches->children == 0 && !finally_ast) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally");
 +      }
  
 -      if (ce->constructor) {
 -              ce->constructor->common.fn_flags |= ZEND_ACC_CTOR;
 -              if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", ce->name->val, ce->constructor->common.function_name->val);
 -              }
 +      zend_compile_stmt(try_ast TSRMLS_CC);
 +
 +      if (catches->children != 0) {
 +              jmp_opnums[0] = zend_emit_jump(0 TSRMLS_CC);
        }
 -      if (ce->destructor) {
 -              ce->destructor->common.fn_flags |= ZEND_ACC_DTOR;
 -              if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", ce->name->val, ce->destructor->common.function_name->val);
 +
 +      for (i = 0; i < catches->children; ++i) {
 +              zend_ast *catch_ast = catches->child[i];
 +              zend_ast *class_ast = catch_ast->child[0];
 +              zend_ast *var_ast = catch_ast->child[1];
 +              zend_ast *stmt_ast = catch_ast->child[2];
 +              zval *var_name = zend_ast_get_zval(var_ast);
 +              zend_bool is_last_catch = (i + 1 == catches->children);
 +
-               zend_uint opnum_catch;
++              uint32_t opnum_catch;
 +
 +              if (!zend_is_const_default_class_ref(class_ast)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement");
                }
 -      }
 -      if (ce->clone) {
 -              ce->clone->common.fn_flags |= ZEND_ACC_CLONE;
 -              if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", ce->name->val, ce->clone->common.function_name->val);
 +
 +              opnum_catch = get_next_op_number(CG(active_op_array));
 +              if (i == 0) {
 +                      CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = opnum_catch;
                }
 -      }
  
 -      ce->info.user.line_end = zend_get_compiled_lineno(TSRMLS_C);
 +              CG(zend_lineno) = catch_ast->lineno;
  
 -      /* Check for traits and proceed like with interfaces.
 -       * The only difference will be a combined handling of them in the end.
 -       * Thus, we need another opcode here. */
 -      if (ce->num_traits > 0) {
 -              zend_op *opline;
 +              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +              opline->opcode = ZEND_CATCH;
 +              opline->op1_type = IS_CONST;
 +              opline->op1.constant = zend_add_class_name_literal(CG(active_op_array),
 +                      zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC);
  
 -              ce->traits = NULL;
 -              ce->num_traits = 0;
 -              ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS;
 +              opline->op2_type = IS_CV;
-               opline->op2.var = lookup_cv(CG(active_op_array), STR_COPY(Z_STR_P(var_name)) TSRMLS_CC);
++              opline->op2.var = lookup_cv(CG(active_op_array), zend_string_copy(Z_STR_P(var_name)) TSRMLS_CC);
 +              opline->result.num = is_last_catch;
  
 -              /* opcode generation: */
 -              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -              opline->opcode = ZEND_BIND_TRAITS;
 -              SET_NODE(opline->op1, &CG(implementing_class));
 -      }
 +              zend_compile_stmt(stmt_ast TSRMLS_CC);
  
 -      if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
 -              && (parent_token || (ce->num_interfaces > 0))) {
 -              zend_verify_abstract_class(ce TSRMLS_CC);
 -              if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
 -                      do_verify_abstract_class(TSRMLS_C);
 +              if (!is_last_catch) {
 +                      jmp_opnums[i + 1] = zend_emit_jump(0 TSRMLS_CC);
                }
 +
 +              opline = &CG(active_op_array)->opcodes[opnum_catch];
 +              opline->extended_value = get_next_op_number(CG(active_op_array));
        }
 -      /* Inherit interfaces; reset number to zero, we need it for above check and
 -       * will restore it during actual implementation.
 -       * The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to
 -       * zend_verify_abstract_class() */
 -      if (ce->num_interfaces > 0) {
 -              ce->interfaces = NULL;
 -              ce->num_interfaces = 0;
 -              ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES;
 +
 +      for (i = 0; i < catches->children; ++i) {
 +              zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC);
 +      }
 +
 +      if (finally_ast) {
-               zend_uint opnum_jmp = get_next_op_number(CG(active_op_array)) + 1;
++              uint32_t opnum_jmp = get_next_op_number(CG(active_op_array)) + 1;
 +
 +              opline = zend_emit_op(NULL, ZEND_FAST_CALL, NULL, NULL TSRMLS_CC);
 +              opline->op1.opline_num = opnum_jmp + 1;
 +
 +              zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC);
 +
 +              CG(context).in_finally++;
 +              zend_compile_stmt(finally_ast TSRMLS_CC);
 +              CG(context).in_finally--;
 +
 +              CG(active_op_array)->try_catch_array[try_catch_offset].finally_op = opnum_jmp + 1;
 +              CG(active_op_array)->try_catch_array[try_catch_offset].finally_end
 +                      = get_next_op_number(CG(active_op_array));
 +              CG(active_op_array)->has_finally_block = 1;
 +
 +              zend_emit_op(NULL, ZEND_FAST_RET, NULL, NULL TSRMLS_CC);
 +
 +              zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC);
        }
  
 -      CG(active_class_entry) = NULL;
 +      efree(jmp_opnums);
 +}
 +
 +/* Encoding declarations must already be handled during parsing */
 +void zend_handle_encoding_declaration(zend_ast_list *declares TSRMLS_DC) {
-       zend_uint i;
++      uint32_t i;
 +      for (i = 0; i < declares->children; ++i) {
 +              zend_ast *declare_ast = declares->child[i];
 +              zend_ast *name_ast = declare_ast->child[0];
 +              zend_ast *value_ast = declare_ast->child[1];
 +              zend_string *name = zend_ast_get_str(name_ast);
 +
 +              if (zend_str_equals_literal_ci(name, "encoding")) {
 +                      if (value_ast->kind != ZEND_AST_ZVAL) {
 +                              zend_error_noreturn(E_COMPILE_ERROR, "Encoding must be a literal");
 +                      }
 +
 +                      if (CG(multibyte)) {
 +                              zend_string *encoding_name = zval_get_string(zend_ast_get_zval(value_ast));
 +
 +                              const zend_encoding *new_encoding, *old_encoding;
 +                              zend_encoding_filter old_input_filter;
 +
 +                              CG(encoding_declared) = 1;
 +
 +                              new_encoding = zend_multibyte_fetch_encoding(encoding_name->val TSRMLS_CC);
 +                              if (!new_encoding) {
 +                                      zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", encoding_name->val);
 +                              } else {
 +                                      old_input_filter = LANG_SCNG(input_filter);
 +                                      old_encoding = LANG_SCNG(script_encoding);
 +                                      zend_multibyte_set_filter(new_encoding TSRMLS_CC);
 +
 +                                      /* need to re-scan if input filter changed */
 +                                      if (old_input_filter != LANG_SCNG(input_filter) ||
 +                                               (old_input_filter && new_encoding != old_encoding)) {
 +                                              zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC);
 +                                      }
 +                              }
 +
-                               STR_RELEASE(encoding_name);
++                              zend_string_release(encoding_name);
 +                      } else {
 +                              zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because "
 +                                      "Zend multibyte feature is turned off by settings");
 +                      }
 +              }
 +      }
  }
 -/* }}} */
  
 -void zend_do_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline;
 +void zend_compile_declare(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *declares = zend_ast_get_list(ast->child[0]);
 +      zend_ast *stmt_ast = ast->child[1];
 +      zend_declarables orig_declarables = CG(declarables);
-       zend_uint i;
++      uint32_t i;
 +
 +      for (i = 0; i < declares->children; ++i) {
 +              zend_ast *declare_ast = declares->child[i];
 +              zend_ast *name_ast = declare_ast->child[0];
 +              zend_ast *value_ast = declare_ast->child[1];
 +
 +              zend_string *name = zend_ast_get_str(name_ast);
 +              if (zend_str_equals_literal_ci(name, "ticks")) {
 +                      zval value_zv;
 +                      zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
-                       convert_to_long(&value_zv);
++                      convert_to_int(&value_zv);
 +                      ZVAL_COPY_VALUE(&CG(declarables).ticks, &value_zv);
 +                      zval_dtor(&value_zv);
 +              } else if (zend_str_equals_literal_ci(name, "encoding")) {
 +                      /* Encoding declaration was already handled during parsing. Here we
 +                       * only check that it is the first statement in the file. */
-                       zend_uint num = CG(active_op_array)->last;
++                      uint32_t num = CG(active_op_array)->last;
 +                      while (num > 0 &&
 +                                 (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
 +                                      CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
 +                              --num;
 +                      }
  
 -      /* Traits can not implement interfaces */
 -      if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' since it is a Trait",
 -                                                       Z_STRVAL(interface_name->u.constant),
 -                                                       CG(active_class_entry)->name->val);
 +                      if (num > 0) {
 +                              zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be "
 +                                      "the very first statement in the script");
 +                      }
 +              } else {
 +                      zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", name->val);
 +              }
        }
  
 -      switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) {
 -              case ZEND_FETCH_CLASS_SELF:
 -              case ZEND_FETCH_CLASS_PARENT:
 -              case ZEND_FETCH_CLASS_STATIC:
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface name as it is reserved", Z_STRVAL(interface_name->u.constant));
 -                      break;
 -              default:
 -                      break;
 +      if (stmt_ast) {
 +              zend_compile_stmt(stmt_ast TSRMLS_CC);
 +
 +              CG(declarables) = orig_declarables;
        }
 +}
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_ADD_INTERFACE;
 -      SET_NODE(opline->op1, &CG(implementing_class));
 -      zend_resolve_class_name(interface_name TSRMLS_CC);
 -      opline->extended_value = (opline->extended_value & ~ZEND_FETCH_CLASS_MASK) | ZEND_FETCH_CLASS_INTERFACE;
 -      opline->op2_type = IS_CONST;
 -      opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &interface_name->u.constant TSRMLS_CC);
 -      CG(active_class_entry)->num_interfaces++;
 +void zend_compile_stmt_list(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint i;
++      uint32_t i;
 +      for (i = 0; i < list->children; ++i) {
 +              zend_compile_stmt(list->child[i] TSRMLS_CC);
 +      }
  }
 -/* }}} */
  
 -void zend_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline;
 +void zend_compile_params(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint i;
++      uint32_t i;
 +      zend_op_array *op_array = CG(active_op_array);
 +      zend_arg_info *arg_infos;
  
 -      if ((CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
 -              zend_error_noreturn(E_COMPILE_ERROR,
 -                              "Cannot use traits inside of interfaces. %s is used in %s",
 -                              Z_STRVAL(trait_name->u.constant), CG(active_class_entry)->name->val);
 +      if (list->children == 0) {
 +              return;
        }
 +      
 +      arg_infos = safe_emalloc(sizeof(zend_arg_info), list->children, 0);
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *param_ast = list->child[i];
 +              zend_ast *type_ast = param_ast->child[0];
 +              zend_ast *var_ast = param_ast->child[1];
 +              zend_ast *default_ast = param_ast->child[2];
 +              zend_string *name = zend_ast_get_str(var_ast);
 +              zend_bool is_ref = (param_ast->attr & ZEND_PARAM_REF) != 0;
 +              zend_bool is_variadic = (param_ast->attr & ZEND_PARAM_VARIADIC) != 0;
 +
 +              znode var_node, default_node;
 +              zend_uchar opcode;
 +              zend_op *opline;
 +              zend_arg_info *arg_info;
  
 +              if (zend_is_auto_global(name TSRMLS_CC)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s",
 +                              name->val);
 +              }
  
 -      switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRLEN(trait_name->u.constant))) {
 -              case ZEND_FETCH_CLASS_SELF:
 -              case ZEND_FETCH_CLASS_PARENT:
 -              case ZEND_FETCH_CLASS_STATIC:
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name as it is reserved", Z_STRVAL(trait_name->u.constant));
 -                      break;
 -              default:
 -                      break;
 -      }
 +              var_node.op_type = IS_CV;
-               var_node.u.op.var = lookup_cv(CG(active_op_array), STR_COPY(name) TSRMLS_CC);
++              var_node.u.op.var = lookup_cv(CG(active_op_array), zend_string_copy(name) TSRMLS_CC);
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_ADD_TRAIT;
 -      SET_NODE(opline->op1, &CG(implementing_class));
 -      zend_resolve_class_name(trait_name TSRMLS_CC);
 -      opline->extended_value = ZEND_FETCH_CLASS_TRAIT;
 -      opline->op2_type = IS_CONST;
 -      opline->op2.constant = zend_add_class_name_literal(CG(active_op_array), &trait_name->u.constant TSRMLS_CC);
 -      CG(active_class_entry)->num_traits++;
 -}
 -/* }}} */
 +              if (EX_VAR_TO_NUM(var_node.u.op.var) != i) {
-                       zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter %s",
++                      zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s",
 +                              name->val);
 +              } else if (zend_str_equals_literal(name, "this")) {
 +                      if (op_array->scope && (op_array->fn_flags & ZEND_ACC_STATIC) == 0) {
 +                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 +                      }
 +                      op_array->this_var = var_node.u.op.var;
 +              }
  
 -ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */
 -{
 -      zend_string *prop_name;
 -      int prop_name_length;
 +              if (op_array->fn_flags & ZEND_ACC_VARIADIC) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic");
 +              }
  
 -      prop_name_length = 1 + src1_length + 1 + src2_length;
 -      prop_name = zend_string_alloc(prop_name_length, internal);
 -      prop_name->val[0] = '\0';
 -      memcpy(prop_name->val + 1, src1, src1_length+1);
 -      memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1);
 -      return prop_name;
 -}
 -/* }}} */
 +              if (is_variadic) {
 +                      opcode = ZEND_RECV_VARIADIC;
 +                      default_node.op_type = IS_UNUSED;
 +                      op_array->fn_flags |= ZEND_ACC_VARIADIC;
  
 -static int zend_strnlen(const char* s, int maxlen) /* {{{ */
 -{
 -      int len = 0;
 -      while (*s++ && maxlen--) len++;
 -      return len;
 -}
 -/* }}} */
 +                      if (default_ast) {
 +                              zend_error_noreturn(E_COMPILE_ERROR,
 +                                      "Variadic parameter cannot have a default value");
 +                      }
 +              } else if (default_ast) {
 +                      opcode = ZEND_RECV_INIT;
 +                      default_node.op_type = IS_CONST;
 +                      zend_const_expr_to_zval(&default_node.u.constant, default_ast TSRMLS_CC);
 +              } else {
 +                      opcode = ZEND_RECV;
 +                      default_node.op_type = IS_UNUSED;
 +                      op_array->required_num_args = i + 1;
 +              }
 +
 +              opline = zend_emit_op(NULL, opcode, NULL, &default_node TSRMLS_CC);
 +              SET_NODE(opline->result, &var_node);
 +              opline->op1.num = i + 1;
 +
 +              arg_info = &arg_infos[i];
 +              arg_info->name = estrndup(name->val, name->len);
 +              arg_info->name_len = name->len;
 +              arg_info->pass_by_reference = is_ref;
 +              arg_info->is_variadic = is_variadic;
 +              arg_info->type_hint = 0;
 +              arg_info->allow_null = 1;
 +              arg_info->class_name = NULL;
 +              arg_info->class_name_len = 0;
 +
 +              if (type_ast) {
 +                      zend_bool has_null_default = default_ast
 +                              && (Z_TYPE(default_node.u.constant) == IS_NULL
 +                                      || (Z_TYPE(default_node.u.constant) == IS_CONSTANT
 +                                              && strcasecmp(Z_STRVAL(default_node.u.constant), "NULL"))
 +                                      || Z_TYPE(default_node.u.constant) == IS_CONSTANT_AST); // ???
 +
 +                      op_array->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS;
 +                      arg_info->allow_null = has_null_default;
 +
 +                      if (type_ast->kind == ZEND_AST_TYPE) {
 +                              arg_info->type_hint = type_ast->attr;
 +                              if (arg_info->type_hint == IS_ARRAY) {
 +                                      if (default_ast && !has_null_default
 +                                              && Z_TYPE(default_node.u.constant) != IS_ARRAY
 +                                      ) {
 +                                              zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
 +                                                      "with array type hint can only be an array or NULL");
 +                                      }
 +                              } else if (arg_info->type_hint == IS_CALLABLE && default_ast) {
 +                                      if (default_ast && !has_null_default) {
 +                                              zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
 +                                                      "with callable type hint can only be NULL");
 +                                      }
 +                              }
 +                      } else {
 +                              zend_string *class_name = zend_ast_get_str(type_ast);
  
 -ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int len, const char **class_name, const char **prop_name, int *prop_len) /* {{{ */
 -{
 -      int class_name_len;
 +                              if (zend_is_const_default_class_ref(type_ast)) {
 +                                      class_name = zend_resolve_class_name_ast(type_ast TSRMLS_CC);
 +                              } else {
-                                       STR_ADDREF(class_name);
++                                      zend_string_addref(class_name);
 +                              }
  
 -      *class_name = NULL;
 +                              arg_info->type_hint = IS_OBJECT;
 +                              arg_info->class_name = estrndup(class_name->val, class_name->len);
 +                              arg_info->class_name_len = class_name->len;
  
-                               STR_RELEASE(class_name);
 -      if (mangled_property[0]!=0) {
 -              *prop_name = mangled_property;
 -              if (prop_len) {
 -                      *prop_len = len;
 -              }
 -              return SUCCESS;
 -      }
 -      if (len < 3 || mangled_property[1]==0) {
 -              zend_error(E_NOTICE, "Illegal member variable name");
 -              *prop_name = mangled_property;
 -              if (prop_len) {
 -                      *prop_len = len;
++                              zend_string_release(class_name);
 +
 +                              if (default_ast && !has_null_default) {
 +                                              zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
 +                                                      "with a class type hint can only be NULL");
 +                              }
 +                      }
                }
 -              return FAILURE;
        }
  
 -      class_name_len = zend_strnlen(mangled_property + 1, --len - 1) + 1;
 -      if (class_name_len >= len || mangled_property[class_name_len]!=0) {
 -              zend_error(E_NOTICE, "Corrupt member variable name");
 -              *prop_name = mangled_property;
 -              if (prop_len) {
 -                      *prop_len = len + 1;
 +      /* These are assigned at the end to avoid unitialized memory in case of an error */
 +      op_array->num_args = list->children;
 +      op_array->arg_info = arg_infos;
 +}
 +
 +void zend_compile_closure_uses(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint i;
++      uint32_t i;
 +
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *var_ast = list->child[i];
 +              zend_string *name = zend_ast_get_str(var_ast);
 +              zend_bool by_ref = var_ast->attr;
 +              zval zv;
 +
 +              if (zend_str_equals_literal(name, "this")) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable");
                }
 -              return FAILURE;
 -      }
 -      *class_name = mangled_property + 1;
 -      *prop_name = (*class_name) + class_name_len;
 -      if (prop_len) {
 -              *prop_len = len - class_name_len;
 +
 +              ZVAL_NULL(&zv);
 +              Z_CONST_FLAGS(zv) = by_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
 +
 +              zend_compile_static_var_common(var_ast, &zv, by_ref TSRMLS_CC);
        }
 -      return SUCCESS;
  }
 -/* }}} */
  
 -void zend_do_declare_property(znode *var_name, znode *value, uint32_t access_type TSRMLS_DC) /* {{{ */
 -{
 -      zval property;
 -      zend_property_info *existing_property_info;
 -      zend_string *comment = NULL;
 +void zend_begin_method_decl(
 +      zend_op_array *op_array, zend_string *name, zend_bool has_body TSRMLS_DC
 +) {
 +      zend_class_entry *ce = CG(active_class_entry);
 +      zend_bool in_interface = (ce->ce_flags & ZEND_ACC_INTERFACE) != 0;
 +      zend_bool in_trait = ZEND_CE_IS_TRAIT(ce);
 +      zend_bool is_public = (op_array->fn_flags & ZEND_ACC_PUBLIC) != 0;
 +      zend_bool is_static = (op_array->fn_flags & ZEND_ACC_STATIC) != 0;
  
 -      if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables");
 -      }
 +      zend_string *lcname;
  
 -      if (access_type & ZEND_ACC_ABSTRACT) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract");
 +      if (in_interface) {
 +              if ((op_array->fn_flags & ZEND_ACC_PPP_MASK) != ZEND_ACC_PUBLIC) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method "
 +                              "%s::%s() must be omitted", ce->name->val, name->val);
 +              }
 +              op_array->fn_flags |= ZEND_ACC_ABSTRACT;
 +      } else if (is_static && (op_array->fn_flags & ZEND_ACC_ABSTRACT)) {
 +              zend_error(E_STRICT, "Static function %s::%s() should not be abstract",
 +                      ce->name->val, name->val);
        }
  
 -      if (access_type & ZEND_ACC_FINAL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, the final modifier is allowed only for methods and classes",
 -                                 CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
 -      }
 +      if (op_array->fn_flags & ZEND_ACC_ABSTRACT) {
 +              //zend_op *opline;
  
 -      if ((existing_property_info = zend_hash_find_ptr(&CG(active_class_entry)->properties_info, Z_STR(var_name->u.constant))) != NULL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
 -      }
 +              if (op_array->fn_flags & ZEND_ACC_PRIVATE) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private",
 +                              in_interface ? "Interface" : "Abstract", ce->name->val, name->val);
 +              }
  
 -      if (value) {
 -              ZVAL_COPY_VALUE(&property, &value->u.constant);
 -      } else {
 -              ZVAL_NULL(&property);
 -      }
 +              if (has_body) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body",
 +                              in_interface ? "Interface" : "Abstract", ce->name->val, name->val);
 +              }
  
 -      if (CG(doc_comment)) {
 -              comment = CG(doc_comment);
 -              CG(doc_comment) = NULL;
 -      }
 +              ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
  
 -      Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC);
 -      if (IS_INTERNED(Z_STR(var_name->u.constant))) {
 -              Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
 +              /*opline = get_next_op(op_array TSRMLS_CC);
 +              opline->opcode = ZEND_RAISE_ABSTRACT_ERROR;
 +              SET_UNUSED(opline->op1);
 +              SET_UNUSED(opline->op2);*/
 +      } else if (!has_body) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body",
 +                      ce->name->val, name->val);
        }
 -      zend_declare_property_ex(CG(active_class_entry), Z_STR(var_name->u.constant), &property, access_type, comment TSRMLS_CC);
 -      zend_string_release(Z_STR(var_name->u.constant));
 -}
 -/* }}} */
  
 -void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC) /* {{{ */
 -{
 -      if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants");
 -              return;
 -      }
 +      op_array->scope = ce;
-       op_array->function_name = STR_COPY(name);
++      op_array->function_name = zend_string_copy(name);
  
-       lcname = STR_ALLOC(name->len, 0);
 -      Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC);
 -      if (IS_INTERNED(Z_STR(var_name->u.constant))) {
 -              Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
 -      }
 -      if (Z_CONSTANT(value->u.constant)) {
 -              CG(active_class_entry)->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
 -      }
 -      if (zend_hash_add(&CG(active_class_entry)->constants_table, Z_STR(var_name->u.constant), &value->u.constant) == NULL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
 -      }
 -      FREE_PNODE(var_name);
++      lcname = zend_string_alloc(name->len, 0);
 +      zend_str_tolower_copy(lcname->val, name->val, name->len);
 +      lcname = zend_new_interned_string(lcname TSRMLS_CC);
  
 -      if (CG(doc_comment)) {
 -              zend_string_release(CG(doc_comment));
 -              CG(doc_comment) = NULL;
 +      if (zend_hash_add_ptr(&ce->function_table, lcname, op_array) == NULL) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()",
 +                      ce->name->val, name->val);
        }
 -}
 -/* }}} */
  
 -void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC) /* {{{ */
 -{
 -      zend_op opline;
 -      zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack));
 -
 -      if (object->op_type == IS_CV) {
 -              if (object->u.op.var == CG(active_op_array)->this_var) {
 -                      object->op_type = IS_UNUSED; /* this means $this for objects */
 -              }
 -      } else if (fetch_list_ptr->count == 1) {
 -              zend_llist_element *le = fetch_list_ptr->head;
 -              zend_op *opline_ptr = (zend_op *) le->data;
 -
 -              if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) {
 -                      zend_del_literal(CG(active_op_array), opline_ptr->op1.constant);
 -                      SET_UNUSED(opline_ptr->op1); /* this means $this for objects */
 -                      SET_NODE(opline_ptr->op2, property);
 -                      /* if it was usual fetch, we change it to object fetch */
 -                      switch (opline_ptr->opcode) {
 -                              case ZEND_FETCH_W:
 -                                      opline_ptr->opcode = ZEND_FETCH_OBJ_W;
 -                                      break;
 -                              case ZEND_FETCH_R:
 -                                      opline_ptr->opcode = ZEND_FETCH_OBJ_R;
 -                                      break;
 -                              case ZEND_FETCH_RW:
 -                                      opline_ptr->opcode = ZEND_FETCH_OBJ_RW;
 -                                      break;
 -                              case ZEND_FETCH_IS:
 -                                      opline_ptr->opcode = ZEND_FETCH_OBJ_IS;
 -                                      break;
 -                              case ZEND_FETCH_UNSET:
 -                                      opline_ptr->opcode = ZEND_FETCH_OBJ_UNSET;
 -                                      break;
 -                              case ZEND_FETCH_FUNC_ARG:
 -                                      opline_ptr->opcode = ZEND_FETCH_OBJ_FUNC_ARG;
 -                                      break;
 +      if (in_interface) {
 +              if (zend_str_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __call() must have "
 +                                      "public visibility and cannot be static");
                        }
 -                      if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) {
 -                              GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant);
 +              } else if (zend_str_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) {
 +                      if (!is_public || !is_static) {
 +                              zend_error(E_WARNING, "The magic method __callStatic() must have "
 +                                      "public visibility and be static");
 +                      }
 +              } else if (zend_str_equals_literal(lcname, ZEND_GET_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __get() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +              } else if (zend_str_equals_literal(lcname, ZEND_SET_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __set() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +              } else if (zend_str_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __unset() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +              } else if (zend_str_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __isset() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +              } else if (zend_str_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __toString() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +              } else if (zend_str_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __invoke() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +              } else if (zend_str_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __debugInfo() must have "
 +                                      "public visibility and cannot be static");
                        }
 -                      GET_NODE(result, opline_ptr->result);
 -                      return;
 +              }
 +      } else {
 +              if (!in_trait && zend_str_equals_str_ci(lcname, ce->name)) {
 +                      if (!ce->constructor) {
 +                              ce->constructor = (zend_function *) op_array;
 +                      }
 +              } else if (zend_str_equals_literal(lcname, ZEND_CONSTRUCTOR_FUNC_NAME)) {
 +                      if (CG(active_class_entry)->constructor) {
 +                              zend_error(E_STRICT, "Redefining already defined constructor for class %s",
 +                                      ce->name->val);
 +                      }
 +                      ce->constructor = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_DESTRUCTOR_FUNC_NAME)) {
 +                      ce->destructor = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_CLONE_FUNC_NAME)) {
 +                      ce->clone = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __call() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +                      ce->__call = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) {
 +                      if (!is_public || !is_static) {
 +                              zend_error(E_WARNING, "The magic method __callStatic() must have "
 +                                      "public visibility and be static");
 +                      }
 +                      ce->__callstatic = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_GET_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __get() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +                      ce->__get = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_SET_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __set() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +                      ce->__set = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __unset() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +                      ce->__unset = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __isset() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +                      ce->__isset = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __toString() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +                      ce->__tostring = (zend_function *) op_array;
 +              } else if (zend_str_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __invoke() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +              } else if (zend_str_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) {
 +                      if (!is_public || is_static) {
 +                              zend_error(E_WARNING, "The magic method __debugInfo() must have "
 +                                      "public visibility and cannot be static");
 +                      }
 +                      ce->__debugInfo = (zend_function *) op_array;
 +              } else if (!is_static) {
 +                      op_array->fn_flags |= ZEND_ACC_ALLOW_STATIC;
                }
        }
  
-       STR_RELEASE(lcname);
 -      if (zend_is_function_or_method_call(object)) {
 -              init_op(&opline TSRMLS_CC);
 -              opline.opcode = ZEND_SEPARATE;
 -              SET_NODE(opline.op1, object);
 -              SET_UNUSED(opline.op2);
 -              opline.result_type = IS_VAR;
 -              opline.result.var = opline.op1.var;
 -              zend_llist_add_element(fetch_list_ptr, &opline);
 -      }
 -
 -      init_op(&opline TSRMLS_CC);
 -      opline.opcode = ZEND_FETCH_OBJ_W;       /* the backpatching routine assumes W */
 -      opline.result_type = IS_VAR;
 -      opline.result.var = get_temporary_variable(CG(active_op_array));
 -      SET_NODE(opline.op1, object);
 -      SET_NODE(opline.op2, property);
 -      if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
 -              GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant);
 -      }
 -      GET_NODE(result, opline.result);
 -
 -      zend_llist_add_element(fetch_list_ptr, &opline);
++      zend_string_release(lcname);
  }
 -/* }}} */
  
 -void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */
 -{
 -      zend_string *name;
 -      zend_string *cfilename;
 -      char haltoff[] = "__COMPILER_HALT_OFFSET__";
 +static void zend_begin_func_decl(
 +      znode *result, zend_op_array *op_array, zend_ast_decl *decl TSRMLS_DC
 +) {
 +      zend_ast *params_ast = decl->child[0];
 +      zend_string *name = decl->name, *lcname;
 +      zend_op *opline;
  
 -      if (CG(has_bracketed_namespaces) && CG(in_namespace)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope");
 -      }
 +      op_array->function_name = name = zend_prefix_with_ns(name TSRMLS_CC);
  
-       lcname = STR_ALLOC(name->len, 0);
 -      cfilename = zend_get_compiled_filename(TSRMLS_C);
 -      name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, cfilename->val, cfilename->len, 0);
 -      zend_register_long_constant(name->val, name->len, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC);
 -      zend_string_free(name);
++      lcname = zend_string_alloc(name->len, 0);
 +      zend_str_tolower_copy(lcname->val, name->val, name->len);
  
 -      if (CG(in_namespace)) {
 -              zend_do_end_namespace(TSRMLS_C);
 +      if (CG(current_import_function)) {
 +              zend_string *import_name = zend_hash_find_ptr(CG(current_import_function), lcname);
 +              if (import_name && !zend_str_equals_str_ci(lcname, import_name)) {
 +                      zend_error(E_COMPILE_ERROR, "Cannot declare function %s "
 +                              "because the name is already in use", name->val);
 +              }
        }
 -}
 -/* }}} */
  
 -void zend_do_push_object(const znode *object TSRMLS_DC) /* {{{ */
 -{
 -      zend_stack_push(&CG(object_stack), object);
 -}
 -/* }}} */
 +      if (zend_str_equals_literal(lcname, ZEND_AUTOLOAD_FUNC_NAME)
 +              && zend_ast_get_list(params_ast)->children != 1
 +      ) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument",
 +                      ZEND_AUTOLOAD_FUNC_NAME);
 +      }
  
 -void zend_do_pop_object(znode *object TSRMLS_DC) /* {{{ */
 -{
 -      if (object) {
 -              znode *tmp = zend_stack_top(&CG(object_stack));
 -              *object = *tmp;
 +      if (op_array->fn_flags & ZEND_ACC_CLOSURE) {
 +              opline = zend_emit_op_tmp(result, ZEND_DECLARE_LAMBDA_FUNCTION, NULL, NULL TSRMLS_CC);
 +      } else {
 +              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +              opline->opcode = ZEND_DECLARE_FUNCTION;
 +              opline->op2_type = IS_CONST;
-               LITERAL_STR(opline->op2, STR_COPY(lcname));
++              LITERAL_STR(opline->op2, zend_string_copy(lcname));
        }
 -      zend_stack_del_top(&CG(object_stack));
 -}
 -/* }}} */
  
 -void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline;
 +      {
 +              zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC);
  
 -      new_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_NEW;
 -      opline->result_type = IS_VAR;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      SET_NODE(opline->op1, class_type);
 -      SET_UNUSED(opline->op2);
 +              opline->op1_type = IS_CONST;
 +              LITERAL_STR(opline->op1, key);
 +
 +              zend_hash_update_ptr(CG(function_table), key, op_array);
 +      }
  
-       STR_RELEASE(lcname);
 -      zend_push_function_call_entry(NULL, new_token->u.op.opline_num TSRMLS_CC);
++      zend_string_release(lcname);
  }
 -/* }}} */
  
 -void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC) /* {{{ */
 -{
 -      znode ctor_result;
 +void zend_compile_func_decl(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast_decl *decl = (zend_ast_decl *) ast;
 +      zend_ast *params_ast = decl->child[0];
 +      zend_ast *uses_ast = decl->child[1];
 +      zend_ast *stmt_ast = decl->child[2];
 +      zend_bool is_method = decl->kind == ZEND_AST_METHOD;
  
 -      zend_do_end_function_call(NULL, &ctor_result, 1, 0 TSRMLS_CC);
 -      zend_do_free(&ctor_result TSRMLS_CC);
 +      zend_op_array *orig_op_array = CG(active_op_array);
 +      zend_op_array *op_array = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
  
 -      CG(active_op_array)->opcodes[new_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
 -      GET_NODE(result, CG(active_op_array)->opcodes[new_token->u.op.opline_num].result);
 -}
 -/* }}} */
 +      // TODO.AST interactive (not just here - also bpc etc!)
 +      
 +      init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
  
 -static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
 -{
 -      zend_constant *c = NULL;
 -      char *lookup_name;
 +      op_array->fn_flags |= decl->flags;
 +      op_array->line_start = decl->start_lineno;
 +      op_array->line_end = decl->end_lineno;
 +      if (decl->doc_comment) {
-               op_array->doc_comment = STR_COPY(decl->doc_comment);
++              op_array->doc_comment = zend_string_copy(decl->doc_comment);
 +      }
 +      if (decl->kind == ZEND_AST_CLOSURE) {
 +              op_array->fn_flags |= ZEND_ACC_CLOSURE;
 +      }
  
 -      if (Z_STRVAL_P(const_name)[0] == '\\') {
 -              if ((c = zend_hash_str_find_ptr(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1)) == NULL) {
 -                      lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1);
 -                      if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)-1)) != NULL) {
 -                              if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
 -                                      efree(lookup_name);
 -                                      return c;
 -                              }
 -                      }
 -                      efree(lookup_name);
 -                      return NULL;
 -              }
 -      } else if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(const_name))) == NULL) {
 -              lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name));
 -              if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name))) != NULL) {
 -                      if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
 -                              efree(lookup_name);
 -                              return c;
 -                      }
 -              }
 -              efree(lookup_name);
 -              return NULL;
 +      if (is_method) {
 +              zend_bool has_body = stmt_ast != NULL;
 +              zend_begin_method_decl(op_array, decl->name, has_body TSRMLS_CC);
 +      } else {
 +              zend_begin_func_decl(result, op_array, decl TSRMLS_CC);
        }
 -      if (c->flags & CONST_CT_SUBST) {
 -              return c;
 +
 +      CG(active_op_array) = op_array;
 +      zend_stack_push(&CG(context_stack), (void *) &CG(context));
 +      zend_init_compiler_context(TSRMLS_C);
 +
 +      if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
 +              zend_op *opline_ext = zend_emit_op(NULL, ZEND_EXT_NOP, NULL, NULL TSRMLS_CC);
 +              opline_ext->lineno = decl->start_lineno;
        }
 -      if (all_internal_constants_substitution &&
 -          (c->flags & CONST_PERSISTENT) &&
 -          !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) &&
 -          !Z_CONSTANT(c->value)) {
 -              return c;
 +
 +      {
 +              /* Push a separator to the switch stack */
 +              zend_switch_entry switch_entry;
 +
 +              switch_entry.cond.op_type = IS_UNUSED;
 +              switch_entry.default_case = 0;
 +              switch_entry.control_var = 0;
 +
 +              zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry);
        }
 -      return NULL;
 -}
 -/* }}} */
  
 -static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
 -{
 -      zend_constant *c = zend_get_ct_const(const_name, all_internal_constants_substitution TSRMLS_CC);
 +      {
 +              /* Push a separator to the foreach stack */
 +              zend_op dummy_opline;
  
 -      if (c) {
 -              zval_dtor(const_name);
 -              result->op_type = IS_CONST;
 -              result->u.constant = c->value;
 -              zval_copy_ctor(&result->u.constant);
 -              return 1;
 +              dummy_opline.result_type = IS_UNUSED;
 +
 +              zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline);
        }
 -      return 0;
 -}
 -/* }}} */
  
 -void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC) /* {{{ */
 -{
 -      znode tmp;
 -      zend_op *opline;
 -      int type;
 -      char *compound;
 -      zend_ulong fetch_type = 0;
 -
 -      if (constant_container) {
 -              switch (mode) {
 -                      case ZEND_CT:
 -                              /* this is a class constant */
 -                              type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant));
 -
 -                              if (ZEND_FETCH_CLASS_STATIC == type) {
 -                                      zend_error(E_ERROR, "\"static::\" is not allowed in compile-time constants");
 -                              } else if (ZEND_FETCH_CLASS_DEFAULT == type) {
 -                                      zend_resolve_class_name(constant_container TSRMLS_CC);
 -                              }
 -                              zend_do_build_full_name(NULL, constant_container, constant_name, 1 TSRMLS_CC);
 -                              *result = *constant_container;
 -                              Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
 -                              if (IS_INTERNED(Z_STR(result->u.constant))) {
 -                                      Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
 -                              }
 -                              Z_CONST_FLAGS(result->u.constant) = fetch_type;
 -                              break;
 -                      case ZEND_RT:
 -                              if (constant_container->op_type == IS_CONST &&
 -                              ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant))) {
 -                                      zend_resolve_class_name(constant_container TSRMLS_CC);
 -                              } else {
 -                                      zend_do_fetch_class(&tmp, constant_container TSRMLS_CC);
 -                                      constant_container = &tmp;
 -                              }
 -                              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -                              opline->opcode = ZEND_FETCH_CONSTANT;
 -                              opline->result_type = IS_TMP_VAR;
 -                              opline->result.var = get_temporary_variable(CG(active_op_array));
 -                              if (constant_container->op_type == IS_CONST) {
 -                                      opline->op1_type = IS_CONST;
 -                                      opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &constant_container->u.constant TSRMLS_CC);
 -                              } else {
 -                                      SET_NODE(opline->op1, constant_container);
 -                              }
 -                              SET_NODE(opline->op2, constant_name);
 -                              if (opline->op1_type == IS_CONST) {
 -                                      GET_CACHE_SLOT(opline->op2.constant);
 -                              } else {
 -                                      GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant);
 -                              }
 -                              GET_NODE(result, opline->result);
 -                              break;
 -              }
 -              return;
 +      zend_compile_params(params_ast TSRMLS_CC);
 +      if (uses_ast) {
 +              zend_compile_closure_uses(uses_ast TSRMLS_CC);
        }
 -      /* namespace constant */
 -      /* only one that did not contain \ from the start can be converted to string if unknown */
 -      switch (mode) {
 -              case ZEND_CT:
 -                      compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
 -                      /* this is a namespace constant, or an unprefixed constant */
 +      zend_compile_stmt(stmt_ast TSRMLS_CC);
  
 -                      if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) {
 -                              break;
 -                      }
 +      if (is_method) {
 +              zend_check_magic_method_implementation(
 +                      CG(active_class_entry), (zend_function *) op_array, E_COMPILE_ERROR TSRMLS_CC);
 +      }
  
 -                      zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC);
 +      zend_do_extended_info(TSRMLS_C);
 +      zend_emit_final_return(NULL TSRMLS_CC);
  
 -                      if(!compound) {
 -                              fetch_type |= IS_CONSTANT_UNQUALIFIED;
 -                      }
 +      pass_two(CG(active_op_array) TSRMLS_CC);
 +      zend_release_labels(0 TSRMLS_CC);
  
 -                      *result = *constant_name;
 -                      Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
 -                      if (IS_INTERNED(Z_STR(result->u.constant))) {
 -                              Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
 -                      }
 -                      Z_CONST_FLAGS(result->u.constant) = fetch_type;
 -                      break;
 -              case ZEND_RT:
 -                      compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
 +      /* Pop the switch and foreach separators */
 +      zend_stack_del_top(&CG(switch_cond_stack));
 +      zend_stack_del_top(&CG(foreach_copy_stack));
  
 -                      zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC);
 +      CG(active_op_array) = orig_op_array;
 +}
  
 -                      if(zend_constant_ct_subst(result, &constant_name->u.constant, 1 TSRMLS_CC)) {
 -                              break;
 -                      }
 +void zend_compile_prop_decl(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint flags = list->attr;
++      uint32_t flags = list->attr;
 +      zend_class_entry *ce = CG(active_class_entry);
-       zend_uint i, children = list->children;
++      uint32_t i, children = list->children;
 +      zend_string *doc_comment = NULL;
  
 -                      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -                      opline->opcode = ZEND_FETCH_CONSTANT;
 -                      opline->result_type = IS_TMP_VAR;
 -                      opline->result.var = get_temporary_variable(CG(active_op_array));
 -                      GET_NODE(result, opline->result);
 -                      SET_UNUSED(opline->op1);
 -                      opline->op2_type = IS_CONST;
 -                      if (compound) {
 -                              /* the name is unambiguous */
 -                              opline->extended_value = 0;
 -                              opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
 -                      } else {
 -                              opline->extended_value = IS_CONSTANT_UNQUALIFIED;
 -                              if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -                                      opline->extended_value |= IS_CONSTANT_IN_NAMESPACE;
 -                                      opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 1 TSRMLS_CC);
 -                              } else {
 -                                      opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
 -                              }
 -                      }
 -                      GET_CACHE_SLOT(opline->op2.constant);
 -                      break;
 +      if (ce->ce_flags & ZEND_ACC_INTERFACE) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables");
        }
 -}
 -/* }}} */
 -
 -void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
  
 -      opline->opcode = ZEND_INIT_FCALL;
 -      opline->extended_value = 1;
 -      SET_UNUSED(opline->op1);
 -      opline->op2_type = IS_CONST;
 -      LITERAL_STR(opline->op2, zend_string_init("shell_exec", sizeof("shell_exec")-1, 0));
 -      GET_CACHE_SLOT(opline->op2.constant);
 +      if (flags & ZEND_ACC_ABSTRACT) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract");
 +      }
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      switch (cmd->op_type) {
 -              case IS_CONST:
 -              case IS_TMP_VAR:
 -                      opline->opcode = ZEND_SEND_VAL;
 -                      break;
 -              default:
 -                      opline->opcode = ZEND_SEND_VAR;
 -                      break;
 +      /* Doc comment has been appended as last element in property list */
 +      if (list->child[children - 1]->kind == ZEND_AST_ZVAL) {
-               doc_comment = STR_COPY(zend_ast_get_str(list->child[children - 1]));
++              doc_comment = zend_string_copy(zend_ast_get_str(list->child[children - 1]));
 +              children -= 1;
        }
 -      SET_NODE(opline->op1, cmd);
 -      opline->op2.opline_num = 1;
 -      SET_UNUSED(opline->op2);
  
 -      /* FIXME: exception support not added to this op2 */
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_DO_FCALL;
 -      opline->extended_value = 1;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      opline->result_type = IS_VAR;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -      GET_NODE(result, opline->result);
 -}
 -/* }}} */
 +      for (i = 0; i < children; ++i) {
 +              zend_ast *prop_ast = list->child[i];
 +              zend_ast *name_ast = prop_ast->child[0];
 +              zend_ast *value_ast = prop_ast->child[1];
 +              zend_string *name = zend_ast_get_str(name_ast);
 +              zval value_zv;
  
 -void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
 -{
 -      int op_num = get_next_op_number(CG(active_op_array));
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +              if (flags & ZEND_ACC_FINAL) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, "
 +                              "the final modifier is allowed only for methods and classes",
 +                              ce->name->val, name->val);
 +              }
  
 -      result->u.op.opline_num = op_num;
 +              if (zend_hash_exists(&ce->properties_info, name)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s",
 +                              ce->name->val, name->val);
 +              }
  
 -      opline->opcode = ZEND_INIT_ARRAY;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      opline->result_type = IS_TMP_VAR;
 -      opline->extended_value = is_ref; /* extval = size << 2 | not_packed << 1 | is_ref */
 -
 -      if (expr) {
 -              opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */
 -              SET_NODE(opline->op1, expr);
 -              if (offset) {
 -                      SET_NODE(opline->op2, offset);
 -                      if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
 -                              zend_ulong index;
 -
 -                              opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
 -                              if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) {
 -                                      zval_dtor(&CONSTANT(opline->op2.constant));
 -                                      ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
 -                              }
 -                      }
 +              if (value_ast) {
 +                      zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
                } else {
 -                      SET_UNUSED(opline->op2);
 +                      ZVAL_NULL(&value_zv);
                }
 -      } else {
 -              SET_UNUSED(opline->op1);
 -              SET_UNUSED(opline->op2);
 -      }
 -}
 -/* }}} */
  
 -void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      zend_op *init_opline = &CG(active_op_array)->opcodes[result->u.op.opline_num];
 -      init_opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */
 -
 -      opline->opcode = ZEND_ADD_ARRAY_ELEMENT;
 -      COPY_NODE(opline->result, init_opline->result);
 -      SET_NODE(opline->op1, expr);
 -      if (offset) {
 -              SET_NODE(opline->op2, offset);
 -              if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
 -                      zend_ulong index;
 -
 -                      init_opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
 -                      if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) {
 -                              zval_dtor(&CONSTANT(opline->op2.constant));
 -                              ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
 -                      }
 -              }
 -      } else {
 -              SET_UNUSED(opline->op2);
 +              name = zend_new_interned_string_safe(name TSRMLS_CC);
 +              zend_declare_property_ex(ce, name, &value_zv, flags, doc_comment TSRMLS_CC);
 +
 +              /* Doc comment is only assigned to first property */
 +              doc_comment = NULL;
        }
 -      opline->extended_value = is_ref;
  }
 -/* }}} */
  
 -void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC) /* {{{ */
 -{
 -      int next_op_num = get_next_op_number(CG(active_op_array));
 -      zend_op *init_opline = &CG(active_op_array)->opcodes[array_node->u.op.opline_num];
 -      zend_op *opline;
 -      int i;
 -      int constant_array = 0;
 -      zval array;
 -
 -      /* check if constructed array consists only from constants */
 -      if ((init_opline->op1_type & (IS_UNUSED | IS_CONST)) &&
 -              (init_opline->op2_type & (IS_UNUSED | IS_CONST))) {
 -              if (next_op_num == array_node->u.op.opline_num + 1) {
 -                      constant_array = 1;
 -              } else if ((init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT) == next_op_num - array_node->u.op.opline_num) {
 -                      opline = init_opline + 1;
 -                      i = next_op_num - array_node->u.op.opline_num - 1;
 -                      while (i > 0) {
 -                              if (opline->opcode != ZEND_ADD_ARRAY_ELEMENT ||
 -                                  opline->op1_type != IS_CONST ||
 -                          !(opline->op2_type & (IS_UNUSED | IS_CONST))) {
 -                                      break;
 -                              }
 -                              opline++;
 -                              i--;
 -                      }
 -                      if (i == 0) {
 -                              constant_array = 1;
 -                      }
 -              }
 -      }
 -      
 -      if (constant_array) {
 -              /* try to construct constant array */
 -              uint32_t size;
 -              zend_long num;
 -              zend_string *str;
 -
 -              if (init_opline->op1_type != IS_UNUSED) {
 -                      size = init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
 -              } else {
 -                      size = 0;
 -              }
 -              ZVAL_NEW_ARR(&array);
 -              zend_hash_init(Z_ARRVAL(array), size, NULL, ZVAL_PTR_DTOR, 0);
 +void zend_compile_class_const_decl(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
 +      zend_class_entry *ce = CG(active_class_entry);
-       zend_uint i;
++      uint32_t i;
  
 -              if (init_opline->op1_type != IS_UNUSED) {
 -                      /* Explicitly initialize array as not-packed if flag is set */
 -                      if (init_opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
 -                              zend_hash_real_init(Z_ARRVAL(array), 0);
 -                      }
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *const_ast = list->child[i];
 +              zend_ast *name_ast = const_ast->child[0];
 +              zend_ast *value_ast = const_ast->child[1];
 +              zend_string *name = zend_ast_get_str(name_ast);
 +              zval value_zv;
  
 -                      opline = init_opline;
 -                      i = next_op_num - array_node->u.op.opline_num;
 -                      while (i > 0 && constant_array) {
 -                              if (opline->op2_type == IS_CONST) {
 -                                      switch (Z_TYPE(CONSTANT(opline->op2.constant))) {
 -                                              case IS_LONG:
 -                                                      num = Z_LVAL(CONSTANT(opline->op2.constant));
 -num_index:
 -                                                      zend_hash_index_update(Z_ARRVAL(array), num, &CONSTANT(opline->op1.constant));
 -                                                      if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
 -                                                      break;
 -                                              case IS_STRING:
 -                                                      str = Z_STR(CONSTANT(opline->op2.constant));
 -str_index:
 -                                                      zend_hash_update(Z_ARRVAL(array), str, &CONSTANT(opline->op1.constant));
 -                                                      if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
 -                                                      break;
 -                                              case IS_DOUBLE:
 -                                                      num = zend_dval_to_lval(Z_DVAL(CONSTANT(opline->op2.constant)));
 -                                                      goto num_index;
 -                                              case IS_FALSE:
 -                                                      num = 0;
 -                                                      goto num_index;
 -                                              case IS_TRUE:
 -                                                      num = 1;
 -                                                      goto num_index;
 -                                              case IS_NULL:
 -                                                      str = STR_EMPTY_ALLOC();
 -                                                      goto str_index;
 -                                              default:
 -                                                      constant_array = 0;
 -                                                      break;
 -                                      }
 -                              } else {
 -                                      zend_hash_next_index_insert(Z_ARRVAL(array), &CONSTANT(opline->op1.constant));
 -                                      if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
 -                              }
 -                              opline++;
 -                              i--;
 -                      }
 -                      if (!constant_array) {
 -                              zval_dtor(&array);
 -                      }
 +              if (ZEND_CE_IS_TRAIT(ce)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants");
 +                      return;
                }
 -      }
  
 -      if (constant_array) {
 -              /* remove run-time array construction and use constant array instead */
 -              opline = &CG(active_op_array)->opcodes[next_op_num-1];
 -              while (1) {
 -                      if (opline->op2_type == IS_CONST) {
 -                              zend_del_literal(CG(active_op_array), opline->op2.constant);
 -                      }
 -                      if (opline->op1_type == IS_CONST) {
 -                              if (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_ARRAY && 
 -                                  Z_REFCOUNTED(CONSTANT(opline->op1.constant)) &&
 -                                  Z_REFCOUNT(CONSTANT(opline->op1.constant)) == 2) {
 -                                  /* don't delete nested arrays */
 -                                      Z_DELREF(CONSTANT(opline->op1.constant));
 -                                      ZVAL_UNDEF(&CONSTANT(opline->op1.constant));
 -                              }
 -                              zend_del_literal(CG(active_op_array), opline->op1.constant);
 -                      }
 -                      if (opline == init_opline) {
 -                              break;
 -                      }
 -                      opline--;
 +              zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
 +
 +              name = zend_new_interned_string_safe(name TSRMLS_CC);
 +              if (zend_hash_add(&ce->constants_table, name, &value_zv) == NULL) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s",
 +                              ce->name->val, name->val);
                }
 -              CG(active_op_array)->last = array_node->u.op.opline_num;
  
 -              result->op_type = IS_CONST;
 -              ZVAL_COPY_VALUE(&result->u.constant, &array);           
 -      } else {
 -              GET_NODE(result, init_opline->result);
 +              if (Z_CONSTANT(value_zv)) {
 +                      ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
 +              }
        }
 -      result->EA = 0;
  }
 -/* }}} */
  
 -void zend_do_add_list_element(const znode *element TSRMLS_DC) /* {{{ */
 -{
 -      list_llist_element lle;
 +static zend_trait_method_reference *zend_compile_method_ref(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *class_ast = ast->child[0];
 +      zend_ast *method_ast = ast->child[1];
  
 -      if (element) {
 -              zend_check_writable_variable(element);
 +      zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference));
 +      method_ref->ce = NULL;
-       method_ref->method_name = STR_COPY(zend_ast_get_str(method_ast));
++      method_ref->method_name = zend_string_copy(zend_ast_get_str(method_ast));
  
 -              lle.var = *element;
 -              zend_llist_copy(&lle.dimensions, &CG(dimension_llist));
 -              zend_llist_prepend_element(&CG(list_llist), &lle);
 +      if (class_ast) {
 +              method_ref->class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC);
 +      } else {
 +              method_ref->class_name = NULL;
        }
 -      (*((int *)CG(dimension_llist).tail->data))++;
 +
 +      return method_ref;
  }
 -/* }}} */
  
 -void zend_do_new_list_begin(TSRMLS_D) /* {{{ */
 -{
 -      int current_dimension = 0;
 -      zend_llist_add_element(&CG(dimension_llist), &current_dimension);
 +static zend_string **zend_compile_name_list(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
 +      zend_string **names = safe_emalloc(sizeof(zend_string *), list->children + 1, 0);
-       zend_uint i;
++      uint32_t i;
 +
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *name_ast = list->child[i];
 +              names[i] = zend_resolve_class_name_ast(name_ast TSRMLS_CC);
 +      }
 +
 +      names[list->children] = NULL;
 +
 +      return names;
  }
 -/* }}} */
  
 -void zend_do_new_list_end(TSRMLS_D) /* {{{ */
 -{
 -      zend_llist_remove_tail(&CG(dimension_llist));
 -      (*((int *)CG(dimension_llist).tail->data))++;
 +static void zend_compile_trait_precedence(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *method_ref_ast = ast->child[0];
 +      zend_ast *insteadof_ast = ast->child[1];
 +      
 +      zend_trait_precedence *precedence = emalloc(sizeof(zend_trait_precedence));
 +      precedence->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC);
 +      precedence->exclude_from_classes
 +              = (void *) zend_compile_name_list(insteadof_ast TSRMLS_CC);
 +
 +      zend_add_to_list(&CG(active_class_entry)->trait_precedences, precedence TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_list_init(TSRMLS_D) /* {{{ */
 -{
 -      zend_stack_push(&CG(list_stack), &CG(list_llist));
 -      zend_stack_push(&CG(list_stack), &CG(dimension_llist));
 -      zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
 -      zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
 -      zend_do_new_list_begin(TSRMLS_C);
 +static void zend_compile_trait_alias(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *method_ref_ast = ast->child[0];
 +      zend_ast *alias_ast = ast->child[1];
-       zend_uint modifiers = ast->attr;
++      uint32_t modifiers = ast->attr;
 +
 +      zend_trait_alias *alias;
 +
 +      if (modifiers == ZEND_ACC_STATIC) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier");
 +      } else if (modifiers == ZEND_ACC_ABSTRACT) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier");
 +      } else if (modifiers == ZEND_ACC_FINAL) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier");
 +      }
 +
 +      alias = emalloc(sizeof(zend_trait_alias));
 +      alias->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC);
 +      alias->modifiers = modifiers;
 +
 +      if (alias_ast) {
-               alias->alias = STR_COPY(zend_ast_get_str(alias_ast));
++              alias->alias = zend_string_copy(zend_ast_get_str(alias_ast));
 +      } else {
 +              alias->alias = NULL;
 +      }
 +
 +      zend_add_to_list(&CG(active_class_entry)->trait_aliases, alias TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) /* {{{ */
 -{
 -      zend_llist_element *le;
 -      zend_llist_element *dimension;
 +void zend_compile_use_trait(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *traits = zend_ast_get_list(ast->child[0]);
 +      zend_ast_list *adaptations = ast->child[1] ? zend_ast_get_list(ast->child[1]) : NULL;
 +      zend_class_entry *ce = CG(active_class_entry);
        zend_op *opline;
-       zend_uint i;
 -      znode last_container;
++      uint32_t i;
  
 -      le = CG(list_llist).head;
 -      while (le) {
 -              zend_llist *tmp_dimension_llist = &((list_llist_element *)le->data)->dimensions;
 -              dimension = tmp_dimension_llist->head;
 -              while (dimension) {
 -                      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -                      if (dimension == tmp_dimension_llist->head) { /* first */
 -                              last_container = *expr;
 -                              switch (expr->op_type) {
 -                                      case IS_VAR:
 -                                      case IS_CV:
 -                                              opline->opcode = ZEND_FETCH_DIM_R;
 -                                              break;
 -                                      case IS_TMP_VAR:
 -                                              opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
 -                                              break;
 -                                      case IS_CONST: /* fetch_dim_tmp_var will handle this bogus fetch */
 -                                              zval_copy_ctor(&expr->u.constant);
 -                                              opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
 -                                              break;
 -                              }
 -                              opline->extended_value |= ZEND_FETCH_ADD_LOCK;
 -                      } else {
 -                              opline->opcode = ZEND_FETCH_DIM_R;
 -                      }
 -                      opline->result_type = IS_VAR;
 -                      opline->result.var = get_temporary_variable(CG(active_op_array));
 -                      SET_NODE(opline->op1, &last_container);
 -                      opline->op2_type = IS_CONST;
 -                      LITERAL_LONG(opline->op2, *((int *) dimension->data));
 -                      GET_NODE(&last_container, opline->result);
 -                      dimension = dimension->next;
 +      for (i = 0; i < traits->children; ++i) {
 +              zend_ast *trait_ast = traits->child[i];
 +              zend_string *name = zend_ast_get_str(trait_ast);
 +
 +              if (ce->ce_flags & ZEND_ACC_INTERFACE) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use traits inside of interfaces. "
 +                              "%s is used in %s", name->val, ce->name->val);
                }
 -              ((list_llist_element *) le->data)->value = last_container;
 -              zend_llist_destroy(&((list_llist_element *) le->data)->dimensions);
 -              zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value TSRMLS_CC);
 -              zend_do_free(result TSRMLS_CC);
 -              le = le->next;
 +
 +              switch (zend_get_class_fetch_type(name)) {
 +                      case ZEND_FETCH_CLASS_SELF:
 +                      case ZEND_FETCH_CLASS_PARENT:
 +                      case ZEND_FETCH_CLASS_STATIC:
 +                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name "
 +                                      "as it is reserved", name->val);
 +                              break;
 +              }
 +
 +              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +              opline->opcode = ZEND_ADD_TRAIT;
 +              SET_NODE(opline->op1, &CG(implementing_class));
 +              opline->extended_value = ZEND_FETCH_CLASS_TRAIT;
 +              opline->op2_type = IS_CONST;
 +              opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
 +                      zend_resolve_class_name_ast(trait_ast TSRMLS_CC) TSRMLS_CC);
 +
 +              ce->num_traits++;
        }
 -      zend_llist_destroy(&CG(dimension_llist));
 -      zend_llist_destroy(&CG(list_llist));
 -      *result = *expr;
 -      {
 -              zend_llist *p;
  
 -              /* restore previous lists */
 -              p = zend_stack_top(&CG(list_stack));
 -              CG(dimension_llist) = *p;
 -              zend_stack_del_top(&CG(list_stack));
 -              p = zend_stack_top(&CG(list_stack));
 -              CG(list_llist) = *p;
 -              zend_stack_del_top(&CG(list_stack));
 +      if (!adaptations) {
 +              return;
 +      }
 +
 +      for (i = 0; i < adaptations->children; ++i) {
 +              zend_ast *adaptation_ast = adaptations->child[i];
 +              switch (adaptation_ast->kind) {
 +                      case ZEND_AST_TRAIT_PRECEDENCE:
 +                              zend_compile_trait_precedence(adaptation_ast TSRMLS_CC);
 +                              break;
 +                      case ZEND_AST_TRAIT_ALIAS:
 +                              zend_compile_trait_alias(adaptation_ast TSRMLS_CC);
 +                              break;
 +                      EMPTY_SWITCH_DEFAULT_CASE()
 +              }
        }
  }
 -/* }}} */
  
 -void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */
 -{
 -      void** list = emalloc(sizeof(void*) * 2);
 +void zend_compile_implements(znode *class_node, zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint i;
++      uint32_t i;
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *class_ast = list->child[i];
 +              zend_string *name = zend_ast_get_str(class_ast);
  
 -      list[0] = item;
 -      list[1] = NULL;
 +              zend_op *opline;
  
 -      *(void**)result = list;
 +              /* Traits can not implement interfaces */
 +              if (ZEND_CE_IS_TRAIT(CG(active_class_entry))) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' "
 +                              "since it is a Trait", name->val, CG(active_class_entry)->name->val);
 +              }
 +
 +              if (!zend_is_const_default_class_ref(class_ast)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR,
 +                              "Cannot use '%s' as interface name as it is reserved", name->val);
 +              }
 +
 +              opline = zend_emit_op(NULL, ZEND_ADD_INTERFACE, class_node, NULL TSRMLS_CC);
 +              opline->extended_value = ZEND_FETCH_CLASS_INTERFACE;
 +              opline->op2_type = IS_CONST;
 +              opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
 +                      zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC);
 +
 +              CG(active_class_entry)->num_interfaces++;
 +      }
  }
 -/* }}} */
  
 -void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */
 -{
 -      void** list = *(void**)result;
 -      size_t n = 0;
 +void zend_compile_class_decl(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_decl *decl = (zend_ast_decl *) ast;
 +      zend_ast *extends_ast = decl->child[0];
 +      zend_ast *implements_ast = decl->child[1];
 +      zend_ast *stmt_ast = decl->child[2];
  
 -      if (list) {
 -              while (list[n]) {
 -                      n++;
 -              }
 +      zend_string *name = decl->name, *lcname, *import_name = NULL;
 +      zend_class_entry *ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry));
 +      zend_op *opline;
 +      znode declare_node, extends_node;
 +
 +      if (CG(active_class_entry)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested");
 +              return;
        }
  
 -      list = erealloc(list, sizeof(void*) * (n+2));
 +      if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved",
 +                      name->val);
 +      }
  
-       lcname = STR_ALLOC(name->len, 0);
 -      list[n]   = item;
 -      list[n+1] = NULL;
++      lcname = zend_string_alloc(name->len, 0);
 +      zend_str_tolower_copy(lcname->val, name->val, name->len);
  
 -      *(void**)result = list;
 -}
 -/* }}} */
 +      if (CG(current_import)) {
 +              import_name = zend_hash_find_ptr(CG(current_import), lcname);
 +      }
  
 -void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */
 -{
 -      zval tmp;
 -      zend_op *opline;
 -      znode lval;
 -      znode result;
 +      if (CG(current_namespace)) {
 +              name = zend_prefix_with_ns(name TSRMLS_CC);
  
-               STR_RELEASE(lcname);
-               lcname = STR_ALLOC(name->len, 0);
 -      if (static_assignment) {
 -              ZVAL_COPY_VALUE(&tmp, &static_assignment->u.constant);
++              zend_string_release(lcname);
++              lcname = zend_string_alloc(name->len, 0);
 +              zend_str_tolower_copy(lcname->val, name->val, name->len);
        } else {
-               STR_ADDREF(name);
 -              ZVAL_NULL(&tmp);
 -              Z_CONST_FLAGS(tmp) = 0;
++              zend_string_addref(name);
        }
 -      if (!CG(active_op_array)->static_variables) {
 -              if (CG(active_op_array)->scope) {
 -                      CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
 -              }
 -              ALLOC_HASHTABLE(CG(active_op_array)->static_variables);
 -              zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0);
 +
 +      if (import_name && !zend_str_equals_str_ci(lcname, import_name)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s "
 +                      "because the name is already in use", name->val);
 +      }
 +
 +      name = zend_new_interned_string(name TSRMLS_CC);
 +      lcname = zend_new_interned_string(lcname TSRMLS_CC);
 +
 +      ce->type = ZEND_USER_CLASS;
 +      ce->name = name;
 +      zend_initialize_class_data(ce, 1 TSRMLS_CC);
 +
 +      ce->ce_flags |= decl->flags;
 +      ce->info.user.filename = zend_get_compiled_filename(TSRMLS_C);
 +      ce->info.user.line_start = decl->start_lineno;
 +      ce->info.user.line_end = decl->end_lineno;
 +      if (decl->doc_comment) {
-               ce->info.user.doc_comment = STR_COPY(decl->doc_comment);
++              ce->info.user.doc_comment = zend_string_copy(decl->doc_comment);
        }
 -      zend_hash_update(CG(active_op_array)->static_variables, Z_STR(varname->u.constant), &tmp);
  
 -      if (varname->op_type == IS_CONST) {
 -              if (Z_TYPE(varname->u.constant) != IS_STRING) {
 -                      convert_to_string(&varname->u.constant);
 +      if (extends_ast) {
 +              if (ZEND_CE_IS_TRAIT(ce)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. "
 +                              "Traits can only be composed from other traits with the 'use' keyword. Error",
 +                              name->val);
 +              }
 +
 +              if (!zend_is_const_default_class_ref(extends_ast)) {
 +                      zend_string *extends_name = zend_ast_get_str(extends_ast);
 +                      zend_error_noreturn(E_COMPILE_ERROR,
 +                              "Cannot use '%s' as class name as it is reserved", extends_name->val);
                }
 +
 +              zend_compile_class_ref(&extends_node, extends_ast TSRMLS_CC);
        }
  
        opline = get_next_op(CG(active_op_array) TSRMLS_CC);
@@@ -6048,419 -6625,308 +6048,419 @@@
                }
        }
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      /* Check for traits and proceed like with interfaces.
 +       * The only difference will be a combined handling of them in the end.
 +       * Thus, we need another opcode here. */
 +      if (ce->num_traits > 0) {
 +              ce->traits = NULL;
 +              ce->num_traits = 0;
 +              ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS;
  
 -      if (varname->op_type == IS_CONST &&
 -         !zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) &&
 -          !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
 -            !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1))) {
 -              opline->opcode = ZEND_BIND_GLOBAL;
 -              SET_NODE(opline->op2, varname);
 -              opline->op1_type = IS_CV;
 -              zval_copy_ctor(&varname->u.constant);
 -              opline->op1.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
 -      } else {
 -              opline->opcode = ZEND_FETCH_W;          /* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
 -              opline->result_type = IS_VAR;
 -              opline->result.var = get_temporary_variable(CG(active_op_array));
 -              SET_NODE(opline->op1, varname);
 -              SET_UNUSED(opline->op2);
 -              opline->extended_value = fetch_type;
 -              GET_NODE(&result, opline->result);
 +              zend_emit_op(NULL, ZEND_BIND_TRAITS, &declare_node, NULL TSRMLS_CC);
 +      }
  
 -              if (varname->op_type == IS_CONST) {
 -                      zval_copy_ctor(&varname->u.constant);
 +      if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
 +              && (extends_ast || ce->num_interfaces > 0)
 +      ) {
 +              zend_verify_abstract_class(ce TSRMLS_CC);
 +              if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
 +                      zend_emit_op(NULL, ZEND_VERIFY_ABSTRACT_CLASS, &declare_node, NULL TSRMLS_CC);
                }
 -              fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
 -
 -              zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
 -              CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result_type |= EXT_TYPE_UNUSED;
        }
 -}
 -/* }}} */
  
 -void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      /* Inherit interfaces; reset number to zero, we need it for above check and
 +       * will restore it during actual implementation.
 +       * The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to
 +       * zend_verify_abstract_class() */
 +      if (ce->num_interfaces > 0) {
 +              ce->interfaces = NULL;
 +              ce->num_interfaces = 0;
 +              ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES;
 +      }
  
 -      opline->opcode = ZEND_CAST;
 -      opline->result_type = IS_VAR;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      SET_NODE(opline->op1, expr);
 -      SET_UNUSED(opline->op2);
 -      opline->extended_value = type;
 -      GET_NODE(result, opline->result);
 +      CG(active_class_entry) = NULL;
  }
 -/* }}} */
 -
 -void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC) /* {{{ */
 -{
 -      zend_do_extended_fcall_begin(TSRMLS_C);
 -      {
 -              zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
  
- static HashTable *zend_get_import_ht(zend_uint type TSRMLS_DC) {
 -              opline->opcode = ZEND_INCLUDE_OR_EVAL;
 -              opline->result_type = IS_VAR;
 -              opline->result.var = get_temporary_variable(CG(active_op_array));
 -              SET_NODE(opline->op1, op1);
 -              SET_UNUSED(opline->op2);
 -              opline->extended_value = type;
 -              GET_NODE(result, opline->result);
++static HashTable *zend_get_import_ht(uint32_t type TSRMLS_DC) {
 +      switch (type) {
 +              case T_CLASS:
 +                      if (!CG(current_import)) {
 +                              CG(current_import) = emalloc(sizeof(HashTable));
 +                              zend_hash_init(CG(current_import), 8, NULL, str_dtor, 0);
 +                      }
 +                      return CG(current_import);
 +              case T_FUNCTION:
 +                      if (!CG(current_import_function)) {
 +                              CG(current_import_function) = emalloc(sizeof(HashTable));
 +                              zend_hash_init(CG(current_import_function), 8, NULL, str_dtor, 0);
 +                      }
 +                      return CG(current_import_function);
 +              case T_CONST:
 +                      if (!CG(current_import_const)) {
 +                              CG(current_import_const) = emalloc(sizeof(HashTable));
 +                              zend_hash_init(CG(current_import_const), 8, NULL, str_dtor, 0);
 +                      }
 +                      return CG(current_import_const);
 +              EMPTY_SWITCH_DEFAULT_CASE()
        }
 -      zend_do_extended_fcall_end(TSRMLS_C);
  }
 -/* }}} */
 -
 -void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC) /* {{{ */
 -{
 -      int i;
  
- static char *zend_get_use_type_str(zend_uint type) {
 -      zend_do_end_variable_parse(variable, BP_VAR_R, 0 TSRMLS_CC);
 -      for (i=1; i<Z_LVAL(num_references->u.constant); i++) {
 -              fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC);
 -              *variable = *result;
++static char *zend_get_use_type_str(uint32_t type) {
 +      switch (type) {
 +              case T_CLASS:
 +                      return "";
 +              case T_FUNCTION:
 +                      return " function";
 +              case T_CONST:
 +                      return " const";
 +              EMPTY_SWITCH_DEFAULT_CASE()
        }
 -      zend_do_begin_variable_parse(TSRMLS_C);
 -      fetch_simple_variable(result, variable, 1 TSRMLS_CC);
 -      /* there is a chance someone is accessing $this */
 -      if (CG(active_op_array)->scope && CG(active_op_array)->this_var == -1) {
 -              zend_string *key = zend_string_init("this", sizeof("this")-1, 0);
 -              CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC);
 +}
 +
 +static void zend_check_already_in_use(
-       zend_uint type, zend_string *old_name, zend_string *new_name, zend_string *check_name
++      uint32_t type, zend_string *old_name, zend_string *new_name, zend_string *check_name
 +) {
 +      if (zend_str_equals_str_ci(old_name, check_name)) {
 +              return;
        }
 +
 +      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name "
 +              "is already in use", zend_get_use_type_str(type), old_name->val, new_name->val);
  }
 -/* }}} */
  
 -void zend_do_unset(znode *variable TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *last_op;
 +void zend_compile_use(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint i;
++      uint32_t i;
 +      zend_string *current_ns = CG(current_namespace);
-       zend_uint type = ast->attr;
++      uint32_t type = ast->attr;
 +      HashTable *current_import = zend_get_import_ht(type TSRMLS_CC);
 +      zend_bool case_sensitive = type == T_CONST;
 +
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *use_ast = list->child[i];
 +              zend_ast *old_name_ast = use_ast->child[0];
 +              zend_ast *new_name_ast = use_ast->child[1];
 +              zend_string *old_name = zend_ast_get_str(old_name_ast);
 +              zend_string *new_name, *lookup_name;
 +
 +              if (new_name_ast) {
-                       new_name = STR_COPY(zend_ast_get_str(new_name_ast));
++                      new_name = zend_string_copy(zend_ast_get_str(new_name_ast));
 +              } else {
 +                      /* The form "use A\B" is eqivalent to "use A\B as B" */
 +                      const char *p = zend_memrchr(old_name->val, '\\', old_name->len);
 +                      if (p) {
-                               new_name = STR_INIT(p + 1, old_name->len - (p - old_name->val + 1), 0);
++                              new_name = zend_string_init(p + 1, old_name->len - (p - old_name->val + 1), 0);
 +                      } else {
-                               new_name = STR_COPY(old_name);
++                              new_name = zend_string_copy(old_name);
  
 -      zend_check_writable_variable(variable);
 +                              if (!current_ns) {
 +                                      if (type == T_CLASS && zend_str_equals_literal(new_name, "strict")) {
 +                                              zend_error_noreturn(E_COMPILE_ERROR,
 +                                                      "You seem to be trying to use a different language...");
 +                                      }
  
 -      if (variable->op_type == IS_CV) {
 -              zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -              opline->opcode = ZEND_UNSET_VAR;
 -              SET_NODE(opline->op1, variable);
 -              SET_UNUSED(opline->op2);
 -              SET_UNUSED(opline->result);
 -              opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
 -      } else {
 -              last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
 +                                      zend_error(E_WARNING, "The use statement with non-compound name '%s' "
 +                                              "has no effect", new_name->val);
 +                              }
 +                      }
 +              }
  
 -              switch (last_op->opcode) {
 -                      case ZEND_FETCH_UNSET:
 -                              last_op->opcode = ZEND_UNSET_VAR;
 -                              SET_UNUSED(last_op->result);
 -                              break;
 -                      case ZEND_FETCH_DIM_UNSET:
 -                              last_op->opcode = ZEND_UNSET_DIM;
 -                              SET_UNUSED(last_op->result);
 -                              break;
 -                      case ZEND_FETCH_OBJ_UNSET:
 -                              last_op->opcode = ZEND_UNSET_OBJ;
 -                              SET_UNUSED(last_op->result);
 -                              break;
 +              if (case_sensitive) {
-                       lookup_name = STR_COPY(new_name);
++                      lookup_name = zend_string_copy(new_name);
 +              } else {
-                       lookup_name = STR_ALLOC(new_name->len, 0);
++                      lookup_name = zend_string_alloc(new_name->len, 0);
 +                      zend_str_tolower_copy(lookup_name->val, new_name->val, new_name->len);
 +              }
  
 +              if (type == T_CLASS && (zend_str_equals_literal(lookup_name, "self")
 +                      || zend_str_equals_literal(lookup_name, "parent"))
 +              ) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' "
 +                              "is a special class name", old_name->val, new_name->val, new_name->val);
                }
 -      }
 -}
 -/* }}} */
  
 -void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *last_op;
 +              if (current_ns) {
-                       zend_string *ns_name = STR_ALLOC(current_ns->len + 1 + new_name->len, 0);
++                      zend_string *ns_name = zend_string_alloc(current_ns->len + 1 + new_name->len, 0);
 +                      zend_str_tolower_copy(ns_name->val, current_ns->val, current_ns->len);
 +                      ns_name->val[current_ns->len] = '\\';
 +                      memcpy(ns_name->val + current_ns->len + 1, lookup_name->val, lookup_name->len);
  
 -      zend_do_end_variable_parse(variable, BP_VAR_IS, 0 TSRMLS_CC);
 +                      if (zend_hash_exists(CG(class_table), ns_name)) {
 +                              zend_check_already_in_use(type, old_name, new_name, ns_name);
 +                      }
  
-                       STR_FREE(ns_name);
 -      if (zend_is_function_or_method_call(variable)) {
 -              if (type == ZEND_ISEMPTY) {
 -                      /* empty(func()) can be transformed to !func() */
 -                      zend_do_unary_op(ZEND_BOOL_NOT, result, variable TSRMLS_CC);
++                      zend_string_free(ns_name);
                } else {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use isset() on the result of a function call (you can use \"null !== func()\" instead)");
 +                      switch (type) {
 +                              case T_CLASS:
 +                              {
 +                                      zend_class_entry *ce = zend_hash_find_ptr(CG(class_table), lookup_name);
 +                                      if (ce && ce->type == ZEND_USER_CLASS
 +                                              && ce->info.user.filename == CG(compiled_filename)
 +                                      ) {
 +                                              zend_check_already_in_use(type, old_name, new_name, lookup_name);
 +                                      }
 +                                      break;
 +                              }
 +                              case T_FUNCTION:
 +                              {
 +                                      zend_function *fn = zend_hash_find_ptr(CG(function_table), lookup_name);
 +                                      if (fn && fn->type == ZEND_USER_FUNCTION
 +                                              && fn->op_array.filename == CG(compiled_filename)
 +                                      ) {
 +                                              zend_check_already_in_use(type, old_name, new_name, lookup_name);
 +                                      }
 +                                      break;
 +                              }
 +                              case T_CONST:
 +                              {
 +                                      zend_string *filename = zend_hash_find_ptr(&CG(const_filenames), lookup_name);
 +                                      if (filename && filename == CG(compiled_filename)) {
 +                                              zend_check_already_in_use(type, old_name, new_name, lookup_name);
 +                                      }
 +                                      break;
 +                              }
 +                              EMPTY_SWITCH_DEFAULT_CASE()
 +                      }
                }
  
-               STR_ADDREF(old_name);
 -              return;
++              zend_string_addref(old_name);
 +              if (!zend_hash_add_ptr(current_import, lookup_name, old_name)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name "
 +                              "is already in use", zend_get_use_type_str(type), old_name->val, new_name->val);
 +              }
 +
-               STR_RELEASE(lookup_name);
-               STR_RELEASE(new_name);
++              zend_string_release(lookup_name);
++              zend_string_release(new_name);
        }
 +}
  
 -      if (variable->op_type == IS_CV) {
 -              last_op = get_next_op(CG(active_op_array) TSRMLS_CC);
 -              last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
 -              SET_NODE(last_op->op1, variable);
 -              SET_UNUSED(last_op->op2);
 -              last_op->result.var = get_temporary_variable(CG(active_op_array));
 -              last_op->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
 -      } else {
 -              last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
 +void zend_compile_const_decl(zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint i;
++      uint32_t i;
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *const_ast = list->child[i];
 +              zend_ast *name_ast = const_ast->child[0];
 +              zend_ast *value_ast = const_ast->child[1];
 +              zend_string *name = zend_ast_get_str(name_ast);
  
 -              switch (last_op->opcode) {
 -                      case ZEND_FETCH_IS:
 -                              last_op->opcode = ZEND_ISSET_ISEMPTY_VAR;
 -                              break;
 -                      case ZEND_FETCH_DIM_IS:
 -                              last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
 -                              break;
 -                      case ZEND_FETCH_OBJ_IS:
 -                              last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
 -                              break;
 +              zend_string *import_name;
 +              znode name_node, value_node;
 +              zval *value_zv = &value_node.u.constant;
 +
 +              value_node.op_type = IS_CONST;
 +              zend_const_expr_to_zval(value_zv, value_ast TSRMLS_CC);
 +
 +              if (zend_get_ct_const(name, 0 TSRMLS_CC)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", name->val);
                }
 -      }
 -      last_op->result_type = IS_TMP_VAR;
 -      last_op->extended_value |= type;
  
 -      GET_NODE(result, last_op->result);
 +              name = zend_prefix_with_ns(name TSRMLS_CC);
 +
 +              if (CG(current_import_const)
 +                      && (import_name = zend_hash_find_ptr(CG(current_import_const), name))
 +              ) {
 +                      if (!zend_str_equals_str(import_name, name)) {
 +                              zend_error(E_COMPILE_ERROR, "Cannot declare const %s because "
 +                                      "the name is already in use", name->val);
 +                      }
 +              }
 +
 +              name_node.op_type = IS_CONST;
 +              ZVAL_STR(&name_node.u.constant, name);
 +
 +              zend_emit_op(NULL, ZEND_DECLARE_CONST, &name_node, &value_node TSRMLS_CC);
 +
 +              zend_hash_add_ptr(&CG(const_filenames), name, CG(compiled_filename));
 +      }
  }
 -/* }}} */
  
 -void zend_do_instanceof(znode *result, znode *expr, znode *class_znode, int type TSRMLS_DC) /* {{{ */
 -{
 -      int last_op_number = get_next_op_number(CG(active_op_array));
 -      zend_op *opline;
 +void zend_compile_namespace(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *name_ast = ast->child[0];
 +      zend_ast *stmt_ast = ast->child[1];
 +      zend_string *name;
 +      zend_bool with_bracket = stmt_ast != NULL;
  
 -      if (last_op_number > 0) {
 -              opline = &CG(active_op_array)->opcodes[last_op_number-1];
 -              if (opline->opcode == ZEND_FETCH_CLASS) {
 -                      opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD;
 +      /* handle mixed syntax declaration or nested namespaces */
 +      if (!CG(has_bracketed_namespaces)) {
 +              if (CG(current_namespace)) {
 +                      /* previous namespace declarations were unbracketed */
 +                      if (with_bracket) {
 +                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations "
 +                                      "with unbracketed namespace declarations");
 +                      }
 +              }
 +      } else {
 +              /* previous namespace declarations were bracketed */
 +              if (!with_bracket) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations "
 +                              "with unbracketed namespace declarations");
 +              } else if (CG(current_namespace) || CG(in_namespace)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Namespace declarations cannot be nested");
                }
        }
  
 -      if (expr->op_type == IS_CONST) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "instanceof expects an object instance, constant given");
 +      if (((!with_bracket && !CG(current_namespace))
 +               || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0
 +      ) {
 +              /* ignore ZEND_EXT_STMT and ZEND_TICKS */
-               zend_uint num = CG(active_op_array)->last;
++              uint32_t num = CG(active_op_array)->last;
 +              while (num > 0 &&
 +                     (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
 +                      CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
 +                      --num;
 +              }
 +              if (num > 0) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be "
 +                              "the very first statement in the script");
 +              }
        }
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_INSTANCEOF;
 -      opline->result_type = IS_TMP_VAR;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      SET_NODE(opline->op1, expr);
 -
 -      SET_NODE(opline->op2, class_znode);
 -
 -      GET_NODE(result, opline->result);
 -}
 -/* }}} */
 +      if (CG(current_namespace)) {
-               STR_RELEASE(CG(current_namespace));
++              zend_string_release(CG(current_namespace));
 +      }
  
 -void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline;
 -      zend_bool is_variable;
 -      zend_op dummy_opline;
 +      if (name_ast) {
 +              name = zend_ast_get_str(name_ast);
  
 -      if (variable) {
 -              if (zend_is_function_or_method_call(array)) {
 -                      is_variable = 0;
 -              } else {
 -                      is_variable = 1;
 +              if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
 +                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", name->val);
                }
 -              /* save the location of FETCH_W instruction(s) */
 -              open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
 -              zend_do_end_variable_parse(array, BP_VAR_W, 0 TSRMLS_CC);
 +
-               CG(current_namespace) = STR_COPY(name);
++              CG(current_namespace) = zend_string_copy(name);
        } else {
 -              is_variable = 0;
 -              open_brackets_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
 +              CG(current_namespace) = NULL;
        }
  
 -      /* save the location of FE_RESET */
 -      foreach_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
 +      zend_reset_import_tables(TSRMLS_C);
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      CG(in_namespace) = 1;
 +      if (with_bracket) {
 +              CG(has_bracketed_namespaces) = 1;
 +      }
  
 -      /* Preform array reset */
 -      opline->opcode = ZEND_FE_RESET;
 -      opline->result_type = IS_VAR;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      SET_NODE(opline->op1, array);
 -      SET_UNUSED(opline->op2);
 -      opline->extended_value = is_variable ? ZEND_FE_RESET_VARIABLE : 0;
 +      if (stmt_ast) {
 +              zend_compile_top_stmt(stmt_ast TSRMLS_CC);
 +              zend_end_namespace(TSRMLS_C);
 +      }
 +}
  
 -      COPY_NODE(dummy_opline.result, opline->result);
 -      zend_stack_push(&CG(foreach_copy_stack), (void *) &dummy_opline);
 +void zend_compile_halt_compiler(zend_ast *ast TSRMLS_DC) {
 +      zend_ast *offset_ast = ast->child[0];
-       long offset = Z_LVAL_P(zend_ast_get_zval(offset_ast));
++      zend_long offset = Z_LVAL_P(zend_ast_get_zval(offset_ast));
  
 -      /* save the location of FE_FETCH */
 -      as_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
 +      zend_string *filename, *name;
 +      const char const_name[] = "__COMPILER_HALT_OFFSET__";
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_FE_FETCH;
 -      opline->result_type = IS_VAR;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      COPY_NODE(opline->op1, dummy_opline.result);
 -      opline->extended_value = 0;
 -      SET_UNUSED(opline->op2);
 +      if (CG(has_bracketed_namespaces) && CG(in_namespace)) {
 +              zend_error_noreturn(E_COMPILE_ERROR,
 +                      "__HALT_COMPILER() can only be used from the outermost scope");
 +      }
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_OP_DATA;
 -      /* Allocate enough space to keep HashPointer on VM stack */
 -      opline->op1_type = IS_TMP_VAR;
 -      opline->op1.var = get_temporary_variable(CG(active_op_array));
 -      if (sizeof(HashPointer) > sizeof(zval)) {
 -              /* Make shure 1 zval is enough for HashPointer (2 must be enough) */
 -              get_temporary_variable(CG(active_op_array));
 +      filename = zend_get_compiled_filename(TSRMLS_C);
 +      name = zend_mangle_property_name(const_name, sizeof(const_name) - 1,
 +              filename->val, filename->len, 0);
 +
 +      zend_register_long_constant(name->val, name->len, offset, CONST_CS, 0 TSRMLS_CC);
-       STR_RELEASE(name);
++      zend_string_release(name);
 +}
 +
 +static zend_bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast TSRMLS_DC) {
 +      zend_op_array *op_array = CG(active_op_array);
 +      zend_class_entry *ce = CG(active_class_entry);
 +
 +      switch (ast->attr) {
 +              case T_FUNC_C:
 +                      if (op_array && op_array->function_name) {
-                               ZVAL_STR(zv, STR_COPY(op_array->function_name));
++                              ZVAL_STR(zv, zend_string_copy(op_array->function_name));
 +                      } else {
 +                              ZVAL_EMPTY_STRING(zv);
 +                      }
 +                      break;
 +              case T_METHOD_C:
 +                      if (ce) {
 +                              if (op_array && op_array->function_name) {
 +                                      ZVAL_STR(zv, zend_concat3(ce->name->val, ce->name->len, "::", 2,
 +                                              op_array->function_name->val, op_array->function_name->len));
 +                              } else {
-                                       ZVAL_STR(zv, STR_COPY(ce->name));
++                                      ZVAL_STR(zv, zend_string_copy(ce->name));
 +                              }
 +                      } else if (op_array && op_array->function_name) {
-                               ZVAL_STR(zv, STR_COPY(op_array->function_name));
++                              ZVAL_STR(zv, zend_string_copy(op_array->function_name));
 +                      } else {
 +                              ZVAL_EMPTY_STRING(zv);
 +                      }
 +                      break;
 +              case T_CLASS_C:
 +                      if (ce) {
 +                              if (ZEND_CE_IS_TRAIT(ce)) {
 +                                      return 0;
 +                              } else {
-                                       ZVAL_STR(zv, STR_COPY(ce->name));
++                                      ZVAL_STR(zv, zend_string_copy(ce->name));
 +                              }
 +                      } else {
 +                              ZVAL_EMPTY_STRING(zv);
 +                      }
 +                      break;
 +              case T_TRAIT_C:
 +                      if (ce && ZEND_CE_IS_TRAIT(ce)) {
-                               ZVAL_STR(zv, STR_COPY(ce->name));
++                              ZVAL_STR(zv, zend_string_copy(ce->name));
 +                      } else {
 +                              ZVAL_EMPTY_STRING(zv);
 +                      }
 +                      break;
 +              case T_NS_C:
 +                      if (CG(current_namespace)) {
-                               ZVAL_STR(zv, STR_COPY(CG(current_namespace)));
++                              ZVAL_STR(zv, zend_string_copy(CG(current_namespace)));
 +                      } else {
 +                              ZVAL_EMPTY_STRING(zv);
 +                      }
 +                      break;
 +              EMPTY_SWITCH_DEFAULT_CASE()
        }
 -      SET_UNUSED(opline->op2);
 -      SET_UNUSED(opline->result);
 +
 +      return 1;
  }
 -/* }}} */
  
 -void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline;
 -      znode dummy, value_node;
 -      zend_bool assign_by_ref=0;
 +static inline void zend_ct_eval_binary_op(
-       zval *result, zend_uint opcode, zval *op1, zval *op2 TSRMLS_DC
++      zval *result, uint32_t opcode, zval *op1, zval *op2 TSRMLS_DC
 +) {
 +      binary_op_type fn = get_binary_op(opcode);
 +      fn(result, op1, op2 TSRMLS_CC);
 +}
  
 -      opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num];
 -      if (key->op_type != IS_UNUSED) {
 -              znode *tmp;
 +static inline void zend_ct_eval_unary_pm(zval *result, zend_ast_kind kind, zval *op TSRMLS_DC) {
 +      binary_op_type fn = kind == ZEND_AST_UNARY_PLUS
 +              ? add_function : sub_function;
  
 -              /* switch between the key and value... */
 -              tmp = key;
 -              key = value;
 -              value = tmp;
 +      zval left;
 +      ZVAL_LONG(&left, 0);
 +      fn(result, &left, op TSRMLS_CC);
 +}
  
 -              /* Mark extended_value in case both key and value are being used */
 -              opline->extended_value |= ZEND_FE_FETCH_WITH_KEY;
 -      }
 +static inline void zend_ct_eval_greater(
 +      zval *result, zend_ast_kind kind, zval *op1, zval *op2 TSRMLS_DC
 +) {
 +      binary_op_type fn = kind == ZEND_AST_GREATER
 +              ? is_smaller_function : is_smaller_or_equal_function;
 +      fn(result, op2, op1 TSRMLS_CC);
 +}
  
 -      if ((key->op_type != IS_UNUSED)) {
 -              if (key->EA & ZEND_PARSED_REFERENCE_VARIABLE) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference");
 -              }
 -              if (key->EA & ZEND_PARSED_LIST_EXPR) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element");
 -              }
 -      }
 +static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
-       zend_uint i;
++      uint32_t i;
  
 -      if (value->EA & ZEND_PARSED_REFERENCE_VARIABLE) {
 -              assign_by_ref = 1;
 +      /* First ensure that *all* child nodes are constant and by-val */
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *elem_ast = list->child[i];
 +              zend_bool by_ref = elem_ast->attr;
 +              zend_eval_const_expr(&elem_ast->child[0] TSRMLS_CC);
 +              zend_eval_const_expr(&elem_ast->child[1] TSRMLS_CC);
  
 -              /* Mark extended_value for assign-by-reference */
 -              opline->extended_value |= ZEND_FE_FETCH_BYREF;
 -              CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].extended_value |= ZEND_FE_RESET_REFERENCE;
 -      } else {
 -              zend_op *fetch = &CG(active_op_array)->opcodes[foreach_token->u.op.opline_num];
 -              zend_op *end = &CG(active_op_array)->opcodes[open_brackets_token->u.op.opline_num];
 -
 -              /* Change "write context" into "read context" */
 -              fetch->extended_value = 0;  /* reset ZEND_FE_RESET_VARIABLE */
 -              while (fetch != end) {
 -                      --fetch;
 -                      if (fetch->opcode == ZEND_FETCH_DIM_W && fetch->op2_type == IS_UNUSED) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
 -                      }
 -                      if (fetch->opcode == ZEND_SEPARATE) {
 -                              MAKE_NOP(fetch);
 -                      } else {
 -                              fetch->opcode -= 3; /* FETCH_W -> FETCH_R */
 -                      }
 +              if (by_ref || elem_ast->child[0]->kind != ZEND_AST_ZVAL
 +                      || (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL)
 +              ) {
 +                      return 0;
                }
        }
  
@@@ -6504,1189 -6949,1014 +6504,1189 @@@
                }
        }
  
 -      if (key->op_type != IS_UNUSED) {
 -              znode key_node;
 +      return 1;
 +}
 +
 +void zend_compile_binary_op(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *left_ast = ast->child[0];
 +      zend_ast *right_ast = ast->child[1];
-       zend_uint opcode = ast->attr;
++      uint32_t opcode = ast->attr;
  
 -              opline = &CG(active_op_array)->opcodes[as_token->u.op.opline_num+1];
 -              opline->result_type = IS_TMP_VAR;
 -              opline->result.opline_num = get_temporary_variable(CG(active_op_array));
 -              GET_NODE(&key_node, opline->result);
 +      znode left_node, right_node;
 +      zend_compile_expr(&left_node, left_ast TSRMLS_CC);
 +      zend_compile_expr(&right_node, right_ast TSRMLS_CC);
  
 -              zend_do_assign(&dummy, key, &key_node TSRMLS_CC);
 -              zend_do_free(&dummy TSRMLS_CC);
 +      if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) {
 +              result->op_type = IS_CONST;
 +              zend_ct_eval_binary_op(&result->u.constant, opcode,
 +                      &left_node.u.constant, &right_node.u.constant TSRMLS_CC);
 +              zval_ptr_dtor(&left_node.u.constant);
 +              zval_ptr_dtor(&right_node.u.constant);
 +              return;
        }
  
 -      do_begin_loop(TSRMLS_C);
 -      INC_BPC(CG(active_op_array));
 +      zend_emit_op_tmp(result, opcode, &left_node, &right_node TSRMLS_CC);
  }
 -/* }}} */
 -
 -void zend_do_foreach_end(const znode *foreach_token, const znode *as_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *container_ptr;
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
  
 -      opline->opcode = ZEND_JMP;
 -      opline->op1.opline_num = as_token->u.op.opline_num;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 +/* We do not use zend_compile_binary_op for this because we want to retain the left-to-right
 + * evaluation order. */
 +void zend_compile_greater(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *left_ast = ast->child[0];
 +      zend_ast *right_ast = ast->child[1];
 +      znode left_node, right_node;
  
 -      CG(active_op_array)->opcodes[foreach_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_RESET */
 -      CG(active_op_array)->opcodes[as_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); /* FE_FETCH */
 +      ZEND_ASSERT(ast->kind == ZEND_AST_GREATER || ast->kind == ZEND_AST_GREATER_EQUAL);
  
 -      do_end_loop(as_token->u.op.opline_num, 1 TSRMLS_CC);
 +      zend_compile_expr(&left_node, left_ast TSRMLS_CC);
 +      zend_compile_expr(&right_node, right_ast TSRMLS_CC);
  
 -      container_ptr = zend_stack_top(&CG(foreach_copy_stack));
 -      generate_free_foreach_copy(container_ptr TSRMLS_CC);
 -      zend_stack_del_top(&CG(foreach_copy_stack));
 +      if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) {
 +              result->op_type = IS_CONST;
 +              zend_ct_eval_greater(&result->u.constant, ast->kind,
 +                      &left_node.u.constant, &right_node.u.constant TSRMLS_CC);
 +              zval_ptr_dtor(&left_node.u.constant);
 +              zval_ptr_dtor(&right_node.u.constant);
 +              return;
 +      }
  
 -      DEC_BPC(CG(active_op_array));
 +      zend_emit_op_tmp(result,
 +              ast->kind == ZEND_AST_GREATER ? ZEND_IS_SMALLER : ZEND_IS_SMALLER_OR_EQUAL,
 +              &right_node, &left_node TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_declare_begin(TSRMLS_D) /* {{{ */
 -{
 -      zend_stack_push(&CG(declare_stack), &CG(declarables));
 -}
 -/* }}} */
 +void zend_compile_unary_op(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
-       zend_uint opcode = ast->attr;
++      uint32_t opcode = ast->attr;
  
 -void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */
 -{
 -      if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) {
 -              convert_to_int(&val->u.constant);
 -              CG(declarables).ticks = val->u.constant;
 -      } else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) {
 -              if (Z_TYPE(val->u.constant) == IS_CONSTANT) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use constants as encoding");
 -              }
 -
 -              /*
 -               * Check that the pragma comes before any opcodes. If the compilation
 -               * got as far as this, the previous portion of the script must have been
 -               * parseable according to the .ini script_encoding setting. We still
 -               * want to tell them to put declare() at the top.
 -               */
 -              {
 -                      int num = CG(active_op_array)->last;
 -                      /* ignore ZEND_EXT_STMT and ZEND_TICKS */
 -                      while (num > 0 &&
 -                             (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
 -                              CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
 -                              --num;
 -                      }
 +      znode expr_node;
 +      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
  
 -                      if (num > 0) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be the very first statement in the script");
 -                      }
 -              }
 +      zend_emit_op_tmp(result, opcode, &expr_node, NULL TSRMLS_CC);
 +}
  
 -              if (CG(multibyte)) {
 -                      const zend_encoding *new_encoding, *old_encoding;
 -                      zend_encoding_filter old_input_filter;
 +void zend_compile_unary_pm(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
 +      znode zero_node, expr_node;
  
 -                      CG(encoding_declared) = 1;
 +      ZEND_ASSERT(ast->kind == ZEND_AST_UNARY_PLUS || ast->kind == ZEND_AST_UNARY_MINUS);
  
 -                      convert_to_string(&val->u.constant);
 -                      new_encoding = zend_multibyte_fetch_encoding(Z_STRVAL(val->u.constant) TSRMLS_CC);
 -                      if (!new_encoding) {
 -                              zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", Z_STRVAL(val->u.constant));
 -                      } else {
 -                              old_input_filter = LANG_SCNG(input_filter);
 -                              old_encoding = LANG_SCNG(script_encoding);
 -                              zend_multibyte_set_filter(new_encoding TSRMLS_CC);
 -
 -                              /* need to re-scan if input filter changed */
 -                              if (old_input_filter != LANG_SCNG(input_filter) ||
 -                                       (old_input_filter && new_encoding != old_encoding)) {
 -                                      zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC);
 -                              }
 -                      }
 -              } else {
 -                      zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because Zend multibyte feature is turned off by settings");
 -              }
 -              zval_dtor(&val->u.constant);
 -      } else {
 -              zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", Z_STRVAL(var->u.constant));
 -              zval_dtor(&val->u.constant);
 -      }
 -      zval_dtor(&var->u.constant);
 -}
 -/* }}} */
 +      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
  
 -void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_declarables *declarables = zend_stack_top(&CG(declare_stack));
 -      /* We should restore if there was more than (current - start) - (ticks?1:0) opcodes */
 -      if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_LVAL(CG(declarables).ticks))?1:0)) {
 -              CG(declarables) = *declarables;
 +      if (expr_node.op_type == IS_CONST) {
 +              result->op_type = IS_CONST;
 +              zend_ct_eval_unary_pm(&result->u.constant, ast->kind, &expr_node.u.constant TSRMLS_CC);
 +              zval_ptr_dtor(&expr_node.u.constant);
 +              return;
        }
 -}
 -/* }}} */
  
 -void zend_do_exit(znode *result, znode *message TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      opline->opcode = ZEND_EXIT;
 -      SET_NODE(opline->op1, message);
 -      SET_UNUSED(opline->op2);
 +      zero_node.op_type = IS_CONST;
 +      ZVAL_LONG(&zero_node.u.constant, 0);
  
 -      result->op_type = IS_CONST;
 -      ZVAL_BOOL(&result->u.constant, 1);
 +      zend_emit_op_tmp(result, ast->kind == ZEND_AST_UNARY_PLUS ? ZEND_ADD : ZEND_SUB,
 +              &zero_node, &expr_node TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_begin_silence(znode *strudel_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +void zend_compile_short_circuiting(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *left_ast = ast->child[0];
 +      zend_ast *right_ast = ast->child[1];
  
 -      opline->opcode = ZEND_BEGIN_SILENCE;
 -      opline->result_type = IS_TMP_VAR;
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -      GET_NODE(strudel_token, opline->result);
 -}
 -/* }}} */
 +      znode left_node, right_node;
 +      zend_op *opline_jmpz, *opline_bool;
-       zend_uint opnum_jmpz;
++      uint32_t opnum_jmpz;
  
 -void zend_do_end_silence(znode *strudel_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      ZEND_ASSERT(ast->kind == ZEND_AST_AND || ast->kind == ZEND_AST_OR);
  
 -      opline->opcode = ZEND_END_SILENCE;
 -      SET_NODE(opline->op1, strudel_token);
 -      SET_UNUSED(opline->op2);
 -}
 -/* }}} */
 +      zend_compile_expr(&left_node, left_ast TSRMLS_CC);
  
 -void zend_do_jmp_set(znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */
 -{
 -      int op_number = get_next_op_number(CG(active_op_array));
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opnum_jmpz = get_next_op_number(CG(active_op_array));
 +      opline_jmpz = zend_emit_op(NULL, ast->kind == ZEND_AST_AND ? ZEND_JMPZ_EX : ZEND_JMPNZ_EX,
 +              &left_node, NULL TSRMLS_CC);
  
 -      if (value->op_type == IS_VAR || value->op_type == IS_CV) {
 -              opline->opcode = ZEND_JMP_SET_VAR;
 -              opline->result_type = IS_VAR;
 +      if (left_node.op_type == IS_TMP_VAR) {
 +              SET_NODE(opline_jmpz->result, &left_node);
        } else {
 -              opline->opcode = ZEND_JMP_SET;
 -              opline->result_type = IS_TMP_VAR;
 +              opline_jmpz->result.var = get_temporary_variable(CG(active_op_array));
 +              opline_jmpz->result_type = IS_TMP_VAR;
        }
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      SET_NODE(opline->op1, value);
 -      SET_UNUSED(opline->op2);
 +      GET_NODE(result, opline_jmpz->result);
  
 -      GET_NODE(colon_token, opline->result);
 +      zend_compile_expr(&right_node, right_ast TSRMLS_CC);
  
 -      jmp_token->u.op.opline_num = op_number;
 +      opline_bool = zend_emit_op(NULL, ZEND_BOOL, &right_node, NULL TSRMLS_CC);
 +      SET_NODE(opline_bool->result, result);
  
 -      INC_BPC(CG(active_op_array));
 +      zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +void zend_compile_post_incdec(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *var_ast = ast->child[0];
 +      ZEND_ASSERT(ast->kind == ZEND_AST_POST_INC || ast->kind == ZEND_AST_POST_DEC);
  
 -      SET_NODE(opline->result, colon_token);
 -      if (colon_token->op_type == IS_TMP_VAR) {
 -              if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) {
 -                      CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].opcode = ZEND_JMP_SET_VAR;
 -                      CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].result_type = IS_VAR;
 -                      opline->opcode = ZEND_QM_ASSIGN_VAR;
 -                      opline->result_type = IS_VAR;
 -              } else {
 -                      opline->opcode = ZEND_QM_ASSIGN;
 -              }
 +      if (var_ast->kind == ZEND_AST_PROP) {
 +              zend_op *opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_RW TSRMLS_CC);
 +              opline->opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_OBJ : ZEND_POST_DEC_OBJ;
 +              zend_make_tmp_result(result, opline TSRMLS_CC);
        } else {
 -              opline->opcode = ZEND_QM_ASSIGN_VAR;
 +              znode var_node;
 +              zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
 +              zend_emit_op_tmp(result, ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC,
 +                      &var_node, NULL TSRMLS_CC);
        }
 -      opline->extended_value = 0;
 -      SET_NODE(opline->op1, false_value);
 -      SET_UNUSED(opline->op2);
 -
 -      GET_NODE(result, opline->result);
 +}
  
 -      CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array));
 +void zend_compile_pre_incdec(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *var_ast = ast->child[0];
 +      ZEND_ASSERT(ast->kind == ZEND_AST_PRE_INC || ast->kind == ZEND_AST_PRE_DEC);
  
 -      DEC_BPC(CG(active_op_array));
 +      if (var_ast->kind == ZEND_AST_PROP) {
 +              zend_op *opline = zend_compile_prop_common(result, var_ast, BP_VAR_RW TSRMLS_CC);
 +              opline->opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC_OBJ : ZEND_PRE_DEC_OBJ;
 +      } else {
 +              znode var_node;
 +              zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
 +              zend_emit_op(result, ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC,
 +                      &var_node, NULL TSRMLS_CC);
 +      }
  }
 -/* }}} */
  
 -void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */
 -{
 -      int jmpz_op_number = get_next_op_number(CG(active_op_array));
 +void zend_compile_cast(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
 +      znode expr_node;
        zend_op *opline;
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      opline->opcode = ZEND_JMPZ;
 -      SET_NODE(opline->op1, cond);
 -      SET_UNUSED(opline->op2);
 -      opline->op2.opline_num = jmpz_op_number;
 -      GET_NODE(qm_token, opline->op2);
 +      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
  
 -      INC_BPC(CG(active_op_array));
 +      opline = zend_emit_op(result, ZEND_CAST, &expr_node, NULL TSRMLS_CC);
 +      opline->extended_value = ast->attr;
  }
 -/* }}} */
  
 -void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +static void zend_compile_shorthand_conditional(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *cond_ast = ast->child[0];
 +      zend_ast *false_ast = ast->child[2];
  
 -      CG(active_op_array)->opcodes[qm_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */
 +      znode cond_node, false_node;
 +      zend_op *opline_jmp_set, *opline_qm_assign;
-       zend_uint opnum_jmp_set;
++      uint32_t opnum_jmp_set;
  
 -      if (true_value->op_type == IS_VAR || true_value->op_type == IS_CV) {
 -              opline->opcode = ZEND_QM_ASSIGN_VAR;
 -              opline->result_type = IS_VAR;
 -      } else {
 -              opline->opcode = ZEND_QM_ASSIGN;
 -              opline->result_type = IS_TMP_VAR;
 -      }
 -      opline->result.var = get_temporary_variable(CG(active_op_array));
 -      SET_NODE(opline->op1, true_value);
 -      SET_UNUSED(opline->op2);
 +      ZEND_ASSERT(ast->child[1] == NULL);
  
 -      GET_NODE(qm_token, opline->result);
 -      colon_token->u.op.opline_num = get_next_op_number(CG(active_op_array));
 +      zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_JMP;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -}
 -/* }}} */
 +      opnum_jmp_set = get_next_op_number(CG(active_op_array));
 +      zend_emit_op_tmp(result, ZEND_JMP_SET, &cond_node, NULL TSRMLS_CC);
  
 -void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      zend_compile_expr(&false_node, false_ast TSRMLS_CC);
  
 -      SET_NODE(opline->result, qm_token);
 -      if (qm_token->op_type == IS_TMP_VAR) {
 -              if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) {
 -                      CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].opcode = ZEND_QM_ASSIGN_VAR;
 -                      CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].result_type = IS_VAR;
 -                      opline->opcode = ZEND_QM_ASSIGN_VAR;
 -                      opline->result_type = IS_VAR;
 -              } else {
 -                      opline->opcode = ZEND_QM_ASSIGN;
 -              }
 +      opline_jmp_set = &CG(active_op_array)->opcodes[opnum_jmp_set];
 +      opline_jmp_set->op2.opline_num = get_next_op_number(CG(active_op_array)) + 1;
 +      if (cond_node.op_type == IS_VAR || cond_node.op_type == IS_CV
 +              || false_node.op_type == IS_VAR || false_node.op_type == IS_CV
 +      ) {
 +              opline_jmp_set->opcode = ZEND_JMP_SET_VAR;
 +              opline_jmp_set->result_type = IS_VAR;
 +              GET_NODE(result, opline_jmp_set->result);
 +
 +              opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN_VAR, &false_node, NULL TSRMLS_CC);
        } else {
 -              opline->opcode = ZEND_QM_ASSIGN_VAR;
 +              opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN, &false_node, NULL TSRMLS_CC);
        }
 -      SET_NODE(opline->op1, false_value);
 -      SET_UNUSED(opline->op2);
 -
 -      CG(active_op_array)->opcodes[colon_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array));
 -
 -      GET_NODE(result, opline->result);
 -
 -      DEC_BPC(CG(active_op_array));
 +      SET_NODE(opline_qm_assign->result, result);
  }
 -/* }}} */
  
 -void zend_do_extended_info(TSRMLS_D) /* {{{ */
 -{
 -      zend_op *opline;
 +void zend_compile_conditional(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *cond_ast = ast->child[0];
 +      zend_ast *true_ast = ast->child[1];
 +      zend_ast *false_ast = ast->child[2];
  
 -      if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
 +      znode cond_node, true_node, false_node;
 +      zend_op *opline_qm_assign1, *opline_qm_assign2;
-       zend_uint opnum_jmpz, opnum_jmp, opnum_qm_assign1;
++      uint32_t opnum_jmpz, opnum_jmp, opnum_qm_assign1;
 +
 +      if (!true_ast) {
 +              zend_compile_shorthand_conditional(result, ast TSRMLS_CC);
                return;
        }
 +      
 +      zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -
 -      opline->opcode = ZEND_EXT_STMT;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -}
 -/* }}} */
 +      opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
  
 -void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */
 -{
 -      zend_op *opline;
 +      zend_compile_expr(&true_node, true_ast TSRMLS_CC);
  
 -      if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
 -              return;
 -      }
 +      opnum_qm_assign1 = get_next_op_number(CG(active_op_array));
 +      zend_emit_op(result, ZEND_QM_ASSIGN, &true_node, NULL TSRMLS_CC);
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opnum_jmp = zend_emit_jump(0 TSRMLS_CC);
  
 -      opline->opcode = ZEND_EXT_FCALL_BEGIN;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -}
 -/* }}} */
 +      zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
  
 -void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */
 -{
 -      zend_op *opline;
 +      zend_compile_expr(&false_node, false_ast TSRMLS_CC);
  
 -      if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
 -              return;
 +      opline_qm_assign1 = &CG(active_op_array)->opcodes[opnum_qm_assign1];
 +      if (true_node.op_type == IS_VAR || true_node.op_type == IS_CV
 +              || false_node.op_type == IS_VAR || false_node.op_type == IS_CV
 +      ) {
 +              opline_qm_assign1->opcode = ZEND_QM_ASSIGN_VAR;
 +              opline_qm_assign1->result_type = IS_VAR;
 +              GET_NODE(result, opline_qm_assign1->result);
        }
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +      opline_qm_assign2 = zend_emit_op(NULL, opline_qm_assign1->opcode, &false_node, NULL TSRMLS_CC);
 +      SET_NODE(opline_qm_assign2->result, result);
  
 -      opline->opcode = ZEND_EXT_FCALL_END;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 +      zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_ticks(TSRMLS_D) /* {{{ */
 -{
 -      zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +void zend_compile_print(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
  
 -      opline->opcode = ZEND_TICKS;
 -      SET_UNUSED(opline->op1);
 -      SET_UNUSED(opline->op2);
 -      opline->extended_value = Z_LVAL(CG(declarables).ticks);
 +      znode expr_node;
 +      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 +
 +      zend_emit_op_tmp(result, ZEND_PRINT, &expr_node, NULL TSRMLS_CC);
  }
 -/* }}} */
  
 -zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */
 -{
 -      zend_auto_global *auto_global;
 +void zend_compile_exit(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
  
 -      if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) {
 -              if (auto_global->armed) {
 -                      auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
 -              }
 -              return 1;
 +      if (expr_ast) {
 +              znode expr_node;
 +              zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 +              zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL TSRMLS_CC);
 +      } else {
 +              zend_emit_op(NULL, ZEND_EXIT, NULL, NULL TSRMLS_CC);
        }
 -      return 0;
 +
 +      result->op_type = IS_CONST;
 +      ZVAL_BOOL(&result->u.constant, 1);
  }
 -/* }}} */
  
 -int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
 -{
 -      zend_auto_global auto_global;
 -      int retval;
 +void zend_compile_yield(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *value_ast = ast->child[0];
 +      zend_ast *key_ast = ast->child[1];
  
 -      auto_global.name = zend_new_interned_string(name TSRMLS_CC);
 -      auto_global.auto_global_callback = auto_global_callback;
 -      auto_global.jit = jit;
 +      znode value_node, key_node;
 +      znode *value_node_ptr = NULL, *key_node_ptr = NULL;
 +      zend_op *opline;
 +      zend_bool returns_by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
  
 -      retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE;
 +      if (!CG(active_op_array)->function_name) {
 +              zend_error_noreturn(E_COMPILE_ERROR,
 +                      "The \"yield\" expression can only be used inside a function");
 +      }
  
 -      zend_string_release(auto_global.name);
 -      return retval;
 -}
 -/* }}} */
 +      CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR;
  
 -ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */
 -{
 -      zend_auto_global *auto_global;
 +      if (key_ast) {
 +              zend_compile_expr(&key_node, key_ast TSRMLS_CC);
 +              key_node_ptr = &key_node;
 +      }
  
 -      ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) {
 -              if (auto_global->jit) {
 -                      auto_global->armed = 1;
 -              } else if (auto_global->auto_global_callback) {
 -                      auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
 +      if (value_ast) {
 +              if (returns_by_ref && zend_is_variable(value_ast) && !zend_is_call(value_ast)) {
 +                      zend_compile_var(&value_node, value_ast, BP_VAR_REF TSRMLS_CC);
                } else {
 -                      auto_global->armed = 0;
 +                      zend_compile_expr(&value_node, value_ast TSRMLS_CC);
                }
 -      } ZEND_HASH_FOREACH_END();
 +              value_node_ptr = &value_node;
 +      }
 +
 +      opline = zend_emit_op(result, ZEND_YIELD, value_node_ptr, key_node_ptr TSRMLS_CC);
 +
 +      if (value_ast && returns_by_ref && zend_is_call(value_ast)) {
 +              opline->extended_value = ZEND_RETURNS_FUNCTION;
 +      }
  }
 -/* }}} */
  
 -int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */
 -{
 -      int retval;
 +void zend_compile_instanceof(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *obj_ast = ast->child[0];
 +      zend_ast *class_ast = ast->child[1];
  
 -      if (CG(increment_lineno)) {
 -              CG(zend_lineno)++;
 -              CG(increment_lineno) = 0;
 +      znode obj_node, class_node;
 +      zend_op *opline;
 +
 +      zend_compile_expr(&obj_node, obj_ast TSRMLS_CC);
 +      if (obj_node.op_type == IS_CONST) {
 +              zend_error_noreturn(E_COMPILE_ERROR,
 +                      "instanceof expects an object instance, constant given");
        }
  
 -again:
 -      Z_TYPE_INFO(zendlval->u.constant) = IS_LONG;
 -      retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
 -      switch (retval) {
 -              case T_COMMENT:
 -              case T_DOC_COMMENT:
 -              case T_OPEN_TAG:
 -              case T_WHITESPACE:
 -                      goto again;
 +      opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
 +      opline->extended_value |= ZEND_FETCH_CLASS_NO_AUTOLOAD;
  
 -              case T_CLOSE_TAG:
 -                      if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
 -                              CG(increment_lineno) = 1;
 -                      }
 -                      if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
 -                              goto again;
 +      zend_emit_op_tmp(result, ZEND_INSTANCEOF, &obj_node, &class_node TSRMLS_CC);
 +}
 +
 +void zend_compile_include_or_eval(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
 +      znode expr_node;
 +      zend_op *opline;
 +
 +      zend_do_extended_fcall_begin(TSRMLS_C);
 +      zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
 +
 +      opline = zend_emit_op(result, ZEND_INCLUDE_OR_EVAL, &expr_node, NULL TSRMLS_CC);
 +      opline->extended_value = ast->attr;
 +
 +      zend_do_extended_fcall_end(TSRMLS_C);
 +}
 +
 +void zend_compile_isset_or_empty(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *var_ast = ast->child[0];
 +
 +      znode var_node;
 +      zend_op *opline;
 +
 +      ZEND_ASSERT(ast->kind == ZEND_AST_ISSET || ast->kind == ZEND_AST_EMPTY);
 +
 +      if (!zend_is_variable(var_ast) || zend_is_call(var_ast)) {
 +              if (ast->kind == ZEND_AST_EMPTY) {
 +                      /* empty(expr) can be transformed to !expr */
 +                      zend_ast *not_ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BOOL_NOT, var_ast);
 +                      zend_compile_expr(result, not_ast TSRMLS_CC);
 +                      return;
 +              } else {
 +                      zend_error_noreturn(E_COMPILE_ERROR,
 +                              "Cannot use isset() on the result of an expression "
 +                              "(you can use \"null !== expression\" instead)");
 +              }
 +      }
 +
 +      switch (var_ast->kind) {
 +              case ZEND_AST_VAR:
 +                      if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) {
 +                              opline = zend_emit_op(result, ZEND_ISSET_ISEMPTY_VAR, &var_node, NULL TSRMLS_CC);
 +                              opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
 +                      } else {
 +                              opline = zend_compile_simple_var_no_cv(result, var_ast, BP_VAR_IS TSRMLS_CC);
 +                              opline->opcode = ZEND_ISSET_ISEMPTY_VAR;
                        }
 -                      retval = ';'; /* implicit ; */
                        break;
 -              case T_OPEN_TAG_WITH_ECHO:
 -                      retval = T_ECHO;
 +              case ZEND_AST_DIM:
 +                      opline = zend_compile_dim_common(result, var_ast, BP_VAR_IS TSRMLS_CC);
 +                      opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
 +                      break;
 +              case ZEND_AST_PROP:
 +                      opline = zend_compile_prop_common(result, var_ast, BP_VAR_IS TSRMLS_CC);
 +                      opline->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
                        break;
 +              case ZEND_AST_STATIC_PROP:
 +                      opline = zend_compile_static_prop_common(result, var_ast, BP_VAR_IS TSRMLS_CC);
 +                      opline->opcode = ZEND_ISSET_ISEMPTY_VAR;
 +                      break;
 +              EMPTY_SWITCH_DEFAULT_CASE()
        }
  
 -      zendlval->op_type = IS_CONST;
 -      return retval;
 +      opline->result_type = IS_TMP_VAR;
 +      opline->extended_value |= ast->kind == ZEND_AST_ISSET ? ZEND_ISSET : ZEND_ISEMPTY;
  }
 -/* }}} */
 -
 -ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */
 -{
 -      zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0;
 -      dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR);
 -
 -      ce->refcount = 1;
 -      ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED;
  
 -      ce->default_properties_table = NULL;
 -      ce->default_static_members_table = NULL;
 -      zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
 -      zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
 -      zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
 +void zend_compile_silence(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
 +      znode silence_node;
  
 -      if (ce->type == ZEND_INTERNAL_CLASS) {
 -#ifdef ZTS
 -              int n = zend_hash_num_elements(CG(class_table));
 +      zend_emit_op_tmp(&silence_node, ZEND_BEGIN_SILENCE, NULL, NULL TSRMLS_CC);
  
 -              if (CG(static_members_table) && n >= CG(last_static_member)) {
 -                      /* Support for run-time declaration: dl() */
 -                      CG(last_static_member) = n+1;
 -                      CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*));
 -                      CG(static_members_table)[n] = NULL;
 -              }
 -              ce->static_members_table = (zval*)(zend_intptr_t)n;
 -#else
 -              ce->static_members_table = NULL;
 -#endif
 +      if (expr_ast->kind == ZEND_AST_VAR) {
 +              /* For @$var we need to force a FETCH instruction, otherwise the CV access will
 +               * happen outside the silenced section. */
 +              zend_compile_simple_var_no_cv(result, expr_ast, BP_VAR_R TSRMLS_CC);
        } else {
 -              ce->static_members_table = ce->default_static_members_table;
 -              ce->info.user.doc_comment = NULL;
 +              zend_compile_expr(result, expr_ast TSRMLS_CC);
        }
  
 -      ce->default_properties_count = 0;
 -      ce->default_static_members_count = 0;
 -
 -      if (nullify_handlers) {
 -              ce->constructor = NULL;
 -              ce->destructor = NULL;
 -              ce->clone = NULL;
 -              ce->__get = NULL;
 -              ce->__set = NULL;
 -              ce->__unset = NULL;
 -              ce->__isset = NULL;
 -              ce->__call = NULL;
 -              ce->__callstatic = NULL;
 -              ce->__tostring = NULL;
 -              ce->create_object = NULL;
 -              ce->get_iterator = NULL;
 -              ce->iterator_funcs.funcs = NULL;
 -              ce->interface_gets_implemented = NULL;
 -              ce->get_static_method = NULL;
 -              ce->parent = NULL;
 -              ce->num_interfaces = 0;
 -              ce->interfaces = NULL;
 -              ce->num_traits = 0;
 -              ce->traits = NULL;
 -              ce->trait_aliases = NULL;
 -              ce->trait_precedences = NULL;
 -              ce->serialize = NULL;
 -              ce->unserialize = NULL;
 -              ce->serialize_func = NULL;
 -              ce->unserialize_func = NULL;
 -              ce->__debugInfo = NULL;
 -              if (ce->type == ZEND_INTERNAL_CLASS) {
 -                      ce->info.internal.module = NULL;
 -                      ce->info.internal.builtin_functions = NULL;
 -              }
 -      }
 +      zend_emit_op(NULL, ZEND_END_SILENCE, &silence_node, NULL TSRMLS_CC);
  }
 -/* }}} */
  
 -int zend_get_class_fetch_type(const char *class_name, uint class_name_len) /* {{{ */
 -{
 -      if ((class_name_len == sizeof("self")-1) &&
 -              !strncasecmp(class_name, "self", sizeof("self")-1)) {
 -              return ZEND_FETCH_CLASS_SELF;
 -      } else if ((class_name_len == sizeof("parent")-1) &&
 -              !strncasecmp(class_name, "parent", sizeof("parent")-1)) {
 -              return ZEND_FETCH_CLASS_PARENT;
 -      } else if ((class_name_len == sizeof("static")-1) &&
 -              !strncasecmp(class_name, "static", sizeof("static")-1)) {
 -              return ZEND_FETCH_CLASS_STATIC;
 -      } else {
 -              return ZEND_FETCH_CLASS_DEFAULT;
 -      }
 -}
 -/* }}} */
 +void zend_compile_shell_exec(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *expr_ast = ast->child[0];
  
 -ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */
 -{
 -      return op_array->vars[EX_VAR_TO_NUM(var)];
 +      zval fn_name;
 +      zend_ast *name_ast, *args_ast, *call_ast;
 +
 +      ZVAL_STRING(&fn_name, "shell_exec");
 +      name_ast = zend_ast_create_zval(&fn_name);
 +      args_ast = (zend_ast *) zend_ast_create_list(1, ZEND_AST_ARG_LIST, expr_ast);
 +      call_ast = zend_ast_create(ZEND_AST_CALL, name_ast, args_ast);
 +
 +      zend_compile_expr(result, call_ast TSRMLS_CC);
 +
 +      zval_ptr_dtor(&fn_name);
  }
 -/* }}} */
  
 -void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC) /* {{{ */
 -{
 -      if (prefix) {
 -              *result = *prefix;
 -              if (Z_TYPE(result->u.constant) == IS_STRING &&
 -                  Z_STRLEN(result->u.constant) == 0) {
 -                      /* namespace\ */
 -                      if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -                              znode tmp;
 -
 -                              zval_dtor(&result->u.constant);
 -                              tmp.op_type = IS_CONST;
 -                              ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
 -                              zend_do_build_namespace_name(result, NULL, &tmp TSRMLS_CC);
 -                      }
 -              }
 -      } else {
 +void zend_compile_array(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
 +      zend_op *opline;
-       zend_uint i, opnum_init;
++      uint32_t i, opnum_init;
 +      zend_bool packed = 1;
 +
 +      if (zend_try_ct_eval_array(&result->u.constant, ast TSRMLS_CC)) {
                result->op_type = IS_CONST;
 -              ZVAL_EMPTY_STRING(&result->u.constant);
 +              return;
        }
 -      /* prefix = result */
 -      zend_do_build_full_name(NULL, result, name, 0 TSRMLS_CC);
 -}
 -/* }}} */
  
 -void zend_do_begin_namespace(znode *name, zend_bool with_bracket TSRMLS_DC) /* {{{ */
 -{
 -      char *lcname;
 +      opnum_init = get_next_op_number(CG(active_op_array));
  
 -      /* handle mixed syntax declaration or nested namespaces */
 -      if (!CG(has_bracketed_namespaces)) {
 -              if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -                      /* previous namespace declarations were unbracketed */
 -                      if (with_bracket) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
 -                      }
 -              }
 -      } else {
 -              /* previous namespace declarations were bracketed */
 -              if (!with_bracket) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
 -              } else if (Z_TYPE(CG(current_namespace)) != IS_UNDEF || CG(in_namespace)) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Namespace declarations cannot be nested");
 -              }
 -      }
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *elem_ast = list->child[i];
 +              zend_ast *value_ast = elem_ast->child[0];
 +              zend_ast *key_ast = elem_ast->child[1];
 +              zend_bool by_ref = elem_ast->attr;
  
 -      if (((!with_bracket && Z_TYPE(CG(current_namespace)) == IS_UNDEF) || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0) {
 -              /* ignore ZEND_EXT_STMT and ZEND_TICKS */
 -              int num = CG(active_op_array)->last;
 -              while (num > 0 &&
 -                     (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
 -                      CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
 -                      --num;
 -              }
 -              if (num > 0) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be the very first statement in the script");
 -              }
 -      }
 +              znode value_node, key_node, *key_node_ptr = NULL;
  
 -      CG(in_namespace) = 1;
 -      if (with_bracket) {
 -              CG(has_bracketed_namespaces) = 1;
 -      }
 +              if (key_ast) {
 +                      zend_compile_expr(&key_node, key_ast TSRMLS_CC);
 +                      zend_handle_numeric_op(&key_node TSRMLS_CC);
 +                      key_node_ptr = &key_node;
 +              }
  
 -      if (name) {
 -              lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant));
 -              if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) &&
 -                    !memcmp(lcname, "self", sizeof("self")-1)) ||
 -                  ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) &&
 -                !memcmp(lcname, "parent", sizeof("parent")-1))) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant));
 +              if (by_ref) {
 +                      zend_ensure_writable_variable(value_ast);
 +                      zend_compile_var(&value_node, value_ast, BP_VAR_W TSRMLS_CC);
 +              } else {
 +                      zend_compile_expr(&value_node, value_ast TSRMLS_CC);
                }
 -              efree(lcname);
  
 -              if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -                      zval_dtor(&CG(current_namespace));
 +              if (i == 0) {
 +                      opline = zend_emit_op_tmp(result, ZEND_INIT_ARRAY, &value_node, key_node_ptr TSRMLS_CC);
 +                      opline->extended_value = list->children << ZEND_ARRAY_SIZE_SHIFT;
 +              } else {
 +                      opline = zend_emit_op(NULL, ZEND_ADD_ARRAY_ELEMENT,
 +                              &value_node, key_node_ptr TSRMLS_CC);
 +                      SET_NODE(opline->result, result);
                }
 -              ZVAL_COPY_VALUE(&CG(current_namespace), &name->u.constant);
 -      } else {
 -              if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -                      zval_dtor(&CG(current_namespace));
 -                      ZVAL_UNDEF(&CG(current_namespace));
 +              opline->extended_value |= by_ref;
 +
 +              if (key_ast && key_node.op_type == IS_CONST && Z_TYPE(key_node.u.constant) == IS_STRING) {
 +                      packed = 0;
                }
        }
  
 -      if (CG(current_import)) {
 -              zend_hash_destroy(CG(current_import));
 -              efree(CG(current_import));
 -              CG(current_import) = NULL;
 +      /* Handle empty array */
 +      if (!list->children) {
 +              zend_emit_op_tmp(result, ZEND_INIT_ARRAY, NULL, NULL TSRMLS_CC);
        }
  
 -      if (CG(current_import_function)) {
 -              zend_hash_destroy(CG(current_import_function));
 -              efree(CG(current_import_function));
 -              CG(current_import_function) = NULL;
 +      /* Add a flag to INIT_ARRAY if we know this array cannot be packed */
 +      if (!packed) {
 +              opline = &CG(active_op_array)->opcodes[opnum_init];
 +              opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
        }
 +}
  
 -      if (CG(current_import_const)) {
 -              zend_hash_destroy(CG(current_import_const));
 -              efree(CG(current_import_const));
 -              CG(current_import_const) = NULL;
 +void zend_compile_const(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *name_ast = ast->child[0];
 +      zend_string *orig_name = zend_ast_get_str(name_ast);
 +      zend_bool is_fully_qualified;
 +
 +      zval resolved_name;
 +      zend_op *opline;
 +
 +      ZVAL_STR(&resolved_name, zend_resolve_const_name(
 +              orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC));
 +
 +      if (zend_constant_ct_subst(result, &resolved_name, 1 TSRMLS_CC)) {
 +              zval_dtor(&resolved_name);
 +              return;
        }
  
 -      if (CG(doc_comment)) {
 -              zend_string_release(CG(doc_comment));
 -              CG(doc_comment) = NULL;
 +      opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, NULL TSRMLS_CC);
 +      opline->op2_type = IS_CONST;
 +
 +      if (is_fully_qualified) {
 +              opline->op2.constant = zend_add_const_name_literal(
 +                      CG(active_op_array), &resolved_name, 0 TSRMLS_CC);
 +      } else {
 +              opline->extended_value = IS_CONSTANT_UNQUALIFIED;
 +              if (CG(current_namespace)) {
 +                      opline->extended_value |= IS_CONSTANT_IN_NAMESPACE;
 +                      opline->op2.constant = zend_add_const_name_literal(
 +                              CG(active_op_array), &resolved_name, 1 TSRMLS_CC);
 +              } else {
 +                      opline->op2.constant = zend_add_const_name_literal(
 +                              CG(active_op_array), &resolved_name, 0 TSRMLS_CC);
 +              }
        }
 +      zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
  }
 -/* }}} */
  
 -void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */
 -{
 -      zend_string *lcname;
 -      zval *name, ns, tmp;
 -      zend_bool warn = 0;
 -      zend_class_entry *ce;
 +void zend_compile_class_const(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *class_ast = ast->child[0];
 +      zend_ast *const_ast = ast->child[1];
  
 -      if (!CG(current_import)) {
 -              CG(current_import) = emalloc(sizeof(HashTable));
 -              zend_hash_init(CG(current_import), 8, NULL, ZVAL_PTR_DTOR, 0);
 +      znode class_node, const_node;
 +      zend_op *opline;
 +
 +      if (zend_is_const_default_class_ref(class_ast)) {
 +              class_node.op_type = IS_CONST;
 +              ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
 +      } else {
 +              zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
        }
  
 -      ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0);
 -      if (new_name) {
 -              name = &new_name->u.constant;
 +      zend_compile_expr(&const_node, const_ast TSRMLS_CC);
 +
 +      opline = zend_emit_op_tmp(result, ZEND_FETCH_CONSTANT, NULL, &const_node TSRMLS_CC);
 +
 +      zend_set_class_name_op1(opline, &class_node TSRMLS_CC);
 +
 +      if (opline->op1_type == IS_CONST) {
 +              zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
        } else {
 -              const char *p;
 -
 -              /* The form "use A\B" is eqivalent to "use A\B as B".
 -                 So we extract the last part of compound name to use as a new_name */
 -              name = &tmp;
 -              p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
 -              if (p) {
 -                      ZVAL_STRING(name, p+1);
 -              } else {
 -                      ZVAL_ZVAL(name, &ns, 1, 0);
 -                      warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF;
 -              }
 +              zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
        }
-       zend_uint fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast));
 +}
 +
 +void zend_compile_resolve_class_name(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *name_ast = ast->child[0];
-                       ZVAL_STR(&result->u.constant, STR_COPY(CG(active_class_entry)->name));
++      uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast));
 +
 +      switch (fetch_type) {
 +              case ZEND_FETCH_CLASS_SELF:
 +                      if (!CG(active_class_entry)) {
 +                              zend_error_noreturn(E_COMPILE_ERROR,
 +                                      "Cannot access self::class when no class scope is active");
 +                      }
 +                      result->op_type = IS_CONST;
++                      ZVAL_STR(&result->u.constant, zend_string_copy(CG(active_class_entry)->name));
 +                      break;
 +        case ZEND_FETCH_CLASS_STATIC:
 +        case ZEND_FETCH_CLASS_PARENT:
 +                      if (!CG(active_class_entry)) {
 +                              zend_error_noreturn(E_COMPILE_ERROR,
 +                                      "Cannot access %s::class when no class scope is active",
 +                                      fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent");
 +                      } else {
 +                              zval class_str_zv;
 +                              zend_ast *class_str_ast, *class_const_ast;
 +
 +                              ZVAL_STRING(&class_str_zv, "class");
 +                              class_str_ast = zend_ast_create_zval(&class_str_zv);
 +                              class_const_ast = zend_ast_create(
 +                                      ZEND_AST_CLASS_CONST, name_ast, class_str_ast);
  
 -      lcname = zend_string_alloc(Z_STRLEN_P(name), 0);
 -      zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
 +                              zend_compile_expr(result, class_const_ast TSRMLS_CC);
  
 -      if (((Z_STRLEN_P(name) == sizeof("self")-1) &&
 -                              !memcmp(lcname->val, "self", sizeof("self")-1)) ||
 -                      ((Z_STRLEN_P(name) == sizeof("parent")-1) &&
 -         !memcmp(lcname->val, "parent", sizeof("parent")-1))) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL(ns), Z_STRVAL_P(name), Z_STRVAL_P(name));
 +                              zval_ptr_dtor(&class_str_zv);
 +                      }
 +                      break;
 +              case ZEND_FETCH_CLASS_DEFAULT:
 +                      result->op_type = IS_CONST;
 +                      ZVAL_STR(&result->u.constant, zend_resolve_class_name_ast(name_ast TSRMLS_CC));
 +                      break;
 +              EMPTY_SWITCH_DEFAULT_CASE()
        }
-       zend_uint i;
 +}
 +
 +void zend_compile_encaps_list(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast_list *list = zend_ast_get_list(ast);
++      uint32_t i;
 +
 +      ZEND_ASSERT(list->children > 0);
  
 -      if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -              /* Prefix import name with current namespace name to avoid conflicts with classes */
 -              zend_string *c_ns_name = zend_string_alloc(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0);
 +      result->op_type = IS_TMP_VAR;
 +      result->u.op.var = get_temporary_variable(CG(active_op_array));
 +
 +      for (i = 0; i < list->children; ++i) {
 +              zend_ast *elem_ast = list->child[i];
 +              znode elem_node;
 +              zend_op *opline;
 +
 +              zend_compile_expr(&elem_node, elem_ast TSRMLS_CC);
  
 -              zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
 -              c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\';
 -              memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lcname->val, Z_STRLEN_P(name)+1);
 -              if (zend_hash_exists(CG(class_table), c_ns_name)) {
 -                      char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
 +              if (elem_ast->kind == ZEND_AST_ZVAL) {
 +                      zval *zv = &elem_node.u.constant;
 +                      ZEND_ASSERT(Z_TYPE_P(zv) == IS_STRING);
  
 -                      if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
 -                              memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) {
 -                              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 +                      if (Z_STRLEN_P(zv) > 1) {
 +                              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +                              opline->opcode = ZEND_ADD_STRING;
 +                      } else if (Z_STRLEN_P(zv) == 1) {
 +                              char ch = *Z_STRVAL_P(zv);
-                               STR_RELEASE(Z_STR_P(zv));
++                              zend_string_release(Z_STR_P(zv));
 +                              ZVAL_LONG(zv, ch);
 +
 +                              opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +                              opline->opcode = ZEND_ADD_CHAR;
 +                      } else {
 +                              /* String can be empty after a variable at the end of a heredoc */
-                               STR_RELEASE(Z_STR_P(zv));
++                              zend_string_release(Z_STR_P(zv));
 +                              continue;
                        }
 -                      efree(tmp2);
 +              } else {
 +                      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 +                      opline->opcode = ZEND_ADD_VAR;
 +                      ZEND_ASSERT(elem_node.op_type != IS_CONST);
                }
 -              zend_string_free(c_ns_name);
 -      } else if ((ce = zend_hash_find_ptr(CG(class_table), lcname)) != NULL &&
 -                 ce->type == ZEND_USER_CLASS &&
 -                 ce->info.user.filename == CG(compiled_filename)) {
 -              char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
  
 -              if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
 -                      memcmp(c_tmp, lcname->val, Z_STRLEN(ns))) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 +              if (i == 0) {
 +                      SET_UNUSED(opline->op1);
 +              } else {
 +                      SET_NODE(opline->op1, result);
                }
 -              efree(c_tmp);
 +              SET_NODE(opline->op2, &elem_node);
 +              SET_NODE(opline->result, result);
        }
 +}
 +
 +void zend_compile_magic_const(znode *result, zend_ast *ast TSRMLS_DC) {
 +      zend_class_entry *ce = CG(active_class_entry);
  
 -      if (zend_hash_add(CG(current_import), lcname, &ns) == NULL) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 +      if (zend_try_ct_eval_magic_const(&result->u.constant, ast TSRMLS_CC)) {
 +              result->op_type = IS_CONST;
 +              return;
        }
 -      if (warn) {
 -              if (!strcmp(Z_STRVAL_P(name), "strict")) {
 -                      zend_error_noreturn(E_COMPILE_ERROR, "You seem to be trying to use a different language...");
 -              }
 -              zend_error(E_WARNING, "The use statement with non-compound name '%s' has no effect", Z_STRVAL_P(name));
 +
 +      ZEND_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce));
 +
 +      {
 +              zend_ast *const_ast = zend_ast_create(ZEND_AST_CONST,
-                       zend_ast_create_zval_from_str(STR_INIT("__CLASS__", sizeof("__CLASS__") - 1, 0)));
++                      zend_ast_create_zval_from_str(zend_string_init("__CLASS__", sizeof("__CLASS__") - 1, 0)));
 +              zend_compile_const(result, const_ast TSRMLS_CC);
 +              zend_ast_destroy(const_ast);
 +      }
 +}
 +
 +zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) {
 +      return kind == ZEND_AST_ZVAL || kind == ZEND_AST_BINARY_OP
 +              || kind == ZEND_AST_GREATER || kind == ZEND_AST_GREATER_EQUAL
 +              || kind == ZEND_AST_AND || kind == ZEND_AST_OR
 +              || kind == ZEND_AST_UNARY_OP
 +              || kind == ZEND_AST_UNARY_PLUS || kind == ZEND_AST_UNARY_MINUS
 +              || kind == ZEND_AST_CONDITIONAL || kind == ZEND_AST_DIM
 +              || kind == ZEND_AST_ARRAY || kind == ZEND_AST_ARRAY_ELEM
 +              || kind == ZEND_AST_CONST || kind == ZEND_AST_CLASS_CONST
 +              || kind == ZEND_AST_RESOLVE_CLASS_NAME || kind == ZEND_AST_MAGIC_CONST;
 +}
 +
 +void zend_compile_const_expr_class_const(zend_ast **ast_ptr TSRMLS_DC) {
 +      zend_ast *ast = *ast_ptr;
 +      zend_ast *class_ast = ast->child[0];
 +      zend_ast *const_ast = ast->child[1];
 +      zend_string *class_name = zend_ast_get_str(class_ast);
 +      zend_string *const_name = zend_ast_get_str(const_ast);
 +      zval result;
 +      int fetch_type;
 +
 +      if (class_ast->kind != ZEND_AST_ZVAL) {
 +              zend_error_noreturn(E_COMPILE_ERROR,
 +                      "Dynamic class names are not allowed in compile-time class constant references");
        }
 -      zend_string_release(lcname);
 -      zval_dtor(name);
 -}
 -/* }}} */
  
 -void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int is_function, zend_bool case_sensitive, HashTable *current_import_sub, HashTable *lookup_table TSRMLS_DC) /* {{{ */
 -{
 -      zend_string *lookup_name;
 -      zval *name, ns, tmp;
 -      zend_bool warn = 0;
 +      fetch_type = zend_get_class_fetch_type(class_name);
  
 -      ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0);
 -      if (new_name) {
 -              name = &new_name->u.constant;
 +      if (ZEND_FETCH_CLASS_STATIC == fetch_type) {
 +              zend_error_noreturn(E_COMPILE_ERROR,
 +                      "\"static::\" is not allowed in compile-time constants");
 +      }
 +      
 +      if (ZEND_FETCH_CLASS_DEFAULT == fetch_type) {
 +              class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC);
        } else {
-               STR_ADDREF(class_name);
 -              const char *p;
 -
 -              /* The form "use A\B" is eqivalent to "use A\B as B".
 -                 So we extract the last part of compound name to use as a new_name */
 -              name = &tmp;
 -              p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
 -              if (p) {
 -                      ZVAL_STRING(name, p+1);
 -              } else {
 -                      ZVAL_ZVAL(name, &ns, 1, 0);
 -                      warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF;
 -              }
++              zend_string_addref(class_name);
        }
  
 -      if (case_sensitive) {
 -              lookup_name = zend_string_copy(Z_STR_P(name));
 -      } else {
 -              lookup_name = zend_string_alloc(Z_STRLEN_P(name), 0);
 -              zend_str_tolower_copy(lookup_name->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
 +      Z_STR(result) = zend_concat3(
 +              class_name->val, class_name->len, "::", 2, const_name->val, const_name->len);
 +
 +      Z_TYPE_INFO(result) = IS_CONSTANT_EX;
 +      if (IS_INTERNED(Z_STR(result))) {
 +              Z_TYPE_FLAGS(result) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
        }
 +      Z_CONST_FLAGS(result) = fetch_type;
  
 -      if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -              /* Prefix import name with current namespace name to avoid conflicts with functions/consts */
 -              zend_string *c_ns_name = zend_string_alloc(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0);
 +      zend_ast_destroy(ast);
-       STR_RELEASE(class_name);
++      zend_string_release(class_name);
  
 -              zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
 -              c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\';
 -              memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lookup_name, Z_STRLEN_P(name)+1);
 -              if (zend_hash_exists(lookup_table, c_ns_name)) {
 -                      char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
 +      *ast_ptr = zend_ast_create_zval(&result);
 +}
  
 -                      if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
 -                              memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) {
 -                              zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name));
 -                      }
 -                      efree(tmp2);
 -              }
 -              zend_string_free(c_ns_name);
 -      } else if (is_function) {
 -              zend_function *function;
 +void zend_compile_const_expr_const(zend_ast **ast_ptr TSRMLS_DC) {
 +      zend_ast *ast = *ast_ptr;
 +      zend_ast *name_ast = ast->child[0];
 +      zval *orig_name = zend_ast_get_zval(name_ast);
 +      zend_bool is_fully_qualified;
 +
 +      znode result;
 +      zval resolved_name;
 +
 +      if (zend_constant_ct_subst(&result, orig_name, 0 TSRMLS_CC)) {
 +              zend_ast_destroy(ast);
 +              *ast_ptr = zend_ast_create_zval(&result.u.constant);
 +              return;
 +      }
 +
 +      ZVAL_STR(&resolved_name, zend_resolve_const_name(
 +              Z_STR_P(orig_name), name_ast->attr, &is_fully_qualified TSRMLS_CC));
 +
 +      Z_TYPE_INFO(resolved_name) = IS_CONSTANT_EX;
 +      if (!is_fully_qualified) {
 +              Z_CONST_FLAGS(resolved_name) = IS_CONSTANT_UNQUALIFIED;
 +      }
 +
 +      zend_ast_destroy(ast);
 +      *ast_ptr = zend_ast_create_zval(&resolved_name);
 +}
  
 -              if ((function = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && function->type == ZEND_USER_FUNCTION && strcmp(function->op_array.filename->val, CG(compiled_filename)->val) == 0) {
 -                      char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
 +void zend_compile_const_expr_resolve_class_name(zend_ast **ast_ptr TSRMLS_DC) {
 +      zend_ast *ast = *ast_ptr;
 +      zend_ast *name_ast = ast->child[0];
-       zend_uint fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast));
++      uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(name_ast));
 +      zval result;
  
 -                      if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
 -                              memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) {
 -                              zend_error(E_COMPILE_ERROR, "Cannot use function %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 +      switch (fetch_type) {
 +              case ZEND_FETCH_CLASS_SELF:
 +                      if (!CG(active_class_entry)) {
 +                              zend_error_noreturn(E_COMPILE_ERROR,
 +                                      "Cannot access self::class when no class scope is active");
                        }
-                       ZVAL_STR(&result, STR_COPY(CG(active_class_entry)->name));
 -                      efree(c_tmp);
 -              }
 -      } else {
 -              zend_string *filename;
++                      ZVAL_STR(&result, zend_string_copy(CG(active_class_entry)->name));
 +                      break;
 +        case ZEND_FETCH_CLASS_STATIC:
 +        case ZEND_FETCH_CLASS_PARENT:
 +                      zend_error_noreturn(E_COMPILE_ERROR,
 +                              "%s::class cannot be used for compile-time class name resolution",
 +                              fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent"
 +                      );
 +                      break;
 +              case ZEND_FETCH_CLASS_DEFAULT:
 +                      ZVAL_STR(&result, zend_resolve_class_name_ast(name_ast TSRMLS_CC));
 +                      break;
 +              EMPTY_SWITCH_DEFAULT_CASE()
 +      }
 +
 +      zend_ast_destroy(ast);
 +      *ast_ptr = zend_ast_create_zval(&result);
 +}
 +
 +void zend_compile_const_expr_magic_const(zend_ast **ast_ptr TSRMLS_DC) {
 +      zend_ast *ast = *ast_ptr;
 +      zend_class_entry *ce = CG(active_class_entry);
  
 -              if ((filename = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && strcmp(filename->val, CG(compiled_filename)->val) == 0) {
 -                      char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
 +      /* Other cases already resolved by constant folding */
 +      ZEND_ASSERT(ast->attr == T_CLASS_C && ce && ZEND_CE_IS_TRAIT(ce));
  
 -                      if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
 -                              memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) {
 -                              zend_error(E_COMPILE_ERROR, "Cannot use const %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 -                      }
 -                      efree(c_tmp);
 -              }
 -      }
 +      {
 +              zval const_zv;
 +              ZVAL_STRING(&const_zv, "__CLASS__");
 +              Z_TYPE_INFO(const_zv) = IS_CONSTANT_EX;
  
 -      if (zend_hash_add(current_import_sub, lookup_name, &ns) == NULL) {
 -              zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name));
 -      }
 -      if (warn) {
 -              zend_error(E_WARNING, "The use %s statement with non-compound name '%s' has no effect", is_function ? "function" : "const", Z_STRVAL_P(name));
 +              zend_ast_destroy(ast);
 +              *ast_ptr = zend_ast_create_zval(&const_zv);
        }
 -      zend_string_release(lookup_name);
 -      zval_dtor(name);
  }
 -/* }}} */
  
 -void zend_do_use_function(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */
 -{
 -      if (!CG(current_import_function)) {
 -              CG(current_import_function) = emalloc(sizeof(HashTable));
 -              zend_hash_init(CG(current_import_function), 8, NULL, ZVAL_PTR_DTOR, 0);
 +void zend_compile_const_expr(zend_ast **ast_ptr TSRMLS_DC) {
 +      zend_ast *ast = *ast_ptr;
 +      if (ast == NULL || ast->kind == ZEND_AST_ZVAL) {
 +              return;
        }
  
 -      zend_do_use_non_class(ns_name, new_name, is_global, 1, 0, CG(current_import_function), CG(function_table) TSRMLS_CC);
 -}
 -/* }}} */
 -
 -void zend_do_use_const(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */
 -{
 -      if (!CG(current_import_const)) {
 -              CG(current_import_const) = emalloc(sizeof(HashTable));
 -              zend_hash_init(CG(current_import_const), 8, NULL, ZVAL_PTR_DTOR, 0);
 +      if (!zend_is_allowed_in_const_expr(ast->kind)) {
 +              zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
        }
  
 -      zend_do_use_non_class(ns_name, new_name, is_global, 0, 1, CG(current_import_const), &CG(const_filenames) TSRMLS_CC);
 +      switch (ast->kind) {
 +              case ZEND_AST_CLASS_CONST:
 +                      zend_compile_const_expr_class_const(ast_ptr TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_CONST:
 +                      zend_compile_const_expr_const(ast_ptr TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_RESOLVE_CLASS_NAME:
 +                      zend_compile_const_expr_resolve_class_name(ast_ptr TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_MAGIC_CONST:
 +                      zend_compile_const_expr_magic_const(ast_ptr TSRMLS_CC);
 +                      break;
 +              default:
 +                      zend_ast_apply(ast, zend_compile_const_expr TSRMLS_CC);
 +                      break;
 +      }
  }
 -/* }}} */
  
 -void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */
 -{
 -      zend_op *opline;
 -      zval *ns_name;
 +void zend_const_expr_to_zval(zval *result, zend_ast *ast TSRMLS_DC) {
 +      zend_ast *orig_ast = ast;
 +      zend_eval_const_expr(&ast TSRMLS_CC);
 +      zend_compile_const_expr(&ast TSRMLS_CC);
 +      if (ast->kind == ZEND_AST_ZVAL) {
 +              ZVAL_COPY_VALUE(result, zend_ast_get_zval(ast));
  
 -      if (zend_get_ct_const(&name->u.constant, 0 TSRMLS_CC)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", Z_STRVAL(name->u.constant));
 +              /* Kill this branch of the original AST, as it was already destroyed.
 +               * It would be nice to find a better solution to this problem in the
 +               * future. */
 +              orig_ast->kind = 0;
 +      } else {
 +              ZVAL_NEW_AST(result, zend_ast_copy(ast));
        }
 +}
  
 -      if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -              /* Prefix constant name with name of current namespace, lowercased */
 -              znode tmp;
 -
 -              tmp.op_type = IS_CONST;
 -              ZVAL_NEW_STR(&tmp.u.constant, zend_string_alloc(Z_STRLEN(CG(current_namespace)), 0));
 -              zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
 -              zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC);
 -              *name = tmp;
 +/* Same as compile_stmt, but with early binding */
 +void zend_compile_top_stmt(zend_ast *ast TSRMLS_DC) {
 +      if (!ast) {
 +              return;
        }
  
 -      /* Constant name must not conflict with import names */
 -      if (CG(current_import_const) &&
 -          (ns_name = zend_hash_find(CG(current_import_const), Z_STR(name->u.constant))) != NULL) {
 -
 -              char *tmp = estrndup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
 -
 -              if (Z_STRLEN_P(ns_name) != Z_STRLEN(name->u.constant) ||
 -                      memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant))) {
 -                      zend_error(E_COMPILE_ERROR, "Cannot declare const %s because the name is already in use", Z_STRVAL(name->u.constant));
 +      if (ast->kind == ZEND_AST_STMT_LIST) {
 +              zend_ast_list *list = zend_ast_get_list(ast);
-               zend_uint i;
++              uint32_t i;
 +              for (i = 0; i < list->children; ++i) {
 +                      zend_compile_top_stmt(list->child[i] TSRMLS_CC);
                }
 -              efree(tmp);
 +              return;
        }
  
 -      opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 -      opline->opcode = ZEND_DECLARE_CONST;
 -      SET_UNUSED(opline->result);
 -      SET_NODE(opline->op1, name);
 -      SET_NODE(opline->op2, value);
 -
 -      zend_hash_add_ptr(&CG(const_filenames), Z_STR(name->u.constant), CG(compiled_filename));
 -}
 -/* }}} */
 +      zend_compile_stmt(ast TSRMLS_CC);
  
 -void zend_verify_namespace(TSRMLS_D) /* {{{ */
 -{
 -      if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
 -              zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}");
 +      if (ast->kind != ZEND_AST_NAMESPACE && ast->kind != ZEND_AST_HALT_COMPILER) {
 +              zend_verify_namespace(TSRMLS_C);
 +      }
 +      if (ast->kind == ZEND_AST_FUNC_DECL || ast->kind == ZEND_AST_CLASS) {
 +              CG(zend_lineno) = ((zend_ast_decl *) ast)->end_lineno;
 +              zend_do_early_binding(TSRMLS_C);
        }
  }
 -/* }}} */
  
 -void zend_do_end_namespace(TSRMLS_D) /* {{{ */
 -{
 -      CG(in_namespace) = 0;
 -      if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 -              zval_dtor(&CG(current_namespace));
 -              ZVAL_UNDEF(&CG(current_namespace));
 -      }
 -      if (CG(current_import)) {
 -              zend_hash_destroy(CG(current_import));
 -              efree(CG(current_import));
 -              CG(current_import) = NULL;
 +void zend_compile_stmt(zend_ast *ast TSRMLS_DC) {
 +      if (!ast) {
 +              return;
        }
 -      if (CG(current_import_function)) {
 -              zend_hash_destroy(CG(current_import_function));
 -              efree(CG(current_import_function));
 -              CG(current_import_function) = NULL;
 +
 +      CG(zend_lineno) = ast->lineno;
 +
 +      switch (ast->kind) {
 +              case ZEND_AST_STMT_LIST:
 +                      zend_compile_stmt_list(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_GLOBAL:
 +                      zend_compile_global_var(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_STATIC:
 +                      zend_compile_static_var(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_UNSET:
 +                      zend_compile_unset(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_RETURN:
 +                      zend_compile_return(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_ECHO:
 +                      zend_compile_echo(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_THROW:
 +                      zend_compile_throw(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_BREAK:
 +              case ZEND_AST_CONTINUE:
 +                      zend_compile_break_continue(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_GOTO:
 +                      zend_compile_goto(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_LABEL:
 +                      zend_compile_label(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_WHILE:
 +                      zend_compile_while(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_DO_WHILE:
 +                      zend_compile_do_while(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_FOR:
 +                      zend_compile_for(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_FOREACH:
 +                      zend_compile_foreach(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_IF:
 +                      zend_compile_if(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_SWITCH:
 +                      zend_compile_switch(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_TRY:
 +                      zend_compile_try(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_DECLARE:
 +                      zend_compile_declare(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_FUNC_DECL:
 +              case ZEND_AST_METHOD:
 +                      zend_compile_func_decl(NULL, ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_PROP_DECL:
 +                      zend_compile_prop_decl(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_CLASS_CONST_DECL:
 +                      zend_compile_class_const_decl(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_USE_TRAIT:
 +                      zend_compile_use_trait(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_CLASS:
 +                      zend_compile_class_decl(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_USE:
 +                      zend_compile_use(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_CONST_DECL:
 +                      zend_compile_const_decl(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_NAMESPACE:
 +                      zend_compile_namespace(ast TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_HALT_COMPILER:
 +                      zend_compile_halt_compiler(ast TSRMLS_CC);
 +                      break;
 +              default:
 +              {
 +                      znode result;
 +                      zend_compile_expr(&result, ast TSRMLS_CC);
 +                      zend_do_free(&result TSRMLS_CC);
 +              }
        }
 -      if (CG(current_import_const)) {
 -              zend_hash_destroy(CG(current_import_const));
 -              efree(CG(current_import_const));
 -              CG(current_import_const) = NULL;
 +
 +      if (Z_LVAL(CG(declarables).ticks) && !zend_is_unticked_stmt(ast)) {
 +              zend_emit_tick(TSRMLS_C);
        }
  }
 -/* }}} */
  
 -void zend_do_end_compilation(TSRMLS_D) /* {{{ */
 -{
 -      CG(has_bracketed_namespaces) = 0;
 -      zend_do_end_namespace(TSRMLS_C);
 -}
 -/* }}} */
 +void zend_compile_expr(znode *result, zend_ast *ast TSRMLS_DC) {
 +      //CG(zend_lineno) = ast->lineno;
 +      CG(zend_lineno) = zend_ast_get_lineno(ast);
  
 -void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 -{
 -      if (ast->kind == ZEND_CONST) {
 -              ZVAL_COPY_VALUE(&result->u.constant, &ast->u.val);
 -              efree(ast);
 -      } else if (zend_ast_is_ct_constant(ast)) {
 -              zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC);
 -              zend_ast_destroy(ast);
 -      } else {
 -              ZVAL_NEW_AST(&result->u.constant, ast);
 +      switch (ast->kind) {
 +              case ZEND_AST_ZVAL:
 +                      ZVAL_COPY(&result->u.constant, zend_ast_get_zval(ast));
 +                      result->op_type = IS_CONST;
 +                      return;
 +              case ZEND_AST_ZNODE:
 +                      *result = *zend_ast_get_znode(ast);
 +                      return;
 +              case ZEND_AST_VAR:
 +              case ZEND_AST_DIM:
 +              case ZEND_AST_PROP:
 +              case ZEND_AST_STATIC_PROP:
 +              case ZEND_AST_CALL:
 +              case ZEND_AST_METHOD_CALL:
 +              case ZEND_AST_STATIC_CALL:
 +                      zend_compile_var(result, ast, BP_VAR_R TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_ASSIGN:
 +                      zend_compile_assign(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_ASSIGN_REF:
 +                      zend_compile_assign_ref(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_NEW:
 +                      zend_compile_new(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_CLONE:
 +                      zend_compile_clone(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_ASSIGN_OP:
 +                      zend_compile_compound_assign(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_BINARY_OP:
 +                      zend_compile_binary_op(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_GREATER:
 +              case ZEND_AST_GREATER_EQUAL:
 +                      zend_compile_greater(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_UNARY_OP:
 +                      zend_compile_unary_op(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_UNARY_PLUS:
 +              case ZEND_AST_UNARY_MINUS:
 +                      zend_compile_unary_pm(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_AND:
 +              case ZEND_AST_OR:
 +                      zend_compile_short_circuiting(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_POST_INC:
 +              case ZEND_AST_POST_DEC:
 +                      zend_compile_post_incdec(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_PRE_INC:
 +              case ZEND_AST_PRE_DEC:
 +                      zend_compile_pre_incdec(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_CAST:
 +                      zend_compile_cast(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_CONDITIONAL:
 +                      zend_compile_conditional(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_PRINT:
 +                      zend_compile_print(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_EXIT:
 +                      zend_compile_exit(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_YIELD:
 +                      zend_compile_yield(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_INSTANCEOF:
 +                      zend_compile_instanceof(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_INCLUDE_OR_EVAL:
 +                      zend_compile_include_or_eval(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_ISSET:
 +              case ZEND_AST_EMPTY:
 +                      zend_compile_isset_or_empty(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_SILENCE:
 +                      zend_compile_silence(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_SHELL_EXEC:
 +                      zend_compile_shell_exec(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_ARRAY:
 +                      zend_compile_array(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_CONST:
 +                      zend_compile_const(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_CLASS_CONST:
 +                      zend_compile_class_const(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_RESOLVE_CLASS_NAME:
 +                      zend_compile_resolve_class_name(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_ENCAPS_LIST:
 +                      zend_compile_encaps_list(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_MAGIC_CONST:
 +                      zend_compile_magic_const(result, ast TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_CLOSURE:
 +                      zend_compile_func_decl(result, ast TSRMLS_CC);
 +                      return;
 +              default:
 +                      ZEND_ASSERT(0 /* not supported */);
        }
  }
 -/* }}} */
  
 -/* {{{ zend_dirname
 -   Returns directory name component of path */
 -ZEND_API size_t zend_dirname(char *path, size_t len)
 -{
 -      register char *end = path + len - 1;
 -      unsigned int len_adjust = 0;
 +void zend_compile_var(znode *result, zend_ast *ast, int type TSRMLS_DC) {
 +      switch (ast->kind) {
 +              case ZEND_AST_VAR:
 +                      zend_compile_simple_var(result, ast, type TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_DIM:
 +                      zend_compile_dim(result, ast, type TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_PROP:
 +                      zend_compile_prop(result, ast, type TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_STATIC_PROP:
 +                      zend_compile_static_prop(result, ast, type TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_CALL:
 +                      zend_compile_call(result, ast, type TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_METHOD_CALL:
 +                      zend_compile_method_call(result, ast, type TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_STATIC_CALL:
 +                      zend_compile_static_call(result, ast, type TSRMLS_CC);
 +                      return;
 +              case ZEND_AST_ZNODE:
 +                      *result = *zend_ast_get_znode(ast);
 +                      return;
 +              default:
 +                      if (type == BP_VAR_W || type == BP_VAR_REF
 +                              || type == BP_VAR_RW || type == BP_VAR_UNSET
 +                      ) {
 +                              /* For BC reasons =& new Foo is allowed */
 +                              if (type != BP_VAR_REF || ast->kind != ZEND_AST_NEW) {
 +                                      zend_error_noreturn(E_COMPILE_ERROR,
 +                                              "Cannot use temporary expression in write context");
 +                              }
 +                      }
  
 -#ifdef PHP_WIN32
 -      /* Note that on Win32 CWD is per drive (heritage from CP/M).
 -       * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive.
 -       */
 -      if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) {
 -              /* Skip over the drive spec (if any) so as not to change */
 -              path += 2;
 -              len_adjust += 2;
 -              if (2 == len) {
 -                      /* Return "c:" on Win32 for dirname("c:").
 -                       * It would be more consistent to return "c:."
 -                       * but that would require making the string *longer*.
 -                       */
 -                      return len;
 -              }
 -      }
 -#elif defined(NETWARE)
 -      /*
 -       * Find the first occurrence of : from the left
 -       * move the path pointer to the position just after :
 -       * increment the len_adjust to the length of path till colon character(inclusive)
 -       * If there is no character beyond : simple return len
 -       */
 -      char *colonpos = NULL;
 -      colonpos = strchr(path, ':');
 -      if (colonpos != NULL) {
 -              len_adjust = ((colonpos - path) + 1);
 -              path += len_adjust;
 -              if (len_adjust == len) {
 -                      return len;
 -              }
 +                      zend_compile_expr(result, ast TSRMLS_CC);
 +                      return;
        }
 -#endif
 +}
  
- void zend_delayed_compile_var(znode *result, zend_ast *ast, zend_uint type TSRMLS_DC) {
 -      if (len == 0) {
 -              /* Illegal use of this function */
 -              return 0;
++void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) {
 +      zend_op *opline;
 +      switch (ast->kind) {
 +              case ZEND_AST_DIM:
 +                      opline = zend_delayed_compile_dim(result, ast, type TSRMLS_CC);
 +                      zend_adjust_for_fetch_type(opline, type);
 +                      return;
 +              case ZEND_AST_PROP:
 +                      opline = zend_delayed_compile_prop(result, ast, type TSRMLS_CC);
 +                      zend_adjust_for_fetch_type(opline, type);
 +                      return;
 +              default:
 +                      zend_compile_var(result, ast, type TSRMLS_CC);
 +                      return;
        }
 +}
  
 -      /* Strip trailing slashes */
 -      while (end >= path && IS_SLASH_P(end)) {
 -              end--;
 -      }
 -      if (end < path) {
 -              /* The path only contained slashes */
 -              path[0] = DEFAULT_SLASH;
 -              path[1] = '\0';
 -              return 1 + len_adjust;
 -      }
 +void zend_eval_const_expr(zend_ast **ast_ptr TSRMLS_DC) {
 +      zend_ast *ast = *ast_ptr;
 +      zval result;
  
 -      /* Strip filename */
 -      while (end >= path && !IS_SLASH_P(end)) {
 -              end--;
 -      }
 -      if (end < path) {
 -              /* No slash found, therefore return '.' */
 -#ifdef NETWARE
 -              if (len_adjust == 0) {
 -                      path[0] = '.';
 -                      path[1] = '\0';
 -                      return 1; /* only one character */
 -              } else {
 -                      path[0] = '\0';
 -                      return len_adjust;
 -              }
 -#else
 -              path[0] = '.';
 -              path[1] = '\0';
 -              return 1 + len_adjust;
 -#endif
 +      if (!ast) {
 +              return;
        }
  
 -      /* Strip slashes which came before the file name */
 -      while (end >= path && IS_SLASH_P(end)) {
 -              end--;
 -      }
 -      if (end < path) {
 -              path[0] = DEFAULT_SLASH;
 -              path[1] = '\0';
 -              return 1 + len_adjust;
 +      switch (ast->kind) {
 +              case ZEND_AST_BINARY_OP:
 +                      zend_eval_const_expr(&ast->child[0] TSRMLS_CC);
 +                      zend_eval_const_expr(&ast->child[1] TSRMLS_CC);
 +                      if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) {
 +                              return;
 +                      }
 +
 +                      zend_ct_eval_binary_op(&result, ast->attr,
 +                              zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1]) TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_GREATER:
 +              case ZEND_AST_GREATER_EQUAL:
 +                      zend_eval_const_expr(&ast->child[0] TSRMLS_CC);
 +                      zend_eval_const_expr(&ast->child[1] TSRMLS_CC);
 +                      if (ast->child[0]->kind != ZEND_AST_ZVAL || ast->child[1]->kind != ZEND_AST_ZVAL) {
 +                              return;
 +                      }
 +
 +                      zend_ct_eval_greater(&result, ast->kind,
 +                              zend_ast_get_zval(ast->child[0]), zend_ast_get_zval(ast->child[1]) TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_UNARY_PLUS:
 +              case ZEND_AST_UNARY_MINUS:
 +                      zend_eval_const_expr(&ast->child[0] TSRMLS_CC);
 +                      if (ast->child[0]->kind != ZEND_AST_ZVAL) {
 +                              return;
 +                      }
 +
 +                      zend_ct_eval_unary_pm(&result, ast->kind,
 +                              zend_ast_get_zval(ast->child[0]) TSRMLS_CC);
 +                      break;
 +              case ZEND_AST_ARRAY:
 +                      if (!zend_try_ct_eval_array(&result, ast TSRMLS_CC)) {
 +                              return;
 +                      }
 +                      break;
 +              case ZEND_AST_MAGIC_CONST:
 +                      if (!zend_try_ct_eval_magic_const(&result, ast TSRMLS_CC)) {
 +                              return;
 +                      }
 +                      break;
 +              default:
 +                      return;
        }
 -      *(end+1) = '\0';
  
 -      return (size_t)(end + 1 - path) + len_adjust;
 +      zend_ast_destroy(ast);
 +      *ast_ptr = zend_ast_create_zval(&result);
  }
 -/* }}} */
  
  /*
   * Local variables:

diff --cc Zend/zend_compile.h
index cecba02661014537a0094f0803ac364c4db470eb,af33b3e0070f1eb698b6d497f189f72741c136d8..c45612355a1eb376f21c58fbdd7a70a3051be658
--- 1/Zend/zend_compile.h
--- 2/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@@ -38,13 -40,15 +38,13 @@@
  #define INC_BPC(op_array)     if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count++); }
  #define DEC_BPC(op_array)     if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count--); }
  #define HANDLE_INTERACTIVE()  if (CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) { execute_new_code(TSRMLS_C); }
 -#define DO_TICKS()            if (Z_LVAL(CG(declarables).ticks)) { zend_do_ticks(TSRMLS_C); }
  
 -#define RESET_DOC_COMMENT()        \
 -    {                              \
 -        if (CG(doc_comment)) {     \
 -          zend_string_release(CG(doc_comment));  \
 -          CG(doc_comment) = NULL;  \
 -        }                          \
 -    }
 +#define RESET_DOC_COMMENT() do { \
 +      if (CG(doc_comment)) { \
-               STR_RELEASE(CG(doc_comment)); \
++              zend_string_release(CG(doc_comment)); \
 +              CG(doc_comment) = NULL; \
 +      } \
 +} while (0)
  
  typedef struct _zend_op_array zend_op_array;
  typedef struct _zend_op zend_op;
@@@ -75,36 -79,12 +75,36 @@@ typedef struct _znode { /* used only du
        union {
                znode_op op;
                zval constant; /* replaced by literal/zv */
 -              zend_op_array *op_array;
 -              zend_ast *ast;
        } u;
 -      uint32_t EA;      /* extended attributes */
  } znode;
  
-       zend_uint lineno;
 +/* Temporarily defined here, to avoid header ordering issues */
 +typedef struct _zend_ast_znode {
 +      zend_ast_kind kind;
 +      zend_ast_attr attr;
++      uint32_t lineno;
 +      znode node;
 +} zend_ast_znode;
 +ZEND_API zend_ast *zend_ast_create_znode(znode *node);
 +
 +static inline znode *zend_ast_get_znode(zend_ast *ast) {
 +      return &((zend_ast_znode *) ast)->node;
 +}
 +
 +typedef union _zend_parser_stack_elem {
 +      zend_ast *ast;
 +      zend_ast_list *list;
 +      zend_string *str;
 +      zend_ulong num;
 +} zend_parser_stack_elem;
 +
 +void zend_compile_top_stmt(zend_ast *ast TSRMLS_DC);
 +void zend_compile_stmt(zend_ast *ast TSRMLS_DC);
 +void zend_compile_expr(znode *node, zend_ast *ast TSRMLS_DC);
 +void zend_compile_var(znode *node, zend_ast *ast, int type TSRMLS_DC);
 +void zend_eval_const_expr(zend_ast **ast_ptr TSRMLS_DC);
 +void zend_const_expr_to_zval(zval *result, zend_ast *ast TSRMLS_DC);
 +
  typedef struct _zend_execute_data zend_execute_data;
  
  #define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data TSRMLS_DC
@@@ -224,15 -208,13 +228,14 @@@ typedef struct _zend_try_catch_element 
  /* function has arguments with type hinting */
  #define ZEND_ACC_HAS_TYPE_HINTS                       0x10000000
  
 -char *zend_visibility_string(uint32_t fn_flags);
 +#define ZEND_CE_IS_TRAIT(ce) (((ce)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)
  
- char *zend_visibility_string(zend_uint fn_flags);
- 
++char *zend_visibility_string(uint32_t fn_flags);
  
  typedef struct _zend_property_info {
-       zend_uint flags;
+       uint32_t flags;
        zend_string *name;
-       ulong h;
+       zend_ulong h;
        int offset;
        zend_string *doc_comment;
        zend_class_entry *ce;
@@@ -435,7 -431,11 +438,7 @@@ ZEND_API zend_string *zend_get_compiled
  ZEND_API int zend_get_compiled_lineno(TSRMLS_D);
  ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D);
  
- ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var);
 -void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC);
 -void zend_resolve_function_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC);
 -void zend_resolve_const_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC);
 -void zend_resolve_class_name(znode *class_name TSRMLS_DC);
+ ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var);
  
  #ifdef ZTS
  const char *zend_get_zendtext(TSRMLS_D);
@@@ -448,16 -466,60 +451,16 @@@ typedef int (*binary_op_type)(zval *, z
  ZEND_API unary_op_type get_unary_op(int opcode);
  ZEND_API binary_op_type get_binary_op(int opcode);
  
 -void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC);
 -void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC);
 -void zend_do_do_while_begin(TSRMLS_D);
 -void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC);
 -
 -
 -void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC);
 -void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC);
 -void zend_do_if_end(TSRMLS_D);
 -
 -void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC);
 -void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC);
 -void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC);
 -
 -void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
 -void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
 -
 -void zend_do_begin_variable_parse(TSRMLS_D);
 -void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC);
 -
 -void zend_check_writable_variable(const znode *variable);
 +void zend_stop_lexing(TSRMLS_D);
 +void zend_emit_final_return(zval *zv TSRMLS_DC);
 +zend_ast *zend_ast_append_str(zend_ast *left, zend_ast *right);
- zend_uint zend_add_member_modifier(zend_uint flags, zend_uint new_flag);
++uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag);
 +zend_ast_list *zend_ast_append_doc_comment(zend_ast_list *list TSRMLS_DC);
 +void zend_handle_encoding_declaration(zend_ast_list *declares TSRMLS_DC);
  
 +/* parser-driven code generators */
  void zend_do_free(znode *op1 TSRMLS_DC);
  
 -void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC);
 -void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC);
 -
 -int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier);
 -void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC);
 -void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC);
 -void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_bool pass_by_reference, zend_bool is_variadic TSRMLS_DC);
 -int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC);
 -void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC);
 -void zend_do_clone(znode *result, znode *expr TSRMLS_DC);
 -void zend_do_begin_dynamic_function_call(znode *function_name, int prefix_len TSRMLS_DC);
 -void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC);
 -void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC);
 -int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC);
 -void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC);
 -void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC);
 -void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC);
 -void zend_do_handle_exception(TSRMLS_D);
 -
 -void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC);
 -void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC);
 -
 -void zend_do_try(znode *try_token TSRMLS_DC);
 -void zend_do_begin_catch(znode *try_token, znode *catch_class, znode *catch_var, znode *first_catch TSRMLS_DC);
 -void zend_do_bind_catch(znode *try_token, znode *catch_token TSRMLS_DC);
 -void zend_do_end_catch(znode *catch_token TSRMLS_DC);
 -void zend_do_finally(znode *finally_token TSRMLS_DC);
 -void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC);
 -void zend_do_throw(znode *expr TSRMLS_DC);
 -
  ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, HashTable *function_table, zend_bool compile_time TSRMLS_DC);
  ZEND_API zend_class_entry *do_bind_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC);
  ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC);
@@@ -528,7 -689,10 +531,7 @@@ zend_brk_cont_element *get_next_brk_con
  ZEND_API zend_bool zend_is_compiling(TSRMLS_D);
  ZEND_API char *zend_make_compiled_string_description(const char *name TSRMLS_DC);
  ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC);
- zend_uint zend_get_class_fetch_type(zend_string *name);
 -int zend_get_class_fetch_type(const char *class_name, uint class_name_len);
++uint32_t zend_get_class_fetch_type(zend_string *name);
  
  typedef zend_bool (*zend_auto_global_callback)(zend_string *name TSRMLS_DC);
  typedef struct _zend_auto_global {

diff --cc Zend/zend_execute_API.c
Simple merge

diff --cc Zend/zend_globals.h
index c27d7bc7176d5d9f350302e83c2f84be37a2b09e,758e373ac20c27b901e542f109c9e5b24a304cde..c4a24486d944e551656a09e563550c352766e3d1
--- 1/Zend/zend_globals.h
--- 2/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@@ -111,11 -123,13 +111,11 @@@ struct _zend_compiler_globals 
  
        znode implementing_class;
  
 -      uint32_t access_type;
 -
        zend_string *doc_comment;
  
-       zend_uint compiler_options; /* set of ZEND_COMPILE_* constants */
+       uint32_t compiler_options; /* set of ZEND_COMPILE_* constants */
  
 -      zval       current_namespace;
 +      zend_string *current_namespace;
        HashTable *current_import;
        HashTable *current_import_function;
        HashTable *current_import_const;

diff --cc Zend/zend_language_parser.y
index 340371aba6503bfecbdb0e294e1b016894872b0f,a6e3182d96691cf25509951353a04a4e1281b27b..8622fbb4416b22df807ba695778c4d00a0661b64
--- 1/Zend/zend_language_parser.y
--- 2/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@@ -747,131 -774,106 +747,131 @@@ new_expr
  ;
  
  expr_without_variable:
 -              T_LIST '(' { zend_do_list_init(TSRMLS_C); } assignment_list ')' '=' expr { zend_do_list_end(&$$, &$7 TSRMLS_CC); }
 -      |       variable '=' expr               { zend_check_writable_variable(&$1); zend_do_assign(&$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable '=' '&' variable { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$4, BP_VAR_W, 1 TSRMLS_CC); zend_do_end_variable_parse(&$1, BP_VAR_W, 0 TSRMLS_CC); zend_do_assign_ref(&$$, &$1, &$4 TSRMLS_CC); }
 -      |       variable '=' '&' T_NEW class_name_reference { zend_error(E_DEPRECATED, "Assigning the return value of new by reference is deprecated");  zend_check_writable_variable(&$1); zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_new_object(&$4, &$5 TSRMLS_CC); } ctor_arguments { zend_do_end_new_object(&$3, &$4 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); zend_do_end_variable_parse(&$1, BP_VAR_W, 0 TSRMLS_CC); $3.EA = ZEND_PARSED_NEW; zend_do_assign_ref(&$$, &$1, &$3 TSRMLS_CC); }
 -      |       T_CLONE expr { zend_do_clone(&$$, &$2 TSRMLS_CC); }
 -      |       variable T_PLUS_EQUAL expr      { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_MINUS_EQUAL expr     { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_MUL_EQUAL expr               { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_POW_EQUAL expr               { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_POW, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_DIV_EQUAL expr               { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_CONCAT_EQUAL expr    { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_MOD_EQUAL expr               { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_AND_EQUAL expr               { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_OR_EQUAL expr                { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_XOR_EQUAL expr               { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_SL_EQUAL expr        { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       variable T_SR_EQUAL expr        { zend_check_writable_variable(&$1); zend_do_end_variable_parse(&$1, BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       rw_variable T_INC { zend_do_post_incdec(&$$, &$1, ZEND_POST_INC TSRMLS_CC); }
 -      |       T_INC rw_variable { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_INC TSRMLS_CC); }
 -      |       rw_variable T_DEC { zend_do_post_incdec(&$$, &$1, ZEND_POST_DEC TSRMLS_CC); }
 -      |       T_DEC rw_variable { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_DEC TSRMLS_CC); }
 -      |       expr T_BOOLEAN_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
 -      |       expr T_BOOLEAN_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
 -      |       expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
 -      |       expr T_LOGICAL_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
 -      |       expr T_LOGICAL_XOR expr { zend_do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       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 T_POW expr { zend_do_binary_op(ZEND_POW, &$$, &$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 %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); } }
 -      |       '-' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { sub_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 TSRMLS_CC); } }
 -      |       '!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 TSRMLS_CC); }
 -      |       '~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 TSRMLS_CC); }
 -      |       expr T_IS_IDENTICAL expr                { zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       expr T_IS_NOT_IDENTICAL expr    { zend_do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       expr T_IS_EQUAL expr                    { zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       expr T_IS_NOT_EQUAL expr                { zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       expr '<' expr                                   { zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       expr T_IS_SMALLER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
 -      |       expr '>' expr                                   { zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 TSRMLS_CC); }
 -      |       expr T_IS_GREATER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 TSRMLS_CC); }
 -      |       expr T_INSTANCEOF class_name_reference { zend_do_instanceof(&$$, &$1, &$3, 0 TSRMLS_CC); }
 -      |       parenthesis_expr        { $$ = $1; }
 -      |       new_expr                { $$ = $1; }
 -      |       '(' new_expr ')' { $$ = $2; } instance_call { $$ = $5; }
 -      |       expr '?' { zend_do_begin_qm_op(&$1, &$2 TSRMLS_CC); }
 -              expr ':' { zend_do_qm_true(&$4, &$2, &$5 TSRMLS_CC); }
 -              expr     { zend_do_qm_false(&$$, &$7, &$2, &$5 TSRMLS_CC); }
 -      |       expr '?' ':' { zend_do_jmp_set(&$1, &$2, &$3 TSRMLS_CC); }
 -              expr     { zend_do_jmp_set_else(&$$, &$5, &$2, &$3 TSRMLS_CC); }
 -      |       internal_functions_in_yacc { $$ = $1; }
 -      |       T_INT_CAST expr         { zend_do_cast(&$$, &$2, IS_LONG TSRMLS_CC); }
 -      |       T_DOUBLE_CAST expr      { zend_do_cast(&$$, &$2, IS_DOUBLE TSRMLS_CC); }
 -      |       T_STRING_CAST expr      { zend_do_cast(&$$, &$2, IS_STRING TSRMLS_CC); }
 -      |       T_ARRAY_CAST expr       { zend_do_cast(&$$, &$2, IS_ARRAY TSRMLS_CC); }
 -      |       T_OBJECT_CAST expr      { zend_do_cast(&$$, &$2, IS_OBJECT TSRMLS_CC); }
 -      |       T_BOOL_CAST expr        { zend_do_cast(&$$, &$2, _IS_BOOL TSRMLS_CC); }
 -      |       T_UNSET_CAST expr       { zend_do_cast(&$$, &$2, IS_NULL TSRMLS_CC); }
 -      |       T_EXIT exit_expr        { zend_do_exit(&$$, &$2 TSRMLS_CC); }
 -      |       '@' { zend_do_begin_silence(&$1 TSRMLS_CC); } expr { zend_do_end_silence(&$1 TSRMLS_CC); $$ = $3; }
 -      |       scalar                          { $$ = $1; }
 -      |       combined_scalar_offset { zend_do_end_variable_parse(&$1, BP_VAR_R, 0 TSRMLS_CC); }
 -      |       combined_scalar { $$ = $1; }
 -      |       '`' backticks_expr '`' { zend_do_shell_exec(&$$, &$2 TSRMLS_CC); }
 -      |       T_PRINT expr  { zend_do_print(&$$, &$2 TSRMLS_CC); }
 -      |       T_YIELD { zend_do_yield(&$$, NULL, NULL, 0 TSRMLS_CC); }
 -      |       function is_reference { zend_do_begin_lambda_function_declaration(&$$, &$1, $2.op_type, 0 TSRMLS_CC); }
 -              '(' parameter_list ')' lexical_vars
 -              '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); $$ = $3; }
 -      |       T_STATIC function is_reference { zend_do_begin_lambda_function_declaration(&$$, &$2, $3.op_type, 1 TSRMLS_CC); }
 -              '(' parameter_list ')' lexical_vars
 -              '{' inner_statement_list '}' { zend_do_end_function_declaration(&$2 TSRMLS_CC); $$ = $4; }
 -;
 -
 -yield_expr:
 -              T_YIELD expr_without_variable { zend_do_yield(&$$, &$2, NULL, 0 TSRMLS_CC); }
 -      |       T_YIELD variable { zend_do_yield(&$$, &$2, NULL, 1 TSRMLS_CC); }
 -      |       T_YIELD expr T_DOUBLE_ARROW expr_without_variable { zend_do_yield(&$$, &$4, &$2, 0 TSRMLS_CC); }
 -      |       T_YIELD expr T_DOUBLE_ARROW variable { zend_do_yield(&$$, &$4, &$2, 1 TSRMLS_CC); }
 -;
 -
 -combined_scalar_offset:
 -              combined_scalar '[' dim_offset ']' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
 -      |       combined_scalar_offset '[' dim_offset ']' { fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
 -      |       T_CONSTANT_ENCAPSED_STRING '[' dim_offset ']' { $1.EA = 0; zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
 -      |       general_constant '[' dim_offset ']' { zend_do_begin_variable_parse(TSRMLS_C); fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
 -;
 -
 -combined_scalar:
 -              T_ARRAY '(' array_pair_list ')' { $$ = $3; }
 -      |       '[' array_pair_list ']' { $$ = $2; }
 +              T_LIST '(' assignment_list ')' '=' expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_ASSIGN, $3.ast, $6.ast); }
 +      |       variable '=' expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_ASSIGN, $1.ast, $3.ast); }
 +      |       variable '=' '&' variable
 +                      { $$.ast = zend_ast_create(ZEND_AST_ASSIGN_REF, $1.ast, $4.ast); }
 +      |       variable '=' '&' T_NEW class_name_reference ctor_arguments
 +                      { zend_error(E_DEPRECATED, "Assigning the return value of new by reference is deprecated");
 +                        $$.ast = zend_ast_create(ZEND_AST_ASSIGN_REF, $1.ast,
 +                            zend_ast_create(ZEND_AST_NEW, $5.ast, $6.ast)); }
 +      |       T_CLONE expr { $$.ast = zend_ast_create(ZEND_AST_CLONE, $2.ast); }
 +      |       variable T_PLUS_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_ADD, $1.ast, $3.ast); }
 +      |       variable T_MINUS_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_SUB, $1.ast, $3.ast); }
 +      |       variable T_MUL_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_MUL, $1.ast, $3.ast); }
 +      |       variable T_POW_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_POW, $1.ast, $3.ast); }
 +      |       variable T_DIV_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_DIV, $1.ast, $3.ast); }
 +      |       variable T_CONCAT_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_CONCAT, $1.ast, $3.ast); }
 +      |       variable T_MOD_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_MOD, $1.ast, $3.ast); }
 +      |       variable T_AND_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_BW_AND, $1.ast, $3.ast); }
 +      |       variable T_OR_EQUAL expr 
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_BW_OR, $1.ast, $3.ast); }
 +      |       variable T_XOR_EQUAL expr 
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_BW_XOR, $1.ast, $3.ast); }
 +      |       variable T_SL_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_SL, $1.ast, $3.ast); }
 +      |       variable T_SR_EQUAL expr
 +                      { $$.ast = zend_ast_create_assign_op(ZEND_ASSIGN_SR, $1.ast, $3.ast); }
 +      |       variable T_INC { $$.ast = zend_ast_create(ZEND_AST_POST_INC, $1.ast); }
 +      |       T_INC variable { $$.ast = zend_ast_create(ZEND_AST_PRE_INC, $2.ast); }
 +      |       variable T_DEC { $$.ast = zend_ast_create(ZEND_AST_POST_DEC, $1.ast); }
 +      |       T_DEC variable { $$.ast = zend_ast_create(ZEND_AST_PRE_DEC, $2.ast); }
 +      |       expr T_BOOLEAN_OR expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_OR, $1.ast, $3.ast); }
 +      |       expr T_BOOLEAN_AND expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_AND, $1.ast, $3.ast); }
 +      |       expr T_LOGICAL_OR expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_OR, $1.ast, $3.ast); }
 +      |       expr T_LOGICAL_AND expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_AND, $1.ast, $3.ast); }
 +      |       expr T_LOGICAL_XOR expr
 +                      { $$.ast = zend_ast_create_binary_op(ZEND_BOOL_XOR, $1.ast, $3.ast); }
 +      |       expr '|' expr   { $$.ast = zend_ast_create_binary_op(ZEND_BW_OR, $1.ast, $3.ast); }
 +      |       expr '&' expr   { $$.ast = zend_ast_create_binary_op(ZEND_BW_AND, $1.ast, $3.ast); }
 +      |       expr '^' expr   { $$.ast = zend_ast_create_binary_op(ZEND_BW_XOR, $1.ast, $3.ast); }
 +      |       expr '.' expr   { $$.ast = zend_ast_create_binary_op(ZEND_CONCAT, $1.ast, $3.ast); }
 +      |       expr '+' expr   { $$.ast = zend_ast_create_binary_op(ZEND_ADD, $1.ast, $3.ast); }
 +      |       expr '-' expr   { $$.ast = zend_ast_create_binary_op(ZEND_SUB, $1.ast, $3.ast); }
 +      |       expr '*' expr   { $$.ast = zend_ast_create_binary_op(ZEND_MUL, $1.ast, $3.ast); }
 +      |       expr T_POW expr { $$.ast = zend_ast_create_binary_op(ZEND_POW, $1.ast, $3.ast); }
 +      |       expr '/' expr   { $$.ast = zend_ast_create_binary_op(ZEND_DIV, $1.ast, $3.ast); }
 +      |       expr '%' expr   { $$.ast = zend_ast_create_binary_op(ZEND_MOD, $1.ast, $3.ast); }
 +      |       expr T_SL expr  { $$.ast = zend_ast_create_binary_op(ZEND_SL, $1.ast, $3.ast); }
 +      |       expr T_SR expr  { $$.ast = zend_ast_create_binary_op(ZEND_SR, $1.ast, $3.ast); }
 +      |       '+' expr %prec T_INC { $$.ast = zend_ast_create(ZEND_AST_UNARY_PLUS, $2.ast); }
 +      |       '-' expr %prec T_INC { $$.ast = zend_ast_create(ZEND_AST_UNARY_MINUS, $2.ast); }
 +      |       '!' expr { $$.ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BOOL_NOT, $2.ast); }
 +      |       '~' expr { $$.ast = zend_ast_create_ex(ZEND_AST_UNARY_OP, ZEND_BW_NOT, $2.ast); }
 +      |       expr T_IS_IDENTICAL expr
 +                      { $$.ast = zend_ast_create_binary_op(ZEND_IS_IDENTICAL, $1.ast, $3.ast); }
 +      |       expr T_IS_NOT_IDENTICAL expr
 +                      { $$.ast = zend_ast_create_binary_op(ZEND_IS_NOT_IDENTICAL, $1.ast, $3.ast); }
 +      |       expr T_IS_EQUAL expr
 +                      { $$.ast = zend_ast_create_binary_op(ZEND_IS_EQUAL, $1.ast, $3.ast); }
 +      |       expr T_IS_NOT_EQUAL expr
 +                      { $$.ast = zend_ast_create_binary_op(ZEND_IS_NOT_EQUAL, $1.ast, $3.ast); }
 +      |       expr '<' expr
 +                      { $$.ast = zend_ast_create_binary_op(ZEND_IS_SMALLER, $1.ast, $3.ast); }
 +      |       expr T_IS_SMALLER_OR_EQUAL expr
 +                      { $$.ast = zend_ast_create_binary_op(ZEND_IS_SMALLER_OR_EQUAL, $1.ast, $3.ast); }
 +      |       expr '>' expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_GREATER, $1.ast, $3.ast); }
 +      |       expr T_IS_GREATER_OR_EQUAL expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_GREATER_EQUAL, $1.ast, $3.ast); }
 +      |       expr T_INSTANCEOF class_name_reference
 +                      { $$.ast = zend_ast_create(ZEND_AST_INSTANCEOF, $1.ast, $3.ast); }
 +      |       parenthesis_expr { $$.ast = $1.ast; }
 +      |       new_expr { $$.ast = $1.ast; }
 +      |       expr '?' expr ':' expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_CONDITIONAL, $1.ast, $3.ast, $5.ast); }
 +      |       expr '?' ':' expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_CONDITIONAL, $1.ast, NULL, $4.ast); }
 +      |       internal_functions_in_yacc { $$.ast = $1.ast; }
 +      |       T_INT_CAST expr
 +                      { $$.ast = zend_ast_create_cast(IS_LONG, $2.ast); }
 +      |       T_DOUBLE_CAST expr
 +                      { $$.ast = zend_ast_create_cast(IS_DOUBLE, $2.ast); }
 +      |       T_STRING_CAST expr
 +                      { $$.ast = zend_ast_create_cast(IS_STRING, $2.ast); }
 +      |       T_ARRAY_CAST expr
 +                      { $$.ast = zend_ast_create_cast(IS_ARRAY, $2.ast); }
 +      |       T_OBJECT_CAST expr
 +                      { $$.ast = zend_ast_create_cast(IS_OBJECT, $2.ast); }
 +      |       T_BOOL_CAST expr
 +                      { $$.ast = zend_ast_create_cast(_IS_BOOL, $2.ast); }
 +      |       T_UNSET_CAST expr
 +                      { $$.ast = zend_ast_create_cast(IS_NULL, $2.ast); }
 +      |       T_EXIT exit_expr { $$.ast = zend_ast_create(ZEND_AST_EXIT, $2.ast); }
 +      |       '@' expr { $$.ast = zend_ast_create(ZEND_AST_SILENCE, $2.ast); }
 +      |       scalar { $$.ast = $1.ast; }
 +      |       '`' backticks_expr '`' { $$.ast = zend_ast_create(ZEND_AST_SHELL_EXEC, $2.ast); }
 +      |       T_PRINT expr { $$.ast = zend_ast_create(ZEND_AST_PRINT, $2.ast); }
 +      |       T_YIELD { $$.ast = zend_ast_create(ZEND_AST_YIELD, NULL, NULL); }
 +      |       T_YIELD expr { $$.ast = zend_ast_create(ZEND_AST_YIELD, $2.ast, NULL); }
 +      |       T_YIELD expr T_DOUBLE_ARROW expr
 +                      { $$.ast = zend_ast_create(ZEND_AST_YIELD, $4.ast, $2.ast); }
 +      |       function returns_ref '(' parameter_list ')' lexical_vars
 +                      { $$.str = CG(doc_comment); CG(doc_comment) = NULL; }
 +              '{' inner_statement_list '}'
 +                      { $$.ast = zend_ast_create_decl(ZEND_AST_CLOSURE, $2.num, $1.num, $7.str,
-                                 STR_INIT("{closure}", sizeof("{closure}") - 1, 0),
++                                zend_string_init("{closure}", sizeof("{closure}") - 1, 0),
 +                            $4.ast, $6.ast, $9.ast); }
 +      |       T_STATIC function returns_ref '(' parameter_list ')' lexical_vars
 +                      { $$.str = CG(doc_comment); CG(doc_comment) = NULL; }
 +              '{' inner_statement_list '}'
 +                      { $$.ast = zend_ast_create_decl(ZEND_AST_CLOSURE, $3.num | ZEND_ACC_STATIC, $2.num,
-                             $8.str, STR_INIT("{closure}", sizeof("{closure}") - 1, 0),
++                            $8.str, zend_string_init("{closure}", sizeof("{closure}") - 1, 0),
 +                            $5.ast, $7.ast, $10.ast); }
  ;
  
  function:

diff --cc Zend/zend_language_scanner.c
index 78654194d1d2c86a68ef4a2b236fa57d07d342ee,33dc6eed245f13d1cc6ab6517bdf6b8c0e4f6209..08db4503744a128eed228c5ec9ddf62d3f5d9c44
--- 1/Zend/zend_language_scanner.c
--- 2/Zend/zend_language_scanner.c
+++ b/Zend/zend_language_scanner.c
@@@ -1637,9 -1643,9 +1637,9 @@@ yy61
                ++YYCURSOR;
                YYDEBUG(62, *YYCURSOR);
                yyleng = YYCURSOR - SCNG(yy_text);
 -#line 2153 "Zend/zend_language_scanner.l"
 +#line 2086 "Zend/zend_language_scanner.l"
                {
-       Z_LVAL_P(zendlval) = (long) '{';
+       Z_LVAL_P(zendlval) = (zend_long) '{';
        yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
        yyless(1);
        return T_CURLY_OPEN;
@@@ -1865,9 -1871,9 +1865,9 @@@ yy83
                ++YYCURSOR;
                YYDEBUG(84, *YYCURSOR);
                yyleng = YYCURSOR - SCNG(yy_text);
 -#line 2153 "Zend/zend_language_scanner.l"
 +#line 2086 "Zend/zend_language_scanner.l"
                {
-       Z_LVAL_P(zendlval) = (long) '{';
+       Z_LVAL_P(zendlval) = (zend_long) '{';
        yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
        yyless(1);
        return T_CURLY_OPEN;
@@@ -2124,9 -2130,9 +2124,9 @@@ yy107
                ++YYCURSOR;
                YYDEBUG(108, *YYCURSOR);
                yyleng = YYCURSOR - SCNG(yy_text);
 -#line 2153 "Zend/zend_language_scanner.l"
 +#line 2086 "Zend/zend_language_scanner.l"
                {
-       Z_LVAL_P(zendlval) = (long) '{';
+       Z_LVAL_P(zendlval) = (zend_long) '{';
        yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
        yyless(1);
        return T_CURLY_OPEN;
@@@ -2943,13 -2950,13 +2943,13 @@@ yy172
  yy173:
                YYDEBUG(173, *YYCURSOR);
                yyleng = YYCURSOR - SCNG(yy_text);
 -#line 1537 "Zend/zend_language_scanner.l"
 +#line 1536 "Zend/zend_language_scanner.l"
                {
        if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
-               ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
+               ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, NULL, 0));
        } else {
                errno = 0;
-               ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
+               ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, NULL, 0));
                if (errno == ERANGE) { /* Overflow */
                        if (yytext[0] == '0') { /* octal overflow */
                                ZVAL_DOUBLE(zendlval, zend_oct_strtod(yytext, NULL));
@@@ -7602,10 -7670,10 +7602,10 @@@ yy838
  yy839:
                YYDEBUG(839, *YYCURSOR);
                yyleng = YYCURSOR - SCNG(yy_text);
 -#line 1578 "Zend/zend_language_scanner.l"
 +#line 1577 "Zend/zend_language_scanner.l"
                { /* Offset could be treated as a long */
        if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
-               ZVAL_LONG(zendlval, strtol(yytext, NULL, 10));
+               ZVAL_LONG(zendlval, ZEND_STRTOL(yytext, NULL, 10));
        } else {
                ZVAL_STRINGL(zendlval, yytext, yyleng);
        }

diff --cc Zend/zend_language_scanner.l
Simple merge

diff --cc Zend/zend_opcode.c
Simple merge

diff --cc Zend/zend_types.h
index 7ce259a34fe3df48fb88aa58822441c677b79df4,a76704beed3ca2204c77b7a6a612b821d34379b9..d2b562ecd984b6e81c801618dd511c9e4e57010b
--- 1/Zend/zend_types.h
--- 2/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@@ -112,14 -125,13 +125,14 @@@ struct _zval_struct 
                                zend_uchar    const_flags,
                                zend_uchar    reserved)     /* various IS_VAR flags */
                } v;
-               zend_uint type_info;
+               uint32_t type_info;
        } u1;
        union {
-               zend_uint     var_flags;
-               zend_uint     next;                 /* hash collision chain */
-               zend_uint     str_offset;           /* string offset */
-               zend_uint     cache_slot;           /* literal cache slot */
-               zend_uint     lineno;                           /* line number (for ast nodes) */
+               uint32_t     var_flags;
+               uint32_t     next;                 /* hash collision chain */
+               uint32_t     str_offset;           /* string offset */
+               uint32_t     cache_slot;           /* literal cache slot */
++              uint32_t     lineno;               /* line number (for ast nodes) */
        } u2;
  };
  

diff --cc Zend/zend_variables.c
Simple merge

diff --cc Zend/zend_vm_def.h
index 3122119998659f66b061fd4d98c843fadf7d07cc,06a84b883588bcc87a12af46cdd75a97662193e3..388a262b185e63e26abac0cf361f5e4debd0645f
--- 1/Zend/zend_vm_def.h
--- 2/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@@ -2427,9 -2421,8 +2427,9 @@@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_
                        if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name));
                        }
-                       STR_FREE(lcname);
+                       zend_string_free(lcname);
                        FREE_OP2();
 +
                        fbc = Z_FUNC_P(func);
                        called_scope = NULL;
                        object = NULL;

diff --cc Zend/zend_vm_execute.h
index 8605333d0511a1a7a629da8ebaebc65c1f208886,c74609e331e5161c77cf5a8a2ada48e4dd46ba3e..3568e03ae6f56c84fa8c7144da11556ce28603a0
--- 1/Zend/zend_vm_execute.h
--- 2/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@@ -1920,9 -1921,8 +1920,9 @@@ static int ZEND_FASTCALL  ZEND_INIT_FCA
                        if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name));
                        }
-                       STR_FREE(lcname);
+                       zend_string_free(lcname);
                        zval_dtor(free_op2.var);
 +
                        fbc = Z_FUNC_P(func);
                        called_scope = NULL;
                        object = NULL;
@@@ -2094,9 -2095,8 +2094,9 @@@ static int ZEND_FASTCALL  ZEND_INIT_FCA
                        if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name));
                        }
-                       STR_FREE(lcname);
+                       zend_string_free(lcname);
                        zval_ptr_dtor_nogc(free_op2.var);
 +
                        fbc = Z_FUNC_P(func);
                        called_scope = NULL;
                        object = NULL;
@@@ -4626,147 -4485,6 +4634,151 @@@ static int ZEND_FASTCALL  ZEND_ISSET_IS
        ZEND_VM_NEXT_OPCODE();
  }
  
-       ulong hval;
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +
 +      zval *container;
 +      int result;
-                       result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
++      zend_ulong hval;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = opline->op1.zv;
 +      offset = opline->op2.zv;
 +
 +      if (Z_TYPE_P(container) == IS_ARRAY) {
 +              HashTable *ht = Z_ARRVAL_P(container);
 +              zval *value;
 +              zend_string *str;
 +
 +isset_again:
 +              if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
 +                      str = Z_STR_P(offset);
 +                      if (IS_CONST != IS_CONST) {
 +                              if (ZEND_HANDLE_NUMERIC(str, hval)) {
 +                                      goto num_index_prop;
 +                              }
 +                      }
 +str_index_prop:
 +                      value = zend_hash_find_ind(ht, str);
 +              } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
 +                      hval = Z_LVAL_P(offset);
 +num_index_prop:
 +                      value = zend_hash_index_find(ht, hval);
 +              } else {
 +                      switch (Z_TYPE_P(offset)) {
 +                              case IS_DOUBLE:
 +                                      hval = zend_dval_to_lval(Z_DVAL_P(offset));
 +                                      goto num_index_prop;
 +                              case IS_NULL:
 +                                      str = STR_EMPTY_ALLOC();
 +                                      goto str_index_prop;
 +                              case IS_FALSE:
 +                                      hval = 0;
 +                                      goto num_index_prop;
 +                              case IS_TRUE:
 +                                      hval = 1;
 +                                      goto num_index_prop;
 +                              case IS_RESOURCE:
 +                                      hval = Z_RES_HANDLE_P(offset);
 +                                      goto num_index_prop;
 +                              case IS_REFERENCE:
 +                                      offset = Z_REFVAL_P(offset);
 +                                      goto isset_again;
 +                              default:
 +                                      zend_error(E_WARNING, "Illegal offset type in isset or empty");
 +                                      value = NULL;
 +                                      break;
 +                      }
 +              }
 +
 +              if (opline->extended_value & ZEND_ISSET) {
 +                      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
-                               convert_to_long(&tmp);
++                      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
++                          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
 +              } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
 +                      result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 +              }
 +      } else if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_dimension) {
 +                      result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check element of non-array");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 +              zval tmp;
 +
 +              result = 0;
 +              if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
++                      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
++                              ZVAL_DEREF(offset);
++                      }
 +                      if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 +                                      || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 +                                              && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
 +                              ZVAL_DUP(&tmp, offset);
++                              convert_to_int(&tmp);
 +                              offset = &tmp;
 +                      }
 +              }
 +              if (Z_TYPE_P(offset) == IS_LONG) {
 +                      if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
 +                              if ((opline->extended_value & ZEND_ISSET) ||
 +                                  Z_STRVAL_P(container)[offset->value.lval] != '0') {
 +                                      result = 1;
 +                              }
 +                      }
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +
 +      zval *container;
 +      int result;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = opline->op1.zv;
 +      offset = opline->op2.zv;
 +
 +      if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_property) {
 +                      result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check property of non-object");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
  static int ZEND_FASTCALL  ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
  {
        USE_OPLINE
@@@ -5683,149 -5248,6 +5695,153 @@@ static int ZEND_FASTCALL  ZEND_INIT_ARR
        }
  }
  
-       ulong hval;
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op2;
 +      zval *container;
 +      int result;
-                       result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
++      zend_ulong hval;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = opline->op1.zv;
 +      offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_ARRAY) {
 +              HashTable *ht = Z_ARRVAL_P(container);
 +              zval *value;
 +              zend_string *str;
 +
 +isset_again:
 +              if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
 +                      str = Z_STR_P(offset);
 +                      if (IS_TMP_VAR != IS_CONST) {
 +                              if (ZEND_HANDLE_NUMERIC(str, hval)) {
 +                                      goto num_index_prop;
 +                              }
 +                      }
 +str_index_prop:
 +                      value = zend_hash_find_ind(ht, str);
 +              } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
 +                      hval = Z_LVAL_P(offset);
 +num_index_prop:
 +                      value = zend_hash_index_find(ht, hval);
 +              } else {
 +                      switch (Z_TYPE_P(offset)) {
 +                              case IS_DOUBLE:
 +                                      hval = zend_dval_to_lval(Z_DVAL_P(offset));
 +                                      goto num_index_prop;
 +                              case IS_NULL:
 +                                      str = STR_EMPTY_ALLOC();
 +                                      goto str_index_prop;
 +                              case IS_FALSE:
 +                                      hval = 0;
 +                                      goto num_index_prop;
 +                              case IS_TRUE:
 +                                      hval = 1;
 +                                      goto num_index_prop;
 +                              case IS_RESOURCE:
 +                                      hval = Z_RES_HANDLE_P(offset);
 +                                      goto num_index_prop;
 +                              case IS_REFERENCE:
 +                                      offset = Z_REFVAL_P(offset);
 +                                      goto isset_again;
 +                              default:
 +                                      zend_error(E_WARNING, "Illegal offset type in isset or empty");
 +                                      value = NULL;
 +                                      break;
 +                      }
 +              }
 +
 +              if (opline->extended_value & ZEND_ISSET) {
 +                      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
-                               convert_to_long(&tmp);
++                      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
++                          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
 +              } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
 +                      result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 +              }
 +      } else if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_dimension) {
 +                      result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check element of non-array");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 +              zval tmp;
 +
 +              result = 0;
 +              if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
++                      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
++                              ZVAL_DEREF(offset);
++                      }
 +                      if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 +                                      || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 +                                              && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
 +                              ZVAL_DUP(&tmp, offset);
++                              convert_to_int(&tmp);
 +                              offset = &tmp;
 +                      }
 +              }
 +              if (Z_TYPE_P(offset) == IS_LONG) {
 +                      if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
 +                              if ((opline->extended_value & ZEND_ISSET) ||
 +                                  Z_STRVAL_P(container)[offset->value.lval] != '0') {
 +                                      result = 1;
 +                              }
 +                      }
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      zval_dtor(free_op2.var);
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op2;
 +      zval *container;
 +      int result;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = opline->op1.zv;
 +      offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_property) {
 +                      result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check property of non-object");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      zval_dtor(free_op2.var);
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
  static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
  {
        USE_OPLINE
@@@ -7014,149 -6283,6 +7030,153 @@@ static int ZEND_FASTCALL  ZEND_ISSET_IS
        ZEND_VM_NEXT_OPCODE();
  }
  
-       ulong hval;
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op2;
 +      zval *container;
 +      int result;
-                       result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
++      zend_ulong hval;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = opline->op1.zv;
 +      offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_ARRAY) {
 +              HashTable *ht = Z_ARRVAL_P(container);
 +              zval *value;
 +              zend_string *str;
 +
 +isset_again:
 +              if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
 +                      str = Z_STR_P(offset);
 +                      if (IS_VAR != IS_CONST) {
 +                              if (ZEND_HANDLE_NUMERIC(str, hval)) {
 +                                      goto num_index_prop;
 +                              }
 +                      }
 +str_index_prop:
 +                      value = zend_hash_find_ind(ht, str);
 +              } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
 +                      hval = Z_LVAL_P(offset);
 +num_index_prop:
 +                      value = zend_hash_index_find(ht, hval);
 +              } else {
 +                      switch (Z_TYPE_P(offset)) {
 +                              case IS_DOUBLE:
 +                                      hval = zend_dval_to_lval(Z_DVAL_P(offset));
 +                                      goto num_index_prop;
 +                              case IS_NULL:
 +                                      str = STR_EMPTY_ALLOC();
 +                                      goto str_index_prop;
 +                              case IS_FALSE:
 +                                      hval = 0;
 +                                      goto num_index_prop;
 +                              case IS_TRUE:
 +                                      hval = 1;
 +                                      goto num_index_prop;
 +                              case IS_RESOURCE:
 +                                      hval = Z_RES_HANDLE_P(offset);
 +                                      goto num_index_prop;
 +                              case IS_REFERENCE:
 +                                      offset = Z_REFVAL_P(offset);
 +                                      goto isset_again;
 +                              default:
 +                                      zend_error(E_WARNING, "Illegal offset type in isset or empty");
 +                                      value = NULL;
 +                                      break;
 +                      }
 +              }
 +
 +              if (opline->extended_value & ZEND_ISSET) {
 +                      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
-                               convert_to_long(&tmp);
++                      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
++                          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
 +              } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
 +                      result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 +              }
 +      } else if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_dimension) {
 +                      result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check element of non-array");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 +              zval tmp;
 +
 +              result = 0;
 +              if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
++                      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
++                              ZVAL_DEREF(offset);
++                      }
 +                      if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 +                                      || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 +                                              && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
 +                              ZVAL_DUP(&tmp, offset);
++                              convert_to_int(&tmp);
 +                              offset = &tmp;
 +                      }
 +              }
 +              if (Z_TYPE_P(offset) == IS_LONG) {
 +                      if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
 +                              if ((opline->extended_value & ZEND_ISSET) ||
 +                                  Z_STRVAL_P(container)[offset->value.lval] != '0') {
 +                                      result = 1;
 +                              }
 +                      }
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      zval_ptr_dtor_nogc(free_op2.var);
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op2;
 +      zval *container;
 +      int result;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = opline->op1.zv;
 +      offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_property) {
 +                      result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check property of non-object");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      zval_ptr_dtor_nogc(free_op2.var);
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
  static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
  {
        USE_OPLINE
@@@ -8819,147 -7759,6 +8839,151 @@@ static int ZEND_FASTCALL  ZEND_INIT_ARR
        }
  }
  
-       ulong hval;
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +
 +      zval *container;
 +      int result;
-                       result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
++      zend_ulong hval;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = opline->op1.zv;
 +      offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_ARRAY) {
 +              HashTable *ht = Z_ARRVAL_P(container);
 +              zval *value;
 +              zend_string *str;
 +
 +isset_again:
 +              if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
 +                      str = Z_STR_P(offset);
 +                      if (IS_CV != IS_CONST) {
 +                              if (ZEND_HANDLE_NUMERIC(str, hval)) {
 +                                      goto num_index_prop;
 +                              }
 +                      }
 +str_index_prop:
 +                      value = zend_hash_find_ind(ht, str);
 +              } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
 +                      hval = Z_LVAL_P(offset);
 +num_index_prop:
 +                      value = zend_hash_index_find(ht, hval);
 +              } else {
 +                      switch (Z_TYPE_P(offset)) {
 +                              case IS_DOUBLE:
 +                                      hval = zend_dval_to_lval(Z_DVAL_P(offset));
 +                                      goto num_index_prop;
 +                              case IS_NULL:
 +                                      str = STR_EMPTY_ALLOC();
 +                                      goto str_index_prop;
 +                              case IS_FALSE:
 +                                      hval = 0;
 +                                      goto num_index_prop;
 +                              case IS_TRUE:
 +                                      hval = 1;
 +                                      goto num_index_prop;
 +                              case IS_RESOURCE:
 +                                      hval = Z_RES_HANDLE_P(offset);
 +                                      goto num_index_prop;
 +                              case IS_REFERENCE:
 +                                      offset = Z_REFVAL_P(offset);
 +                                      goto isset_again;
 +                              default:
 +                                      zend_error(E_WARNING, "Illegal offset type in isset or empty");
 +                                      value = NULL;
 +                                      break;
 +                      }
 +              }
 +
 +              if (opline->extended_value & ZEND_ISSET) {
 +                      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
-                               convert_to_long(&tmp);
++                      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
++                          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
 +              } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
 +                      result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 +              }
 +      } else if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_dimension) {
 +                      result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check element of non-array");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 +              zval tmp;
 +
 +              result = 0;
 +              if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
++                      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
++                              ZVAL_DEREF(offset);
++                      }
 +                      if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 +                                      || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 +                                              && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
 +                              ZVAL_DUP(&tmp, offset);
++                              convert_to_int(&tmp);
 +                              offset = &tmp;
 +                      }
 +              }
 +              if (Z_TYPE_P(offset) == IS_LONG) {
 +                      if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
 +                              if ((opline->extended_value & ZEND_ISSET) ||
 +                                  Z_STRVAL_P(container)[offset->value.lval] != '0') {
 +                                      result = 1;
 +                              }
 +                      }
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +
 +      zval *container;
 +      int result;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = opline->op1.zv;
 +      offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_property) {
 +                      result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check property of non-object");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
  static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
  {
        USE_OPLINE
@@@ -11237,147 -9893,6 +11269,151 @@@ static int ZEND_FASTCALL  ZEND_ISSET_IS
        ZEND_VM_NEXT_OPCODE();
  }
  
-       ulong hval;
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op1;
 +      zval *container;
 +      int result;
-                       result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
++      zend_ulong hval;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 +      offset = opline->op2.zv;
 +
 +      if (Z_TYPE_P(container) == IS_ARRAY) {
 +              HashTable *ht = Z_ARRVAL_P(container);
 +              zval *value;
 +              zend_string *str;
 +
 +isset_again:
 +              if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
 +                      str = Z_STR_P(offset);
 +                      if (IS_CONST != IS_CONST) {
 +                              if (ZEND_HANDLE_NUMERIC(str, hval)) {
 +                                      goto num_index_prop;
 +                              }
 +                      }
 +str_index_prop:
 +                      value = zend_hash_find_ind(ht, str);
 +              } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
 +                      hval = Z_LVAL_P(offset);
 +num_index_prop:
 +                      value = zend_hash_index_find(ht, hval);
 +              } else {
 +                      switch (Z_TYPE_P(offset)) {
 +                              case IS_DOUBLE:
 +                                      hval = zend_dval_to_lval(Z_DVAL_P(offset));
 +                                      goto num_index_prop;
 +                              case IS_NULL:
 +                                      str = STR_EMPTY_ALLOC();
 +                                      goto str_index_prop;
 +                              case IS_FALSE:
 +                                      hval = 0;
 +                                      goto num_index_prop;
 +                              case IS_TRUE:
 +                                      hval = 1;
 +                                      goto num_index_prop;
 +                              case IS_RESOURCE:
 +                                      hval = Z_RES_HANDLE_P(offset);
 +                                      goto num_index_prop;
 +                              case IS_REFERENCE:
 +                                      offset = Z_REFVAL_P(offset);
 +                                      goto isset_again;
 +                              default:
 +                                      zend_error(E_WARNING, "Illegal offset type in isset or empty");
 +                                      value = NULL;
 +                                      break;
 +                      }
 +              }
 +
 +              if (opline->extended_value & ZEND_ISSET) {
 +                      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
-                               convert_to_long(&tmp);
++                      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
++                          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
 +              } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
 +                      result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 +              }
 +      } else if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_dimension) {
 +                      result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check element of non-array");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 +              zval tmp;
 +
 +              result = 0;
 +              if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
++                      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
++                              ZVAL_DEREF(offset);
++                      }
 +                      if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 +                                      || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 +                                              && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
 +                              ZVAL_DUP(&tmp, offset);
++                              convert_to_int(&tmp);
 +                              offset = &tmp;
 +                      }
 +              }
 +              if (Z_TYPE_P(offset) == IS_LONG) {
 +                      if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
 +                              if ((opline->extended_value & ZEND_ISSET) ||
 +                                  Z_STRVAL_P(container)[offset->value.lval] != '0') {
 +                                      result = 1;
 +                              }
 +                      }
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +      zval_dtor(free_op1.var);
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op1;
 +      zval *container;
 +      int result;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 +      offset = opline->op2.zv;
 +
 +      if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_property) {
 +                      result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check property of non-object");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +      zval_dtor(free_op1.var);
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
  static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
  {
        USE_OPLINE
@@@ -12218,149 -10580,6 +12254,153 @@@ static int ZEND_FASTCALL  ZEND_INIT_ARR
        }
  }
  
-       ulong hval;
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op1, free_op2;
 +      zval *container;
 +      int result;
-                       result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
++      zend_ulong hval;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 +      offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_ARRAY) {
 +              HashTable *ht = Z_ARRVAL_P(container);
 +              zval *value;
 +              zend_string *str;
 +
 +isset_again:
 +              if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
 +                      str = Z_STR_P(offset);
 +                      if (IS_TMP_VAR != IS_CONST) {
 +                              if (ZEND_HANDLE_NUMERIC(str, hval)) {
 +                                      goto num_index_prop;
 +                              }
 +                      }
 +str_index_prop:
 +                      value = zend_hash_find_ind(ht, str);
 +              } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
 +                      hval = Z_LVAL_P(offset);
 +num_index_prop:
 +                      value = zend_hash_index_find(ht, hval);
 +              } else {
 +                      switch (Z_TYPE_P(offset)) {
 +                              case IS_DOUBLE:
 +                                      hval = zend_dval_to_lval(Z_DVAL_P(offset));
 +                                      goto num_index_prop;
 +                              case IS_NULL:
 +                                      str = STR_EMPTY_ALLOC();
 +                                      goto str_index_prop;
 +                              case IS_FALSE:
 +                                      hval = 0;
 +                                      goto num_index_prop;
 +                              case IS_TRUE:
 +                                      hval = 1;
 +                                      goto num_index_prop;
 +                              case IS_RESOURCE:
 +                                      hval = Z_RES_HANDLE_P(offset);
 +                                      goto num_index_prop;
 +                              case IS_REFERENCE:
 +                                      offset = Z_REFVAL_P(offset);
 +                                      goto isset_again;
 +                              default:
 +                                      zend_error(E_WARNING, "Illegal offset type in isset or empty");
 +                                      value = NULL;
 +                                      break;
 +                      }
 +              }
 +
 +              if (opline->extended_value & ZEND_ISSET) {
 +                      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
-                               convert_to_long(&tmp);
++                      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
++                          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
 +              } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
 +                      result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 +              }
 +      } else if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_dimension) {
 +                      result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check element of non-array");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 +              zval tmp;
 +
 +              result = 0;
 +              if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
++                      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
++                              ZVAL_DEREF(offset);
++                      }
 +                      if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 +                                      || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 +                                              && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
 +                              ZVAL_DUP(&tmp, offset);
++                              convert_to_int(&tmp);
 +                              offset = &tmp;
 +                      }
 +              }
 +              if (Z_TYPE_P(offset) == IS_LONG) {
 +                      if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
 +                              if ((opline->extended_value & ZEND_ISSET) ||
 +                                  Z_STRVAL_P(container)[offset->value.lval] != '0') {
 +                                      result = 1;
 +                              }
 +                      }
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      zval_dtor(free_op2.var);
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +      zval_dtor(free_op1.var);
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op1, free_op2;
 +      zval *container;
 +      int result;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 +      offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_property) {
 +                      result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check property of non-object");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      zval_dtor(free_op2.var);
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +      zval_dtor(free_op1.var);
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
  static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
  {
        USE_OPLINE
@@@ -13506,149 -11572,6 +13546,153 @@@ static int ZEND_FASTCALL  ZEND_ISSET_IS
        ZEND_VM_NEXT_OPCODE();
  }
  
-       ulong hval;
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op1, free_op2;
 +      zval *container;
 +      int result;
-                       result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
++      zend_ulong hval;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 +      offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_ARRAY) {
 +              HashTable *ht = Z_ARRVAL_P(container);
 +              zval *value;
 +              zend_string *str;
 +
 +isset_again:
 +              if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
 +                      str = Z_STR_P(offset);
 +                      if (IS_VAR != IS_CONST) {
 +                              if (ZEND_HANDLE_NUMERIC(str, hval)) {
 +                                      goto num_index_prop;
 +                              }
 +                      }
 +str_index_prop:
 +                      value = zend_hash_find_ind(ht, str);
 +              } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
 +                      hval = Z_LVAL_P(offset);
 +num_index_prop:
 +                      value = zend_hash_index_find(ht, hval);
 +              } else {
 +                      switch (Z_TYPE_P(offset)) {
 +                              case IS_DOUBLE:
 +                                      hval = zend_dval_to_lval(Z_DVAL_P(offset));
 +                                      goto num_index_prop;
 +                              case IS_NULL:
 +                                      str = STR_EMPTY_ALLOC();
 +                                      goto str_index_prop;
 +                              case IS_FALSE:
 +                                      hval = 0;
 +                                      goto num_index_prop;
 +                              case IS_TRUE:
 +                                      hval = 1;
 +                                      goto num_index_prop;
 +                              case IS_RESOURCE:
 +                                      hval = Z_RES_HANDLE_P(offset);
 +                                      goto num_index_prop;
 +                              case IS_REFERENCE:
 +                                      offset = Z_REFVAL_P(offset);
 +                                      goto isset_again;
 +                              default:
 +                                      zend_error(E_WARNING, "Illegal offset type in isset or empty");
 +                                      value = NULL;
 +                                      break;
 +                      }
 +              }
 +
 +              if (opline->extended_value & ZEND_ISSET) {
 +                      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
-                               convert_to_long(&tmp);
++                      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
++                          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
 +              } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
 +                      result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 +              }
 +      } else if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_dimension) {
 +                      result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check element of non-array");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 +              zval tmp;
 +
 +              result = 0;
 +              if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
++                      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
++                              ZVAL_DEREF(offset);
++                      }
 +                      if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 +                                      || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 +                                              && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
 +                              ZVAL_DUP(&tmp, offset);
++                              convert_to_int(&tmp);
 +                              offset = &tmp;
 +                      }
 +              }
 +              if (Z_TYPE_P(offset) == IS_LONG) {
 +                      if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
 +                              if ((opline->extended_value & ZEND_ISSET) ||
 +                                  Z_STRVAL_P(container)[offset->value.lval] != '0') {
 +                                      result = 1;
 +                              }
 +                      }
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      zval_ptr_dtor_nogc(free_op2.var);
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +      zval_dtor(free_op1.var);
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op1, free_op2;
 +      zval *container;
 +      int result;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 +      offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_property) {
 +                      result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check property of non-object");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      zval_ptr_dtor_nogc(free_op2.var);
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +      zval_dtor(free_op1.var);
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
  static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
  {
        USE_OPLINE
@@@ -15073,147 -12810,6 +15117,151 @@@ static int ZEND_FASTCALL  ZEND_INIT_ARR
        }
  }
  
-       ulong hval;
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op1;
 +      zval *container;
 +      int result;
-                       result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
++      zend_ulong hval;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 +      offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_ARRAY) {
 +              HashTable *ht = Z_ARRVAL_P(container);
 +              zval *value;
 +              zend_string *str;
 +
 +isset_again:
 +              if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
 +                      str = Z_STR_P(offset);
 +                      if (IS_CV != IS_CONST) {
 +                              if (ZEND_HANDLE_NUMERIC(str, hval)) {
 +                                      goto num_index_prop;
 +                              }
 +                      }
 +str_index_prop:
 +                      value = zend_hash_find_ind(ht, str);
 +              } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
 +                      hval = Z_LVAL_P(offset);
 +num_index_prop:
 +                      value = zend_hash_index_find(ht, hval);
 +              } else {
 +                      switch (Z_TYPE_P(offset)) {
 +                              case IS_DOUBLE:
 +                                      hval = zend_dval_to_lval(Z_DVAL_P(offset));
 +                                      goto num_index_prop;
 +                              case IS_NULL:
 +                                      str = STR_EMPTY_ALLOC();
 +                                      goto str_index_prop;
 +                              case IS_FALSE:
 +                                      hval = 0;
 +                                      goto num_index_prop;
 +                              case IS_TRUE:
 +                                      hval = 1;
 +                                      goto num_index_prop;
 +                              case IS_RESOURCE:
 +                                      hval = Z_RES_HANDLE_P(offset);
 +                                      goto num_index_prop;
 +                              case IS_REFERENCE:
 +                                      offset = Z_REFVAL_P(offset);
 +                                      goto isset_again;
 +                              default:
 +                                      zend_error(E_WARNING, "Illegal offset type in isset or empty");
 +                                      value = NULL;
 +                                      break;
 +                      }
 +              }
 +
 +              if (opline->extended_value & ZEND_ISSET) {
 +                      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
-                               convert_to_long(&tmp);
++                      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
++                          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
 +              } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
 +                      result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 +              }
 +      } else if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_dimension) {
 +                      result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check element of non-array");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 +              zval tmp;
 +
 +              result = 0;
 +              if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
++                      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
++                              ZVAL_DEREF(offset);
++                      }
 +                      if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 +                                      || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 +                                              && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
 +                              ZVAL_DUP(&tmp, offset);
++                              convert_to_int(&tmp);
 +                              offset = &tmp;
 +                      }
 +              }
 +              if (Z_TYPE_P(offset) == IS_LONG) {
 +                      if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
 +                              if ((opline->extended_value & ZEND_ISSET) ||
 +                                  Z_STRVAL_P(container)[offset->value.lval] != '0') {
 +                                      result = 1;
 +                              }
 +                      }
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +      zval_dtor(free_op1.var);
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +      USE_OPLINE
 +      zend_free_op free_op1;
 +      zval *container;
 +      int result;
 +      zval *offset;
 +
 +      SAVE_OPLINE();
 +      container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 +      offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 +
 +      if (Z_TYPE_P(container) == IS_OBJECT) {
 +              if (Z_OBJ_HT_P(container)->has_property) {
 +                      result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC);
 +              } else {
 +                      zend_error(E_NOTICE, "Trying to check property of non-object");
 +                      result = 0;
 +              }
 +              if ((opline->extended_value & ZEND_ISSET) == 0) {
 +                      result = !result;
 +              }
 +      } else {
 +              result = ((opline->extended_value & ZEND_ISSET) == 0);
 +      }
 +
 +      ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +      zval_dtor(free_op1.var);
 +      CHECK_EXCEPTION();
 +      ZEND_VM_NEXT_OPCODE();
 +}
 +
  static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
  {
        USE_OPLINE

diff --cc ext/opcache/Optimizer/pass1_5.c
Simple merge

diff --cc ext/opcache/zend_accelerator_util_funcs.c
index 0639e353cd6022cacb46943e34a1afd992de25db,46eb03ee47ca5d5f8bc6abd2b1782453dea31914..e9bb7a15e90553a7eebd79796144ee92eddf9faf
--- 1/ext/opcache/zend_accelerator_util_funcs.c
--- 2/ext/opcache/zend_accelerator_util_funcs.c
+++ b/ext/opcache/zend_accelerator_util_funcs.c
@@@ -305,44 -305,28 +305,44 @@@ static inline void zend_clone_zval(zva
  
  static zend_ast *zend_ast_clone(zend_ast *ast TSRMLS_DC)
  {
-       zend_uint i;
 -      int i;
 -      zend_ast *node;
 -
 -      if (ast->kind == ZEND_CONST) {
 -              node = emalloc(sizeof(zend_ast) + sizeof(zval));
 -              node->kind = ZEND_CONST;
 -              node->children = 0;
 -              ZVAL_COPY_VALUE(&node->u.val, &ast->u.val);
 -              zend_clone_zval(&node->u.val, 0 TSRMLS_CC);
++      uint32_t i;
 +
 +      if (ast->kind == ZEND_AST_ZVAL) {
 +              zend_ast_zval *copy = emalloc(sizeof(zend_ast_zval));
 +              copy->kind = ZEND_AST_ZVAL;
 +              copy->attr = ast->attr;
 +              ZVAL_COPY_VALUE(&copy->val, zend_ast_get_zval(ast));
 +              zend_clone_zval(&copy->val, 0 TSRMLS_CC);
 +              return (zend_ast *) copy;
 +      } else if (zend_ast_is_list(ast)) {
 +              zend_ast_list *list = zend_ast_get_list(ast);
 +              zend_ast_list *copy = emalloc(
 +                      sizeof(zend_ast_list) + sizeof(zend_ast *) * (list->children - 1));
 +              copy->kind = list->kind;
 +              copy->attr = list->attr;
 +              copy->children = list->children;
 +              for (i = 0; i < list->children; i++) {
 +                      if (list->child[i]) {
 +                              copy->child[i] = zend_ast_clone(list->child[i] TSRMLS_CC);
 +                      } else {
 +                              copy->child[i] = NULL;
 +                      }
 +              }
 +              return (zend_ast *) copy;
        } else {
-               zend_uint children = zend_ast_get_num_children(ast);
 -              node = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
 -              node->kind = ast->kind;
 -              node->children = ast->children;
 -              for (i = 0; i < ast->children; i++) {
 -                      if ((&ast->u.child)[i]) {
 -                              (&node->u.child)[i] = zend_ast_clone((&ast->u.child)[i] TSRMLS_CC);
++              uint32_t children = zend_ast_get_num_children(ast);
 +              zend_ast *copy = emalloc(sizeof(zend_ast) + sizeof(zend_ast *) * (children - 1));
 +              copy->kind = ast->kind;
 +              copy->attr = ast->attr;
 +              for (i = 0; i < children; i++) {
 +                      if (ast->child[i]) {
 +                              copy->child[i] = zend_ast_clone(ast->child[i] TSRMLS_CC);
                        } else {
 -                              (&node->u.child)[i] = NULL;
 +                              copy->child[i] = NULL;
                        }
                }
 +              return copy;
        }
 -      return node;
  }
  
  static void zend_hash_clone_zval(HashTable *ht, HashTable *source, int bind)

diff --cc ext/opcache/zend_persist.c
index cbe7d4dcca085e4c79e07784af3bf969fc40b838,2427cfdec8fb060ed13eb8e0b2202aa43d8f5467..5e290745bd20249bf21b1dcf4271613d1af55b2e
--- 1/ext/opcache/zend_persist.c
--- 2/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@@ -144,29 -144,17 +144,29 @@@ static void zend_hash_persist_immutable
  
  static zend_ast *zend_persist_ast(zend_ast *ast TSRMLS_DC)
  {
-       zend_uint i;
 -      int i;
++      uint32_t i;
        zend_ast *node;
  
 -      if (ast->kind == ZEND_CONST) {
 -              node = zend_accel_memdup(ast, sizeof(zend_ast));
 -              zend_persist_zval(&node->u.val TSRMLS_CC);
 +      if (ast->kind == ZEND_AST_ZVAL) {
 +              zend_ast_zval *copy = zend_accel_memdup(ast, sizeof(zend_ast_zval));
 +              zend_persist_zval(&copy->val TSRMLS_CC);
 +              node = (zend_ast *) copy;
 +      } else if (zend_ast_is_list(ast)) {
 +              zend_ast_list *list = zend_ast_get_list(ast);
 +              zend_ast_list *copy = zend_accel_memdup(ast,
 +                      sizeof(zend_ast_list) + sizeof(zend_ast *) * (list->children - 1));
 +              for (i = 0; i < list->children; i++) {
 +                      if (copy->child[i]) {
 +                              copy->child[i] = zend_persist_ast(copy->child[i] TSRMLS_CC);
 +                      }
 +              }
 +              node = (zend_ast *) copy;
        } else {
-               zend_uint children = zend_ast_get_num_children(ast);
 -              node = zend_accel_memdup(ast, sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
 -              for (i = 0; i < ast->children; i++) {
 -                      if ((&node->u.child)[i]) {
 -                              (&node->u.child)[i] = zend_persist_ast((&node->u.child)[i] TSRMLS_CC);
++              uint32_t children = zend_ast_get_num_children(ast);
 +              node = zend_accel_memdup(ast, sizeof(zend_ast) + sizeof(zend_ast *) * (children - 1));
 +              for (i = 0; i < children; i++) {
 +                      if (node->child[i]) {
 +                              node->child[i] = zend_persist_ast(node->child[i] TSRMLS_CC);
                        }
                }
        }

diff --cc ext/opcache/zend_persist_calc.c
index b1f90c9ff5eb673008ccca254002be18bcdb7863,1328213397c23e5f94d8f473bf40db30887461cd..989195119c89cc2bbdd07cb3b4f480fb7fcc02b1
--- 1/ext/opcache/zend_persist_calc.c
--- 2/ext/opcache/zend_persist_calc.c
+++ b/ext/opcache/zend_persist_calc.c
@@@ -83,26 -83,17 +83,26 @@@ static uint zend_hash_persist_calc(Hash
  
  static uint zend_persist_ast_calc(zend_ast *ast TSRMLS_DC)
  {
-       zend_uint i;
 -      int i;
++      uint32_t i;
        START_SIZE();
  
 -      if (ast->kind == ZEND_CONST) {
 -              ADD_SIZE(sizeof(zend_ast));
 -              ADD_SIZE(zend_persist_zval_calc(&ast->u.val TSRMLS_CC));
 +      if (ast->kind == ZEND_AST_ZVAL) {
 +              ADD_SIZE(sizeof(zend_ast_zval));
 +              ADD_SIZE(zend_persist_zval_calc(zend_ast_get_zval(ast) TSRMLS_CC));
 +      } else if (zend_ast_is_list(ast)) {
 +              zend_ast_list *list = zend_ast_get_list(ast);
 +              ADD_SIZE(sizeof(zend_ast_list) + sizeof(zend_ast *) * (list->children - 1));
 +              for (i = 0; i < list->children; i++) {
 +                      if (list->child[i]) {
 +                              ADD_SIZE(zend_persist_ast_calc(list->child[i] TSRMLS_CC));
 +                      }
 +              }
        } else {
-               zend_uint children = zend_ast_get_num_children(ast);
 -              ADD_SIZE(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
 -              for (i = 0; i < ast->children; i++) {
 -                      if ((&ast->u.child)[i]) {
 -                              ADD_SIZE(zend_persist_ast_calc((&ast->u.child)[i] TSRMLS_CC));
++              uint32_t children = zend_ast_get_num_children(ast);
 +              ADD_SIZE(sizeof(zend_ast) + sizeof(zend_ast *) * (children - 1));
 +              for (i = 0; i < children; i++) {
 +                      if (ast->child[i]) {
 +                              ADD_SIZE(zend_persist_ast_calc(ast->child[i] TSRMLS_CC));
                        }
                }
        }