Add phper-sys macros.

Author: jmjoy

phper-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "phper-sys"
-version = "0.1.0"
+version = "0.0.1"
 authors = ["__JM_Joy__ <[email protected]>"]
 edition = "2018"
 description = "PHP binding."

phper-sys/src/lib.rs

@@ -2,21 +2,13 @@
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
 
-use std::os::raw::c_char;
+#[macro_use]
+mod macros;
+mod zend;
 
 include!(concat!(env!("OUT_DIR"), "/php_bindings.rs"));
 
-impl Default for _zend_function_entry {
-    fn default() -> Self {
-        Self {
-            fname: 0 as *const c_char,
-            handler: None,
-            arg_info: 0 as *const _zend_internal_arg_info,
-            num_args: 0,
-            flags: 0,
-        }
-    }
-}
+pub use crate::zend::*;
 
 #[repr(C)]
 pub struct zend_function_entry_wrapper(pub *const zend_function_entry);

phper-sys/src/macros.rs

@@ -0,0 +1,6 @@
+macro_rules! pub_use_mod {
+    ($i: ident) => {
+        mod $i;
+        pub use self::$i::*;
+    };
+}

phper-sys/src/zend/mod.rs

@@ -0,0 +1,5 @@
+pub_use_mod!(zend_alloc);
+pub_use_mod!(zend_api);
+pub_use_mod!(zend_compile);
+pub_use_mod!(zend_string);
+pub_use_mod!(zend_types);

phper-sys/src/zend/zend_alloc.rs

@@ -0,0 +1,13 @@
+#[macro_export]
+macro_rules! emalloc {
+    ($size: expr) => {
+        $crate::_emalloc($size)
+    };
+}
+
+#[macro_export]
+macro_rules! efree {
+    ($ptr: expr) => {
+        $crate::_efree($ptr)
+    };
+}

phper-sys/src/zend/zend_api.rs

@@ -0,0 +1,12 @@
+#[macro_export]
+macro_rules! zend_fe_end {
+    () => {
+        $crate::zend_function_entry {
+            fname: 0 as *const c_char,
+            handler: None,
+            arg_info: 0 as *const $crate::zend_internal_arg_info,
+            num_args: 0,
+            flags: 0,
+        }
+    };
+}

phper-sys/src/zend/zend_compile.rs

@@ -0,0 +1,6 @@
+#[macro_export]
+macro_rules! zend_call_num_args {
+    ($call: expr) => {
+        (*$call).This.u2.num_args
+    };
+}

phper-sys/src/zend/zend_string.rs

@@ -0,0 +1,6 @@
+#[macro_export]
+macro_rules! zstr_is_interned {
+    ($s: expr) => {
+        $crate::gc_flags!($s) as u32 & ::phper_sys::IS_STR_INTERNED != 0
+    };
+}

phper-sys/src/zend/zend_types.rs

@@ -0,0 +1,124 @@
+#[macro_export]
+macro_rules! gc_flags {
+    ($p: expr) => {
+        (*$p).gc.u.v.flags
+    };
+}
+
+#[macro_export]
+macro_rules! z_type_info {
+    ($zval: expr) => {
+        $zval.u1.type_info
+    };
+}
+
+#[macro_export]
+macro_rules! z_type_info_p {
+    ($zval_p: expr) => {
+        $crate::z_type_info!(*$zval_p)
+    };
+}
+
+#[macro_export]
+macro_rules! z_lval {
+    ($zval: expr) => {
+        $zval.value.lval
+    };
+}
+
+#[macro_export]
+macro_rules! z_lval_p {
+    ($zval_p: expr) => {
+        $crate::z_lval!(*$zval_p)
+    };
+}
+
+#[macro_export]
+macro_rules! z_dval {
+    ($zval: expr) => {
+        $zval.value.dval
+    };
+}
+
+#[macro_export]
+macro_rules! z_dval_p {
+    ($zval_p: expr) => {
+        $crate::z_dval!(*$zval_p)
+    };
+}
+
+#[macro_export]
+macro_rules! zval_null {
+    ($z: expr) => {
+        $crate::z_type_info!($z) = $crate::IS_NULL;
+    };
+}
+
+#[macro_export]
+macro_rules! zval_false {
+    ($z: expr) => {
+        $crate::z_type_info!($z) = $crate::IS_FALSE;
+    };
+}
+
+#[macro_export]
+macro_rules! zval_true {
+    ($z: expr) => {
+        $crate::z_type_info!($z) = $crate::IS_TRUE;
+    };
+}
+
+#[macro_export]
+macro_rules! zval_bool {
+    ($z: expr, $b: expr) => {
+        let $b: bool = $b;
+        $crate::z_type_info!($z) = if $b { $crate::IS_TRUE } else { $crate::IS_FALSE };
+    };
+}
+
+#[macro_export]
+macro_rules! zval_long {
+    ($z: expr, $l: expr) => {
+    	let $z: *mut $crate::zval = $z;
+        $crate::z_lval_p($z) = $l;
+        $crate::z_type_info!($z) = $crate::IS_LONG;
+    };
+}
+
+#[macro_export]
+macro_rules! zval_double {
+    ($z: expr, $d: expr) => {
+    	let $z: *mut $crate::zval = $z;
+        $crate::z_lval_p($z) = $l;
+        $crate::z_type_info!($z) = $crate::IS_DOUBLE;
+    };
+}
+
+#[macro_export]
+macro_rules! z_str {
+    ($zval: expr) => {
+        ($zval).value.str
+    };
+}
+
+#[macro_export]
+macro_rules! z_str_p {
+    ($zval_p: expr) => {
+        $crate::z_str!(*$zval_p)
+    };
+}
+
+#[macro_export]
+macro_rules! zval_str {
+    ($z: expr, $s: expr) => {
+        let $z: *mut $crate::zval = $z;
+        let $s: *mut $crate::zend_string = $s;
+        $crate::z_str_p!($z) = $s;
+        $crate::z_type_info_p!($z) = if $crate::zstr_is_interned!(__s) {
+            ::phper_sys::IS_INTERNED_STRING_EX
+         } else {
+			::phper_sys::IS_STRING_EX
+         } as u32;
+    };
+}
+