Add Zend String and Array.

Author: jmjoy

.github/workflows/ci.yml

@@ -7,9 +7,9 @@ on:
     branches: [ "**" ]
 
 env:
-  CARGO_TERM_COLOR: always
-  #  RUST_BACKTRACE: 1
   #  RUST_LOG: debug
+  CARGO_TERM_COLOR: always
+  RUST_BACKTRACE: 1
   RUSTFLAGS: "-D warnings"
 
 jobs:
@@ -49,12 +49,6 @@ jobs:
           override: true
           components: rustfmt, clippy
 
-      # - name: Install Cargo make
-      #   uses: actions-rs/cargo@v1
-      #   with:
-      #     command: install
-      #     args: cargo-make
-
       - name: Cargo fmt
         uses: actions-rs/cargo@v1
         with:

examples/hello/Makefile.toml

@@ -1,6 +1,7 @@
+use std::{fs::OpenOptions, io::Write};
 use phper::{
     c_str_ptr,
-    classes::{Class, MethodEntity, StdClass, This},
+    classes::{Class, StdClass, This},
     functions::{create_zend_arg_info, Argument},
     ini::Policy,
     modules::{read_global_module, write_global_module, Module, ModuleArgs},
@@ -9,18 +10,23 @@ use phper::{
         php_info_print_table_end, php_info_print_table_row, php_info_print_table_start,
         zend_function_entry, OnUpdateBool, PHP_INI_SYSTEM,
     },
-    throws::{Exception, Throwable},
     values::{ExecuteData, Val},
+    Throwable,
 };
-use std::{fs::OpenOptions, io::Write};
+use phper::arrays::Array;
+use phper::values::SetVal;
 
 fn module_init(_args: ModuleArgs) -> bool {
     true
 }
 
 fn say_hello(arguments: &mut [Val]) -> String {
     let name = arguments[0].as_string();
-    format!("Hello, {}\n", name)
+    format!("Hello, {}!\n", name)
+}
+
+fn throw_exception(_: &mut [Val]) -> phper::Result<()> {
+    Err(phper::Error::other("I am sorry"))
 }
 
 #[php_get_module]
@@ -44,25 +50,34 @@ pub extern "C" fn get_module(module: &mut Module) {
 
     // register functions
     module.add_function("hello_say_hello", say_hello, vec![Argument::by_val("name")]);
+    module.add_function("hello_throw_exception", throw_exception, vec![]);
     module.add_function(
         "hello_get_all_ini",
-        |_: &mut [Val]| -> Result<String, Exception> {
-            let hello_enable = Module::get_bool_ini("hello.enable");
-            dbg!(hello_enable);
+        |_: &mut [Val]| -> Array {
+            let mut arr = Array::new();
 
-            let hello_description = Module::get_str_ini("hello.description");
-            dbg!(hello_description);
+            let mut hello_enable = Val::null();
+            Module::get_bool_ini("hello.enable").set_val(&mut hello_enable);
+            arr.insert("hello.enable", &mut hello_enable);
 
-            Ok(String::new())
+            let mut hello_description = Val::null();
+            Module::get_str_ini("hello.description").set_val(&mut hello_description);
+            arr.insert("hello.description", &mut hello_description);
+
+            arr
         },
         vec![],
     );
 
     // register classes
     let mut std_class = StdClass::new();
     std_class.add_property("foo", 100);
-    std_class.add_method("test1", |_: &mut This| {
-        println!("hello test1");
-    });
+    std_class.add_method(
+        "test1",
+        |_: &mut This, _: &mut [Val]| {
+            println!("hello test1");
+        },
+        vec![],
+    );
     module.add_class("Test1", std_class);
 }

examples/hello/src/lib.rs

@@ -31,7 +31,7 @@ pub(crate) fn php_get_module(_attr: TokenStream, input: TokenStream) -> TokenStr
 
             ::phper::modules::write_global_module(internal);
             unsafe {
-                ::phper::modules::read_global_module(|module| {
+                ::phper::modules::write_global_module(|module| {
                     module.module_entry()
                 })
             }

phper-macros/src/inner.rs

@@ -1,9 +1,5 @@
 #include "php_wrapper.h"
 
-zend_string *phper_zend_string_init(const char *str, size_t len, int persistent) {
-    return zend_string_init(str, len, persistent);
-}
-
 zend_string *phper_zend_new_interned_string(zend_string *str) {
     return zend_new_interned_string(str);
 }
@@ -22,6 +18,10 @@ 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_stringl(zval *return_value, const char *s, size_t len) {
     ZVAL_STRINGL(return_value, s, len);
 }
@@ -42,10 +42,18 @@ zend_string *phper_zval_get_string(zval *op) {
     return zval_get_string(op);
 }
 
-void phper_zend_string_release(zend_string *s) {
-    return zend_string_release(s);
-}
-
 zend_long phper_zval_get_long(zval *op) {
     return zval_get_long(op);
 }
+
+zend_string *phper_zend_string_init(const char *str, size_t len, int persistent) {
+    return zend_string_init(str, len, persistent);
+}
+
+zend_string *phper_zend_string_alloc(size_t len, int persistent) {
+    return zend_string_alloc(len, persistent);
+}
+
+void phper_zend_string_release(zend_string *s) {
+    return zend_string_release(s);
+}

phper-sys/php_wrapper.c

@@ -8,11 +8,11 @@
 
 typedef ZEND_INI_MH(phper_zend_ini_mh);
 
-zend_string *zend_string_init_(const char *str, size_t len, int persistent);
 zend_string *zend_new_interned_string_(zend_string *str);
 zend_class_entry phper_init_class_entry_ex(const char *class_name, size_t class_name_len, 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_arr(zval *return_value, zend_array *arr);
 void phper_zval_stringl(zval *return_value, const char *s, size_t len);
 char *phper_z_strval_p(const zval *v);
 zval *phper_get_this(zend_execute_data *execute_data);
@@ -21,4 +21,8 @@ zend_string *phper_zval_get_string(zval *op);
 void phper_zend_string_release(zend_string *s);
 zend_long phper_zval_get_long(zval *op);
 
+zend_string *phper_zend_string_init(const char *str, size_t len, int persistent);
+zend_string *phper_zend_string_alloc(size_t len, int persistent);
+void phper_zend_string_release(zend_string *s);
+
 #endif //PHPER_PHP_WRAPPER_H

phper-sys/php_wrapper.h

@@ -0,0 +1,62 @@
+use crate::sys::*;
+use std::ptr::null_mut;
+use std::mem::zeroed;
+use crate::values::Val;
+use std::ops::{Deref, DerefMut};
+
+pub struct Array {
+    inner: Box<zend_array>,
+}
+
+impl Array {
+    pub fn new() -> Self {
+        let mut inner = Box::new(unsafe { zeroed::<zend_array>() });
+        unsafe {
+            _zend_hash_init(&mut *inner, 0, None, 1);
+        }
+        Self {
+            inner,
+        }
+    }
+
+    pub fn insert(&mut self, key: impl AsRef<str>, value: &mut Val) {
+        let key = key.as_ref();
+        unsafe {
+            zend_hash_str_update(&mut *self.inner, key.as_ptr().cast(), key.len(), value.as_mut());
+        }
+    }
+
+    pub fn get(&mut self, key: impl AsRef<str>) -> &mut Val {
+        let key = key.as_ref();
+        unsafe {
+            let value = zend_hash_str_find(&mut *self.inner, key.as_ptr().cast(), key.len());
+            Val::from_mut(value)
+        }
+    }
+
+    pub fn len(&mut self) -> usize {
+        unsafe {
+            zend_array_count(&mut *self.inner) as usize
+        }
+    }
+}
+
+impl AsRef<zend_array> for Array {
+    fn as_ref(&self) -> &zend_array {
+        self.inner.deref()
+    }
+}
+
+impl AsMut<zend_array> for Array {
+    fn as_mut(&mut self) -> &mut zend_array {
+        self.inner.deref_mut()
+    }
+}
+
+impl Drop for Array {
+    fn drop(&mut self) {
+        unsafe {
+            zend_hash_destroy(&mut *self.inner);
+        }
+    }
+}