Add zend_add_literal_string

And simplify additional of special literals based on it.

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 95db9a759a481d5e425d6e181abd8a08d9497d38..4c51bb4b989ba37bac3ff0c0c258b7eacfe4d47f 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -319,45 +319,44 @@ int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static int zend_add_func_name_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
+static inline int zend_add_literal_string(zend_op_array *op_array, zend_string **str TSRMLS_DC) /* {{{ */
 {
-       zend_string *lc_name;
-       zval c;
+       int ret;
+       zval zv;
+       ZVAL_STR(&zv, *str);
+       ret = zend_add_literal(op_array, &zv TSRMLS_CC);
+       *str = Z_STR(zv);
+       return ret;
+}
 
-       int ret = zend_add_literal(op_array, zv TSRMLS_CC);
+static int zend_add_func_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) /* {{{ */
+{
+       int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
 
-       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);
+       zend_string *lc_name = zend_string_alloc(name->len, 0);
+       zend_str_tolower_copy(lc_name->val, name->val, name->len);
+       zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
 
        return ret;
 }
 /* }}} */
 
-static int zend_add_ns_func_name_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
+static int zend_add_ns_func_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) /* {{{ */
 {
-       zend_string *lc_name;
        const char *ns_separator;
-       int lc_len;
-       zval c;
-
-       int ret = zend_add_literal(op_array, zv TSRMLS_CC);
 
-       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);
+       int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
 
-       ns_separator = (const char*)zend_memrchr(Z_STRVAL_P(zv), '\\', Z_STRLEN_P(zv));
+       zend_string *lc_name = zend_string_alloc(name->len, 0);
+       zend_str_tolower_copy(lc_name->val, name->val, name->len);
+       zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
 
+       ns_separator = zend_memrchr(name->val, '\\', name->len);
        if (ns_separator != NULL) {
-               ns_separator += 1;
-               lc_len = Z_STRLEN_P(zv) - (ns_separator - Z_STRVAL_P(zv));
-               lc_name = zend_string_alloc(lc_len, 0);
-               zend_str_tolower_copy(lc_name->val, ns_separator, lc_len);
-               ZVAL_NEW_STR(&c, lc_name);
-               zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
+               size_t len = name->len - (ns_separator - name->val + 1);
+               lc_name = zend_string_alloc(len, 0);
+               zend_str_tolower_copy(lc_name->val, ns_separator + 1, len);
+               zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
        }
 
        return ret;
@@ -366,20 +365,11 @@ static int zend_add_ns_func_name_literal(zend_op_array *op_array, zval *zv TSRML
 
 static int zend_add_class_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) /* {{{ */
 {
-       int ret;
-       zend_string *lc_name;
-
-       zval zv;
-       ZVAL_STR(&zv, name);
-
-       ret = zend_add_literal(op_array, &zv TSRMLS_CC);
-       name = Z_STR(zv); /* Load new name string in case it was interned */
+       int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
 
-       lc_name = zend_string_alloc(name->len, 0);
+       zend_string *lc_name = zend_string_alloc(name->len, 0);
        zend_str_tolower_copy(lc_name->val, name->val, name->len);
-
-       ZVAL_NEW_STR(&zv, lc_name);
-       zend_add_literal(CG(active_op_array), &zv TSRMLS_CC);
+       zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
 
        zend_alloc_cache_slot(ret TSRMLS_CC);
 
@@ -387,58 +377,44 @@ static int zend_add_class_name_literal(zend_op_array *op_array, zend_string *nam
 }
 /* }}} */
 
-static int zend_add_const_name_literal(zend_op_array *op_array, zval *zv, int unqualified TSRMLS_DC) /* {{{ */
+static int zend_add_const_name_literal(zend_op_array *op_array, zend_string *name, zend_bool unqualified TSRMLS_DC) /* {{{ */
 {
-       char *name;
        zend_string *tmp_name;
-       const char *ns_separator;
-       int name_len, ns_len;
-       zval c;
 
-       int ret = zend_add_literal(op_array, zv TSRMLS_CC);
+       int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
 
-       name_len = Z_STRLEN_P(zv);
-       name = Z_STRVAL_P(zv);
-       ns_separator = zend_memrchr(name, '\\', name_len);
-       if (ns_separator) {
-               ns_len = ns_separator - name;
-       } else {
-               ns_len = 0;
-       }
+       size_t ns_len = 0, after_ns_len = name->len;
+       const char *after_ns = zend_memrchr(name->val, '\\', name->len);
+       if (after_ns) {
+               after_ns += 1;
+               ns_len = after_ns - name->val - 1;
+               after_ns_len = name->len - ns_len - 1;
 
-       if (ns_len) {
                /* lowercased namespace name & original constant name */
-               tmp_name = zend_string_init(name, name_len, 0);
+               tmp_name = zend_string_init(name->val, name->len, 0);
                zend_str_tolower(tmp_name->val, ns_len);
-               ZVAL_NEW_STR(&c, tmp_name);
-               zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
+               zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
 
                /* lowercased namespace name & lowercased constant name */
-               tmp_name = zend_string_alloc(name_len, 0);
-               zend_str_tolower_copy(tmp_name->val, name, name_len);
-               ZVAL_NEW_STR(&c, tmp_name);
-               zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-       }
+               tmp_name = zend_string_alloc(name->len, 0);
+               zend_str_tolower_copy(tmp_name->val, name->val, name->len);
+               zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
 
-       if (ns_len) {
                if (!unqualified) {
                        return ret;
                }
-               ns_len++;
-               name += ns_len;
-               name_len -= ns_len;
+       } else {
+               after_ns = name->val;
        }
 
-       /* original constant name */
-       tmp_name = zend_string_init(name, name_len, 0);
-       ZVAL_NEW_STR(&c, tmp_name);
-       zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
+       /* original unqualified constant name */
+       tmp_name = zend_string_init(after_ns, after_ns_len, 0);
+       zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
 
-       /* lowercased constant name */
-       tmp_name = zend_string_alloc(name_len, 0);
-       zend_str_tolower_copy(tmp_name->val, name, name_len);
-       ZVAL_NEW_STR(&c, tmp_name);
-       zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
+       /* lowercased unqualified constant name */
+       tmp_name = zend_string_alloc(after_ns_len, 0);
+       zend_str_tolower_copy(tmp_name->val, after_ns, after_ns_len);
+       zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
 
        return ret;
 }
@@ -1197,14 +1173,12 @@ static zend_constant *zend_get_ct_const(zend_string *name, int all_internal_cons
 }
 /* }}} */
 
-static int zend_constant_ct_subst(znode *result, zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
+static int zend_constant_ct_subst(zval *result, zend_string *name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
 {
-       zend_constant *c = zend_get_ct_const(Z_STR_P(const_name),
-               all_internal_constants_substitution TSRMLS_CC);
+       zend_constant *c = zend_get_ct_const(name, all_internal_constants_substitution TSRMLS_CC);
 
        if (c) {
-               result->op_type = IS_CONST;
-               ZVAL_DUP(&result->u.constant, &c->value);
+               ZVAL_DUP(result, &c->value);
                return 1;
        }
        return 0;
@@ -2564,7 +2538,7 @@ void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args_ast TS
        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);
+               CG(active_op_array), Z_STR(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);
@@ -2578,8 +2552,8 @@ void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_a
        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);
+               opline->op2.constant = zend_add_func_name_literal(CG(active_op_array),
+                       Z_STR(name_node->u.constant) TSRMLS_CC);
                zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
        } else {
                SET_NODE(opline->op2, name_node);
@@ -2891,8 +2865,8 @@ void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type TSRMLS
                }
 
                opline->op2_type = IS_CONST;
-               opline->op2.constant =
-                       zend_add_func_name_literal(CG(active_op_array), &method_node.u.constant TSRMLS_CC);
+               opline->op2.constant = zend_add_func_name_literal(CG(active_op_array),
+                       Z_STR(method_node.u.constant) TSRMLS_CC);
                zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
        } else {
                SET_NODE(opline->op2, &method_node);
@@ -2946,8 +2920,8 @@ void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type TSRMLS
 
        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);
+               opline->op2.constant = zend_add_func_name_literal(CG(active_op_array),
+                       Z_STR(method_node.u.constant) TSRMLS_CC);
                if (opline->op1_type == IS_CONST) {
                        zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
                } else {
@@ -5616,17 +5590,17 @@ void zend_compile_array(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 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));
+       zend_bool is_fully_qualified;
+       zend_string *orig_name = zend_ast_get_str(name_ast);
+       zend_string *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);
+       if (zend_constant_ct_subst(&result->u.constant, resolved_name, 1 TSRMLS_CC)) {
+               result->op_type = IS_CONST;
+               zend_string_release(resolved_name);
                return;
        }
 
@@ -5635,16 +5609,16 @@ void zend_compile_const(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 
        if (is_fully_qualified) {
                opline->op2.constant = zend_add_const_name_literal(
-                       CG(active_op_array), &resolved_name, 0 TSRMLS_CC);
+                       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);
+                               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);
+                               CG(active_op_array), resolved_name, 0 TSRMLS_CC);
                }
        }
        zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
@@ -5856,20 +5830,19 @@ 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_string *orig_name = zend_ast_get_str(name_ast);
        zend_bool is_fully_qualified;
 
-       znode result;
-       zval resolved_name;
+       zval result, 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);
+               *ast_ptr = zend_ast_create_zval(&result);
                return;
        }
 
        ZVAL_STR(&resolved_name, zend_resolve_const_name(
-               Z_STR_P(orig_name), name_ast->attr, &is_fully_qualified TSRMLS_CC));
+               orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC));
 
        Z_TYPE_INFO(resolved_name) = IS_CONSTANT_EX;
        if (!is_fully_qualified) {
@@ -6351,16 +6324,11 @@ void zend_eval_const_expr(zend_ast **ast_ptr TSRMLS_DC) /* {{{ */
                                return;
                        }
                        break;
-               case ZEND_AST_CONST: {
-                       znode result_node;
-
-                       if (!zend_constant_ct_subst(&result_node, zend_ast_get_zval(ast->child[0]), 0 TSRMLS_CC)) {
+               case ZEND_AST_CONST:
+                       if (!zend_constant_ct_subst(&result, zend_ast_get_str(ast->child[0]), 0 TSRMLS_CC)) {
                                return;
                        }
-                       zend_ast_destroy(ast);
-                       *ast_ptr = zend_ast_create_zval(&result_node.u.constant);
-                       return;
-               }
+                       break;
                default:
                        return;
        }