Add argument infos.

Author: jmjoy

examples/hello/src/lib.rs

@@ -1,7 +1,7 @@
 use phper::{
     c_str_ptr,
     classes::{Class, MethodEntity, StdClass, This},
-    functions::create_zend_arg_info,
+    functions::{create_zend_arg_info, Argument},
     ini::Policy,
     modules::{read_global_module, write_global_module, Module, ModuleArgs},
     php_get_module,
@@ -43,7 +43,7 @@ pub extern "C" fn get_module(module: &mut Module) {
     module.on_request_shutdown(|_| true);
 
     // register functions
-    module.add_function("hello_say_hello", say_hello);
+    module.add_function("hello_say_hello", say_hello, vec![Argument::by_val("name")]);
     module.add_function(
         "hello_get_all_ini",
         |_: &mut [Val]| -> Result<String, Exception> {
@@ -55,6 +55,7 @@ pub extern "C" fn get_module(module: &mut Module) {
 
             Ok(String::new())
         },
+        vec![],
     );
 
     // register classes

phper/src/functions.rs

@@ -1,11 +1,7 @@
 use crate::{
     classes::Method,
     ini::create_ini_entry_ex,
-    sys::{
-        _zend_get_parameters_array_ex, phper_z_strval_p, phper_zval_zval, zend_arg_info,
-        zend_ce_exception, zend_execute_data, zend_function_entry, zend_ini_entry_def,
-        zend_internal_arg_info, zend_throw_exception, zend_uchar, zif_handler, zval,
-    },
+    sys::*,
     throws::Throwable,
     values::{ExecuteData, SetVal, Val},
 };
@@ -40,6 +36,55 @@ pub struct FunctionEntry {
 pub(crate) struct FunctionEntity {
     pub(crate) name: String,
     pub(crate) handler: Box<dyn Function>,
+    pub(crate) arguments: Vec<Argument>,
+}
+
+pub struct Argument {
+    pub(crate) name: String,
+    pub(crate) pass_by_ref: bool,
+    pub(crate) required: bool,
+}
+
+impl Argument {
+    pub fn by_val(name: impl ToString) -> Self {
+        let mut name = name.to_string();
+        name.push('\0');
+        Self {
+            name,
+            pass_by_ref: false,
+            required: true,
+        }
+    }
+
+    pub fn by_ref(name: impl ToString) -> Self {
+        let mut name = name.to_string();
+        name.push('\0');
+        Self {
+            name,
+            pass_by_ref: true,
+            required: true,
+        }
+    }
+
+    pub fn by_val_optional(name: impl ToString) -> Self {
+        let mut name = name.to_string();
+        name.push('\0');
+        Self {
+            name,
+            pass_by_ref: false,
+            required: false,
+        }
+    }
+
+    pub fn by_ref_optional(name: impl ToString) -> Self {
+        let mut name = name.to_string();
+        name.push('\0');
+        Self {
+            name,
+            pass_by_ref: true,
+            required: false,
+        }
+    }
 }
 
 pub(crate) unsafe extern "C" fn invoke(
@@ -49,14 +94,38 @@ pub(crate) unsafe extern "C" fn invoke(
     let execute_data = ExecuteData::from_mut(execute_data);
     let return_value = Val::from_mut(return_value);
 
+    // TODO I don't know why this field is zero.
     let num_args = execute_data.common_num_args();
     let arg_info = execute_data.common_arg_info();
 
+    let mut num_args = 0isize;
+    for i in 0..10isize {
+        let buf = transmute::<_, [u8; size_of::<zend_arg_info>()]>(*arg_info.offset(i as isize));
+        if buf == zeroed::<[u8; size_of::<zend_arg_info>()]>() {
+            num_args = i;
+            break;
+        }
+    }
+    if num_args == 0 {
+        unreachable!();
+    }
+    num_args += 1;
+
     let last_arg_info = arg_info.offset(num_args as isize);
     let handler = (*last_arg_info).name as *const Box<dyn Function>;
     let handler = handler.as_ref().expect("handler is null");
 
-    // TODO Do num args check
+    // Check arguments count.
+    if execute_data.num_args() < execute_data.common_required_num_args() {
+        let s = format!(
+            "expects at least {} parameter(s), {} given\0",
+            execute_data.common_required_num_args(),
+            execute_data.num_args()
+        );
+        php_error_docref(null(), E_WARNING as i32, s.as_ptr().cast());
+        ().set_val(return_value);
+        return;
+    }
 
     let mut arguments = execute_data.get_parameters_array();
 
@@ -103,7 +172,7 @@ pub const fn create_zend_arg_info(
         }
     }
 
-    #[cfg(any(phper_php_version = "7.1", phper_php_version = "7.0",))]
+    #[cfg(any(phper_php_version = "7.1", phper_php_version = "7.0"))]
     {
         zend_internal_arg_info {
             name,

phper/src/modules.rs

@@ -1,7 +1,7 @@
 use crate::{
     c_str_ptr,
     classes::{Class, ClassEntity, ClassEntry},
-    functions::{invoke, Function, FunctionEntity},
+    functions::{create_zend_arg_info, invoke, Argument, Function, FunctionEntity},
     ini::{IniEntity, IniValue, Policy, StrPtrBox},
     sys::*,
 };
@@ -209,13 +209,19 @@ impl Module {
         })
     }
 
-    pub fn add_function(&mut self, name: impl ToString, handler: impl Function + 'static) {
+    pub fn add_function(
+        &mut self,
+        name: impl ToString,
+        handler: impl Function + 'static,
+        arguments: Vec<Argument>,
+    ) {
         let mut name = name.to_string();
         name.push('\0');
 
         self.function_entities.push(FunctionEntity {
             name,
             handler: Box::new(handler),
+            arguments,
         });
     }
 
@@ -270,6 +276,20 @@ impl Module {
 
         for f in &self.function_entities {
             let mut infos = Vec::new();
+
+            let require_arg_count = f.arguments.iter().filter(|arg| arg.required).count();
+            infos.push(create_zend_arg_info(
+                require_arg_count as *const c_char,
+                false,
+            ));
+
+            for arg in &f.arguments {
+                infos.push(create_zend_arg_info(
+                    arg.name.as_ptr().cast(),
+                    arg.pass_by_ref,
+                ));
+            }
+
             infos.push(unsafe { zeroed::<zend_internal_arg_info>() });
 
             let mut last_arg_info = unsafe { zeroed::<zend_internal_arg_info>() };

phper/src/values.rs

@@ -50,6 +50,11 @@ impl ExecuteData {
         (*self.inner.func).common.num_args
     }
 
+    #[inline]
+    pub unsafe fn common_required_num_args(&self) -> u32 {
+        (*self.inner.func).common.required_num_args
+    }
+
     #[inline]
     pub unsafe fn common_arg_info(&self) -> *mut zend_arg_info {
         (*self.inner.func).common.arg_info