Fixing properties str parse failed.

Author: jmjoy

.github/workflows/ci.yml

@@ -44,7 +44,7 @@ jobs:
       - name: Install Rust
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2020-11-09
+          toolchain: nightly
           override: true
           components: rustfmt, clippy
 
@@ -64,12 +64,13 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
+          args: --release
 
       - name: Cargo test
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: -- --nocapture
+          args: --release -- --nocapture
 
       - name: Cargo doc
         uses: actions-rs/cargo@v1

examples/simple/Makefile.toml

@@ -4,8 +4,8 @@ TARGET_DIR = "${CARGO_MAKE_WORKING_DIRECTORY}/../../target"
 
 [env.development]
 TARGET_BUILD_DIR = "${TARGET_DIR}/debug"
-BUILD_ARGS = ""
-TEST_ARGS = ""
+BUILD_ARGS = "--"
+TEST_ARGS = "--"
 
 [env.production]
 TARGET_BUILD_DIR = "${TARGET_DIR}/release"

examples/simple/src/lib.rs

@@ -12,7 +12,7 @@ use phper::{
         compile::{create_zend_arg_info, MultiInternalArgInfo},
         ini::IniEntries,
         modules::{create_zend_module_entry, ModuleArgs, ModuleEntry},
-        types::{ClassEntry, ExecuteData, SetVal, Val},
+        types::{ClassEntry, ExecuteData, SetVal, Val, Value},
     },
     zend_get_module,
 };
@@ -35,7 +35,7 @@ static INI_ENTRIES: IniEntries<2> = IniEntries::new([
 fn m_init_simple(args: ModuleArgs) -> bool {
     args.register_ini_entries(&INI_ENTRIES);
     MY_CLASS_CE.init(c_str_ptr!("MyClass"), &MY_CLASS_METHODS);
-    MY_CLASS_CE.declare_property("foo", "3", ZEND_ACC_PUBLIC);
+    MY_CLASS_CE.declare_property("foo", "foo", ZEND_ACC_PUBLIC);
     true
 }
 
@@ -131,8 +131,13 @@ pub fn my_class_foo(execute_data: ExecuteData) -> impl SetVal {
             zend_read_property(MY_CLASS_CE.get(), this, c_str_ptr!("foo"), 3, 1, null_mut())
         };
         let foo = Val::from_raw(foo);
-        let foo = foo.as_c_str().unwrap().to_str().unwrap();
-        format!("{}{}", prefix, foo)
+        let value = foo.try_into_value().unwrap();
+
+        if let Value::CStr(foo) = value {
+            Some(format!("{}{}", prefix, foo.to_str().unwrap()))
+        } else {
+            None
+        }
     })
 }
 

examples/simple/tests/php/test.php

@@ -6,7 +6,7 @@
 
 assert_eq(get_extension_funcs('simple'), ["test_simple"]);
 assert_eq(test_simple("aaa", "bbb"), "a = aaa, a_len = 3, b = bbb, b_len = 3");
-assert_eq((new MyClass())->foo("foo-"), "foo-3");
+assert_eq((new MyClass())->foo("bar-"), "bar-foo");
 
 function assert_eq($left, $right) {
     if ($left !== $right) {

phper-sys/php_wrapper.c

@@ -25,3 +25,7 @@ zend_uchar phper_zval_get_type(const zval* pz) {
 void phper_zval_stringl(zval *return_value, const char *s, size_t len) {
     ZVAL_STRINGL(return_value, s, len);
 }
+
+char *phper_z_strval_p(const zval *v) {
+    return Z_STRVAL_P(v);
+}

phper-sys/php_wrapper.h

@@ -12,5 +12,6 @@ zend_class_entry phper_init_class_entry(const char *class_name, const zend_funct
 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);
+char *phper_z_strval_p(const zval *v);
 
 #endif //PHPER_PHP_WRAPPER_H

phper-test/src/lib.rs

@@ -82,7 +82,9 @@ fn php_context() -> &'static Context {
         ini_content.push_str(&read_to_string(ini_file).unwrap());
         for file in ini_files.split(',') {
             let file = file.trim();
-            ini_content.push_str(&read_to_string(file).unwrap());
+            if !file.is_empty() {
+                ini_content.push_str(&read_to_string(file).unwrap());
+            }
         }
 
         Context {

phper/src/error.rs

@@ -1,4 +1,12 @@
+use std::str::Utf8Error;
+
 pub type Result<T> = std::result::Result<T, self::Error>;
 
 #[derive(thiserror::Error, Debug)]
-pub enum Error {}
+pub enum Error {
+    #[error(transparent)]
+    Utf8(#[from] Utf8Error),
+
+    #[error("unknown value type `{0}`")]
+    UnKnownValueType(u32),
+}

phper/src/zend/types.rs

@@ -1,10 +1,10 @@
 use crate::{
     c_str_ptr,
     sys::{
-        phper_init_class_entry, phper_zval_get_type, phper_zval_stringl, zend_class_entry,
-        zend_declare_property, zend_execute_data, zend_parse_parameters,
-        zend_register_internal_class, zend_throw_exception, zval, IS_FALSE, IS_LONG, IS_NULL,
-        IS_STRING, IS_TRUE, ZEND_RESULT_CODE_SUCCESS,
+        self, phper_init_class_entry, phper_z_strval_p, phper_zval_get_type, phper_zval_stringl,
+        zend_class_entry, zend_declare_property, zend_execute_data, zend_parse_parameters,
+        zend_register_internal_class, zend_throw_exception, zval, IS_DOUBLE, IS_FALSE, IS_LONG,
+        IS_NULL, IS_STRING, IS_STRING_EX, IS_TRUE, ZEND_RESULT_CODE_SUCCESS,
     },
     zend::{api::FunctionEntries, exceptions::Throwable},
 };
@@ -309,21 +309,6 @@ fn zend_parse_fixed_parameters(
     b == ZEND_RESULT_CODE_SUCCESS
 }
 
-#[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,
 }
@@ -337,16 +322,8 @@ impl Val {
         self.raw
     }
 
-    pub fn as_c_str(&self) -> Option<&CStr> {
-        unsafe {
-            if phper_zval_get_type(self.raw) == IS_STRING as u8 {
-                Some(CStr::from_ptr(
-                    (&((*(*self.raw).value.str).val)).as_ptr().cast(),
-                ))
-            } else {
-                None
-            }
-        }
+    pub fn try_into_value<'a>(self) -> crate::Result<Value<'a>> {
+        Value::from_zval(self.raw)
     }
 
     unsafe fn type_info(&mut self) -> &mut u32 {
@@ -432,20 +409,33 @@ impl<T: SetVal, E: Throwable> SetVal for Result<T, E> {
     }
 }
 
+#[derive(Debug)]
 pub enum Value<'a> {
     Null,
     Bool(bool),
-    Str(&'a str),
-    String(String),
+    Long(i64),
+    Double(f64),
+    CStr(&'a CStr),
+    Array(()),
+    Object(()),
+    Resource(()),
 }
 
-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),
+impl<'a> Value<'a> {
+    pub fn from_zval(v: *const zval) -> crate::Result<Self> {
+        unsafe {
+            match phper_zval_get_type(v) as u32 {
+                sys::IS_NULL => Ok(Self::Null),
+                sys::IS_FALSE => Ok(Self::Bool(false)),
+                sys::IS_TRUE => Ok(Self::Bool(true)),
+                sys::IS_LONG => Ok(Self::Long((*v).value.lval)),
+                sys::IS_DOUBLE => Ok(Self::Double((*v).value.dval)),
+                sys::IS_STRING | sys::IS_STRING_EX => {
+                    let s = phper_z_strval_p(v);
+                    Ok(Self::CStr(CStr::from_ptr(s)))
+                }
+                t => Err(crate::Error::UnKnownValueType(t)),
+            }
         }
     }
 }

rust-toolchain

@@ -1 +1 @@
-nightly-2020-11-09
+nightly