Remove a lot of unused codes.

Author: jmjoy

rustfmt.toml renamed to .rustfmt.toml

@@ -6,7 +6,6 @@ A library that allows us to write PHP extensions using pure Rust and using safe
 
 ## Requirement
 
-- rust nightly channel (now)
 - libclang >= 9
 
 ## Usage

README.md

@@ -1,24 +1,19 @@
-use once_cell::sync::Lazy;
+use std::{fs::OpenOptions, io::Write};
+
 use phper::{
-    c_str_ptr, php_function, php_get_module, php_minfo_function, php_minit_function,
-    php_mshutdown_function, php_rinit_function, php_rshutdown_function,
+    c_str_ptr,
+    classes::{Class, MethodEntity, StdClass, This},
+    functions::create_zend_arg_info,
+    ini::Policy,
+    modules::{read_global_module, write_global_module, Module, ModuleArgs},
+    php_function, php_get_module, php_minfo_function, php_minit_function, php_mshutdown_function,
+    php_rinit_function, php_rshutdown_function,
     sys::{
         php_info_print_table_end, php_info_print_table_row, php_info_print_table_start,
         zend_function_entry, OnUpdateBool, PHP_INI_SYSTEM,
     },
-    zend::{
-        api::{FunctionEntries, ModuleGlobals},
-        classes::{Class, MethodEntity, StdClass, This},
-        compile::{create_zend_arg_info, MultiInternalArgInfo},
-        ini::{IniEntries, Policy},
-        modules::{
-            read_global_module, write_global_module, Module, ModuleArgs, ModuleEntry,
-            ModuleEntryBuilder,
-        },
-        types::{ExecuteData, SetVal, Val},
-    },
+    values::{ExecuteData, Val},
 };
-use std::{fs::OpenOptions, io::Write};
 
 // static HELLO_ENABLE: ModuleGlobals<bool> = ModuleGlobals::new(false);
 //
@@ -108,22 +103,22 @@ use std::{fs::OpenOptions, io::Write};
 //     module
 // }
 
-fn module_init(args: ModuleArgs) -> bool {
+fn module_init(_args: ModuleArgs) -> bool {
     // append_file("module_init");
     true
 }
 
-fn module_shutdown(args: ModuleArgs) -> bool {
+fn module_shutdown(_args: ModuleArgs) -> bool {
     // append_file("module_shutdown");
     true
 }
 
-fn request_init(args: ModuleArgs) -> bool {
+fn request_init(_args: ModuleArgs) -> bool {
     // append_file("request_init");
     true
 }
 
-fn request_shutdown(args: ModuleArgs) -> bool {
+fn request_shutdown(_args: ModuleArgs) -> bool {
     // append_file("request_shutdown");
     true
 }
@@ -154,7 +149,7 @@ pub extern "C" fn get_module() -> *const ::phper::sys::zend_module_entry {
         module.set_name(env!("CARGO_PKG_NAME"));
         module.set_version(env!("CARGO_PKG_VERSION"));
 
-        module.add_ini("hello.enable", "on", Policy::All);
+        module.add_ini("hello.enable", "off", Policy::All);
 
         module.on_module_init(module_init);
         module.on_module_shutdown(module_shutdown);

examples/hello/src/lib.rs

@@ -0,0 +1,5 @@
+use phper::cmd::make;
+
+fn main() {
+    make();
+}

examples/hello/src/main.rs

@@ -12,6 +12,8 @@ keywords = ["php", "binding", "extension"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+anyhow = "1.0.40"
+clap = "3.0.0-beta.2"
 once_cell = "1.7.2"
 phper-alloc = { version = "0.2", path = "../phper-alloc" }
 phper-macros = { version = "0.2", path = "../phper-macros" }

phper/Cargo.toml

@@ -1,15 +1,3 @@
-use crate::{
-    sys::{
-        phper_init_class_entry_ex, zend_class_entry, zend_declare_property_long,
-        zend_function_entry, zend_internal_arg_info, zend_register_internal_class, zval,
-    },
-    zend::{
-        api::{invoke, method_invoke, FunctionEntry},
-        compile::Visibility,
-        types::Val,
-    },
-};
-use once_cell::sync::OnceCell;
 use std::{
     mem::zeroed,
     os::raw::c_int,
@@ -20,6 +8,18 @@ use std::{
     },
 };
 
+use once_cell::sync::OnceCell;
+
+use crate::{
+    functions::{method_invoke, FunctionEntry},
+    sys::{
+        phper_init_class_entry_ex, zend_class_entry, zend_declare_property_long,
+        zend_function_entry, zend_internal_arg_info, zend_register_internal_class, zval,
+        ZEND_ACC_PRIVATE, ZEND_ACC_PROTECTED, ZEND_ACC_PUBLIC,
+    },
+    values::Val,
+};
+
 pub trait Method: Send + Sync {
     fn call(&self, this: &mut This, arguments: &mut [Val], return_value: &mut Val);
 }
@@ -28,7 +28,7 @@ impl<F> Method for F
 where
     F: Fn(&mut This) + Send + Sync,
 {
-    fn call(&self, this: &mut This, arguments: &mut [Val], return_value: &mut Val) {
+    fn call(&self, this: &mut This, _arguments: &mut [Val], _return_value: &mut Val) {
         self(this)
     }
 }
@@ -199,3 +199,11 @@ impl PropertyEntity {
         }
     }
 }
+
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum Visibility {
+    Public = ZEND_ACC_PUBLIC,
+    Protected = ZEND_ACC_PROTECTED,
+    Private = ZEND_ACC_PRIVATE,
+}

phper/src/zend/classes.rs renamed to phper/src/classes.rs

@@ -0,0 +1,63 @@
+use crate::sys::PHP_EXTENSION_DIR;
+use anyhow::Context;
+use clap::Clap;
+use std::{
+    env,
+    ffi::{CStr, OsString},
+    fs,
+    path::{Path, PathBuf},
+};
+
+/// Make utility.
+#[derive(Clap)]
+struct Make {
+    #[clap(subcommand)]
+    sub: SubCommand,
+}
+
+#[derive(Clap)]
+enum SubCommand {
+    Install(InstallCommand),
+}
+
+#[derive(Clap)]
+struct InstallCommand {}
+
+pub fn make() {
+    try_make().expect("make failed");
+}
+
+pub fn try_make() -> anyhow::Result<()> {
+    let make: Make = Make::parse();
+    match make.sub {
+        SubCommand::Install(_) => {
+            let (lib_path, ext_name) = get_lib_path_and_ext_name()?;
+            let extension_dir = CStr::from_bytes_with_nul(PHP_EXTENSION_DIR)?.to_str()?;
+            println!("Installing shared extensions:     {}", extension_dir);
+            let ext_path = Path::new(extension_dir).join(ext_name);
+            fs::copy(lib_path, ext_path)?;
+        }
+    }
+    Ok(())
+}
+
+fn get_lib_path_and_ext_name() -> anyhow::Result<(PathBuf, OsString)> {
+    let exe_path = env::current_exe()?;
+    let exe_stem = exe_path
+        .file_stem()
+        .context("failed to get current exe stem")?;
+    let target_dir = exe_path
+        .parent()
+        .context("failed to get current exe directory")?;
+
+    let mut exe_name = OsString::new();
+    exe_name.push("lib");
+    exe_name.push(exe_stem);
+    exe_name.push(".so");
+
+    let mut ext_name = OsString::new();
+    ext_name.push(exe_stem);
+    ext_name.push(".so");
+
+    Ok((target_dir.join(exe_name), ext_name))
+}

phper/src/cmd.rs

@@ -0,0 +1,117 @@
+use std::{
+    cell::Cell,
+    ffi::CStr,
+    mem::{size_of, transmute, zeroed},
+    os::raw::{c_char, c_int},
+    ptr::null,
+};
+
+use crate::{
+    classes::Method,
+    ini::create_ini_entry_ex,
+    sys::{
+        _zend_get_parameters_array_ex, phper_z_strval_p, zend_arg_info, zend_execute_data,
+        zend_function_entry, zend_ini_entry_def, zend_internal_arg_info, zend_uchar, zif_handler,
+        zval,
+    },
+    values::{ExecuteData, Val},
+};
+
+pub struct Parameters;
+
+pub trait Function: Send + Sync {
+    fn call(&self, arguments: &mut [Val], return_value: &mut Val);
+}
+
+impl<F> Function for F
+where
+    F: Fn() + Send + Sync,
+{
+    fn call(&self, _arguments: &mut [Val], _return_value: &mut Val) {
+        self()
+    }
+}
+
+#[repr(transparent)]
+pub struct FunctionEntry {
+    inner: zend_function_entry,
+}
+
+pub(crate) struct FunctionEntity {
+    pub(crate) name: String,
+    pub(crate) handler: Box<dyn Function>,
+}
+
+pub(crate) unsafe extern "C" fn invoke(
+    execute_data: *mut zend_execute_data,
+    return_value: *mut zval,
+) {
+    let execute_data = ExecuteData::from_mut(execute_data);
+    let return_value = Val::from_mut(return_value);
+
+    let num_args = execute_data.common_num_args();
+    let arg_info = execute_data.common_arg_info();
+
+    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
+
+    let mut arguments = execute_data.get_parameters_array();
+
+    handler.call(&mut arguments, return_value);
+}
+
+pub(crate) unsafe extern "C" fn method_invoke(
+    execute_data: *mut zend_execute_data,
+    return_value: *mut zval,
+) {
+    let execute_data = ExecuteData::from_mut(execute_data);
+    let return_value = Val::from_mut(return_value);
+
+    let num_args = execute_data.common_num_args();
+    let arg_info = execute_data.common_arg_info();
+
+    let last_arg_info = arg_info.offset(num_args as isize);
+    let handler = (*last_arg_info).name as *const Box<dyn Method>;
+    let handler = handler.as_ref().expect("handler is null");
+
+    // TODO Do num args check
+
+    let mut arguments = execute_data.get_parameters_array();
+
+    handler.call(execute_data.get_this(), &mut arguments, return_value);
+}
+
+pub const fn create_zend_arg_info(
+    name: *const c_char,
+    pass_by_ref: bool,
+) -> zend_internal_arg_info {
+    #[cfg(any(
+        phper_php_version = "8.0",
+        phper_php_version = "7.4",
+        phper_php_version = "7.3",
+        phper_php_version = "7.2"
+    ))]
+    {
+        zend_internal_arg_info {
+            name,
+            type_: 0 as crate::sys::zend_type,
+            pass_by_reference: pass_by_ref as zend_uchar,
+            is_variadic: 0,
+        }
+    }
+
+    #[cfg(any(phper_php_version = "7.1", phper_php_version = "7.0",))]
+    {
+        zend_internal_arg_info {
+            name,
+            class_name: std::ptr::null(),
+            type_hint: 0,
+            allow_null: 0,
+            pass_by_reference: pass_by_ref as zend_uchar,
+            is_variadic: 0,
+        }
+    }
+}