Remove (&ast->u.child)[i] weirdness

diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index 7a9547b475a6324adee809b975a321ea4c3f9efb..82bf42b0d2436bd678d1c51b0d98e622bd7ff472 100644 (file)
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -25,11 +25,11 @@
 
 ZEND_API zend_ast *zend_ast_create_constant(zval *zv)
 {
-       zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zval));
+       zend_ast_zval *ast = emalloc(sizeof(zend_ast_zval));
        ast->kind = ZEND_CONST;
        ast->children = 0;
-       ZVAL_COPY_VALUE(&ast->u.val, zv);
-       return ast;
+       ZVAL_COPY_VALUE(&ast->val, zv);
+       return (zend_ast *) ast;
 }
 
 ZEND_API zend_ast* zend_ast_create_unary(uint kind, zend_ast *op0)
@@ -37,50 +37,55 @@ ZEND_API zend_ast* zend_ast_create_unary(uint kind, zend_ast *op0)
        zend_ast *ast = emalloc(sizeof(zend_ast));
        ast->kind = kind;
        ast->children = 1;
-       (&ast->u.child)[0] = op0;
+       ast->child[0] = op0;
        return 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*));
+       zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast *));
        ast->kind = kind;
        ast->children = 2;
-       (&ast->u.child)[0] = op0;
-       (&ast->u.child)[1] = op1;
+       ast->child[0] = op0;
+       ast->child[1] = op1;
        return ast;
 }
 
 ZEND_API zend_ast* zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *op1, zend_ast *op2)
 {
-       zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * 2);
+       zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast *) * 2);
        ast->kind = kind;
        ast->children = 3;
-       (&ast->u.child)[0] = op0;
-       (&ast->u.child)[1] = op1;
-       (&ast->u.child)[2] = op2;
+       ast->child[0] = op0;
+       ast->child[1] = op1;
+       ast->child[2] = op2;
        return ast;
 }
 
 ZEND_API zend_ast* zend_ast_create_dynamic(uint kind)
 {
-       zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * 3); /* use 4 children as deafult */
+       /* use 4 children as default */
+       zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast *) * 3);
        ast->kind = kind;
        ast->children = 0;
        return ast;
 }
 
+static inline zend_bool is_power_of_two(unsigned short n) {
+       return n == (n & -n);
+}
+
 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));
+       if ((*ast)->children >= 4 && is_power_of_two((*ast)->children)) {
+               *ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast *) * ((*ast)->children * 2 - 1));
        }
-       (&(*ast)->u.child)[(*ast)->children++] = op;
+       (*ast)->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));
+       *ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast *) * ((*ast)->children - 1));
 }
 
 ZEND_API int zend_ast_is_ct_constant(zend_ast *ast)
@@ -88,11 +93,11 @@ ZEND_API int zend_ast_is_ct_constant(zend_ast *ast)
        int i;
 
        if (ast->kind == ZEND_CONST) {
-               return !Z_CONSTANT(ast->u.val);
+               return !Z_CONSTANT_P(zend_ast_get_zval(ast));
        } else {
                for (i = 0; i < ast->children; i++) {
-                       if ((&ast->u.child)[i]) {
-                               if (!zend_ast_is_ct_constant((&ast->u.child)[i])) {
+                       if (ast->child[i]) {
+                               if (!zend_ast_is_ct_constant(ast->child[i])) {
                                        return 0;
                                }
                        }
@@ -139,158 +144,158 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
 
        switch (ast->kind) {
                case ZEND_ADD:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        add_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_SUB:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        sub_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_MUL:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        mul_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_POW:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        pow_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_DIV:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        div_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_MOD:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        mod_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_SL:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        shift_left_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_SR:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        shift_right_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_CONCAT:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        concat_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_BW_OR:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        bitwise_or_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_BW_AND:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        bitwise_and_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_BW_XOR:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        bitwise_xor_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_BW_NOT:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
                        bitwise_not_function(result, &op1 TSRMLS_CC);
                        zval_dtor(&op1);
                        break;
                case ZEND_BOOL_NOT:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
                        boolean_not_function(result, &op1 TSRMLS_CC);
                        zval_dtor(&op1);
                        break;
                case ZEND_BOOL_XOR:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        boolean_xor_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_IS_IDENTICAL:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        is_identical_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_IS_NOT_IDENTICAL:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        is_not_identical_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_IS_EQUAL:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        is_equal_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_IS_NOT_EQUAL:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        is_not_equal_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_IS_SMALLER:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        is_smaller_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_IS_SMALLER_OR_EQUAL:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                        is_smaller_or_equal_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op1);
                        zval_dtor(&op2);
                        break;
                case ZEND_CONST:
-                       ZVAL_DUP(result, &ast->u.val);
+                       ZVAL_DUP(result, zend_ast_get_zval(ast));
                        if (Z_OPT_CONSTANT_P(result)) {
                                zval_update_constant_ex(result, 1, scope TSRMLS_CC);
                        }
                        break;
                case ZEND_BOOL_AND:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
                        if (zend_is_true(&op1 TSRMLS_CC)) {
-                               zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                               zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                                ZVAL_BOOL(result, zend_is_true(&op2 TSRMLS_CC));
                                zval_dtor(&op2);
                        } else {
@@ -299,39 +304,39 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
                        zval_dtor(&op1);
                        break;
                case ZEND_BOOL_OR:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
                        if (zend_is_true(&op1 TSRMLS_CC)) {
                                ZVAL_BOOL(result, 1);
                        } else {
-                               zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+                               zend_ast_evaluate(&op2, ast->child[1], scope TSRMLS_CC);
                                ZVAL_BOOL(result, zend_is_true(&op2 TSRMLS_CC));
                                zval_dtor(&op2);
                        }
                        zval_dtor(&op1);
                        break;
                case ZEND_SELECT:
-                       zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op1, ast->child[0], scope TSRMLS_CC);
                        if (zend_is_true(&op1 TSRMLS_CC)) {
-                               if (!(&ast->u.child)[1]) {
+                               if (!ast->child[1]) {
                                        *result = op1;
                                } else {
-                                       zend_ast_evaluate(result, (&ast->u.child)[1], scope TSRMLS_CC);
+                                       zend_ast_evaluate(result, ast->child[1], scope TSRMLS_CC);
                                        zval_dtor(&op1);
                                }
                        } else {
-                               zend_ast_evaluate(result, (&ast->u.child)[2], scope TSRMLS_CC);
+                               zend_ast_evaluate(result, ast->child[2], scope TSRMLS_CC);
                                zval_dtor(&op1);
                        }
                        break;
                case ZEND_UNARY_PLUS:
                        ZVAL_LONG(&op1, 0);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[0], scope TSRMLS_CC);
                        add_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op2);
                        break;
                case ZEND_UNARY_MINUS:
                        ZVAL_LONG(&op1, 0);
-                       zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC);
+                       zend_ast_evaluate(&op2, ast->child[0], scope TSRMLS_CC);
                        sub_function(result, &op1, &op2 TSRMLS_CC);
                        zval_dtor(&op2);
                        break;
@@ -340,12 +345,12 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
                        {
                                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);
+                                       if (ast->child[i]) {
+                                               zend_ast_evaluate(&op1, ast->child[i], scope TSRMLS_CC);
                                        } else {
                                                ZVAL_UNDEF(&op1);
                                        }
-                                       zend_ast_evaluate(&op2, (&ast->u.child)[i+1], scope TSRMLS_CC);
+                                       zend_ast_evaluate(&op2, ast->child[i+1], scope TSRMLS_CC);
                                        zend_ast_add_array_element(result, &op1, &op2 TSRMLS_CC);
                                }
                        }
@@ -360,16 +365,16 @@ ZEND_API zend_ast *zend_ast_copy(zend_ast *ast)
        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);
+               zend_ast *copy = zend_ast_create_constant(zend_ast_get_zval(ast));
+               zval_copy_ctor(zend_ast_get_zval(copy));
                return copy;
        } else if (ast->children) {
-               zend_ast *new = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
+               zend_ast *new = emalloc(sizeof(zend_ast) + sizeof(zend_ast *) * (ast->children - 1));
                int i;
                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->child[i] = zend_ast_copy(ast->child[i]);
                }
                return new;
        }
@@ -381,11 +386,11 @@ ZEND_API void zend_ast_destroy(zend_ast *ast)
        int i;
 
        if (ast->kind == ZEND_CONST) {
-               zval_dtor(&ast->u.val);
+               zval_dtor(zend_ast_get_zval(ast));
        } else {
                for (i = 0; i < ast->children; i++) {
-                       if ((&ast->u.child)[i]) {
-                               zend_ast_destroy((&ast->u.child)[i]);
+                       if (ast->child[i]) {
+                               zend_ast_destroy(ast->child[i]);
                        }
                }
        }

diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h
index 8678299f0fabdf35bf49ab2242413fcfc9a90fec..d411e4e802fd67e97dfc924c1f7d2483ce62ae6c 100644 (file)
--- a/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@ -37,12 +37,19 @@ typedef enum _zend_ast_kind {
 struct _zend_ast {
        unsigned short kind;
        unsigned short children;
-       union {
-               zval      val;
-               zend_ast *child;
-       } u;
+       zend_ast *child[1];
 };
 
+typedef struct _zend_ast_zval {
+       unsigned short kind;
+       unsigned short children;
+       zval val;
+} zend_ast_zval;
+
+static inline zval *zend_ast_get_zval(zend_ast *ast) {
+       return &((zend_ast_zval *) ast)->val;
+}
+
 ZEND_API zend_ast *zend_ast_create_constant(zval *zv);
 
 ZEND_API zend_ast *zend_ast_create_unary(uint kind, zend_ast *op0);

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index f5efd841445448e0450ac968a36a99c30fa08a0c..f7adf95ed30d9598ac2f207139533705f21d7a64 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -7478,7 +7478,7 @@ void zend_make_immutable_array_r(zval *zv TSRMLS_DC) /* {{{ */
 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);
+               ZVAL_COPY_VALUE(&result->u.constant, zend_ast_get_zval(ast));
                efree(ast);
        } else if (zend_ast_is_ct_constant(ast)) {
                zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC);