Break change for values, strings, arrays.

Author: jmjoy

examples/hello/src/lib.rs

@@ -9,26 +9,26 @@
 // See the Mulan PSL v2 for more details.
 
 use phper::{
-    arrays::Array,
+    arrays::ZArray,
     classes::{DynamicClass, Visibility},
     functions::Argument,
     ini::{Ini, Policy},
     modules::{Module, ModuleContext},
     objects::Object,
     php_get_module,
-    values::Val,
+    values::ZVal,
 };
 
 fn module_init(_args: ModuleContext) -> bool {
     true
 }
 
-fn say_hello(arguments: &mut [Val]) -> phper::Result<String> {
+fn say_hello(arguments: &mut [ZVal]) -> phper::Result<String> {
     let name = arguments[0].as_string_value()?;
     Ok(format!("Hello, {}!\n", name))
 }
 
-fn throw_exception(_: &mut [Val]) -> phper::Result<()> {
+fn throw_exception(_: &mut [ZVal]) -> phper::Result<()> {
     Err(phper::Error::other("I am sorry"))
 }
 
@@ -57,13 +57,13 @@ pub fn get_module() -> Module {
     module.add_function("hello_throw_exception", throw_exception, vec![]);
     module.add_function(
         "hello_get_all_ini",
-        |_: &mut [Val]| {
-            let mut arr = Array::new();
+        |_: &mut [ZVal]| {
+            let mut arr = ZArray::new();
 
-            let hello_enable = Val::new(Ini::get::<bool>("hello.enable"));
+            let hello_enable = ZVal::new(Ini::get::<bool>("hello.enable"));
             arr.insert("hello.enable", hello_enable);
 
-            let hello_description = Val::new(Ini::get::<String>("hello.description"));
+            let hello_description = ZVal::new(Ini::get::<String>("hello.description"));
             arr.insert("hello.description", hello_description);
 
             arr
@@ -77,7 +77,7 @@ pub fn get_module() -> Module {
     foo_class.add_method(
         "getFoo",
         Visibility::Public,
-        |this: &mut Object<()>, _: &mut [Val]| {
+        |this: &mut Object<()>, _: &mut [ZVal]| {
             let prop = this.get_property("foo");
             Ok::<_, phper::Error>(prop.as_string_value()?)
         },
@@ -86,8 +86,8 @@ pub fn get_module() -> Module {
     foo_class.add_method(
         "setFoo",
         Visibility::Public,
-        |this: &mut Object<()>, arguments: &mut [Val]| -> phper::Result<()> {
-            this.set_property("foo", Val::new(arguments[0].as_string_value()?));
+        |this: &mut Object<()>, arguments: &mut [ZVal]| -> phper::Result<()> {
+            this.set_property("foo", ZVal::new(arguments[0].as_string_value()?));
             Ok(())
         },
         vec![Argument::by_val("foo")],

examples/http-server/src/server.rs

@@ -21,7 +21,7 @@ use phper::{
     classes::{ClassEntry, DynamicClass, StatelessClassEntry, Visibility},
     errors::Error::Throw,
     functions::Argument,
-    values::Val,
+    values::ZVal,
 };
 use std::{convert::Infallible, mem::replace, net::SocketAddr, sync::Arc};
 use tokio::{runtime::Handle, sync::Mutex};
@@ -41,8 +41,8 @@ pub fn make_server_class() -> DynamicClass<Option<Builder<AddrIncoming>>> {
         |this, arguments| {
             let host = arguments[0].to_string()?;
             let port = arguments[1].as_long()?;
-            this.set_property("host", Val::new(&*host));
-            this.set_property("port", Val::new(port));
+            this.set_property("host", ZVal::new(&*host));
+            this.set_property("port", ZVal::new(port));
             let addr = format!("{}:{}", host, port).parse::<SocketAddr>()?;
             let builder = Server::bind(&addr);
             *this.as_mut_state() = Some(builder);
@@ -55,7 +55,7 @@ pub fn make_server_class() -> DynamicClass<Option<Builder<AddrIncoming>>> {
         "onRequest",
         Visibility::Public,
         |this, arguments| {
-            this.set_property("onRequestHandle", Val::new(arguments[0].duplicate()?));
+            this.set_property("onRequestHandle", ZVal::new(arguments[0].duplicate()?));
             Ok::<_, phper::Error>(())
         },
         vec![Argument::by_val("handle")],
@@ -84,14 +84,14 @@ pub fn make_server_class() -> DynamicClass<Option<Builder<AddrIncoming>>> {
                                 let request =
                                     StatelessClassEntry::from_globals(HTTP_REQUEST_CLASS_NAME)?
                                         .new_object([])?;
-                                let request = Val::new(request);
+                                let request = ZVal::new(request);
 
                                 let mut response = ClassEntry::<Response<Body>>::from_globals(
                                     HTTP_RESPONSE_CLASS_NAME,
                                 )?
                                 .new_object([])?;
                                 let response_val = response.duplicate();
-                                let response_val = Val::new(response_val);
+                                let response_val = ZVal::new(response_val);
 
                                 match handle.call([request, response_val]) {
                                     Err(Throw(ex)) => {

examples/logging/src/lib.rs

@@ -10,7 +10,7 @@
 
 use phper::{
     deprecated, echo, error, functions::Argument, modules::Module, notice, php_get_module,
-    values::Val, warning,
+    values::ZVal, warning,
 };
 
 #[php_get_module]
@@ -23,7 +23,7 @@ pub fn get_module() -> Module {
 
     module.add_function(
         "log_say",
-        |params: &mut [Val]| -> phper::Result<()> {
+        |params: &mut [ZVal]| -> phper::Result<()> {
             let message = params[0].as_string_value()?;
             echo!("Hello, {}!", message);
             Ok(())
@@ -33,7 +33,7 @@ pub fn get_module() -> Module {
 
     module.add_function(
         "log_notice",
-        |params: &mut [Val]| -> phper::Result<()> {
+        |params: &mut [ZVal]| -> phper::Result<()> {
             let message = params[0].as_string_value()?;
             notice!("Something happened: {}", message);
             Ok(())
@@ -43,7 +43,7 @@ pub fn get_module() -> Module {
 
     module.add_function(
         "log_warning",
-        |params: &mut [Val]| -> phper::Result<()> {
+        |params: &mut [ZVal]| -> phper::Result<()> {
             let message = params[0].as_string_value()?;
             warning!("Something warning: {}", message);
             Ok(())
@@ -53,7 +53,7 @@ pub fn get_module() -> Module {
 
     module.add_function(
         "log_error",
-        |params: &mut [Val]| -> phper::Result<()> {
+        |params: &mut [ZVal]| -> phper::Result<()> {
             let message = params[0].as_string_value()?;
             error!("Something gone failed: {}", message);
             Ok(())
@@ -63,7 +63,7 @@ pub fn get_module() -> Module {
 
     module.add_function(
         "log_deprecated",
-        |params: &mut [Val]| -> phper::Result<()> {
+        |params: &mut [ZVal]| -> phper::Result<()> {
             let message = params[0].as_string_value()?;
             deprecated!("Something deprecated: {}", message);
             Ok(())

phper-sys/php_wrapper.c

@@ -31,28 +31,24 @@ zend_class_entry phper_init_class_entry_ex(const char *class_name, size_t class_
     return class_container;
 }
 
-void phper_zval_string(zval *return_value, const char *s) {
-    ZVAL_STRING(return_value, s);
-}
-
 zend_uchar phper_zval_get_type(const zval* pz) {
     return zval_get_type(pz);
 }
 
-void phper_zval_arr(zval *return_value, zend_array *arr) {
-    ZVAL_ARR(return_value, arr);
+void phper_zval_arr(zval *val, zend_array *arr) {
+    ZVAL_ARR(val, arr);
 }
 
-void phper_zval_new_arr(zval *return_value) {
+void phper_zval_new_arr(zval *val) {
 #if PHP_VERSION_ID < 80100
-    ZVAL_NEW_ARR(return_value);
+    ZVAL_NEW_ARR(val);
 #else
-    array_init(return_value);
+    array_init(val);
 #endif
 }
 
-void phper_zval_stringl(zval *return_value, const char *s, size_t len) {
-    ZVAL_STRINGL(return_value, s, len);
+void phper_zval_stringl(zval *val, const char *s, size_t len) {
+    ZVAL_STRINGL(val, s, len);
 }
 
 char *phper_z_strval_p(const zval *v) {
@@ -63,20 +59,16 @@ zval *phper_get_this(zend_execute_data *execute_data) {
     return getThis();
 }
 
-void phper_zval_zval(zval *return_value, zval *zv, int copy, int dtor) {
-    ZVAL_ZVAL(return_value, zv, copy, dtor);
-}
-
-void phper_zval_dup(zval *return_value, const zval *zv) {
-    ZVAL_DUP(return_value, zv);
+void phper_zval_zval(zval *val, zval *zv, int copy, int dtor) {
+    ZVAL_ZVAL(val, zv, copy, dtor);
 }
 
-void phper_zval_copy(zval *return_value, zval *zv) {
-    ZVAL_COPY(return_value, zv);
+void phper_zval_copy(zval *val, const zval *zv) {
+    ZVAL_COPY(val, zv);
 }
 
-void phper_zval_copy_value(zval *return_value, zval *zv) {
-    ZVAL_COPY_VALUE(return_value, zv);
+void phper_zval_copy_value(zval *val, const zval *zv) {
+    ZVAL_COPY_VALUE(val, zv);
 }
 
 zend_string *phper_zval_get_string(zval *op) {
@@ -159,8 +151,8 @@ zend_string *phper_get_function_or_method_name(const zend_function *func) {
     #endif
 }
 
-void phper_zval_ptr_dtor(zval *pDest) {
-    ZVAL_PTR_DTOR(pDest);
+void phper_zval_ptr_dtor(zval *zv) {
+    ZVAL_PTR_DTOR(zv);
 }
 
 size_t phper_zend_object_properties_size(zend_class_entry *ce) {
@@ -229,3 +221,47 @@ void *phper_emalloc(size_t size) {
 void phper_efree(void *ptr) {
     return efree(ptr);
 }
+
+void phper_separate_string(zval *zv) {
+    SEPARATE_STRING(zv);
+}
+
+void phper_separate_array(zval *zv) {
+    SEPARATE_ARRAY(zv);
+}
+
+void phper_zval_null(zval *zv) {
+    ZVAL_NULL(zv);
+}
+
+void phper_zval_true(zval *zv) {
+    ZVAL_TRUE(zv);
+}
+
+void phper_zval_false(zval *zv) {
+    ZVAL_FALSE(zv);
+}
+
+void phper_zval_long(zval *zv, zend_long l) {
+    ZVAL_LONG(zv, l);
+}
+
+void phper_zval_double(zval *zv, double d) {
+    ZVAL_DOUBLE(zv, d);
+}
+
+int phper_z_type_info_p(zval *zv) {
+    return Z_TYPE_INFO_P(zv);
+}
+
+int phper_z_type_p(zval *zv) {
+    return Z_TYPE_P(zv);
+}
+
+void phper_zval_str(zval *zv, zend_string *s) {
+    ZVAL_STR(zv, s);
+}
+
+zend_array *phper_zend_new_array(uint32_t nSize) {
+    return zend_new_array(nSize);
+}

phper/build.rs

@@ -8,6 +8,17 @@
 // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 // See the Mulan PSL v2 for more details.
 
+use phper_sys::*;
+
 fn main() {
     phper_build::register_configures();
+    assert_eq!(
+        PHP_DEBUG, 0,
+        "PHPER not support DEBUG mode now (php built with `--enable-debug`)."
+    );
+    assert_eq!(
+        USING_ZTS, 0,
+        "PHPER not support ZTS mode now (php built with `--enable-maintainer-zts` or \
+         `--enable-zts`)."
+    );
 }