Refactor Handler of ArgumentCountError and TypeError.

Author: jmjoy

phper/src/classes.rs

@@ -2,6 +2,7 @@ use crate::{
     functions::{Argument, Callable, FunctionEntity, FunctionEntry, Method},
     sys::*,
     utils::ensure_end_with_zero,
+    ClassNotFoundError,
 };
 use once_cell::sync::OnceCell;
 use std::{
@@ -76,6 +77,15 @@ pub struct ClassEntry {
 }
 
 impl ClassEntry {
+    pub fn from_globals<'a>(class_name: impl AsRef<str>) -> Result<&'a Self, ClassNotFoundError> {
+        let name = class_name.as_ref();
+        let ptr: *mut Self = find_global_class_entry_ptr(name).cast();
+        unsafe {
+            ptr.as_ref()
+                .ok_or_else(|| ClassNotFoundError::new(name.to_string()))
+        }
+    }
+
     pub fn from_ptr<'a>(ptr: *const zend_class_entry) -> &'a Self {
         unsafe { (ptr as *const Self).as_ref() }.expect("ptr should not be null")
     }
@@ -89,6 +99,19 @@ impl ClassEntry {
     }
 }
 
+fn find_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {
+    let name = name.as_ref();
+    let name = name.to_lowercase();
+    unsafe {
+        phper_zend_hash_str_find_ptr(
+            compiler_globals.class_table,
+            name.as_ptr().cast(),
+            name.len(),
+        )
+        .cast()
+    }
+}
+
 pub struct ClassEntity {
     pub(crate) name: String,
     pub(crate) entry: AtomicPtr<ClassEntry>,
@@ -186,15 +209,3 @@ pub enum Visibility {
     Protected = ZEND_ACC_PROTECTED,
     Private = ZEND_ACC_PRIVATE,
 }
-
-pub(crate) fn get_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {
-    let name = name.as_ref();
-    unsafe {
-        phper_zend_hash_str_find_ptr(
-            compiler_globals.class_table,
-            name.as_ptr().cast(),
-            name.len(),
-        )
-        .cast()
-    }
-}

phper/src/errors.rs

@@ -1,7 +1,26 @@
-use crate::{classes::ClassEntity, modules::read_global_module, Error::Other};
+use crate::{
+    classes::{ClassEntity, ClassEntry},
+    modules::read_global_module,
+    Error::{ClassNotFound, Other},
+};
 use anyhow::anyhow;
 use std::{error, ffi::FromBytesWithNulError, io, str::Utf8Error};
 
+pub(crate) const EXCEPTION_CLASS_NAME: &'static str = "Phper\\OtherException";
+
+/// PHP Throwable, can cause throwing an exception when setting to [crate::values::Val].
+pub trait Throwable: error::Error {
+    fn class_entry(&self) -> &ClassEntry;
+
+    fn code(&self) -> u64 {
+        0
+    }
+
+    fn message(&self) -> String {
+        self.to_string()
+    }
+}
+
 /// Type of [std::result::Result]<T, [crate::Error]>.
 pub type Result<T> = std::result::Result<T, self::Error>;
 
@@ -23,6 +42,9 @@ pub enum Error {
     #[error(transparent)]
     ClassNotFound(#[from] ClassNotFoundError),
 
+    #[error(transparent)]
+    ArgumentCountError(#[from] ArgumentCountError),
+
     #[error(transparent)]
     Other(#[from] anyhow::Error),
 }
@@ -35,6 +57,27 @@ impl Error {
     }
 }
 
+// TODO Add message() implement.
+impl Throwable for Error {
+    fn class_entry(&self) -> &ClassEntry {
+        match self {
+            Self::TypeError(e) => e.class_entry(),
+            Self::ClassNotFound(e) => e.class_entry(),
+            Self::ArgumentCountError(e) => e.class_entry(),
+            _ => ClassEntry::from_globals(EXCEPTION_CLASS_NAME).unwrap(),
+        }
+    }
+
+    fn code(&self) -> u64 {
+        match self {
+            Self::TypeError(e) => e.code(),
+            Self::ClassNotFound(e) => e.code(),
+            Self::ArgumentCountError(e) => e.code(),
+            _ => 0,
+        }
+    }
+}
+
 /// PHP type error.
 #[derive(thiserror::Error, Debug)]
 #[error("type error: {message}")]
@@ -48,8 +91,14 @@ impl TypeError {
     }
 }
 
+impl Throwable for TypeError {
+    fn class_entry(&self) -> &ClassEntry {
+        ClassEntry::from_globals("TypeError").unwrap()
+    }
+}
+
 #[derive(thiserror::Error, Debug)]
-#[error("class `{class_name}` not found")]
+#[error("Class '{class_name}' not found")]
 pub struct ClassNotFoundError {
     class_name: String,
 }
@@ -60,25 +109,32 @@ impl ClassNotFoundError {
     }
 }
 
-/// PHP Throwable, can cause throwing an exception when setting to [crate::values::Val].
-pub trait Throwable: error::Error {
-    fn class_entity(&self) -> *const ClassEntity;
-    fn code(&self) -> u64;
+impl Throwable for ClassNotFoundError {
+    fn class_entry(&self) -> &ClassEntry {
+        ClassEntry::from_globals("Error").unwrap()
+    }
 }
 
-pub(crate) const EXCEPTION_CLASS_NAME: &'static str = "Phper\\OtherException";
+#[derive(thiserror::Error, Debug)]
+#[error("{function_name}(): expects at least {expect_count} parameter(s), {given_count} given")]
+pub struct ArgumentCountError {
+    function_name: String,
+    expect_count: usize,
+    given_count: usize,
+}
 
-impl Throwable for Error {
-    fn class_entity(&self) -> *const ClassEntity {
-        read_global_module(|module| {
-            module
-                .class_entities
-                .get(EXCEPTION_CLASS_NAME)
-                .expect("Must be called after module init") as *const _
-        })
+impl ArgumentCountError {
+    pub fn new(function_name: String, expect_count: usize, given_count: usize) -> Self {
+        Self {
+            function_name,
+            expect_count,
+            given_count,
+        }
     }
+}
 
-    fn code(&self) -> u64 {
-        500
+impl Throwable for ArgumentCountError {
+    fn class_entry(&self) -> &ClassEntry {
+        ClassEntry::from_globals("ArgumentCountError").unwrap()
     }
 }

phper/src/functions.rs

@@ -2,11 +2,13 @@ use std::{mem::zeroed, os::raw::c_char, sync::atomic::AtomicPtr};
 
 use crate::{
     classes::ClassEntry,
+    errors::ArgumentCountError,
     objects::Object,
     sys::*,
     utils::ensure_end_with_zero,
     values::{ExecuteData, SetVal, Val},
 };
+use std::{slice::from_raw_parts, str, str::Utf8Error};
 
 pub trait Function: Send + Sync {
     fn call(&self, arguments: &mut [Val], return_value: &mut Val);
@@ -142,6 +144,38 @@ impl Argument {
     }
 }
 
+#[repr(transparent)]
+pub struct ZendFunction {
+    inner: zend_function,
+}
+
+impl ZendFunction {
+    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_function) -> &'a mut ZendFunction {
+        let ptr = ptr as *mut Self;
+        ptr.as_mut().expect("ptr shouldn't be null")
+    }
+
+    #[inline]
+    pub fn as_ptr(&self) -> *const zend_function {
+        &self.inner
+    }
+
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut zend_function {
+        &mut self.inner
+    }
+
+    pub fn get_name(&self) -> Result<String, Utf8Error> {
+        unsafe {
+            let s = get_function_or_method_name(self.as_ptr());
+            let buf = from_raw_parts(&(*s).val as *const c_char as *const u8, (*s).len);
+            let result = str::from_utf8(buf).map(ToString::to_string);
+            phper_zend_string_release(s);
+            result
+        }
+    }
+}
+
 pub(crate) unsafe extern "C" fn invoke(
     execute_data: *mut zend_execute_data,
     return_value: *mut zval,
@@ -157,13 +191,20 @@ pub(crate) unsafe extern "C" fn invoke(
     let handler = handler.as_ref().expect("handler is null");
 
     // Check arguments count.
-    if execute_data.num_args() < execute_data.common_required_num_args() {
-        warning!(
-            "expects at least {} parameter(s), {} given\0",
-            execute_data.common_required_num_args(),
-            execute_data.num_args()
-        );
-        SetVal::set_val((), return_value);
+    let num_args = execute_data.num_args() as usize;
+    let required_num_args = execute_data.common_required_num_args() as usize;
+    if num_args < required_num_args {
+        let func_name = execute_data.func().get_name();
+        let result = func_name
+            .map(|func_name| {
+                Err::<(), _>(ArgumentCountError::new(
+                    func_name,
+                    required_num_args,
+                    num_args,
+                ))
+            })
+            .map_err(crate::Error::Utf8);
+        SetVal::set_val(result, return_value);
         return;
     }
 

phper/src/objects.rs

@@ -1,5 +1,5 @@
 use crate::{
-    classes::get_global_class_entry_ptr,
+    classes::ClassEntry,
     sys::*,
     values::{SetVal, Val},
     ClassNotFoundError,
@@ -16,24 +16,22 @@ pub struct Object {
 }
 
 impl Object {
-    pub fn new(class_name: impl AsRef<str>) -> Result<Self, ClassNotFoundError> {
+    pub fn new(class_entry: &ClassEntry) -> Self {
         unsafe {
             let mut object = zeroed::<Object>();
-            let class_name = class_name.as_ref();
-            let ce = get_global_class_entry_ptr(class_name);
-            if ce.is_null() {
-                forget(object);
-                Err(ClassNotFoundError::new(class_name.to_string()))
-            } else {
-                zend_object_std_init(object.as_mut_ptr(), ce);
-                object.inner.handlers = &std_object_handlers;
-                Ok(object)
-            }
+            zend_object_std_init(object.as_mut_ptr(), class_entry.as_ptr() as *mut _);
+            object.inner.handlers = &std_object_handlers;
+            object
         }
     }
 
-    pub fn new_std() -> Self {
-        Self::new("stdclass").expect("stdClass not found")
+    pub fn new_by_class_name(class_name: impl AsRef<str>) -> Result<Self, ClassNotFoundError> {
+        let class_entry = ClassEntry::from_globals(class_name)?;
+        Ok(Self::new(class_entry))
+    }
+
+    pub fn new_by_std_class() -> Self {
+        Self::new_by_class_name("stdclass").unwrap()
     }
 
     pub unsafe fn from_mut_ptr<'a>(ptr: *mut zend_object) -> &'a mut Object {

phper/src/strings.rs

@@ -1,4 +1,5 @@
-use crate::sys::*;
+use crate::{alloc::EBox, sys::*};
+use std::{slice::from_raw_parts, str::Utf8Error};
 
 /// Wrapper of [crate::sys::zend_string].
 #[repr(transparent)]
@@ -9,7 +10,7 @@ pub struct ZendString {
 impl ZendString {
     // TODO Remove dead_code tag
     #[allow(dead_code)]
-    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_array) -> &'a mut Self {
+    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_string) -> &'a mut Self {
         let ptr = ptr as *mut Self;
         ptr.as_mut().expect("ptr shouldn't be null")
     }
@@ -21,4 +22,8 @@ impl ZendString {
     pub fn as_mut_ptr(&mut self) -> *mut zend_string {
         &mut self.inner
     }
+
+    pub unsafe fn from_raw(s: *mut zend_string) -> EBox<ZendString> {
+        EBox::from_raw(s.cast())
+    }
 }