interned strings

[m6w6/ext-psi] / src / call.c

diff --git a/src/call.c b/src/call.c
index 9b6f79f32c3af14382df03cac252fb86077c7552..22516c77cf7f2280d627fc6bffbd745f9b19868b 100644 (file)
--- a/src/call.c
+++ b/src/call.c
@@ -159,9 +159,9 @@ struct psi_call_frame_symbol *psi_call_frame_fetch_symbol(
                struct psi_call_frame *frame, struct psi_decl_var *dvar) {
        struct psi_call_frame_symbol *frame_sym;
 
-       frame_sym = zend_hash_str_find_ptr(&frame->symbols, dvar->fqn, strlen(dvar->fqn));
+       frame_sym = zend_hash_find_ptr(&frame->symbols, dvar->fqn);
        if (!frame_sym) {
-               frame_sym = zend_hash_str_add_ptr(&frame->symbols, dvar->fqn, strlen(dvar->fqn),
+               frame_sym = zend_hash_add_ptr(&frame->symbols, dvar->fqn,
                                psi_call_frame_symbol_init(dvar));
        }
        return frame_sym;
@@ -173,17 +173,16 @@ zval *psi_call_frame_new_argument(struct psi_call_frame *frame,
                /* varargs are just appended with numeric indices */
                return zend_hash_next_index_insert_ptr(&frame->arguments, frame_arg);
        } else {
-               return zend_hash_str_add_ptr(&frame->arguments,
-                               frame_arg->spec->var->name, strlen(frame_arg->spec->var->name),
-                               frame_arg);
+               return zend_hash_add_ptr(&frame->arguments,
+                               frame_arg->spec->var->name, frame_arg);
        }
 }
 
 zval *psi_call_frame_sub_argument(struct psi_call_frame *frame,
-               struct psi_impl_var *inner_var, zval *outer_zval, const char *name) {
+               struct psi_impl_var *inner_var, zval *outer_zval, zend_string *name) {
        struct psi_call_frame_argument *iarg;
        zval *inner_zval = zend_symtable_str_find(Z_ARRVAL_P(outer_zval),
-                       &inner_var->name[1], strlen(&inner_var->name[1]));
+                       &inner_var->name->val[1], inner_var->name->len - 1);
 
        if (!inner_zval) {
                zval empty_zval;
@@ -191,7 +190,7 @@ zval *psi_call_frame_sub_argument(struct psi_call_frame *frame,
                SEPARATE_ZVAL(outer_zval);
                ZVAL_NULL(&empty_zval);
                inner_zval = zend_symtable_str_update(Z_ARRVAL_P(outer_zval),
-                               &inner_var->name[1], strlen(&inner_var->name[1]),
+                               &inner_var->name->val[1], inner_var->name->len - 1,
                                &empty_zval);
        }
 
@@ -200,21 +199,23 @@ zval *psi_call_frame_sub_argument(struct psi_call_frame *frame,
        if (!iarg) {
                struct psi_call_frame_argument *frame_arg;
                impl_val empty_val = {0};
+               zend_string *type_str = zend_string_init_interned(ZEND_STRL("mixed"), 1);
                struct psi_impl_arg *carg_spec = psi_impl_arg_init(
-                               psi_impl_type_init(PSI_T_MIXED, "mixed"),
+                               psi_impl_type_init(PSI_T_MIXED, type_str),
                                psi_impl_var_copy(inner_var), NULL);
 
                psi_call_frame_push_auto_ex(frame, carg_spec, (void(*)(void*)) psi_impl_arg_free);
                frame_arg = psi_call_frame_argument_init(carg_spec, &empty_val, inner_zval, 0);
-               zend_hash_str_add_ptr(&frame->arguments, name, strlen(name), frame_arg);
+               zend_hash_add_ptr(&frame->arguments, name, frame_arg);
+               zend_string_release(type_str);
        }
 
        return inner_zval;
 }
 
 struct psi_call_frame_argument *psi_call_frame_get_argument(
-               struct psi_call_frame *frame, const char *name) {
-       return zend_hash_str_find_ptr(&frame->arguments, name, strlen(name));
+               struct psi_call_frame *frame, zend_string *name) {
+       return zend_hash_find_ptr(&frame->arguments, name);
 }
 
 size_t psi_call_frame_num_var_args(struct psi_call_frame *frame) {
@@ -234,6 +235,27 @@ void **psi_call_frame_get_arg_pointers(struct psi_call_frame *frame) {
        return frame->pointers;
 }
 
+void *psi_call_frame_get_rpointer(struct psi_call_frame *frame) {
+       return frame->rpointer;
+}
+
+struct psi_decl *psi_call_frame_get_decl(struct psi_call_frame *frame) {
+       return frame->decl;
+}
+
+struct psi_impl *psi_call_frame_get_impl(struct psi_call_frame *frame) {
+       return frame->impl;
+}
+
+struct psi_context *psi_call_frame_get_context(struct psi_call_frame *frame) {
+       return frame->context;
+}
+
+#if PHP_VERSION_ID < 70300
+#      define PARAM_PROLOGUE(separate) Z_PARAM_PROLOGUE(separate)
+#else
+#      define PARAM_PROLOGUE(separate) Z_PARAM_PROLOGUE(1, separate)
+#endif
 ZEND_RESULT_CODE psi_call_frame_parse_args(struct psi_call_frame *frame,
                zend_execute_data *execute_data) {
        size_t i, argc = psi_plist_count(frame->impl->func->args);
@@ -284,9 +306,9 @@ ZEND_RESULT_CODE psi_call_frame_parse_args(struct psi_call_frame *frame,
                        Z_PARAM_ARRAY_EX(tmp, _optional || iarg->var->reference,
                                        iarg->var->reference);
                } else if (PSI_T_OBJECT == iarg->type->type) {
-                       Z_PARAM_PROLOGUE(iarg->var->reference);
+                       PARAM_PROLOGUE(iarg->var->reference);
                } else if (PSI_T_MIXED == iarg->type->type) {
-                       Z_PARAM_PROLOGUE(iarg->var->reference);
+                       PARAM_PROLOGUE(iarg->var->reference);
                } else if (PSI_T_CALLABLE == iarg->type->type) {
                        zend_fcall_info fci;
                        zend_fcall_info_cache fcc;
@@ -419,36 +441,7 @@ ZEND_RESULT_CODE psi_call_frame_do_assert(struct psi_call_frame *frame, enum psi
 }
 
 void psi_call_frame_do_call(struct psi_call_frame *frame) {
-       size_t va_count = psi_call_frame_num_var_args(frame);
-
-       if (va_count) {
-               void **va_types = ecalloc(va_count, sizeof(void *));
-               size_t i;
-
-               for (i = 0; i < va_count; ++i) {
-                       struct psi_call_frame_argument *frame_arg;
-
-                       frame_arg = psi_call_frame_get_var_argument(frame, i);
-                       va_types[i] = frame->context->ops->query(frame->context,
-                                       PSI_CONTEXT_QUERY_TYPE, &frame_arg->va_type);
-               }
-
-               frame->context->ops->call_va(frame->context,
-                               frame,
-                               frame->decl,
-                               frame->rpointer,
-                               frame->pointers,
-                               va_count,
-                               va_types);
-
-               efree(va_types);
-       } else {
-               frame->context->ops->call(frame->context,
-                               frame,
-                               frame->decl,
-                               frame->rpointer,
-                               frame->pointers);
-       }
+       frame->context->ops->call(frame);
 }
 
 void psi_call_frame_do_callback(struct psi_call_frame *frame, struct psi_call_frame_callback *cbdata)
@@ -554,8 +547,7 @@ void psi_call_frame_free(struct psi_call_frame *frame) {
 
                memcpy(temp, &frame->temp, sizeof(*temp));
                ZVAL_OBJ(&zlocal, psi_object_init_ex(NULL, temp, psi_call_frame_local_auto_dtor));
-               zend_set_local_var_str(frame->impl->func->name,
-                               strlen(frame->impl->func->name), &zlocal, /* force */ 1);
+               zend_set_local_var(frame->impl->func->name, &zlocal, /* force */ 1);
        } else {
                zend_llist_destroy(&frame->temp);
        }