php_vm 1.0.0

data/ext/extconf.rb

@@ -0,0 +1,9 @@
+require "mkmf"
+
+if !have_library('php5', 'php_embed_init')
+  exit(1)
+end
+
+$CFLAGS += " "+`php-config --includes`
+$LOCAL_LIBS += ""
+create_makefile("php_vm")

data/ext/php_vm.c

@@ -0,0 +1,567 @@
+#include "php_vm.h"
+#include "php_vm_z2v.h"
+#include "php_vm_v2z.h"
+#include <string.h>
+
+
+// global
+
+VALUE rb_mPHPVM;
+VALUE rb_cPHPClass;
+VALUE rb_cPHPObject;
+VALUE rb_ePHPError;
+VALUE rb_ePHPExceptionObject;
+VALUE rb_ePHPSyntaxError;
+
+
+// PHP
+
+void php_eval_string(char *code, int code_len TSRMLS_DC)
+{
+	int syntax_error = 0;
+
+	// eval
+	zend_try {
+		if (zend_eval_stringl(code, code_len, NULL, "php_vm" TSRMLS_CC)==FAILURE) {
+			syntax_error = 1;
+		}
+	} zend_end_try();
+
+	// syntax error
+	if (syntax_error) {
+		VALUE exception = rb_exc_new2(rb_ePHPSyntaxError, "Syntax error");
+		rb_exc_raise(exception);
+	}
+
+	// exception
+	if (EG(exception)) {
+		VALUE exception = zval_to_value(EG(exception));
+		EG(exception) = NULL;
+		rb_exc_raise(exception);
+	}
+
+	// exit
+	if (EG(exit_status)!=0) {
+		int exit_status = EG(exit_status);
+		EG(exit_status) = 0;
+
+		char message[32];
+		sprintf(message, "exit status error: %d", exit_status);
+
+		VALUE exception = rb_exc_new2(rb_ePHPError, message);
+		rb_exc_raise(exception);
+	}
+}
+
+void find_zend_class_entry(char *name, int name_len, zend_class_entry ***ce)
+{
+	// lowercase
+	char *lcname = malloc(name_len+1);
+	memcpy(lcname, name, name_len);
+	zend_str_tolower(lcname, name_len);
+	lcname[name_len] = '\0';
+
+	// find zend class
+	*ce = NULL;
+	zend_hash_find(CG(class_table), lcname, name_len+1, (void **)ce);
+	if (*ce) {
+		// check string case
+		if (strcmp(name, (**ce)->name)!=0) {
+			*ce = NULL;
+		}
+	}
+
+	free(lcname);
+}
+
+int is_exception_zend_class_entry(zend_class_entry *ce TSRMLS_DC)
+{
+	return instanceof_function(ce, zend_exception_get_default() TSRMLS_CC);
+}
+
+int is_exception_zval(zval *z TSRMLS_DC)
+{
+	return is_exception_zend_class_entry(Z_OBJCE_P(z) TSRMLS_CC);
+}
+
+void find_zend_function(zend_class_entry *ce, char *name, int name_len, zend_function **mptr)
+{
+	// function_table
+	HashTable *function_table = NULL;
+	if (ce && &ce->function_table) {
+		function_table = &ce->function_table;
+	} else {
+		function_table = EG(function_table);
+	}
+
+	// lowercase
+	char *lcname = malloc(name_len+1);
+	memcpy(lcname, name, name_len);
+	zend_str_tolower(lcname, name_len);
+	lcname[name_len] = '\0';
+
+	// find zend function
+	*mptr = NULL;
+	zend_hash_find(function_table, lcname, name_len+1, (void **)mptr);
+	if (*mptr) {
+		// check string case
+		if (strcmp(name, (*mptr)->common.function_name)!=0) {
+			*mptr = NULL;
+		}
+	}
+
+	free(lcname);
+}
+
+int new_php_object(zend_class_entry *ce, VALUE v_args, zval *retval)
+{
+	int result = FAILURE;
+
+	if (ce->constructor) {
+		// defined constructor
+/*
+		if (!(ce->constructor->common.fn_flags & ZEND_ACC_PUBLIC)) {
+			char *message = malloc(50+strlen(ce->name));
+			sprintf(message, "Access to non-public constructor of class %s", ce->name);
+			VALUE v_exception = rb_exc_new2(rb_ePHPError, message);
+			free(message);
+			rb_exc_raise(v_exception);
+		}
+*/
+
+		// alloc
+		object_init_ex(retval, ce);
+
+		// call
+		int result = call_php_method(ce, retval, ce->constructor, RARRAY_LEN(v_args), RARRAY_PTR(v_args), &retval TSRMLS_CC);
+
+		// error
+		if (result==FAILURE) {
+			char *message = malloc(40+strlen(ce->name));
+			sprintf(message, "Invocation of %s's constructor failed", ce->name);
+			VALUE v_exception = rb_exc_new2(rb_ePHPError, message);
+			free(message);
+			rb_exc_raise(v_exception);
+		}
+
+	} else if (!RARRAY_LEN(v_args)) {
+		// undefined constructor, hasnt args
+		object_init_ex(retval, ce);
+		result = SUCCESS;
+
+	} else {
+		// undefine constructor, has args
+		char *message = malloc(90+strlen(ce->name));
+		sprintf(message, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ce->name);
+		VALUE v_exception = rb_exc_new2(rb_ePHPError, message);
+		free(message);
+		rb_exc_raise(v_exception);
+	}
+	return result;
+}
+
+void define_php_methods(VALUE v_obj, zend_class_entry *ce, int is_static)
+{
+	// TODO: access modifier
+	// TODO: __toString
+	// TODO: __clone
+	// TODO: __call
+	// TODO: __callStatic
+	// TODO: __get
+	// TODO: __set
+	// TODO: __isset
+
+	HashPosition pos;
+	zend_function *mptr;
+
+	zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
+
+	while (zend_hash_get_current_data_ex(&ce->function_table, (void **)&mptr, &pos) == SUCCESS) {
+		int flag = mptr->common.fn_flags;
+		const char *fname = mptr->common.function_name;
+
+		if (is_static) {
+			// class method
+			if (strcmp("new", fname)==0) {
+				// new => no define
+			} else if (0<(flag & ZEND_ACC_STATIC)) {
+				// other method
+				rb_define_singleton_method(v_obj, fname, rb_php_class_call, -1);
+			}
+		} else {
+			// instance method
+			if (strcmp("__construct", fname)==0) {
+				// __construct => no define
+
+			} else if (0==(flag & ZEND_ACC_STATIC)) {
+				// other method
+				rb_define_singleton_method(v_obj, fname, rb_php_object_call, -1);
+			}
+		}
+
+		zend_hash_move_forward_ex(&ce->function_table, &pos);
+	}
+}
+
+int call_php_method(zend_class_entry *ce, zval *obj, zend_function *mptr, int argc, VALUE *v_argv, zval **retval_ptr TSRMLS_DC)
+{
+	int result = FAILURE;
+
+	// argv
+	zval ***z_argv = malloc(sizeof(zval **) * argc);
+	long i;
+	for (i=0; i<argc; i++) {
+		zval *tmp;
+		MAKE_STD_ZVAL(tmp);
+		value_to_zval(v_argv[i], tmp);
+		z_argv[i] = &tmp;
+	}
+
+	// call info
+	zend_fcall_info fci;
+	zend_fcall_info_cache fcc;
+	zval *return_value;
+	ALLOC_INIT_ZVAL(return_value);
+
+	fci.size = sizeof(fci);
+	fci.function_table = NULL;
+	fci.function_name = NULL;
+	fci.symbol_table = NULL;
+	fci.object_ptr = obj;
+	fci.retval_ptr_ptr = retval_ptr;
+	fci.param_count = argc;
+	fci.params = z_argv;
+	fci.no_separation = 1;
+
+	fcc.initialized = 1;
+	fcc.function_handler = mptr;
+	fcc.calling_scope = ce ? ce : EG(scope);
+	fcc.called_scope = ce ? ce : NULL;
+	fcc.object_ptr = obj;
+
+	// call
+	zend_try {
+		result = zend_call_function(&fci, &fcc TSRMLS_CC);
+	} zend_catch {
+		//printf("call_php_method exception: %p\n", EG(exception));
+	} zend_end_try();
+
+	// release
+	for (i=0; i<argc; i++) {
+		zval_ptr_dtor(z_argv[i]);
+	}
+	free(z_argv);
+
+	return result;
+}
+
+
+// Ruby
+
+VALUE get_callee_name()
+{
+	VALUE backtrace_arr = rb_funcall(rb_mKernel, rb_intern("caller"), 1, INT2NUM(0));
+	if (backtrace_arr) {
+		VALUE backtrace = rb_funcall(backtrace_arr, rb_intern("first"), 0);
+		if (backtrace) {
+			VALUE re = rb_funcall(rb_cRegexp, rb_intern("new"), 1, rb_str_new2("^(.+?):(\\d+)(?::in `(.*)')?"));
+			VALUE m = rb_funcall(backtrace, rb_intern("match"), 1, re);
+			if (m) {
+				return rb_funcall(m, rb_intern("[]"), 1, INT2NUM(3));
+			}
+		}
+	}
+	return Qnil;
+}
+
+VALUE call_php_method_bridge(zend_class_entry *ce, zval *obj, VALUE callee, int argc, VALUE *argv)
+{
+	// callee
+	if (callee==Qnil) {
+		VALUE exception = rb_exc_new2(rb_ePHPError, "callee is nil");
+		rb_exc_raise(exception);
+	}
+
+	// method
+	zend_function *mptr;
+	find_zend_function(ce, RSTRING_PTR(callee), RSTRING_LEN(callee), &mptr);
+
+	// call
+	zval *retval;
+	int result = call_php_method(ce, obj, mptr, argc, argv, &retval TSRMLS_CC);
+
+	// exception
+	if (result==FAILURE) {
+		// TODO: read var
+		// TODO: raise exception. method missing
+	}
+
+	return zval_to_value(retval);
+}
+
+
+// PHP Native resource
+
+void php_native_resource_delete(PHPNativeResource *p)
+{
+	free(p);
+}
+
+zend_class_entry* get_zend_class_entry(VALUE self)
+{
+	VALUE resource = rb_iv_get(self, "php_native_resource");
+	if (resource==Qnil) {
+		return NULL;
+	}
+
+	PHPNativeResource *p;
+	Data_Get_Struct(rb_iv_get(self, "php_native_resource"), PHPNativeResource, p);
+	if (p) {
+		return p->ce;
+	}
+	return NULL;
+}
+
+zval* get_zval(VALUE self)
+{
+	VALUE resource = rb_iv_get(self, "php_native_resource");
+	if (resource==Qnil) {
+		return NULL;
+	}
+
+	PHPNativeResource *p;
+	Data_Get_Struct(rb_iv_get(self, "php_native_resource"), PHPNativeResource, p);
+	if (p) {
+		return p->zobj;
+	}
+	return NULL;
+}
+
+
+// module PHPVM
+
+VALUE rb_php_vm_require(VALUE cls, VALUE filepath)
+{
+	StringValue(filepath);
+	filepath = rb_funcall(filepath, rb_intern("gsub"), 2, rb_str_new2("\\"), rb_str_new2("\\\\"));
+	filepath = rb_funcall(filepath, rb_intern("gsub"), 2, rb_str_new2("\""), rb_str_new2("\\\""));
+
+	VALUE code = rb_str_new2("require \"");
+	code = rb_str_plus(code, filepath);
+	code = rb_str_plus(code, rb_str_new2("\";"));
+
+	php_eval_string(RSTRING_PTR(code), RSTRING_LEN(code));
+
+	return Qnil;
+}
+
+VALUE rb_php_vm_require_once(VALUE cls, VALUE filepath)
+{
+	StringValue(filepath);
+	filepath = rb_funcall(filepath, rb_intern("gsub"), 2, rb_str_new2("\\"), rb_str_new2("\\\\"));
+	filepath = rb_funcall(filepath, rb_intern("gsub"), 2, rb_str_new2("\""), rb_str_new2("\\\""));
+
+	VALUE code = rb_str_new2("require_once \"");
+	code = rb_str_plus(code, filepath);
+	code = rb_str_plus(code, rb_str_new2("\";"));
+
+	php_eval_string(RSTRING_PTR(code), RSTRING_LEN(code));
+
+	return Qnil;
+}
+
+VALUE rb_php_vm_exec(VALUE cls, VALUE code)
+{
+	php_eval_string(RSTRING_PTR(code), RSTRING_LEN(code) TSRMLS_CC);
+	return Qnil;
+}
+
+VALUE rb_php_vm_getClass(VALUE cls, VALUE v_class_name)
+{
+	return rb_php_class_get(rb_cPHPClass, v_class_name);
+}
+
+
+// class PHPVM::PHPClass
+
+VALUE rb_php_class_get(VALUE cls, VALUE v_name)
+{
+	// find
+	VALUE name_sym = rb_str_intern(v_name);
+	VALUE classes = rb_cv_get(cls, "@@classes");
+	VALUE class = rb_hash_lookup(classes, name_sym);
+
+	if (class==Qnil) {
+		// create
+		class = rb_obj_alloc(rb_cPHPClass);
+		rb_php_class_initialize(class, v_name);
+		rb_hash_aset(classes, name_sym, class);
+	}
+
+	return class;
+}
+
+VALUE rb_php_class_initialize(VALUE self, VALUE v_name)
+{
+	rb_iv_set(self, "name", v_name);
+
+	// find zend class
+	zend_class_entry **ce = NULL;
+	find_zend_class_entry(RSTRING_PTR(v_name), RSTRING_LEN(v_name), &ce);
+
+	// class not found
+	if (!ce) {
+		char *message = malloc(32+RSTRING_LEN(v_name));
+		sprintf(message, "Class is not found: %s", RSTRING_PTR(v_name));
+		VALUE exception = rb_exc_new2(rb_ePHPError, message);
+		free(message);
+		rb_exc_raise(exception);
+	}
+
+	// set resource
+	PHPNativeResource *p = ALLOC(PHPNativeResource);
+	p->ce = *ce;
+	VALUE resource = Data_Wrap_Struct(CLASS_OF(self), 0, php_native_resource_delete, p);
+	rb_iv_set(self, "php_native_resource", resource);
+
+	// define php static methods
+	define_php_methods(self, *ce, 1);
+
+	return self;
+}
+
+VALUE rb_php_class_name(VALUE self)
+{
+	return rb_iv_get(self, "name");
+}
+
+VALUE rb_php_class_new(int argc, VALUE *argv, VALUE self)
+{
+	VALUE args;
+	rb_scan_args(argc, argv, "*", &args);
+
+	VALUE obj = Qnil;
+	zend_class_entry *ce = get_zend_class_entry(self);
+	if (is_exception_zend_class_entry(ce)) {
+		obj = rb_obj_alloc(rb_ePHPExceptionObject);
+	} else {
+		obj = rb_obj_alloc(rb_cPHPObject);
+	}
+	rb_php_object_initialize(obj, self, args);
+
+	// define php instance method
+	define_php_methods(obj, ce, 0);
+
+	return obj;
+}
+
+VALUE rb_php_class_call(int argc, VALUE *argv, VALUE self)
+{
+	zend_class_entry *ce = get_zend_class_entry(self);
+	VALUE callee = get_callee_name();
+	return call_php_method_bridge(ce, NULL, callee, argc, argv);
+}
+
+
+// class PHPVM::PHPObject
+
+VALUE rb_php_object_initialize(VALUE self, VALUE class, VALUE args)
+{
+	// set class
+	rb_iv_set(self, "php_class", class);
+
+	// create php object
+	zend_class_entry *ce = get_zend_class_entry(class);
+	zval *z_obj;
+	ALLOC_INIT_ZVAL(z_obj);
+	new_php_object(ce, args, z_obj);
+	
+	// set resource
+	PHPNativeResource *p = ALLOC(PHPNativeResource);
+	p->ce = ce;
+	p->zobj = z_obj;
+	VALUE resource = Data_Wrap_Struct(CLASS_OF(self), 0, php_native_resource_delete, p);
+	rb_iv_set(self, "php_native_resource", resource);
+
+	return self;
+}
+
+VALUE rb_php_object_php_class(VALUE self)
+{
+	return rb_iv_get(self, "php_class");
+}
+
+VALUE rb_php_object_call(int argc, VALUE *argv, VALUE self)
+{
+	zend_class_entry *ce = get_zend_class_entry(self);
+	zval *zobj = get_zval(self);
+	VALUE callee = get_callee_name();
+	return call_php_method_bridge(ce, zobj, callee, argc, argv);
+}
+
+
+// class PHPVM::PHPExceptionObject
+
+VALUE rb_php_exception_object_initialize(int argc, VALUE *argv, VALUE self)
+{
+	rb_call_super(argc, argv);
+	return self;
+}
+
+
+// module
+
+void php_vm_module_init()
+{
+	int argc = 1;
+	char *argv[2] = {"php_vm", NULL};
+	php_embed_init(argc, argv PTSRMLS_CC);
+	EG(bailout) = NULL;
+}
+
+void php_vm_module_exit()
+{
+	php_embed_shutdown(TSRMLS_C);
+}
+
+void Init_php_vm()
+{
+	// initialize php_vm
+	php_vm_module_init();
+	atexit(php_vm_module_exit);
+
+	// module PHPVM
+	rb_mPHPVM = rb_define_module("PHPVM");
+
+	rb_define_singleton_method(rb_mPHPVM, "require", rb_php_vm_require, 1);
+	rb_define_singleton_method(rb_mPHPVM, "require_once", rb_php_vm_require_once, 1);
+	rb_define_singleton_method(rb_mPHPVM, "exec", rb_php_vm_exec, 1);
+	rb_define_singleton_method(rb_mPHPVM, "getClass", rb_php_vm_getClass, 1);
+
+	// class PHPVM::PHPClass
+	rb_cPHPClass = rb_define_class_under(rb_mPHPVM, "PHPClass", rb_cObject);
+	rb_define_class_variable(rb_cPHPClass, "@@classes", rb_obj_alloc(rb_cHash));
+
+	rb_define_private_method(rb_cPHPClass, "initialize", rb_php_class_initialize, 1);
+	rb_define_method(rb_cPHPClass, "name", rb_php_class_name, 0);
+	rb_define_method(rb_cPHPClass, "new", rb_php_class_new, -1);
+	rb_define_singleton_method(rb_cPHPClass, "get", rb_php_class_get, 1);
+
+	// class PHPVM::PHPObject
+	rb_cPHPObject = rb_define_class_under(rb_mPHPVM, "PHPObject", rb_cObject);
+
+	rb_define_private_method(rb_cPHPObject, "initialize", rb_php_object_initialize, 1);
+	rb_define_method(rb_cPHPObject, "php_class", rb_php_object_php_class, 0);
+
+	// class PHPVM::PHPError < StandardError
+	rb_ePHPError = rb_define_class_under(rb_mPHPVM, "PHPError", rb_eStandardError);
+
+	// class PHPVM::PHPExceptionObject < PHPVM::PHPError
+	rb_ePHPExceptionObject = rb_define_class_under(rb_mPHPVM, "PHPExceptionObject", rb_ePHPError);
+
+	rb_define_method(rb_ePHPExceptionObject, "initialize", rb_php_exception_object_initialize, -1);
+	rb_define_method(rb_ePHPExceptionObject, "php_class", rb_php_object_php_class, 0);
+
+	// class PHPVM::PHPSyntaxError < PHPVM::PHPError
+	rb_ePHPSyntaxError = rb_define_class_under(rb_mPHPVM, "PHPSyntaxError", rb_ePHPError);
+}

data/ext/php_vm.h

@@ -0,0 +1,64 @@
+#ifndef PHP_VM_H
+#define PHP_VM_H
+
+#include <ruby.h>
+#include <sapi/embed/php_embed.h>
+#include <Zend/zend_execute.h>
+#include <Zend/zend_exceptions.h>
+
+
+extern VALUE rb_mPHPVM;
+extern VALUE rb_cPHPClass;
+extern VALUE rb_cPHPObject;
+extern VALUE rb_ePHPExceptionObject;
+extern VALUE rb_ePHPError;
+extern VALUE rb_ePHPSyntaxError;
+
+typedef struct {
+	zend_class_entry *ce;
+	zval *zobj;
+} PHPNativeResource;
+
+
+// PHP
+extern void php_eval_string(char *code, int code_len TSRMLS_DC);
+extern void find_zend_class_entry(char *name, int name_len, zend_class_entry ***ce);
+extern void find_zend_class_entry2(char *name, zend_class_entry ***ce);
+extern int is_exception_zend_class_entry(zend_class_entry *ce TSRMLS_DC);
+extern int is_exception_zval(zval *z TSRMLS_DC);
+extern int new_php_object(zend_class_entry *ce, VALUE v_args, zval *retval);
+extern void define_php_methods(VALUE v_obj, zend_class_entry *ce, int is_static);
+extern int call_php_method(zend_class_entry *ce, zval *obj, zend_function *mptr, int argc, VALUE *v_argv, zval **retval_ptr TSRMLS_DC);
+
+// Ruby
+extern VALUE get_callee_name();
+extern VALUE call_php_method_bridge(zend_class_entry *ce, zval *obj, VALUE callee, int argc, VALUE *argv);
+
+// PHP Native resource
+extern void php_native_resource_delete(PHPNativeResource *p);
+extern zend_class_entry* get_zend_class_entry(VALUE self);
+extern zval* get_zval(VALUE self);
+
+// module PHPVM
+extern VALUE rb_php_vm_require(VALUE cls, VALUE rbv_filepath);
+extern VALUE rb_php_vm_exec(VALUE cls, VALUE rbv_code);
+extern VALUE rb_php_vm_getClass(VALUE cls, VALUE rbv_class_name);
+
+// class PHPVM::PHPClass
+extern VALUE rb_php_class_get(VALUE cls, VALUE rbv_name);
+extern VALUE rb_php_class_initialize(VALUE self, VALUE rbv_name);
+extern VALUE rb_php_class_name(VALUE self);
+extern VALUE rb_php_class_new(int argc, VALUE *argv, VALUE self);
+extern VALUE rb_php_class_call(int argc, VALUE *argv, VALUE self);
+
+// class PHPVM::PHPObject
+extern VALUE rb_php_object_initialize(VALUE self, VALUE class, VALUE arg_arr);
+extern VALUE rb_php_object_php_class(VALUE self);
+extern VALUE rb_php_object_call(int argc, VALUE *argv, VALUE self);
+
+// module
+extern void php_vm_module_init();
+extern void php_vm_module_exit();
+extern void Init_php_vm();
+
+#endif

data/ext/php_vm_v2z.c

@@ -0,0 +1,81 @@
+#include "php_vm.h"
+#include "php_vm_v2z.h"
+#include <string.h>
+
+
+static void value_to_zval_array(VALUE v, zval *z)
+{
+	array_init(z);
+
+	long i;
+	for (i=0; i<RARRAY_LEN(v); i++) {
+		zval *new_var;
+		MAKE_STD_ZVAL(z);
+		value_to_zval(RARRAY_PTR(v)[i], new_var);
+
+		zend_hash_next_index_insert(Z_ARRVAL_P(z), &new_var, sizeof(zval *), NULL);
+	}
+}
+
+static void value_to_zval_hash(VALUE v, zval *z)
+{
+	array_init(z);
+
+	v = rb_funcall(v, rb_intern("flatten"), 0);
+
+	long i;
+	for (i=0; i<RARRAY_LEN(v); i+=2) {
+		VALUE v_key = RARRAY_PTR(v)[i];
+		StringValue(v_key);
+
+		zval *z_value;
+		MAKE_STD_ZVAL(z);
+		value_to_zval(RARRAY_PTR(v)[i+1], z_value);
+
+		add_assoc_zval_ex(z, RSTRING_PTR(v_key), RSTRING_LEN(v), z_value);
+	}
+}
+
+
+void value_to_zval(VALUE v, zval *z)
+{
+	switch (TYPE(v)) {
+		// nil
+		case T_NIL:
+			ZVAL_NULL(z);
+			break;
+		// bool
+		case T_TRUE:
+			ZVAL_TRUE(z);
+			break;
+		case T_FALSE:
+			ZVAL_FALSE(z);
+			break;
+		// number
+		case T_FIXNUM:
+			ZVAL_LONG(z, NUM2LONG(v));
+			break;
+		case T_FLOAT:
+			ZVAL_DOUBLE(z, RFLOAT_VALUE(v));
+			break;
+		// array
+		case T_ARRAY:
+			value_to_zval_array(v, z);
+			break;
+		// hash
+		case T_HASH:
+			value_to_zval_hash(v, z);
+			break;
+		// object string
+		default:{
+			VALUE cls = CLASS_OF(v);
+			if (cls==rb_cPHPObject || cls==rb_ePHPExceptionObject) {
+				// wrap php object
+			} else {
+				// other to_s
+				StringValue(v);
+				ZVAL_STRING(z, RSTRING_PTR(v), 1);
+			}
+		}
+	}
+}

data/ext/php_vm_v2z.h

@@ -0,0 +1,9 @@
+#ifndef PHP_VM_V2Z
+#define PHP_VM_V2Z
+
+#include <ruby.h>
+#include <sapi/embed/php_embed.h>
+
+extern void value_to_zval(VALUE v, zval *z);
+
+#endif

data/ext/php_vm_z2v.c

@@ -0,0 +1,155 @@
+#include "php_vm.h"
+#include "php_vm_z2v.h"
+#include <string.h>
+
+
+static int is_array_convertable(HashTable* ht)
+{
+	HashPosition pos;
+	char  *string_key;
+	ulong num_index;
+	ulong index = 0;
+
+	zend_hash_internal_pointer_reset_ex(ht, &pos);
+	do {
+		switch(zend_hash_get_current_key_ex(ht, &string_key, NULL, &num_index, 0, &pos)) {
+			case HASH_KEY_IS_STRING:
+				return 0;
+			case HASH_KEY_NON_EXISTANT:
+				return 1;
+			case HASH_KEY_IS_LONG:
+				if (num_index != index) {
+					return 0;
+				}
+				++index;
+		}
+	} while(SUCCESS == zend_hash_move_forward_ex(ht, &pos));
+	return 1;
+}
+
+static VALUE zval_to_value_array(HashTable* ht)
+{
+	HashPosition pos;
+	zval** data;
+	VALUE ret;
+
+	ret = rb_ary_new2(zend_hash_num_elements(ht));
+
+	zend_hash_internal_pointer_reset_ex(ht, &pos);
+	while (SUCCESS == zend_hash_get_current_data_ex(ht, (void **)&data, &pos)) {
+		VALUE t = zval_to_value(*data);
+		rb_ary_push(ret, t);
+		zend_hash_move_forward_ex(ht, &pos);
+	}
+	return ret;
+}
+
+static VALUE zval_to_value_hash(HashTable* ht)
+{
+	HashPosition pos;
+	zval** data;
+	VALUE ret;
+
+	ret = rb_hash_new();
+
+	zend_hash_internal_pointer_reset_ex(ht, &pos);
+	while (SUCCESS == zend_hash_get_current_data_ex(ht, (void **)&data, &pos)) {
+		char* string_key;
+		ulong num_index;
+		VALUE key = Qnil;
+		VALUE val = zval_to_value(*data);
+
+		switch(zend_hash_get_current_key_ex(ht, &string_key, NULL, &num_index, 0, &pos)) {
+			case HASH_KEY_IS_STRING:
+				key = rb_str_new_cstr(string_key);
+				break;
+			case HASH_KEY_IS_LONG:
+				key = LONG2NUM(num_index);
+				break;
+		}
+
+		rb_hash_aset(ret, key, val);
+		zend_hash_move_forward_ex(ht, &pos);
+	}
+	return ret;
+}
+
+static VALUE zval_to_value_object(zval *z)
+{
+	// class name
+	const char *name = "";
+	zend_uint name_len = 0;
+	int dup;
+	dup = zend_get_object_classname(z, &name, &name_len TSRMLS_CC);
+	VALUE v_name = rb_str_new(name, name_len);
+
+	// class
+	VALUE class = rb_php_class_get(rb_cPHPClass, v_name);
+
+	// object
+	VALUE obj = Qnil;
+	if (is_exception_zval(z)) {
+		// exception object
+		zval *z_message = zend_read_property(zend_exception_get_default(TSRMLS_C), z, "message", sizeof("message")-1, 0 TSRMLS_CC);
+
+		obj = rb_exc_new2(rb_ePHPExceptionObject, Z_STRVAL_P(z_message));
+
+		rb_iv_set(obj, "php_class", class);
+	} else {
+		// normal object
+		obj = rb_obj_alloc(rb_cPHPObject);
+
+		rb_iv_set(obj, "php_class", class);
+	}
+
+	// resource
+	PHPNativeResource *p = ALLOC(PHPNativeResource);
+	p->ce = get_zend_class_entry(class);
+	p->zobj = z;
+	VALUE resource = Data_Wrap_Struct(CLASS_OF(obj), 0, php_native_resource_delete, p);
+	rb_iv_set(obj, "php_native_resource", resource);
+
+	return obj;
+}
+
+
+VALUE zval_to_value(zval *z)
+{
+	if (z) {
+		switch(Z_TYPE_P(z)) {
+			case IS_NULL:
+				return Qnil;
+			case IS_BOOL:
+				return (zval_is_true(z)) ? Qtrue : Qfalse;
+			case IS_LONG:
+				return INT2NUM(Z_LVAL_P(z));
+			case IS_DOUBLE:
+				return DBL2NUM(Z_DVAL_P(z));
+			case IS_ARRAY:
+			case IS_CONSTANT_ARRAY:{
+				HashTable* ht = Z_ARRVAL_P(z);
+
+				if (0 == zend_hash_num_elements(ht)) {
+					return rb_ary_new();
+				}
+
+				if (is_array_convertable(ht)) {
+					return zval_to_value_array(ht);
+				}
+
+				return zval_to_value_hash(ht);
+			}
+			case IS_OBJECT:
+			case IS_RESOURCE:
+			case IS_CONSTANT:
+				return zval_to_value_object(z);
+			case IS_STRING:
+				return rb_str_new(Z_STRVAL_P(z), Z_STRLEN_P(z));
+			default:
+				return Qnil;
+		}
+	}
+	return Qnil;
+}
+
+

data/ext/php_vm_z2v.h

@@ -0,0 +1,9 @@
+#ifndef PHP_VM_Z2V
+#define PHP_VM_Z2V
+
+#include <ruby.h>
+#include <sapi/embed/php_embed.h>
+
+extern VALUE zval_to_value(zval *z);
+
+#endif

data/sample/class.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/")
+require "php_vm"
+
+PHPVM.exec <<EOS
+class HelloClass
+{
+	public function __construct($name)
+	{
+		$this->name = $name;
+	}
+
+
+	// instance
+
+	public function instanceGetHello()
+	{
+		return "Hello {$this->name}!!";
+	}
+
+	public function instanceSayHello()
+	{
+		var_dump($this->instanceGetHello());
+	}
+
+
+	// static
+
+	public static function classGetHello($name)
+	{
+		return "Hello {$name}!!";
+	}
+
+	public static function classSayHello($name)
+	{
+		var_dump(self::classGetHello($name));
+	}
+}
+EOS
+
+HelloClass = PHPVM::getClass("HelloClass")
+
+puts "[class]"
+puts HelloClass
+puts HelloClass.name
+puts ""
+
+puts "[instance method]"
+h = HelloClass.new("instance world")
+h.instanceSayHello
+p h.instanceGetHello
+puts ""
+
+puts "[class method]"
+HelloClass.classSayHello("class world")
+p HelloClass.classGetHello("class world")

data/sample/exec.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/")
+require "php_vm"
+
+PHPVM.exec('echo "Hello world!!\n";')

data/sample/exec_raise_exception.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/")
+require "php_vm"
+
+begin
+  PHPVM.exec("throw new Exception('throw exception!!');")
+rescue PHPVM::PHPError => e
+  puts "#{e.php_class.name}: #{e}"
+end

data/sample/require.php

@@ -0,0 +1,3 @@
+<?php
+
+echo "Hello world!!\n";

data/sample/require.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/")
+require "php_vm"
+
+PHPVM.require(File.expand_path(__FILE__+"/../require.php"))

data/sample/version.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << File.expand_path(__FILE__+"/../../ext/")
+require "php_vm"
+
+puts PHPVM::VERSION

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: php_vm
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Yoshida Tetsuya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-23 00:00:00.000000000 Z
+dependencies: []
+description: php_vm is a native bridge between Ruby and PHP.
+email:
+- yoshida.eth0@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/extconf.rb
+- ext/php_vm.c
+- ext/php_vm.h
+- ext/php_vm_v2z.c
+- ext/php_vm_v2z.h
+- ext/php_vm_z2v.c
+- ext/php_vm_z2v.h
+- sample/class.rb
+- sample/exec.rb
+- sample/exec_raise_exception.rb
+- sample/require.php
+- sample/require.rb
+- sample/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: php_vm is a native bridge between Ruby and PHP.
+test_files: []