Add zval types.

Author: jmjoy

Cargo.toml

@@ -8,5 +8,5 @@ members = [
 
     # internal
     "examples/simple",
-    "examples/class",
+#    "examples/class",
 ]

examples/simple/src/lib.rs

@@ -7,7 +7,7 @@ use phper::zend::api::FunctionEntries;
 use phper::zend::compile::InternalArgInfos;
 use phper::zend::ini::IniEntryDefs;
 use phper::zend::modules::ModuleEntry;
-use phper::zend::types::{ExecuteData, Val};
+use phper::zend::types::{ExecuteData, Val, SetVal, Value};
 use phper::{
     php_function, php_minit, php_minit_function, php_mshutdown, php_mshutdown_function,
     php_rinit_function, php_rshutdown_function,
@@ -66,12 +66,7 @@ fn m_info_simple(zend_module: *mut ::phper::sys::zend_module_entry) {
 }
 
 #[php_function]
-pub fn test_simple(execute_data: ExecuteData, return_value: Val) {
-    println!(
-        "zif_test_simple success, num args: {}",
-        execute_data.num_args()
-    );
-
+pub fn test_simple(execute_data: ExecuteData) -> impl SetVal {
     let mut a: *const c_char = null_mut();
     let mut a_len = 0;
     let mut b: *const c_char = null_mut();
@@ -87,14 +82,14 @@ pub fn test_simple(execute_data: ExecuteData, return_value: Val) {
             &mut b_len,
         ) != ZEND_RESULT_CODE_SUCCESS
         {
-            return;
+            return Value::Null;
         }
 
-        println!(
-            "echo param, a: {:?}, b: {:?}",
-            CStr::from_ptr(a).to_str(),
-            CStr::from_ptr(b).to_str()
-        );
+        Value::String(format!(
+            "(a . b) = {}{}",
+            CStr::from_ptr(a).to_str().unwrap(),
+            CStr::from_ptr(b).to_str().unwrap(),
+        ))
     }
 }
 

examples/simple/tests/confirm_compiled.php

@@ -4,6 +4,5 @@
 ini_set("display_startup_errors", "On");
 error_reporting(E_ALL);
 
-$functions = get_extension_funcs('simple');
-var_dump($functions);
+var_dump(get_extension_funcs('simple'));
 var_dump(test_simple("aaa", "bbb"));

phper-macros/src/inner.rs

@@ -92,11 +92,9 @@ pub(crate) fn php_function(_attr: TokenStream, input: TokenStream) -> TokenStrea
             fn internal(#inputs) #ret {
                 #body
             }
-            let internal: fn(::phper::zend::types::ExecuteData, ::phper::zend::types::Val) = internal;
-            internal(
-                ::phper::zend::types::ExecuteData::from_raw(execute_data),
-                ::phper::zend::types::Val::from_raw(return_value),
-            );
+            // let internal: fn(::phper::zend::types::ExecuteData) -> impl ::phper::zend::types::SetVal = internal;
+            let value = internal(::phper::zend::types::ExecuteData::from_raw(execute_data));
+            ::phper::zend::types::SetVal::set_val(value, &mut ::phper::zend::types::Val::from_raw(return_value));
         }
     };
 

phper-sys/php_wrapper.c

@@ -20,4 +20,8 @@ void phper_zval_string(zval *return_value, const char *s) {
 
 zend_uchar phper_zval_get_type(const zval* pz) {
     return zval_get_type(pz);
+}
+
+void phper_zval_stringl(zval *return_value, const char *s, size_t len) {
+    ZVAL_STRINGL(return_value, s, len);
 }

phper-sys/php_wrapper.h

@@ -10,5 +10,6 @@ zend_string *zend_new_interned_string_(zend_string *str);
 zend_class_entry phper_init_class_entry(const char *class_name, const zend_function_entry *functions);
 void phper_zval_string(zval *return_value, const char *s);
 zend_uchar phper_zval_get_type(const zval* pz);
+void phper_zval_stringl(zval *return_value, const char *s, size_t len);
 
 #endif //PHPER_PHP_WRAPPER_H

phper/src/zend/types.rs

@@ -1,5 +1,6 @@
-use crate::sys::{zend_execute_data, zval, zend_type, phper_zval_get_type, IS_STRING};
+use crate::sys::{zend_execute_data, zval, zend_type, phper_zval_get_type, IS_STRING, IS_NULL, IS_TRUE, IS_FALSE, phper_zval_stringl};
 use std::ffi::CStr;
+use std::borrow::Cow;
 
 pub struct ExecuteData {
     raw: *mut zend_execute_data,
@@ -32,14 +33,31 @@ impl ExecuteData {
     }
 }
 
+#[repr(u32)]
+pub enum ValType {
+    UNDEF	 =      crate::sys::IS_UNDEF,
+    NULL	=	    crate::sys::IS_NULL,
+    FALSE	=       crate::sys::IS_FALSE,
+    TRUE	=	    crate::sys::IS_TRUE,
+    LONG	=	    crate::sys::IS_LONG,
+    DOUBLE	=       crate::sys::IS_DOUBLE,
+    STRING	=       crate::sys::IS_STRING,
+    ARRAY	=       crate::sys::IS_ARRAY,
+    OBJECT	=       crate::sys::IS_OBJECT,
+    RESOURCE =	    crate::sys::IS_RESOURCE,
+    REFERENCE =     crate::sys::IS_REFERENCE,
+}
+
 pub struct Val {
     raw: *mut zval,
 }
 
 impl Val {
     #[inline]
     pub fn from_raw(val: *mut zval) -> Self {
-        Self { raw: val }
+        Self {
+            raw: val,
+        }
     }
 
     pub fn get(&self) -> *mut zval {
@@ -55,4 +73,66 @@ impl Val {
             }
         }
     }
+
+    unsafe fn type_info(&mut self) -> &mut u32 {
+        &mut (*self.raw).u1.type_info
+    }
 }
+
+pub trait SetVal {
+    fn set_val(self, val: &mut Val);
+}
+
+impl SetVal for () {
+    fn set_val(self, val: &mut Val) {
+        unsafe {
+            *val.type_info() = IS_NULL;
+        }
+    }
+}
+
+impl SetVal for bool {
+    fn set_val(self, val: &mut Val) {
+        unsafe {
+            *val.type_info() = if self {
+                IS_TRUE
+            } else {
+                IS_FALSE
+            };
+        }
+    }
+}
+
+impl SetVal for &str {
+    fn set_val(self, val: &mut Val) {
+        unsafe {
+            phper_zval_stringl(val.raw, self.as_ptr().cast(), self.len());
+        }
+    }
+}
+
+impl SetVal for String {
+    fn set_val(self, val: &mut Val) {
+        unsafe {
+            phper_zval_stringl(val.raw, self.as_ptr().cast(), self.len());
+        }
+    }
+}
+
+pub enum Value<'a> {
+    Null,
+    Bool(bool),
+    Str(&'a str),
+    String(String),
+}
+
+impl SetVal for Value<'_> {
+    fn set_val(self, val: &mut Val) {
+        match self {
+            Value::Null => ().set_val(val),
+            Value::Bool(b) => b.set_val(val),
+            Value::Str(s) => s.set_val(val),
+            Value::String(s) => s.set_val(val),
+        }
+    }
+}