php5-midgard2-10.05.7/0000775000175000017500000000000011730073440012050 5ustar ppppphp5-midgard2-10.05.7/query_builder.c0000664000175000017500000002530611730073440015075 0ustar pppp/* Copyright (C) 2005 Jukka Zitting * Copyright (C) 2008, 2009 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" #include #define _GET_BUILDER_OBJECT \ zval *zval_object = getThis(); \ php_midgard_gobject *php_gobject = __php_objstore_object(zval_object); \ MidgardQueryBuilder *builder = MIDGARD_QUERY_BUILDER(php_gobject->gobject); \ if (!builder) \ php_error(E_ERROR, "Can not find underlying builder instance"); zend_class_entry *php_midgard_query_builder_class; /* Object constructor */ static PHP_METHOD(midgard_query_builder, __construct) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *classname; long classname_length; zval *zval_object = getThis(); GObject *gobject; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) { return; } zend_class_entry *ce = zend_fetch_class(classname, classname_length, ZEND_FETCH_CLASS_AUTO TSRMLS_CC); if (ce == NULL) { php_error(E_WARNING, "Didn't find %s class", classname); php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC); return; } zend_class_entry *base_ce = php_midgard_get_baseclass_ptr(ce); const gchar *g_base_class_name = php_class_name_to_g_class_name(base_ce->name); GType classtype = g_type_from_name(g_base_class_name); if (!g_type_is_a(classtype, MIDGARD_TYPE_DBOBJECT)) { php_error(E_WARNING, "Expected %s derived class", g_type_name(MIDGARD_TYPE_DBOBJECT)); php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC); return; } gobject = __php_gobject_ptr(zval_object); if (!gobject) { MidgardQueryBuilder *builder = midgard_query_builder_new(mgd, g_base_class_name); if (!builder) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } MGD_PHP_SET_GOBJECT(zval_object, builder); } else { // we already have gobject injected } php_midgard_gobject *php_gobject = __php_objstore_object(zval_object); /* Set user defined class. We might need it when execute is invoked */ php_gobject->user_ce = ce; php_gobject->user_class_name = (char *)ce->name; } ZEND_BEGIN_ARG_INFO_EX(arginfo_mqb___construct, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, add_constraint) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *name, *op; long name_length, op_length; zval *value; zval *zval_object = getThis(); zend_bool rv; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz", &name, &name_length, &op, &op_length, &value) != SUCCESS) { return; } MidgardQueryBuilder *builder = MIDGARD_QUERY_BUILDER(__php_gobject_ptr(zval_object)); GValue *gvalue = php_midgard_zval2gvalue(value TSRMLS_CC); if (gvalue == NULL) RETURN_FALSE; rv = midgard_query_builder_add_constraint(builder, name, op, gvalue); g_value_unset(gvalue); g_free(gvalue); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mqb_add_constraint, 0, 0, 3) ZEND_ARG_INFO(0, property) ZEND_ARG_INFO(0, operator) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, add_constraint_with_property) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *name_a, *name_b, *op; int name_a_length, name_b_length, op_length; gboolean rv; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &name_a, &name_a_length, &op, &op_length, &name_b, &name_b_length) != SUCCESS) { return; } _GET_BUILDER_OBJECT; rv = midgard_query_builder_add_constraint_with_property(builder, (const gchar *)name_a, (const gchar *)op, (const gchar *)name_b); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mqb_add_constraint_with_property, 0, 0, 3) ZEND_ARG_INFO(0, property) ZEND_ARG_INFO(0, operator) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, begin_group) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *type = NULL; int type_length; gboolean rv; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &type, &type_length) != SUCCESS) { return; } _GET_BUILDER_OBJECT; rv = midgard_query_builder_begin_group(builder, type); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_mqb_begin_group, 0) ZEND_ARG_INFO(0, type) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, end_group) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); gboolean rv; if (zend_parse_parameters_none() == FAILURE) return; _GET_BUILDER_OBJECT; rv = midgard_query_builder_end_group(builder); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_mqb_end_group, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, execute) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_BUILDER_OBJECT; zend_class_entry *ce = php_gobject->user_ce; if (ce == NULL) { php_error(E_WARNING, "Query Builder instance not associated with any class"); return; } guint i, n_objects; GObject **objects = midgard_query_builder_execute(builder, &n_objects); array_init(return_value); if (!objects) return; /* TODO: Should use iterator, instead, and create objects lazily */ for (i = 0; i < n_objects; i++) { GObject *gobject = objects[i]; zval *zobject; MAKE_STD_ZVAL(zobject); php_midgard_gobject_new_with_gobject(zobject, ce, gobject, TRUE TSRMLS_CC); zend_hash_next_index_insert(HASH_OF(return_value), &zobject, sizeof(zval *), NULL); } if (objects) g_free(objects); } ZEND_BEGIN_ARG_INFO(arginfo_mqb_execute, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, add_order) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *field, *order = "ASC"; int field_length, order_length; gboolean rv; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &field, &field_length, &order, &order_length) != SUCCESS) { return; } _GET_BUILDER_OBJECT; rv = midgard_query_builder_add_order(builder, field, order); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mqb_add_order, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_ARG_INFO(0, type) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, set_limit) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); long limit; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &limit) != SUCCESS) { return; } _GET_BUILDER_OBJECT; /* TODO, check if limit check can be ignored */ if (limit < 0) { php_error(E_WARNING, "Ignoring a negative query limit"); RETURN_FALSE; } midgard_query_builder_set_limit(builder, limit); RETURN_TRUE; } ZEND_BEGIN_ARG_INFO_EX(arginfo_mqb_set_limit, 0, 0, 1) ZEND_ARG_INFO(0, limit) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, set_offset) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); long offset; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &offset) != SUCCESS) { return; } _GET_BUILDER_OBJECT; if (offset < 0) { php_error(E_WARNING, "Ingoring a negative query offset"); RETURN_FALSE; } midgard_query_builder_set_offset(builder, offset); RETURN_TRUE; } ZEND_BEGIN_ARG_INFO_EX(arginfo_mqb_set_offset, 0, 0, 1) ZEND_ARG_INFO(0, offset) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, include_deleted) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; _GET_BUILDER_OBJECT; midgard_query_builder_include_deleted(builder); RETURN_TRUE; } ZEND_BEGIN_ARG_INFO(arginfo_mqb_include_deleted, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_builder, count) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) { return; } _GET_BUILDER_OBJECT; RETURN_LONG(midgard_query_builder_count(builder)); } ZEND_BEGIN_ARG_INFO(arginfo_mqb_count, 0) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_query_builder) { static zend_function_entry query_builder_methods[] = { PHP_ME(midgard_query_builder, __construct, arginfo_mqb___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_query_builder, add_constraint, arginfo_mqb_add_constraint, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_builder, add_constraint_with_property, arginfo_mqb_add_constraint_with_property, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_builder, begin_group, arginfo_mqb_begin_group, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_builder, end_group, arginfo_mqb_end_group, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_builder, execute, arginfo_mqb_execute, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_builder, add_order, arginfo_mqb_add_order, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_builder, set_limit, arginfo_mqb_set_limit, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_builder, set_offset, arginfo_mqb_set_offset, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_builder, include_deleted, arginfo_mqb_include_deleted, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_builder, count, arginfo_mqb_count, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry query_builder_class_entry; INIT_CLASS_ENTRY(query_builder_class_entry, "MidgardQueryBuilder", query_builder_methods); php_midgard_query_builder_class = zend_register_internal_class(&query_builder_class_entry TSRMLS_CC); php_midgard_query_builder_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_builder_class, strdup("API for building complex data-queries")); zend_register_class_alias("midgard_query_builder", php_midgard_query_builder_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_gobject.h0000664000175000017500000000533311730073440016200 0ustar pppp/* Copyright (C) 2007 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef PHP_MIDGARD_GOBJECT_GENERIC #define PHP_MIDGARD_GOBJECT_GENERIC #include "php_midgard.h" #define PHP_MIDGARD_GOBJ_MAGIC 0x01020E0F extern zend_class_entry *php_midgard_dbobject_class; extern zend_class_entry *php_midgard_object_class; extern zend_class_entry *php_midgard_view_class; /* Opaque struct to extend zend_object */ typedef struct _php_midgard_gobject { zend_object zo; uint32_t magic; GObject *gobject; gboolean has_properties; zend_class_entry *user_ce; gchar *user_class_name; } php_midgard_gobject; /* Global handlers */ extern zend_object_handlers php_midgard_gobject_handlers; /* Generic zend_object constructor */ zend_object_value php_midgard_gobject_new(zend_class_entry *class_type TSRMLS_DC); /* Inititlize new php object for given GObject */ void php_midgard_gobject_new_with_gobject(zval *zvalue, zend_class_entry *ce, GObject *gobject, gboolean dtor TSRMLS_DC); /* Initialize new php object by classname */ void php_midgard_gobject_init(zval *zvalue, const char *php_classname, GObject *gobject, gboolean dtor TSRMLS_DC); /* Get base class pointer */ zend_class_entry *php_midgard_get_baseclass_ptr(zend_class_entry *ce); zend_class_entry *php_midgard_get_mgdschema_class_ptr(zend_class_entry *ce); zend_class_entry *php_midgard_get_mgdschema_class_ptr_by_name(const char *name TSRMLS_DC); /* Routines */ int __serialize_object_hook(zval *zobject, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC); int __unserialize_object_hook(zval **zobject, zend_class_entry *ce, const unsigned char *buffer, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC); void php_midgard_gobject_unset_property(zval *object, zval *member TSRMLS_DC); /* SIGNALS */ void php_midgard_gobject_connect(INTERNAL_FUNCTION_PARAMETERS); void php_midgard_object_class_connect_default(INTERNAL_FUNCTION_PARAMETERS); const gchar* php_class_name_to_g_class_name(const char *php_class_name); #endif /* PHP_MIDGARD_GOBJECT_GENERIC */ php5-midgard2-10.05.7/README0000664000175000017500000000007511730073440012732 0ustar ppppRead INSTALL file for installation and configuration notes. php5-midgard2-10.05.7/php_midgard_config.c0000664000175000017500000001313611730073440016023 0ustar pppp/* Copyright (C) 2007 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" zend_class_entry *php_midgard_config_class; /* Object constructor */ static PHP_METHOD(midgard_config, __construct) { RETVAL_FALSE; zval *object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; MidgardConfig *config = midgard_config_new(); if (!config) RETURN_FALSE; MGD_PHP_SET_GOBJECT(object, config); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_config___construct, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_config, save_file) { RETVAL_FALSE; zend_bool zbool = FALSE; char *name; int name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &name, &name_length, &zbool) == FAILURE) { return; } MidgardConfig *config = (MidgardConfig *) __php_gobject_ptr(getThis()); gboolean rv = midgard_config_save_file(config ,name, zbool, NULL); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_config_save_file, 0, 0, 1) ZEND_ARG_INFO(0, name) ZEND_ARG_INFO(0, user) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_config, read_file) { RETVAL_FALSE; zend_bool zbool = FALSE; char *name; int name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &name, &name_length, &zbool) == FAILURE) { return; } MidgardConfig *config = (MidgardConfig *) __php_gobject_ptr(getThis()); gboolean rv = midgard_config_read_file(config, name, zbool, NULL); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_config_read_file, 0, 0, 1) ZEND_ARG_INFO(0, name) ZEND_ARG_INFO(0, user) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_config, read_file_at_path) { RETVAL_FALSE; char *path; int path_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_length) == FAILURE) { return; } MidgardConfig *config = (MidgardConfig *) __php_gobject_ptr(getThis()); gboolean rv = midgard_config_read_file_at_path(config, path, NULL); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_config_read_file_at_path, 0, 0, 1) ZEND_ARG_INFO(0, path) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_config, read_data) { RETVAL_FALSE; char *data; int data_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data, &data_length) == FAILURE) { return; } MidgardConfig *config = (MidgardConfig *) __php_gobject_ptr(getThis()); gboolean rv = midgard_config_read_data(config, data, NULL); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_config_read_data, 0, 0, 1) ZEND_ARG_INFO(0, data) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_config, list_files) { RETVAL_FALSE; zend_bool user = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &user) == FAILURE) { return; } array_init(return_value); gchar **files = midgard_config_list_files(user); if (!files) return; size_t i = 0; while (files[i] != NULL) { add_index_string(return_value, i, files[i], 1); i++; } g_strfreev(files); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_config_list_files, 0, 0, 0) ZEND_ARG_INFO(0, user) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_config, create_blobdir) { RETVAL_FALSE; gboolean rv; zval *zval_object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; MidgardConfig *config = NULL; if (zval_object) { config = (MidgardConfig *) __php_gobject_ptr(zval_object); } rv = midgard_config_create_blobdir(config); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_config_create_blobdir, 0) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_config) { static zend_function_entry midgard_config_methods[] = { PHP_ME(midgard_config, __construct, arginfo_midgard_config___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_config, save_file, arginfo_midgard_config_save_file, ZEND_ACC_PUBLIC) PHP_ME(midgard_config, read_file, arginfo_midgard_config_read_file, ZEND_ACC_PUBLIC) PHP_ME(midgard_config, read_file_at_path, arginfo_midgard_config_read_file_at_path, ZEND_ACC_PUBLIC) PHP_ME(midgard_config, read_data, arginfo_midgard_config_read_data, ZEND_ACC_PUBLIC) PHP_ME(midgard_config, list_files, arginfo_midgard_config_list_files, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_config, create_blobdir, arginfo_midgard_config_create_blobdir, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_config_class_entry; INIT_CLASS_ENTRY(php_midgard_config_class_entry, "MidgardConfig", midgard_config_methods); php_midgard_config_class = zend_register_internal_class(&php_midgard_config_class_entry TSRMLS_CC); php_midgard_config_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_config_class, strdup("Represents Midgard unified configuration file")); zend_register_class_alias("midgard_config", php_midgard_config_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard.h0000664000175000017500000002554511730073440014512 0ustar pppp/* * Copyright (C) 2006, 2008, 2009 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of\ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifdef G_LOG_DOMAIN # undef G_LOG_DOMAIN #endif #define G_LOG_DOMAIN "midgard-core" #ifndef PHP_MIDGARD_H #define PHP_MIDGARD_H #include "config.h" #ifdef PHP_WIN32 # include "config.w32.h" #endif #ifndef PHP_CONFIG_H # define PHP_CONFIG_H # include "php_config.h" #endif /* Do not load Apache regex when php compiled with 'system' as regex's TYPE */ #if REGEX == 0 # ifndef _REGEX_H # define _REGEX_H 1 # endif #endif #include "php.h" #include "php_globals.h" #include #include #include "ext/standard/info.h" #include "ext/standard/php_var.h" #include "SAPI.h" #include "ext/standard/php_standard.h" #include "ext/standard/php_smart_str.h" #include "ext/standard/info.h" #include #if HAVE_MIDGARD #define PHP_MIDGARD2_EXTNAME MIDGARD_PACKAGE_NAME #define PHP_MIDGARD2_EXTVER MIDGARD_LIB_VERSION #define PHP_MIDGARD2_WRAPPER "midgard" #define PHP_MIDGARD2_STREAMTYPE "midgard2stream" #define MGD_FUNCTION(ret, name, param) \ PHP_FUNCTION(mgd_##name) #define MGD_FE(name, arg_types) \ PHP_FE(mgd_##name, arg_types) # include # ifdef ZTS # include # endif typedef struct _MgdGHolder MgdGHolder; typedef struct _php_midgard2stream_data { MidgardObject *obj; char *buffer; int size; off_t position; } php_midgard2stream_data; extern guint global_loghandler; extern gboolean php_midgard_log_enabled; MidgardConnection *mgd_handle(TSRMLS_D); /* FIXME, is_connected is confusing because it says about connection instance pointer only */ #define php_midgard_is_connected() (MGDG(connection_established) == TRUE) # define phpext_midgard_ptr &midgard2_module_entry # ifdef PHP_WIN32 # define PHP_MIDGARD_API __declspec(dllexport) # else # define PHP_MIDGARD_API # endif PHP_MINIT_FUNCTION(midgard2); PHP_MSHUTDOWN_FUNCTION(midgard2); PHP_RINIT_FUNCTION(midgard2); PHP_RSHUTDOWN_FUNCTION(midgard2); PHP_MINFO_FUNCTION(midgard2); ZEND_BEGIN_MODULE_GLOBALS(midgard2) zend_bool connection_established; GHashTable *all_configs; MgdGHolder *midgard_global_holder; zend_bool can_deliver_signals; char *midgard_configuration; char *midgard_configuration_file; zend_bool midgard_engine; zend_bool midgard_http; zend_bool midgard_memory_debug; zend_bool superglobals_compat; zend_bool valgrind_friendly; zend_bool glib_loghandler; ZEND_END_MODULE_GLOBALS(midgard2) ZEND_EXTERN_MODULE_GLOBALS(midgard2) # ifdef ZTS # define MGDG(v) TSRMG(midgard2_globals_id, zend_midgard2_globals *, v) # else # define MGDG(v) (midgard2_globals.v) # endif #else # define phpext_midgard2_ptr NULL #endif PHP_FUNCTION(_midgard_php_object_constructor); /* FIXME , change name */ PHP_FUNCTION(_get_type_by_id); PHP_FUNCTION(_midgard_php_object_get_by_guid); PHP_FUNCTION(_midgard_php_object_update); PHP_FUNCTION(_midgard_php_object_create); PHP_FUNCTION(_midgard_php_object_is_in_parent_tree); PHP_FUNCTION(_midgard_php_object_is_in_tree); PHP_FUNCTION(_midgard_php_object_get_tree); PHP_FUNCTION(_midgard_php_object_delete); PHP_FUNCTION(_midgard_php_object_get_parent); PHP_FUNCTION(_midgard_php_object_get); PHP_FUNCTION(_midgard_php_object_list); PHP_FUNCTION(_midgard_php_object_list_children); PHP_FUNCTION(_midgard_php_object_get_by_path); PHP_FUNCTION(_midgard_php_object_parent); PHP_FUNCTION(_php_midgard_object_get_languages); PHP_FUNCTION(_php_midgard_object_purge); PHP_FUNCTION(_php_midgard_object_undelete); PHP_FUNCTION(_php_midgard_object_parameter); PHP_FUNCTION(_php_midgard_object_connect); /* Underlying GObject bindings */ #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 zval *php_midgard_gobject_read_property(zval *zobject, zval *prop, int type, const zend_literal *key TSRMLS_DC); zval **php_midgard_gobject_get_property_ptr_ptr(zval *object, zval *member, const zend_literal *key TSRMLS_DC); void php_midgard_gobject_write_property(zval *zobject, zval *prop, zval *value, const zend_literal *key TSRMLS_DC); int php_midgard_gobject_has_property(zval *zobject, zval *prop, int type, const zend_literal *key TSRMLS_DC); #else zval *php_midgard_gobject_read_property(zval *zobject, zval *prop, int type TSRMLS_DC); zval **php_midgard_gobject_get_property_ptr_ptr(zval *object, zval *member TSRMLS_DC); void php_midgard_gobject_write_property(zval *zobject, zval *prop, zval *value TSRMLS_DC); int php_midgard_gobject_has_property(zval *zobject, zval *prop, int type TSRMLS_DC); #endif HashTable *php_midgard_zendobject_get_properties (zval *zobject TSRMLS_DC); void php_midgard_array_from_objects(GObject **objects, const gchar *class_name, zval *zarray TSRMLS_DC); GValue *php_midgard_zval2gvalue(const zval *zvalue TSRMLS_DC); zend_bool php_midgard_gvalue2zval(const GValue *gvalue, zval *zvalue TSRMLS_DC); GParameter *php_midgard_array_to_gparameter(zval *params, guint *n_params TSRMLS_DC); gboolean php_midgard_is_derived_from_class(const gchar *classname, GType basetype, gboolean check_parent, zend_class_entry **base_class TSRMLS_DC); #define PHP_MIDGARD_PARSE_CLASS_ARGUMENT(__name, __type, __check_parent, __base_ce) { \ gboolean __isderived = \ php_midgard_is_derived_from_class(__name, __type, __check_parent, __base_ce TSRMLS_CC); \ if (!__isderived) { \ php_error(E_WARNING, "Expected %s derived class", g_type_name(__type)); \ php_midgard_error_exception_force_throw(mgd_handle(TSRMLS_C), MGD_ERR_INVALID_OBJECT); \ return; \ } \ } /* DBObject routines and hooks */ int php_midgard_serialize_dbobject_hook(zval *zobject, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC); int php_midgard_unserialize_dbobject_hook(zval **zobject, zend_class_entry *ce, const unsigned char *buffer, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC); /* closures */ void php_midgard_object_connect_class_closures(GObject *object, zval *zobject TSRMLS_DC); void php_midgard_gobject_closure_hash_new(); void php_midgard_gobject_closure_hash_reset(); void php_midgard_gobject_closure_hash_free(); /* Midgard core's classes */ PHP_MINIT_FUNCTION(midgard2_urlwrapper); PHP_MINIT_FUNCTION(midgard2_collector); PHP_MINIT_FUNCTION(midgard2_config); PHP_MINIT_FUNCTION(midgard2_user); PHP_MINIT_FUNCTION(midgard2_blob); PHP_MINIT_FUNCTION(midgard2_query_builder); PHP_MINIT_FUNCTION(midgard2_object_class); PHP_MINIT_FUNCTION(midgard2_reflection_property); PHP_MINIT_FUNCTION(midgard2_connection); PHP_MINIT_FUNCTION(midgard2_object); PHP_MINIT_FUNCTION(midgard2_dbus); PHP_MINIT_FUNCTION(midgard2_replicator); PHP_MINIT_FUNCTION(midgard2_datetime); PHP_MINIT_FUNCTION(midgard2_error); PHP_MINIT_FUNCTION(midgard2_transaction); PHP_MINIT_FUNCTION(midgard2_view); PHP_MINIT_FUNCTION(midgard2_storage); PHP_MINIT_FUNCTION(midgard2_key_config_context); PHP_MINIT_FUNCTION(midgard2_key_config_file_context); PHP_MINIT_FUNCTION(midgard2_key_config); PHP_MINIT_FUNCTION(midgard2_key_config_file); PHP_MINIT_FUNCTION(midgard2_reflection_workaround); PHP_MINIT_FUNCTION(midgard2_query); PHP_MINIT_FUNCTION(midgard2_g_mainloop); PHP_MINIT_FUNCTION(midgard2_workspaces); PHP_MINIT_FUNCTION(midgard2_base_abstract); PHP_MINIT_FUNCTION(midgard2_base_interface); PHP_MINIT_FUNCTION(midgard2_reflector_object); PHP_MINIT_FUNCTION(midgard2_reflector_property); PHP_MINIT_FUNCTION(midgard2_repligard); PHP_MINIT_FUNCTION(midgard2_query_selectors); zend_class_entry *php_midgard_get_baseclass_ptr(zend_class_entry *ce); zend_class_entry *php_midgard_get_baseclass_ptr_by_name(const char *name TSRMLS_DC); zend_class_entry *php_midgard_get_class_ptr_by_name(const char *name TSRMLS_DC); /* Exceptions */ gboolean php_midgard_error_exception_throw(MidgardConnection *mgd TSRMLS_DC); void php_midgard_error_exception_force_throw(MidgardConnection *mgd, gint errcode TSRMLS_DC); /* Logging */ void php_midgard_log_errors(const gchar *domain, GLogLevelFlags level, const gchar *msg, gpointer userdata); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 #define CHECK_MGD(handle) \ { \ if (!handle) { \ zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to get connection"); \ return; \ } \ const gchar *_check_cname_space = ""; \ const gchar *_check_class_name = get_active_class_name(&_check_cname_space TSRMLS_CC); \ g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, " %s%s%s(...)", \ _check_class_name, _check_cname_space, get_active_function_name(TSRMLS_C)); \ } #else #define CHECK_MGD(handle) \ { \ if (!handle) { \ zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to get connection"); \ return; \ } \ gchar *_check_cname_space = NULL; \ gchar *_check_class_name = get_active_class_name(&_check_cname_space TSRMLS_CC); \ g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, " %s%s%s(...)", \ _check_class_name, _check_cname_space, get_active_function_name(TSRMLS_C)); \ } #endif /* RAGNAROEK COMPATIBLE*/ extern zend_class_entry *php_midgard_connection_class; extern zend_class_entry *php_midgard_config_class; extern zend_class_entry *php_midgard_collector_class; extern zend_class_entry *php_midgard_query_builder_class; extern zend_class_entry *php_midgard_reflection_property_class; extern zend_class_entry *php_midgard_user_class; extern zend_class_entry *ce_midgard_error_exception; extern zend_class_entry *php_midgard_datetime_class; extern zend_class_entry *php_midgard_workspace_storage_class; extern zend_class_entry *php_midgard_workspace_class; extern zend_class_entry *php_midgard_reflector_object_class; extern zend_class_entry *php_midgard_reflector_property_class; extern zend_class_entry *php_midgard_query_executor_class; extern zend_class_entry *php_midgard_query_constraint_simple_class; #define __php_objstore_object(instance) ((php_midgard_gobject *)zend_object_store_get_object(instance TSRMLS_CC)) #define __php_gobject_ptr(instance) (__php_objstore_object(instance)->gobject) #define __midgard_connection_get_ptr(instance) MIDGARD_CONNECTION(__php_gobject_ptr(instance)) #define __midgard_object_get_ptr(instance) MIDGARD_OBJECT(__php_gobject_ptr(instance)) #define __midgard_dbobject_get_ptr(instance) MIDGARD_DBOBJECT(__php_gobject_ptr(instance)) #define MGD_PHP_SET_GOBJECT_G(instance, object) (__php_gobject_ptr(instance) = object) #define MGD_PHP_SET_GOBJECT(instance, object) MGD_PHP_SET_GOBJECT_G(instance, G_OBJECT(object)) #endif /* PHP_MIDGARD_H */ php5-midgard2-10.05.7/.travis/0000775000175000017500000000000011730073440013436 5ustar ppppphp5-midgard2-10.05.7/.travis/install.sh0000775000175000017500000000156611730073440015453 0ustar pppp#!/bin/bash # Install Pake pyrus channel-discover pear.indeyets.ru pyrus install -f http://pear.indeyets.ru/get/pake-1.6.3.tgz # Options MIDGARD_LIBS_VERSION=10.05.5.1-1 MIDGARD_EXT_VERSION=ratatoskr # Install Midgard2 library dependencies from OBS sudo apt-get install -y dbus libglib2.0-dev libgda-4.0-4 libgda-4.0-dev libxml2-dev libdbus-1-dev libdbus-glib-1-dev valgrind php-pear # Build Midgard2 core from recent tarball wget -q https://github.com/midgardproject/midgard-core/tarball/${MIDGARD_EXT_VERSION} tar -xzf ratatoskr sh -c "cd midgardproject-midgard-core-*&&./autogen.sh --prefix=/usr; make; sudo make install" rm -f ${MIDGARD_EXT_VERSION} # Build and install the Midgard2 extension php `pyrus get php_dir|tail -1`/pake.php install # Enable dynamic loading of extensions in PHP echo "enable_dl=On" >> `php --ini | grep "Loaded Configuration" | sed -e "s|.*:\s*||"` php5-midgard2-10.05.7/.travis/test.sh0000775000175000017500000000055111730073440014755 0ustar pppp#!/bin/bash # PHPUnit tests sudo /usr/bin/pear install -f pear sudo /usr/bin/pear channel-discover pear.phpunit.de sudo /usr/bin/pear channel-discover pear.symfony-project.com sudo /usr/bin/pear install --alldeps phpunit/PHPUnit sh -c "cd phpunit&&php -c midgard2.ini /usr/bin/phpunit -c phpunit_sqlite.xml.dist" php `pyrus get php_dir|tail -1`/pake.php test php5-midgard2-10.05.7/php_midgard_query_constraints.c0000664000175000017500000003676411730073440020366 0ustar pppp/* Copyright (C) 2010 Alexey Zakhlestin * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_query.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" static void php_midgard_array_from_constraints(MidgardQueryConstraintSimple **objects, guint n_objects, zval *zarray TSRMLS_DC); zend_class_entry *php_midgard_query_constraint_simple_class = NULL; zend_class_entry *php_midgard_query_constraint_class; zend_class_entry *php_midgard_query_constraint_group_class; // midgard_query_constraint_simple static PHP_METHOD(midgard_query_constraint_simple, list_constraints) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryConstraintSimple *object = MIDGARD_QUERY_CONSTRAINT_SIMPLE(__php_gobject_ptr(getThis())); guint n_objects; MidgardQueryConstraintSimple **constraints = midgard_query_constraint_simple_list_constraints(object, &n_objects); array_init(return_value); if (constraints) { php_midgard_array_from_constraints(constraints, n_objects, return_value TSRMLS_CC); g_free(constraints); } } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_simple_list_constraints, 0, 0, 0) ZEND_END_ARG_INFO() // midgard_query_constraint static PHP_METHOD(midgard_query_constraint, __construct) { char *operator = NULL; int operator_len = 0; zval *z_property = NULL; zval *z_holder = NULL; zval *z_storage = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO|O", &z_property, php_midgard_query_property_class, &operator, &operator_len, &z_holder, php_midgard_query_holder_class, &z_storage, php_midgard_query_storage_class ) == FAILURE ) { return; } MidgardQueryProperty *property = MIDGARD_QUERY_PROPERTY(__php_gobject_ptr(z_property)); MidgardQueryHolder *holder = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(z_holder)); MidgardQueryStorage *storage = NULL; if (z_storage) { storage = MIDGARD_QUERY_STORAGE(__php_gobject_ptr(z_storage)); } MidgardQueryConstraint *constraint = midgard_query_constraint_new(property, operator, holder, storage); if (!constraint) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint"); return; } MGD_PHP_SET_GOBJECT(getThis(), constraint); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint___construct, 0, 0, 3) ZEND_ARG_OBJ_INFO(0, property, midgard_query_property, 0) ZEND_ARG_INFO(0, operator) ZEND_ARG_OBJ_INFO(0, holder, midgard_query_holder, 0) ZEND_ARG_OBJ_INFO(0, storage, midgard_query_storage, 1) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_constraint, get_storage) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryConstraint *constraint = MIDGARD_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); MidgardQueryStorage *storage = midgard_query_constraint_get_storage(constraint); if (!storage) { return; } object_init_ex(return_value, php_midgard_query_storage_class); MGD_PHP_SET_GOBJECT(return_value, storage); // ^^^ no need to call constructor, as constructor doesn't do any magic here } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_get_storage, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_constraint, set_storage) { zval *z_storage = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_storage, php_midgard_query_storage_class) == FAILURE) { return; } MidgardQueryConstraint *constraint = MIDGARD_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); MidgardQueryStorage *storage = MIDGARD_QUERY_STORAGE(__php_gobject_ptr(z_storage)); zend_bool result = midgard_query_constraint_set_storage(constraint, storage); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_set_storage, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, storage, midgard_query_storage, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_constraint, get_property) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryConstraint *constraint = MIDGARD_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); MidgardQueryProperty *property = midgard_query_constraint_get_property(constraint); if (!property) { return; } object_init_ex(return_value, php_midgard_query_property_class); MGD_PHP_SET_GOBJECT(return_value, property); // ^^^ no need to call constructor, as constructor doesn't do any magic here } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_get_property, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_constraint, set_property) { zval *z_property = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_property, php_midgard_query_property_class) == FAILURE) { return; } MidgardQueryConstraint *constraint = MIDGARD_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); MidgardQueryProperty *property = MIDGARD_QUERY_PROPERTY(__php_gobject_ptr(z_property)); zend_bool result = midgard_query_constraint_set_property(constraint, property); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_set_property, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, property, midgard_query_property, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_constraint, get_operator) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryConstraint *constraint = MIDGARD_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); const gchar *operator = midgard_query_constraint_get_operator(constraint); if (!operator) { return; } RETURN_STRING(operator, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_get_operator, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_constraint, set_operator) { char *operator = NULL; int operator_len = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &operator, &operator_len) == FAILURE) { return; } MidgardQueryConstraint *constraint = MIDGARD_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); zend_bool result = (zend_bool) midgard_query_constraint_set_operator(constraint, operator); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_set_operator, 0, 0, 1) ZEND_ARG_INFO(0, operator) ZEND_END_ARG_INFO() // midgard_query_constraint_group static PHP_METHOD(midgard_query_constraint_group, __construct) { char *type = "AND"; int type_len = 3, num_varargs = 0; zval ***varargs = NULL; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &type, &type_len) == FAILURE) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to create constraint group"); return; } #else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s*", &type, &type_len, &varargs, &num_varargs) == FAILURE) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to create constraint group"); return; } #endif MidgardQueryConstraintGroup *constraint_group = NULL; if (num_varargs) { MidgardQueryConstraintSimple **constraints = ecalloc(num_varargs, sizeof(MidgardQueryConstraintSimple *)); size_t i; for (i = 0; i < num_varargs; i++) { constraints[i] = MIDGARD_QUERY_CONSTRAINT_SIMPLE(__php_gobject_ptr(*varargs[i])); } efree(varargs); constraint_group = midgard_query_constraint_group_new_with_constraints(type, constraints, num_varargs); efree(constraints); if (!constraint_group) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint group"); return; } } else { constraint_group = midgard_query_constraint_group_new(); if (!constraint_group) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint group"); return; } zend_bool result = midgard_query_constraint_group_set_group_type(constraint_group, type); if (!result) { g_object_unref(constraint_group); zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint group: couldn't set type"); return; } } MGD_PHP_SET_GOBJECT(getThis(), constraint_group); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_group___construct, 0, 0, 0) ZEND_ARG_INFO(0, type) #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 2 #else ZEND_ARG_OBJ_INFO(0, constraint, midgard_query_constraint_simple, 1) ZEND_ARG_INFO(0, ...) #endif ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_constraint_group, get_type) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryConstraintGroup *constraint_group = MIDGARD_QUERY_CONSTRAINT_GROUP(__php_gobject_ptr(getThis())); const gchar *type = midgard_query_constraint_group_get_group_type(constraint_group); if (!type) { return; } RETURN_STRING(type, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_group_get_type, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_constraint_group, set_type) { char *type = NULL; int type_len = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &type, &type_len) == FAILURE) { return; } MidgardQueryConstraintGroup *constraint_group = MIDGARD_QUERY_CONSTRAINT_GROUP(__php_gobject_ptr(getThis())); zend_bool result = midgard_query_constraint_group_set_group_type(constraint_group, type); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_group_set_type, 0, 0, 1) ZEND_ARG_INFO(0, type) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_constraint_group, add_constraint) { zval *z_constraint = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_constraint, php_midgard_query_constraint_simple_class) == FAILURE) { return; } MidgardQueryConstraintGroup *constraint_group = MIDGARD_QUERY_CONSTRAINT_GROUP(__php_gobject_ptr(getThis())); MidgardQueryConstraintSimple *constraint = MIDGARD_QUERY_CONSTRAINT_SIMPLE(__php_gobject_ptr(z_constraint)); zend_bool result = midgard_query_constraint_group_add_constraint(constraint_group, constraint); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_constraint_group_add_constraint, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, constraint, midgard_query_constraint_simple, 0) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_query_constraints) { static zend_function_entry midgard_query_constraint_simple_methods[] = { PHP_ME(midgard_query_constraint_simple, list_constraints, arginfo_midgard_query_constraint_simple_list_constraints, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_constraint_simple_class_entry; INIT_CLASS_ENTRY(php_midgard_query_constraint_simple_class_entry, "MidgardQueryConstraintSimple", midgard_query_constraint_simple_methods); php_midgard_query_constraint_simple_class = zend_register_internal_class(&php_midgard_query_constraint_simple_class_entry TSRMLS_CC); php_midgard_query_constraint_simple_class->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; php_midgard_query_constraint_simple_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_constraint_simple_class, strdup("Base class for holding constraint information for midgard_query")); zend_register_class_alias("midgard_query_constraint_simple", php_midgard_query_constraint_simple_class); static zend_function_entry midgard_query_constraint_methods[] = { PHP_ME(midgard_query_constraint, __construct, arginfo_midgard_query_constraint___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_query_constraint, get_storage, arginfo_midgard_query_constraint_get_storage, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_constraint, set_storage, arginfo_midgard_query_constraint_set_storage, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_constraint, get_property, arginfo_midgard_query_constraint_get_property, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_constraint, set_property, arginfo_midgard_query_constraint_set_property, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_constraint, get_operator, arginfo_midgard_query_constraint_get_operator, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_constraint, set_operator, arginfo_midgard_query_constraint_set_operator, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_constraint_class_entry; INIT_CLASS_ENTRY(php_midgard_query_constraint_class_entry, "MidgardQueryConstraint", midgard_query_constraint_methods); php_midgard_query_constraint_class = zend_register_internal_class_ex(&php_midgard_query_constraint_class_entry, php_midgard_query_constraint_simple_class, "midgard_query_constraint_simple" TSRMLS_CC); php_midgard_query_constraint_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_constraint_class, strdup("Class for holding simple constraint in midgard_query")); zend_register_class_alias("midgard_query_constraint", php_midgard_query_constraint_class); static zend_function_entry midgard_query_constraint_group_methods[] = { PHP_ME(midgard_query_constraint_group, __construct, arginfo_midgard_query_constraint_group___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_query_constraint_group, get_type, arginfo_midgard_query_constraint_group_get_type, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_constraint_group, set_type, arginfo_midgard_query_constraint_group_set_type, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_constraint_group, add_constraint, arginfo_midgard_query_constraint_group_add_constraint, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_constraint_group_class_entry; INIT_CLASS_ENTRY(php_midgard_query_constraint_group_class_entry, "MidgardQueryConstraintGroup", midgard_query_constraint_group_methods); php_midgard_query_constraint_group_class = zend_register_internal_class_ex(&php_midgard_query_constraint_group_class_entry, php_midgard_query_constraint_simple_class, "midgard_query_constraint_group" TSRMLS_CC); php_midgard_query_constraint_group_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_constraint_group_class, strdup("Class for holding group of constraints in midgard_query")); zend_register_class_alias("midgard_query_constraint_group", php_midgard_query_constraint_group_class); return SUCCESS; } // =========================== // = Helper-functions follow = // =========================== static void php_midgard_array_from_constraints(MidgardQueryConstraintSimple **objects, guint n_objects, zval *zarray TSRMLS_DC) { if (!objects) return; size_t i; for (i = 0; i < n_objects; i++) { MidgardQueryConstraintSimple *constraint = objects[i]; zend_class_entry *ce = NULL; if (MIDGARD_IS_QUERY_CONSTRAINT(constraint)) { ce = php_midgard_query_constraint_class; } else if (MIDGARD_IS_QUERY_CONSTRAINT_GROUP(constraint)) { ce = php_midgard_query_constraint_group_class; } else { php_error_docref(NULL TSRMLS_CC, E_ERROR, "found constraint of unknown class. midgard-php has to be fixed"); return; } zval *zobject; MAKE_STD_ZVAL(zobject); g_object_ref(constraint); php_midgard_gobject_new_with_gobject(zobject, ce, G_OBJECT(constraint), TRUE TSRMLS_CC); zend_hash_next_index_insert(HASH_OF(zarray), &zobject, sizeof(zval *), NULL); } } php5-midgard2-10.05.7/php_midgard_user.c0000664000175000017500000002266411730073440015542 0ustar pppp/* Copyright (C) 2007 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" #include zend_class_entry *php_midgard_user_class; #define _GET_USER_OBJECT \ zval *zval_object = getThis(); \ MidgardUser *user = MIDGARD_USER(__php_gobject_ptr(zval_object)); \ if (!user) \ php_error(E_ERROR, "Can not find underlying user instance"); /* Object constructor */ static PHP_METHOD(midgard_user, __construct) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zval_object = getThis(); GObject *gobject; gobject = __php_gobject_ptr(zval_object); if (!gobject) { zval *params = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶ms) != SUCCESS) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "invalid parameter-list passed"); return; } guint n_params = 0; GParameter *parameters = php_midgard_array_to_gparameter(params, &n_params TSRMLS_CC); MidgardUser *user = midgard_user_new(mgd, n_params, parameters); PHP_MGD_FREE_GPARAMETERS(parameters, n_params); if (!user) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } MGD_PHP_SET_GOBJECT(zval_object, user); } else { // we already have gobject injected } } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_user___construct, 0, 1, 1) ZEND_ARG_INFO(0, properties) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, set_person) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zobject; zend_bool rv = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobject) == FAILURE) return; _GET_USER_OBJECT; MidgardObject *person = __midgard_object_get_ptr(zobject); rv = midgard_user_set_person(user, person); RETURN_BOOL (rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_user_set_person, 0, 0, 1) ZEND_ARG_OBJ_INFO (0, person, midgard_person, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, get_person) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zend_class_entry *person_ce = php_midgard_get_mgdschema_class_ptr_by_name("midgard_person" TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) return; _GET_USER_OBJECT; MidgardObject *person = midgard_user_get_person(user); if (person == NULL) RETURN_NULL(); g_object_ref(person); // we need to keep additional reference, because midgard_user_get_person doesn't transfer php_midgard_gobject_new_with_gobject(return_value, person_ce, G_OBJECT(person), TRUE TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_user_get_person, 0, 1, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, is_user) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_USER_OBJECT; RETURN_BOOL(midgard_user_is_user(user)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_user_is_user, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, is_admin) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_USER_OBJECT; RETURN_BOOL(midgard_user_is_admin(user)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_user_is_admin, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, get) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *params = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", ¶ms) != SUCCESS) return; guint n_params = 0; GParameter *parameters = php_midgard_array_to_gparameter(params, &n_params TSRMLS_CC); MidgardUser *user = midgard_user_get(mgd, n_params, parameters); PHP_MGD_FREE_GPARAMETERS(parameters, n_params); if (user == NULL) RETURN_NULL(); /* HACK, there's no safe API for this (or at least is unknown for me) */ #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 const char *class_name = EG(scope)->name; #else char *class_name = EG(scope)->name; #endif zend_class_entry *ce = zend_fetch_class(class_name, strlen(class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); php_midgard_gobject_new_with_gobject(return_value, ce, G_OBJECT(user), TRUE TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_user_get, 0, 1, 1) ZEND_ARG_INFO(0, properties) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, query) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *params = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", ¶ms) != SUCCESS) return; guint n_params = 0; GParameter *parameters = php_midgard_array_to_gparameter(params, &n_params TSRMLS_CC); MidgardUser **users = midgard_user_query(mgd, n_params, parameters); PHP_MGD_FREE_GPARAMETERS(parameters, n_params); array_init(return_value); if (!users) return; guint i = 0; while (users[i] != NULL) { zval *zobject; MAKE_STD_ZVAL(zobject); object_init_ex(zobject, php_midgard_user_class); MGD_PHP_SET_GOBJECT(zobject, users[i]); zend_hash_next_index_insert(HASH_OF(return_value), &zobject, sizeof(zval *), NULL); } } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_user_query, 0, 0, 1) ZEND_ARG_INFO(0, properties) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, create) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_USER_OBJECT; RETURN_BOOL(midgard_user_create(user)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_user_create, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, update) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_USER_OBJECT; RETURN_BOOL(midgard_user_update(user)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_user_update, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, delete) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_USER_OBJECT; RETURN_BOOL(midgard_user_delete(user)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_user_delete, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, login) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_USER_OBJECT; RETURN_BOOL(midgard_user_log_in(user)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_user_login, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_user_root_login, 0, 0, 2) ZEND_ARG_INFO(0, login) ZEND_ARG_INFO(0, password) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_user, logout) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_USER_OBJECT; RETURN_BOOL(midgard_user_log_out(user)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_user_logout, 0) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_user) { static zend_function_entry midgard_user_methods[] = { PHP_ME(midgard_user, get, arginfo_midgard_user_get, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_user, query, arginfo_midgard_user_query, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_user, __construct, arginfo_midgard_user___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_user, is_user, arginfo_midgard_user_is_user, ZEND_ACC_PUBLIC) PHP_ME(midgard_user, is_admin, arginfo_midgard_user_is_admin, ZEND_ACC_PUBLIC) PHP_ME(midgard_user, set_person, arginfo_midgard_user_set_person, ZEND_ACC_PUBLIC) PHP_ME(midgard_user, get_person, arginfo_midgard_user_get_person, ZEND_ACC_PUBLIC) PHP_ME(midgard_user, create, arginfo_midgard_user_create, ZEND_ACC_PUBLIC) PHP_ME(midgard_user, update, arginfo_midgard_user_update, ZEND_ACC_PUBLIC) PHP_ME(midgard_user, delete, arginfo_midgard_user_delete, ZEND_ACC_PUBLIC) PHP_ME(midgard_user, login, arginfo_midgard_user_login, ZEND_ACC_PUBLIC) PHP_ME(midgard_user, logout, arginfo_midgard_user_logout, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_user_class_entry; INIT_CLASS_ENTRY(php_midgard_user_class_entry, "MidgardUser", midgard_user_methods); php_midgard_user_class = zend_register_internal_class_ex(&php_midgard_user_class_entry, NULL, "midgard_dbobject" TSRMLS_CC); /* Set function to initialize underlying data */ php_midgard_user_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_user_class, strdup("Midgard's Authentication API")); php_midgard_user_class->serialize = php_midgard_serialize_dbobject_hook; php_midgard_user_class->unserialize = php_midgard_unserialize_dbobject_hook; zend_register_class_alias("midgard_user", php_midgard_user_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_repligard.c0000664000175000017500000000277511730073440016536 0ustar pppp/* * Copyright (C) 2009 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard_object.h" #include "php_midgard__helpers.h" zend_class_entry *php_midgard_repligard_class = NULL; PHP_MINIT_FUNCTION(midgard2_repligard) { /* Register midgard_repligard class */ static zend_class_entry php_midgard_repligard_ce; INIT_CLASS_ENTRY(php_midgard_repligard_ce, "MidgardRepligard", NULL); php_midgard_repligard_class = zend_register_internal_class_ex(&php_midgard_repligard_ce, php_midgard_dbobject_class, "MidgardDBObject" TSRMLS_CC); php_midgard_repligard_class->ce_flags = ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; zend_register_class_alias("midgard_repligard", php_midgard_repligard_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_timestamp_api.c0000664000175000017500000000602711730073440017413 0ustar pppp#include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard_timestamp.h" gboolean php_midgard_is_property_timestamp(MidgardDBObjectClass *klass, const gchar *property) { g_assert(klass != NULL); g_assert(property != NULL); MidgardReflectionProperty *mrp = midgard_reflection_property_new(MIDGARD_DBOBJECT_CLASS(klass)); GType midgard_type = midgard_reflection_property_get_midgard_type(mrp, property); g_object_unref(mrp); if (midgard_type == MGD_TYPE_TIMESTAMP) return TRUE; return FALSE; } zval *php_midgard_datetime_get_timestamp(const zval *object TSRMLS_DC) { /* Prepare DateTime::format argument */ zval *fmt; MAKE_STD_ZVAL(fmt); ZVAL_STRING(fmt, "c", 1); /* Invoke Datetime::format */ zval *_retval; zend_call_method_with_1_params((zval **)&object, Z_OBJCE_P(object), NULL, "format", &_retval, fmt); zval_ptr_dtor(&fmt); return _retval; } zval *php_midgard_datetime_get_timestamp_from_gval(const GValue *gval TSRMLS_DC) { g_assert(gval != NULL); g_return_val_if_fail(G_VALUE_HOLDS(gval, MGD_TYPE_TIMESTAMP), NULL); GValue str_val = {0, }; g_value_init(&str_val, G_TYPE_STRING); g_value_transform(gval, &str_val); const gchar *timestamp = g_value_get_string(&str_val); if (timestamp == NULL) timestamp = g_strdup(MIDGARD_DEFAULT_DATETIME); zval *date; MAKE_STD_ZVAL(date); ZVAL_STRING(date, (gchar *)timestamp, 1); g_value_unset(&str_val); return date; } void php_midgard_datetime_from_gvalue(const GValue *gval, zval *zvalue TSRMLS_DC) { g_assert(gval != NULL); g_assert(zvalue != NULL); g_return_if_fail(G_VALUE_HOLDS(gval, MGD_TYPE_TIMESTAMP)); zval *date = php_midgard_datetime_get_timestamp_from_gval(gval TSRMLS_CC); if (zvalue == NULL) MAKE_STD_ZVAL(zvalue); object_init_ex(zvalue, php_midgard_datetime_class); zend_call_method_with_1_params(&zvalue, php_midgard_datetime_class, &php_midgard_datetime_class->constructor, "__construct", NULL, date); zval_ptr_dtor(&date); return; } zval *php_midgard_datetime_object_from_property(zval *object, const gchar *property TSRMLS_DC) { g_assert(object != NULL); g_assert(property != NULL); GObject *gobject = __php_gobject_ptr(object); if (gobject == NULL) { php_error(E_ERROR, "Can not find underlying GObject for given %s zend object", Z_OBJCE_P(object)->name); } GValue tprop = {0, }; g_value_init(&tprop, MGD_TYPE_TIMESTAMP); g_object_get_property(gobject, property, &tprop); zval *date = php_midgard_datetime_get_timestamp_from_gval(&tprop TSRMLS_CC); g_value_unset(&tprop); zval *mdate_object; MAKE_STD_ZVAL(mdate_object); object_init_ex(mdate_object, php_midgard_datetime_class); zend_call_method_with_1_params(&mdate_object, php_midgard_datetime_class, &php_midgard_datetime_class->constructor, "__construct", NULL, date); zval_ptr_dtor(&date); zend_update_property_string(php_midgard_datetime_class, mdate_object, "property", sizeof("property")-1, (gchar *)property TSRMLS_CC); zend_update_property(php_midgard_datetime_class, mdate_object, "object", sizeof("object")-1, object TSRMLS_CC); return mdate_object; } php5-midgard2-10.05.7/php_midgard_key_config.c0000664000175000017500000002010311730073440016663 0ustar pppp/* * Copyright (C) 2009 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" static zend_class_entry *php_midgard_key_config_class; static PHP_METHOD(midgard_key_config, set_value) { zval *zval_object = getThis(); char *group = NULL, *key = NULL, *value = NULL; int group_length, key_length, value_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &group, &group_length, &key, &key_length, &value, &value_length) == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); midgard_key_config_set_value (mkc, group, key, value); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_set_value, 0, 0, 3) ZEND_ARG_INFO(0, group_name) ZEND_ARG_INFO(0, key_name) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config, get_value) { zval *zval_object = getThis(); char *group = NULL, *key = NULL; int group_length, key_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &group, &group_length, &key, &key_length) == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); gchar *value = midgard_key_config_get_value (mkc, group, key); if (!value) RETURN_NULL(); RETVAL_STRING(value, 1); g_free(value); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_get_value, 0, 0, 3) ZEND_ARG_INFO(0, group_name) ZEND_ARG_INFO(0, key_name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config, set_comment) { zval *zval_object = getThis(); char *group = NULL, *key = NULL, *comment = NULL; int group_length, key_length, comment_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &group, &group_length, &key, &key_length, &comment, &comment_length) == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); midgard_key_config_set_comment (mkc, group, key, comment); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_set_comment, 0, 0, 3) ZEND_ARG_INFO(0, group_name) ZEND_ARG_INFO(0, key_name) ZEND_ARG_INFO(0, comment) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config, get_comment) { zval *zval_object = getThis(); char *group = NULL, *key = NULL; int group_length, key_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &group, &group_length, &key, &key_length) == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); gchar *comment = midgard_key_config_get_comment (mkc, group, key); if (!comment) RETURN_NULL(); RETVAL_STRING(comment, 1); g_free(comment); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_get_comment, 0, 0, 3) ZEND_ARG_INFO(0, group_name) ZEND_ARG_INFO(0, key_name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config, list_groups) { RETVAL_FALSE; zval *zval_object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); array_init (return_value); gint n_groups; gchar **groups = midgard_key_config_list_groups (mkc, &n_groups); if (!groups) return; guint i; for (i = 0; i < n_groups; i++) { add_assoc_string(return_value, (gchar *)groups[i], "", 1); } g_strfreev(groups); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_key_config_list_groups, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config, group_exists) { zval *zval_object = getThis(); char *group = NULL; int group_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &group, &group_length) == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); RETURN_BOOL(midgard_key_config_group_exists (mkc, group)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_group_exists, 0, 0, 1) ZEND_ARG_INFO(0, group_name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config, delete_group) { zval *zval_object = getThis(); char *group = NULL; int group_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &group, &group_length) == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); RETURN_BOOL(midgard_key_config_delete_group (mkc, group)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_delete_group, 0, 0, 1) ZEND_ARG_INFO(0, group_name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config, store) { zval *zval_object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); RETURN_BOOL(midgard_key_config_store (mkc)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_key_config_store, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config, to_data) { zval *zval_object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); gchar *data = midgard_key_config_to_data (mkc); if (!data) RETURN_NULL(); RETVAL_STRING(data, 1); g_free(data); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_key_config_to_data, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config, load_from_data) { zval *zval_object = getThis(); char *data = NULL; int data_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data, &data_length) == FAILURE) return; MidgardKeyConfig *mkc = (MidgardKeyConfig *) __php_gobject_ptr(zval_object); RETURN_BOOL(midgard_key_config_load_from_data (mkc, data)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_load_from_data, 0, 0, 1) ZEND_ARG_INFO(0, data) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_key_config) { static zend_function_entry midgard_key_config_methods[] = { PHP_ME(midgard_key_config, set_value, arginfo_midgard_key_config_set_value, ZEND_ACC_PUBLIC) PHP_ME(midgard_key_config, get_value, arginfo_midgard_key_config_get_value, ZEND_ACC_PUBLIC) PHP_ME(midgard_key_config, set_comment, arginfo_midgard_key_config_set_comment, ZEND_ACC_PUBLIC) PHP_ME(midgard_key_config, get_comment, arginfo_midgard_key_config_get_comment, ZEND_ACC_PUBLIC) PHP_ME(midgard_key_config, list_groups, arginfo_midgard_key_config_list_groups, ZEND_ACC_PUBLIC) PHP_ME(midgard_key_config, group_exists, arginfo_midgard_key_config_group_exists, ZEND_ACC_PUBLIC) PHP_ME(midgard_key_config, delete_group, arginfo_midgard_key_config_delete_group, ZEND_ACC_PUBLIC) PHP_ME(midgard_key_config, store, arginfo_midgard_key_config_store, ZEND_ACC_PUBLIC) PHP_ME(midgard_key_config, to_data, arginfo_midgard_key_config_to_data, ZEND_ACC_PUBLIC) PHP_ME(midgard_key_config, load_from_data, arginfo_midgard_key_config_load_from_data, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_key_config_class_entry; INIT_CLASS_ENTRY(php_midgard_key_config_class_entry, "MidgardKeyConfig", midgard_key_config_methods); php_midgard_key_config_class = zend_register_internal_class(&php_midgard_key_config_class_entry TSRMLS_CC); php_midgard_key_config_class->ce_flags = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; CLASS_SET_DOC_COMMENT(php_midgard_key_config_class, strdup("Abstract class for key-value (ini like) configurations")); php_midgard_key_config_class->create_object = php_midgard_gobject_new; zend_register_class_alias("midgard_key_config", php_midgard_key_config_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_connection.c0000664000175000017500000004772311730073440016726 0ustar pppp/* Copyright (C) 2007 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard_handle.h" #include "php_midgard__helpers.h" #include zend_class_entry *php_midgard_connection_class; #define PHP_MGD_HASH_UPDATE(k, v) zend_hash_update(Z_ARRVAL_PP(_midgard), k, sizeof(k), v, sizeof(zval *), NULL) /* Object constructor */ PHP_METHOD(midgard_connection, __construct) { MidgardConnection *mgd = NULL; if (MGDG(midgard_memory_debug)) { php_printf("[%p] midgard_connection::__construct()\n", getThis()); } if (zend_parse_parameters_none() == FAILURE) return; if (MGDG(midgard_http)) { /* trying to reuse saved connection */ mgd = php_midgard_handle_lookup(&MGDG(midgard_global_holder), MGDG(all_configs) TSRMLS_CC); if (mgd == NULL) { /* @todo throw exception, instead */ php_error(E_ERROR, "Midgard handle-lookup failed (could not connect to database)"); return; } } else { mgd = midgard_connection_new(); if (mgd == NULL) { /* @todo throw exception, instead */ php_error(E_ERROR, "Failed to create underlying GObject instance"); return; } } if (global_loghandler) { if (MGDG(midgard_memory_debug)) { php_printf("---> g_log_remove_handler(..., %d)\n", global_loghandler); } g_log_remove_handler(G_LOG_DOMAIN, global_loghandler); } // midgard_connection_set_loglevel(mgd, "warning", NULL); global_loghandler = midgard_connection_get_loghandler(mgd); if (MGDG(midgard_memory_debug)) { php_printf("---> global_loghandler = %d\n", global_loghandler); } /* storing midgard_connection in object's store-structure */ MGD_PHP_SET_GOBJECT(getThis(), mgd); // explicitly enable replication (to stay compatible with mjölnir) midgard_connection_enable_replication(mgd, TRUE); if (MGDG(midgard_memory_debug)) { php_printf("[%p] --> glib refcount=%d\n", getThis(), ((GObject *) mgd)->ref_count); php_printf("[%p] <= midgard_connection::__construct()\n", getThis()); } } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection___construct, 0) ZEND_END_ARG_INFO() PHP_METHOD(midgard_connection, __destruct) { if (MGDG(midgard_memory_debug)) { php_printf("[%p] midgard_connection::__destruct()\n", getThis()); } MidgardConnection *mgd = __midgard_connection_get_ptr(getThis()); int loghandler = midgard_connection_get_loghandler(mgd); if (loghandler) { if (MGDG(midgard_memory_debug)) { php_printf("[%p] ---> g_log_remove_handler(..., %d)\n", getThis(), loghandler); } g_log_remove_handler(G_LOG_DOMAIN, loghandler); if (global_loghandler != loghandler && MGDG(midgard_memory_debug)) { php_printf("[%p] ---> (?) global_loghandler != connection's handler\n", getThis()); } // still just null it, as it is not valid anyway global_loghandler = 0; midgard_connection_set_loghandler (mgd, 0); } MGDG(connection_established) = FALSE; if (MGDG(midgard_memory_debug)) { php_printf("[%p] <= midgard_connection::__destruct()\n", getThis()); } } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection___destruct, 0) ZEND_END_ARG_INFO() PHP_METHOD(midgard_connection, get_instance) { zval *instance; if (zend_parse_parameters_none() == FAILURE) { return; } if (MGDG(midgard_memory_debug)) { php_printf(":: midgard_connection::get_instance()\n"); } instance = zend_read_static_property(php_midgard_connection_class, "instance", sizeof("instance")-1, 0 TSRMLS_CC); if (MGDG(midgard_memory_debug)) { php_printf(":: ==> instance=%p\n", instance); } if (ZVAL_IS_NULL(instance)) { object_init_ex(instance, php_midgard_connection_class); zend_call_method_with_0_params(&instance, php_midgard_connection_class, &php_midgard_connection_class->constructor, "__construct", NULL); MGDG(connection_established) = TRUE; } Z_ADDREF_P(instance); if (MGDG(midgard_memory_debug)) { php_printf(":: ==> refcount=%d\n", Z_REFCOUNT_P(instance)); } zval_ptr_dtor(return_value_ptr); *return_value_ptr = instance; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_get_instance, 0, 1, 0) ZEND_END_ARG_INFO() PHP_METHOD(midgard_connection, copy) { if (zend_parse_parameters_none() == FAILURE) return; MidgardConnection *mgd = __midgard_connection_get_ptr(getThis()); MidgardConnection *copy = midgard_connection_copy(mgd); guint loghandler = g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK, php_midgard_log_errors, (gpointer)copy); midgard_connection_set_loghandler(copy, loghandler); MGD_PHP_SET_GOBJECT(getThis(), copy); RETURN_TRUE; } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_copy, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, open) { RETVAL_FALSE; char *cnf_name; int cnf_name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &cnf_name, &cnf_name_length) == FAILURE) return; MidgardConnection *mgd = __midgard_connection_get_ptr(getThis()); gboolean rv = midgard_connection_open(mgd, (const gchar *)cnf_name, NULL); if (rv) { guint loghandler = midgard_connection_get_loghandler(mgd); if (loghandler) g_log_remove_handler(G_LOG_DOMAIN, loghandler); global_loghandler = g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK, php_midgard_log_errors, (gpointer)mgd); midgard_connection_set_loghandler(mgd, global_loghandler); if (MGDG(midgard_memory_debug)) { php_printf("---> global_loghandler = %d\n", global_loghandler); } } RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_open, 0, 0, 1) ZEND_ARG_INFO(0, name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, reopen) { RETVAL_FALSE; zend_bool rv; if (zend_parse_parameters_none() == FAILURE) return; MidgardConnection *mgd = __midgard_connection_get_ptr(getThis()); rv = (zend_bool) midgard_connection_reopen(mgd); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_reopen, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, open_config) { RETVAL_FALSE; zval *cnf_object; zend_bool rv; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &cnf_object, php_midgard_config_class) == FAILURE) return; MidgardConfig *config = MIDGARD_CONFIG(__php_gobject_ptr(cnf_object)); MidgardConnection *mgd = __midgard_connection_get_ptr(getThis()); rv = (zend_bool) midgard_connection_open_config(mgd, config); // if (rv) { // Z_ADDREF_P(cnf_object); // } RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_open_config, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, config, midgard_config, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, is_connected) { RETVAL_FALSE; zend_bool rv; if (zend_parse_parameters_none() == FAILURE) return; MidgardConnection *mgd = __midgard_connection_get_ptr (getThis()); rv = (zend_bool) midgard_connection_is_connected (mgd); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_is_connected, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, get_error) { MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; long err_code = midgard_connection_get_error(mgd); RETURN_LONG(err_code); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_get_error, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, set_error) { MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); long errcode; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &errcode) == FAILURE) return; if (errcode > 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "errcode must be negative"); return; } midgard_connection_set_error(mgd, errcode); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_set_error, 0, 0, 1) ZEND_ARG_INFO(0, errorcode) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, get_error_string) { RETVAL_NULL(); /* Disable debug log for function call. * It resets error. Keep it like this for backward compatibility */ /* CHECK_MGD; */ if (zend_parse_parameters_none() == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); const char *err_string = midgard_connection_get_error_string(mgd); RETURN_STRING((gchar *)err_string, 1); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_get_error_string, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, get_user) { RETVAL_NULL(); MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; MidgardUser *user = midgard_connection_get_user(mgd); if (user == NULL) RETURN_NULL(); g_object_ref(user); // this is a direct-pointer: we need to "ref" it explicitly php_midgard_gobject_new_with_gobject(return_value, php_midgard_user_class, G_OBJECT(user), TRUE TSRMLS_CC); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_get_user, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, set_loglevel) { RETVAL_NULL(); MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); char *level; int level_length; zval *callback; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &level, &level_length, &callback) == FAILURE) return; /* no support for callback atm */ gboolean rv = midgard_connection_set_loglevel(mgd, (gchar *)level, php_midgard_log_errors); global_loghandler = midgard_connection_get_loghandler(mgd); if (MGDG(midgard_memory_debug)) { php_printf("---> global_loghandler = %d\n", global_loghandler); } RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_set_loglevel, 0, 0, 1) ZEND_ARG_INFO(0, level) ZEND_ARG_INFO(0, callback) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_connection, connect) { MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); php_midgard_gobject_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_connect, 0, 0, 2) ZEND_ARG_INFO(0, signal) ZEND_ARG_INFO(0, callback) ZEND_ARG_INFO(0, userdata) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, list_auth_types) { MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); array_init (return_value); if (zend_parse_parameters_none () == FAILURE) return; guint n_types; gchar **auth_types = midgard_connection_list_auth_types(mgd, &n_types); if (!auth_types) return; guint i; for (i = 0; i < n_types; i++) { add_next_index_string(return_value, auth_types[i], 1); } g_free(auth_types); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_list_auth_types, 0) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, enable_workspace) { zend_bool toggle = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &toggle) == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); midgard_connection_enable_workspace(mgd, toggle); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_enable_workspace, 0, 0, 1) ZEND_ARG_INFO(0, toggle) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, is_enabled_workspace) { if (zend_parse_parameters_none() == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); zend_bool rv = midgard_connection_is_enabled_workspace(mgd); RETURN_BOOL (rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_is_enabled_workspace, 0) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, enable_replication) { zend_bool toggle = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &toggle) == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); midgard_connection_enable_replication(mgd, toggle); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_enable_replication, 0, 0, 1) ZEND_ARG_INFO(0, toggle) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, is_enabled_replication) { if (zend_parse_parameters_none() == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); zend_bool rv = midgard_connection_is_enabled_replication(mgd); RETURN_BOOL (rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_is_enabled_replication, 0) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, enable_quota) { zend_bool toggle = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &toggle) == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); midgard_connection_enable_quota(mgd, toggle); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_enable_quota, 0, 0, 1) ZEND_ARG_INFO(0, toggle) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, is_enabled_quota) { if (zend_parse_parameters_none() == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); zend_bool rv = midgard_connection_is_enabled_quota(mgd); RETURN_BOOL (rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_is_enabled_quota, 0) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, enable_dbus) { zend_bool toggle = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &toggle) == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); midgard_connection_enable_dbus(mgd, toggle); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_connection_enable_dbus, 0, 0, 1) ZEND_ARG_INFO(0, toggle) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, is_enabled_dbus) { if (zend_parse_parameters_none() == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); zend_bool rv = midgard_connection_is_enabled_dbus(mgd); RETURN_BOOL (rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_is_enabled_dbus, 0) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, get_workspace) { if (zend_parse_parameters_none() == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); const MidgardWorkspaceStorage *workspace = midgard_connection_get_workspace(mgd); if (!workspace) return; const char *g_class_name = G_OBJECT_TYPE_NAME (workspace); zend_class_entry *ce = zend_fetch_class ((char *) g_class_name, strlen (g_class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); php_midgard_gobject_new_with_gobject (return_value, ce, g_object_ref (G_OBJECT (workspace)), TRUE TSRMLS_CC); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_connection_get_workspace, 0) ZEND_END_ARG_INFO() static PHP_METHOD (midgard_connection, set_workspace) { zval *z_workspace; if (zend_parse_parameters (ZEND_NUM_ARGS () TSRMLS_CC, "O", &z_workspace, php_midgard_workspace_storage_class) == FAILURE) return; MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); MidgardWorkspaceStorage *workspace = MIDGARD_WORKSPACE_STORAGE (__php_gobject_ptr (z_workspace)); zend_bool rv = midgard_connection_set_workspace(mgd, workspace); RETURN_BOOL (rv); } ZEND_BEGIN_ARG_INFO_EX (arginfo_midgard_connection_set_workspace, 0, 0, 1) ZEND_ARG_OBJ_INFO (0, workspace, midgard_workspace_storage, 0) ZEND_END_ARG_INFO() int __serialize_cnc_hook(zval *zobject, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC) { php_error(E_WARNING, "Unable to serialize midgard_connection object"); return FAILURE; } int __unserialize_cnc_hook(zval **zobject, zend_class_entry *ce, const unsigned char *buffer, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC) { php_error(E_WARNING, "Unable to unserialize midgard_connection object"); return FAILURE; } PHP_MINIT_FUNCTION(midgard2_connection) { static zend_function_entry connection_methods[] = { PHP_ME(midgard_connection, __construct, arginfo_midgard_connection___construct, ZEND_ACC_PRIVATE | ZEND_ACC_CTOR) PHP_ME(midgard_connection, __destruct, arginfo_midgard_connection___destruct, ZEND_ACC_PUBLIC | ZEND_ACC_DTOR) PHP_ME(midgard_connection, get_instance, arginfo_midgard_connection_get_instance, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_connection, copy, arginfo_midgard_connection_copy, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, open, arginfo_midgard_connection_open, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, reopen, arginfo_midgard_connection_reopen, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, open_config, arginfo_midgard_connection_open_config, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, is_connected, arginfo_midgard_connection_is_connected, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, connect, arginfo_midgard_connection_connect, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, get_error, arginfo_midgard_connection_get_error, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, set_error, arginfo_midgard_connection_set_error, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, get_error_string, arginfo_midgard_connection_get_error_string, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, get_user, arginfo_midgard_connection_get_user, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, set_loglevel, arginfo_midgard_connection_set_loglevel, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, list_auth_types, arginfo_midgard_connection_list_auth_types, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, enable_workspace, arginfo_midgard_connection_enable_workspace, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, is_enabled_workspace, arginfo_midgard_connection_is_enabled_workspace, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, enable_replication, arginfo_midgard_connection_enable_replication, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, is_enabled_replication, arginfo_midgard_connection_is_enabled_replication, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, enable_dbus, arginfo_midgard_connection_enable_dbus, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, is_enabled_dbus, arginfo_midgard_connection_is_enabled_dbus, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, enable_quota, arginfo_midgard_connection_enable_quota, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, is_enabled_quota, arginfo_midgard_connection_is_enabled_quota, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, get_workspace, arginfo_midgard_connection_get_workspace, ZEND_ACC_PUBLIC) PHP_ME(midgard_connection, set_workspace, arginfo_midgard_connection_set_workspace, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_connection_class_entry; INIT_CLASS_ENTRY(php_midgard_connection_class_entry, "MidgardConnection", connection_methods); php_midgard_connection_class = zend_register_internal_class(&php_midgard_connection_class_entry TSRMLS_CC); php_midgard_connection_class->create_object = php_midgard_gobject_new; php_midgard_connection_class->serialize = __serialize_cnc_hook; php_midgard_connection_class->unserialize = __unserialize_cnc_hook; CLASS_SET_DOC_COMMENT(php_midgard_connection_class, strdup("midgard_connection class represents connection to underlying data-source and is responsible for holding and setting environmental variables (like error, authenticated user, debug level, etc.)")); zend_declare_property_null(php_midgard_connection_class, "instance", sizeof("instance")-1, ZEND_ACC_PRIVATE|ZEND_ACC_STATIC TSRMLS_CC); zend_register_class_alias("midgard_connection", php_midgard_connection_class); return SUCCESS; } php5-midgard2-10.05.7/.travis.yml0000664000175000017500000000023411730073440014160 0ustar pppplanguage: php php: - 5.3 - 5.4 before_script: - ./.travis/install.sh script: ./.travis/test.sh notifications: irc: "irc.freenode.org#midgard" php5-midgard2-10.05.7/php_midgard_object_parameter.c0000664000175000017500000001370711730073440020070 0ustar pppp/* * Copyright (C) 2006, 2007 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" PHP_FUNCTION(_php_midgard_object_list_parameters) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *domain = NULL; int domain_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &domain, &domain_length) != SUCCESS) { return; } array_init(return_value); MidgardObject *mobj = __midgard_object_get_ptr(getThis()); MidgardObject **objects = midgard_object_list_parameters(mobj, domain); if (objects) { php_midgard_array_from_objects((GObject **)objects, "midgard_parameter", return_value TSRMLS_CC); g_free(objects); } } PHP_FUNCTION(php_midgard_object_has_parameters) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *mobj = __midgard_object_get_ptr(getThis()); zend_bool rv = (zend_bool)midgard_object_has_parameters(mobj); RETURN_BOOL(rv); } PHP_FUNCTION(_php_midgard_object_delete_parameters) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *params = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶ms) != SUCCESS) { return; } MidgardObject *mobj = __midgard_object_get_ptr(getThis()); guint n_params = 0; GParameter *parameters = php_midgard_array_to_gparameter(params, &n_params TSRMLS_CC); zend_bool rv = (zend_bool) midgard_object_delete_parameters(mobj, n_params, parameters); PHP_MGD_FREE_GPARAMETERS(parameters, n_params); RETURN_BOOL(rv); } PHP_FUNCTION(_php_midgard_object_purge_parameters) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *params = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶ms) != SUCCESS) { return; } MidgardObject *mobj = __midgard_object_get_ptr(getThis()); guint n_params = 0; GParameter *parameters = php_midgard_array_to_gparameter(params, &n_params TSRMLS_CC); zend_bool rv = (zend_bool) midgard_object_purge_parameters(mobj, n_params, parameters); PHP_MGD_FREE_GPARAMETERS(parameters, n_params); RETURN_BOOL(rv); } PHP_FUNCTION(_php_midgard_object_find_parameters) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *params = NULL; MidgardObject **objects = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", ¶ms) != SUCCESS) { return; } array_init(return_value); MidgardObject *mobj = __midgard_object_get_ptr(getThis()); guint n_params = 0; GParameter *parameters = php_midgard_array_to_gparameter(params, &n_params TSRMLS_CC); objects = midgard_object_find_parameters(mobj, n_params, parameters); PHP_MGD_FREE_GPARAMETERS(parameters, n_params); if (objects) { php_midgard_array_from_objects((GObject **)objects, "midgard_parameter", return_value TSRMLS_CC); g_free(objects); } } PHP_FUNCTION(_php_midgard_object_get_parameter) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *domain, *name; int domain_length, name_length; const GValue *gvalue = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &domain, &domain_length, &name, &name_length) != SUCCESS) { return; } MidgardObject *mobj = __midgard_object_get_ptr(getThis()); gvalue = midgard_object_get_parameter(mobj, domain, name); if (gvalue == NULL) RETURN_NULL(); php_midgard_gvalue2zval(gvalue, return_value TSRMLS_CC); } PHP_FUNCTION(_php_midgard_object_set_parameter) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *domain, *name, *strval; int domain_length, name_length, strval_length; zend_bool zbool = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|z", &domain, &domain_length, &name, &name_length, &strval, &strval_length, &zbool) != SUCCESS) { return; } MidgardObject *mobj = __midgard_object_get_ptr(getThis()); if (strval == NULL) strval = ""; GValue *sval = g_new0 (GValue, 1); g_value_init(sval, G_TYPE_STRING); g_value_set_string(sval, strval); gboolean rv = midgard_object_set_parameter(mobj, domain, name, sval); RETURN_BOOL(rv); } PHP_FUNCTION(_php_midgard_object_parameter) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *domain, *name, *strval = NULL; int domain_length, name_length, strval_length; int _args = ZEND_NUM_ARGS(); if (zend_parse_parameters(_args TSRMLS_CC, "ss|s", &domain, &domain_length, &name, &name_length, &strval, &strval_length) != SUCCESS) { return; } MidgardObject *mobj = __midgard_object_get_ptr(getThis()); switch (_args) { case 2: // get parameter { const GValue *gvalue = midgard_object_get_parameter(mobj, domain, name); if (gvalue != NULL) php_midgard_gvalue2zval((GValue *)gvalue, return_value TSRMLS_CC); else RETURN_NULL(); } break; case 3: // set parameter { if (strval == NULL) strval = ""; GValue *sval = g_new0(GValue, 1); g_value_init(sval, G_TYPE_STRING); g_value_set_string(sval, strval); gboolean rv = midgard_object_set_parameter(mobj, domain, name, (GValue *)sval); RETURN_BOOL(rv); } break; } } php5-midgard2-10.05.7/php_midgard_functions.c0000664000175000017500000000113011730073440016555 0ustar pppp#include "php_midgard.h" #include "php_midgard__helpers.h" PHP_FUNCTION(mgd_version) { if (zend_parse_parameters_none() == FAILURE) return; const gchar *version = midgard_version(); if (!version) version = ""; RETURN_STRING((char *)version, 1); } PHP_FUNCTION(mgd_is_guid) { zval *guid_zval = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &guid_zval) == FAILURE) { return; } if (Z_TYPE_P(guid_zval) != IS_STRING) { // this should fail without an error RETURN_FALSE; } gchar *guid = (gchar *)Z_STRVAL_P(guid_zval); RETURN_BOOL(midgard_is_guid(guid)); } php5-midgard2-10.05.7/php_midgard_query_holders.c0000664000175000017500000001436611730073440017451 0ustar pppp/* Copyright (C) 2010 Alexey Zakhlestin * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_query.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" zend_class_entry *php_midgard_query_holder_class; zend_class_entry *php_midgard_query_property_class; zend_class_entry *php_midgard_query_value_class; static PHP_METHOD(midgard_query_holder, get_value) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryHolder *holder = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(getThis())); GValue val = {0, }; midgard_query_holder_get_value(holder, &val); zend_bool result = php_midgard_gvalue2zval(&val, return_value TSRMLS_CC); if (!result) { RETURN_FALSE; } } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_holder_get_value, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_holder, set_value) { zval *value = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) { return; } MidgardQueryHolder *holder = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(getThis())); GValue *tmp = php_midgard_zval2gvalue(value TSRMLS_CC); zend_bool result = (zend_bool) midgard_query_holder_set_value(holder, (const GValue *) tmp); g_value_unset(tmp); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_holder_set_value, 0, 0, 1) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_property, __construct) { char *property_name; int property_name_length = 0; zval *z_storage = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|O", &property_name, &property_name_length, &z_storage, php_midgard_query_storage_class) == FAILURE) { return; } MidgardQueryStorage *storage = NULL; if (z_storage) storage = MIDGARD_QUERY_STORAGE(__php_gobject_ptr(z_storage)); MidgardQueryProperty *property = midgard_query_property_new(property_name, storage); if (!property) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Can not wrap this property in midgard_query_property"); return; } MGD_PHP_SET_GOBJECT(getThis(), property); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_property___construct, 0, 0, 1) ZEND_ARG_INFO(0, property_name) ZEND_ARG_OBJ_INFO(0, storage, midgard_query_storage, 1) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_value, __construct) { zval *zvalue = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &zvalue) == FAILURE) { return; } MidgardQueryValue *qvalue; if (zvalue) { GValue *tmp = php_midgard_zval2gvalue(zvalue TSRMLS_CC); qvalue = midgard_query_value_create_with_value((const GValue *)tmp); g_value_unset(tmp); g_free(tmp); } else { qvalue = midgard_query_value_new(); } if (!qvalue) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Can not wrap this value in midgard_query_value"); return; } MGD_PHP_SET_GOBJECT(getThis(), qvalue); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_value___construct, 0, 0, 0) ZEND_ARG_INFO(0, data) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_query_holders) { static zend_function_entry midgard_query_holder_methods[] = { PHP_ME(midgard_query_holder, get_value, arginfo_midgard_query_holder_get_value, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_holder, set_value, arginfo_midgard_query_holder_set_value, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_holder_class_entry; INIT_CLASS_ENTRY(php_midgard_query_holder_class_entry, "MidgardQueryHolder", midgard_query_holder_methods); php_midgard_query_holder_class = zend_register_internal_class(&php_midgard_query_holder_class_entry TSRMLS_CC); php_midgard_query_holder_class->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; php_midgard_query_holder_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_holder_class, strdup("Base class for holding data-atom in midgard_query")); zend_register_class_alias("midgard_query_holder", php_midgard_query_holder_class); static zend_function_entry midgard_query_property_methods[] = { PHP_ME(midgard_query_property, __construct, arginfo_midgard_query_property___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_property_class_entry; INIT_CLASS_ENTRY(php_midgard_query_property_class_entry, "MidgardQueryProperty", midgard_query_property_methods); php_midgard_query_property_class = zend_register_internal_class_ex(&php_midgard_query_property_class_entry, php_midgard_query_holder_class, "midgard_query_holder" TSRMLS_CC); php_midgard_query_property_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_property_class, strdup("Class for holding object-properties")); zend_register_class_alias("midgard_query_property", php_midgard_query_property_class); static zend_function_entry midgard_query_value_methods[] = { PHP_ME(midgard_query_value, __construct, arginfo_midgard_query_value___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_value_class_entry; INIT_CLASS_ENTRY(php_midgard_query_value_class_entry, "MidgardQueryValue", midgard_query_value_methods); php_midgard_query_value_class = zend_register_internal_class_ex(&php_midgard_query_value_class_entry, php_midgard_query_holder_class, "midgard_query_holder" TSRMLS_CC); php_midgard_query_value_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_value_class, strdup("Class for holding literal data")); zend_register_class_alias("midgard_query_value", php_midgard_query_value_class); return SUCCESS; } php5-midgard2-10.05.7/Makefile.frag0000664000175000017500000000157511730073440014436 0ustar pppp# Copyright (C) 2000 Emile Heyns # # This program is free software; you can redistribute it and/or modify it # under the terms of the GNU Lesser General Public License as published # by the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA $(srcdir)/mgd_errno.c $(srcdir)/mgd_errno.h: $(srcdir)/mgd_errno.pl perl $(srcdir)/mgd_errno.pl php5-midgard2-10.05.7/php_midgard_workspace_storage.c0000664000175000017500000004316111730073440020301 0ustar pppp/* * Copyright (C) 2011 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" zend_class_entry *php_midgard_workspace_storage_class; zend_class_entry *php_midgard_workspace_context_class; zend_class_entry *php_midgard_workspace_class; zend_class_entry *php_midgard_workspace_manager; /* MidgardWorkspaceStorage */ static PHP_METHOD(midgard_workspace_storage, get_path) { if (zend_parse_parameters_none() == FAILURE) return; MidgardWorkspaceStorage *self = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(getThis())); const char *path = midgard_workspace_storage_get_path(self); if (path) RETURN_STRING(path, 1); RETURN_NULL(); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_workspace_storage_get_path, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_storage, get_workspace_by_name) { char *name; int name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_length) == FAILURE) return; MidgardWorkspaceStorage *self = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(getThis())); MidgardWorkspaceStorage *workspace = midgard_workspace_storage_get_workspace_by_name(self, name); if (!workspace) RETURN_NULL(); if (MIDGARD_IS_WORKSPACE(self)) object_init_ex(return_value, php_midgard_workspace_class); else object_init_ex(return_value, php_midgard_workspace_context_class); MGD_PHP_SET_GOBJECT(return_value, workspace); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_storage_get_workspace_by_name, 0, 0, 1) ZEND_ARG_INFO(0, name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_storage, list_children) { if (zend_parse_parameters_none() == FAILURE) return; guint n_objects; MidgardWorkspaceStorage *self = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(getThis())); MidgardWorkspaceStorage **children = midgard_workspace_storage_list_children(self, &n_objects); array_init(return_value); if (!children) return; const char *g_class_name = G_OBJECT_TYPE_NAME(children[0]); zend_class_entry *ce = zend_fetch_class((char *) g_class_name, strlen(g_class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); int i; for (i = 0; i < n_objects; i++) { zval *zobject; MAKE_STD_ZVAL(zobject); php_midgard_gobject_new_with_gobject(zobject, ce, G_OBJECT(children[i]), TRUE TSRMLS_CC); zend_hash_next_index_insert(HASH_OF(return_value), &zobject, sizeof(zval *), NULL); } } ZEND_BEGIN_ARG_INFO(arginfo_midgard_workspace_storage_list_children, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_storage, list_workspace_names) { if (zend_parse_parameters_none() == FAILURE) return; guint n_names; MidgardWorkspaceStorage *self = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(getThis())); char **names = midgard_workspace_storage_list_workspace_names(self, &n_names); array_init(return_value); if (!names) return; int i; for (i = 0; i < n_names; i++) add_index_string(return_value, i, names[i], 1); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_workspace_storage_list_workspace_names, 0) ZEND_END_ARG_INFO() /* MidgardWorkspace */ static PHP_METHOD(midgard_workspace, __construct) { zval *object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; MidgardWorkspace *self = midgard_workspace_new(); if (!self) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create workspace object"); return; } MGD_PHP_SET_GOBJECT(object, self); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_workspace___construct, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace, get_context) { if (zend_parse_parameters_none() == FAILURE) return; MidgardWorkspace *self = MIDGARD_WORKSPACE(__php_gobject_ptr(getThis())); const MidgardWorkspaceContext *context = midgard_workspace_get_context(self); if (!context) RETURN_NULL(); object_init_ex(return_value, php_midgard_workspace_context_class); MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(context))); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_workspace_get_context, 0) ZEND_END_ARG_INFO() /* MidgardWorkspaceContext */ static PHP_METHOD(midgard_workspace_context, __construct) { zval *object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; MidgardWorkspaceContext *self = midgard_workspace_context_new(); if (!self) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create workspace context object"); return; } MGD_PHP_SET_GOBJECT(object, self); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_workspace_context___construct, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_context, has_workspace) { zval *z_workspace = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_workspace, php_midgard_workspace_class) == FAILURE) { return; } MidgardWorkspaceContext *self = MIDGARD_WORKSPACE_CONTEXT(__php_gobject_ptr(getThis())); MidgardWorkspace *workspace = MIDGARD_WORKSPACE(__php_gobject_ptr(z_workspace)); zend_bool result = midgard_workspace_context_has_workspace(self, workspace); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_context_has_workspace, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, workspace, midgard_workspace, 0) ZEND_END_ARG_INFO() /* MidgardWorkspaceManager */ static PHP_METHOD(midgard_workspace_manager, __construct) { zval *z_mgd = NULL; const gchar *g_class_name = g_type_name(MIDGARD_TYPE_CONNECTION); zend_class_entry *ce = zend_fetch_class((char *)g_class_name, strlen(g_class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_mgd, ce) == FAILURE) { return; } zval *object = getThis(); MidgardWorkspaceManager *self = midgard_workspace_manager_new(MIDGARD_CONNECTION(__php_gobject_ptr(z_mgd))); if (!self) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create workspace object"); return; } MGD_PHP_SET_GOBJECT(object, self); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_manager___construct, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, mgd, midgard_connection, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_manager, get_workspace_by_path) { char *path; int path_length; zval *z_workspace; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &z_workspace, php_midgard_workspace_storage_class, &path, &path_length) == FAILURE) { return; } MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis())); MidgardWorkspaceStorage *workspace = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(z_workspace)); GError *error = NULL; zend_bool result = midgard_workspace_manager_get_workspace_by_path(self, workspace, path, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to get workspace by path. %s", error->message); g_error_free(error); } RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_manager_get_workspace_by_path, 0, 0, 2) ZEND_ARG_OBJ_INFO(0, workspace, midgard_workspace_storage, 0) ZEND_ARG_INFO(0, path) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_manager, create_workspace) { char *path; int path_length; zval *z_workspace; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &z_workspace, php_midgard_workspace_storage_class, &path, &path_length) == FAILURE) { return; } MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis())); MidgardWorkspaceStorage *workspace = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(z_workspace)); GError *error = NULL; zend_bool result = midgard_workspace_manager_create_workspace(self, workspace, path, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to create workspace. %s", error->message); g_error_free(error); } RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_manager_create_workspace, 0, 0, 2) ZEND_ARG_OBJ_INFO(0, workspace, midgard_workspace_storage, 0) ZEND_ARG_INFO(0, path) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_manager, update_workspace) { zval *z_workspace; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_workspace, php_midgard_workspace_storage_class) == FAILURE) { return; } MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis())); MidgardWorkspaceStorage *workspace = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(z_workspace)); GError *error = NULL; zend_bool result = midgard_workspace_manager_update_workspace(self, workspace, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to update workspace. %s", error->message); g_error_free(error); } RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_manager_update_workspace, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, workspace, midgard_workspace_storage, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_manager, purge_workspace) { zval *z_workspace; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_workspace, php_midgard_workspace_storage_class) == FAILURE) { return; } MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis())); MidgardWorkspaceStorage *workspace = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(z_workspace)); GError *error = NULL; zend_bool result = midgard_workspace_manager_purge_workspace(self, workspace, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to purge workspace. %s", error->message); g_error_free(error); } RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_manager_purge_workspace, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, workspace, midgard_workspace_storage, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_manager, path_exists) { char *path; int path_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_length) == FAILURE) { return; } MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis())); zend_bool result = midgard_workspace_manager_path_exists(self, path); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_manager_path_exists, 0, 0, 1) ZEND_ARG_INFO(0, path) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_manager, purge_content) { char *type; int type_length; zval *z_workspace; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sO", &type, &type_length, &z_workspace, php_midgard_workspace_class) == FAILURE) { return; } MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis())); MidgardWorkspace *workspace = MIDGARD_WORKSPACE(__php_gobject_ptr(z_workspace)); GError *error = NULL; zend_bool result = midgard_workspace_manager_purge_content(self, type, workspace, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to purge %s content from workspace. %s", type, error->message); g_error_free(error); } RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_manager_purge_content, 0, 0, 2) ZEND_ARG_INFO(0, type) ZEND_ARG_OBJ_INFO(0, workspace, midgard_workspace_storage, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_workspace_manager, move_content) { char *type; int type_length; zval *z_src_workspace; zval *z_dest_workspace; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sOO", &type, &type_length, &z_src_workspace, php_midgard_workspace_class, &z_dest_workspace, php_midgard_workspace_class) == FAILURE) { return; } MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis())); MidgardWorkspace *src_workspace = MIDGARD_WORKSPACE(__php_gobject_ptr(z_src_workspace)); MidgardWorkspace *dest_workspace = MIDGARD_WORKSPACE(__php_gobject_ptr(z_dest_workspace)); GError *error = NULL; zend_bool result = midgard_workspace_manager_move_content(self, type, src_workspace, dest_workspace, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to move %s content betwen workspaces. %s", type, error->message); g_error_free(error); } RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_workspace_manager_move_content, 0, 0, 3) ZEND_ARG_INFO(0, type) ZEND_ARG_OBJ_INFO(0, src_workspace, midgard_workspace_storage, 0) ZEND_ARG_OBJ_INFO(0, dest_workspace, midgard_workspace_storage, 0) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_workspaces) { static zend_function_entry midgard_workspace_storage_methods[] = { PHP_ME(midgard_workspace_storage, get_path, arginfo_midgard_workspace_storage_get_path, ZEND_ACC_PUBLIC) PHP_ME(midgard_workspace_storage, get_workspace_by_name, arginfo_midgard_workspace_storage_get_workspace_by_name, ZEND_ACC_PUBLIC) PHP_ME(midgard_workspace_storage, list_children, arginfo_midgard_workspace_storage_list_children, ZEND_ACC_PUBLIC) PHP_ME(midgard_workspace_storage, list_workspace_names, arginfo_midgard_workspace_storage_list_workspace_names, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_workspace_storage_class_entry; INIT_CLASS_ENTRY(php_midgard_workspace_storage_class_entry, "MidgardWorkspaceStorage", midgard_workspace_storage_methods); php_midgard_workspace_storage_class = zend_register_internal_class(&php_midgard_workspace_storage_class_entry TSRMLS_CC); php_midgard_workspace_storage_class->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; php_midgard_workspace_storage_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_workspace_storage_class, strdup("Base class for workspaces")); zend_register_class_alias("midgard_workspace_storage", php_midgard_workspace_storage_class); static zend_function_entry midgard_workspace_methods[] = { PHP_ME(midgard_workspace, __construct, arginfo_midgard_workspace___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_workspace, get_context, arginfo_midgard_workspace_get_context, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_workspace_class_entry; INIT_CLASS_ENTRY(php_midgard_workspace_class_entry, "MidgardWorkspace", midgard_workspace_methods); php_midgard_workspace_class = zend_register_internal_class_ex(&php_midgard_workspace_class_entry, php_midgard_workspace_storage_class, "midgard_workspace_storage" TSRMLS_CC); php_midgard_workspace_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_workspace_class, strdup("Represents single workspace")); zend_register_class_alias("midgard_workspace", php_midgard_workspace_class); static zend_function_entry midgard_workspace_context_methods[] = { PHP_ME(midgard_workspace_context, __construct, arginfo_midgard_workspace_context___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_workspace_context, has_workspace, arginfo_midgard_workspace_context_has_workspace, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_workspace_context_class_entry; INIT_CLASS_ENTRY(php_midgard_workspace_context_class_entry, "MidgardWorkspaceContext", midgard_workspace_context_methods); php_midgard_workspace_context_class = zend_register_internal_class_ex(&php_midgard_workspace_context_class_entry, php_midgard_workspace_storage_class, "midgard_workspace_storage" TSRMLS_CC); php_midgard_workspace_context_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_workspace_context_class, strdup("Represents workspaces' tree")); zend_register_class_alias("midgard_workspace_context", php_midgard_workspace_context_class); static zend_function_entry midgard_workspace_manager_methods[] = { PHP_ME(midgard_workspace_manager, __construct, arginfo_midgard_workspace_manager___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_workspace_manager, get_workspace_by_path, arginfo_midgard_workspace_manager_get_workspace_by_path, ZEND_ACC_PUBLIC) PHP_ME(midgard_workspace_manager, create_workspace, arginfo_midgard_workspace_manager_create_workspace, ZEND_ACC_PUBLIC) PHP_ME(midgard_workspace_manager, update_workspace, arginfo_midgard_workspace_manager_update_workspace, ZEND_ACC_PUBLIC) PHP_ME(midgard_workspace_manager, purge_workspace, arginfo_midgard_workspace_manager_purge_workspace, ZEND_ACC_PUBLIC) PHP_ME(midgard_workspace_manager, path_exists, arginfo_midgard_workspace_manager_path_exists, ZEND_ACC_PUBLIC) PHP_ME(midgard_workspace_manager, purge_content, arginfo_midgard_workspace_manager_purge_content, ZEND_ACC_PUBLIC) PHP_ME(midgard_workspace_manager, move_content, arginfo_midgard_workspace_manager_move_content, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_workspace_manager_class_entry; INIT_CLASS_ENTRY(php_midgard_workspace_manager_class_entry, "MidgardWorkspaceManager", midgard_workspace_manager_methods); php_midgard_workspace_manager = zend_register_internal_class(&php_midgard_workspace_manager_class_entry TSRMLS_CC); php_midgard_workspace_manager->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_workspace_manager, strdup("Workspaces' manager")); zend_register_class_alias("midgard_workspace_manager", php_midgard_workspace_manager); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_query_executors.c0000664000175000017500000002656411730073440020035 0ustar pppp/* Copyright (C) 2010 Alexey Zakhlestin * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_query.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" #include zend_class_entry *php_midgard_query_executor_class = NULL; zend_class_entry *php_midgard_query_select_class; // midgard_query_executor static PHP_METHOD(midgard_query_executor, set_constraint) { zval *z_constraint = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_constraint, php_midgard_query_constraint_simple_class) == FAILURE) { return; } MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR(__php_gobject_ptr(getThis())); MidgardQueryConstraintSimple *constraint = MIDGARD_QUERY_CONSTRAINT_SIMPLE(__php_gobject_ptr(z_constraint)); zend_bool result = midgard_query_executor_set_constraint(executor, constraint); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_executor_set_constraint, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, property, midgard_query_constraint_simple, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_executor, set_offset) { long offset = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &offset) == FAILURE) { return; } if (offset < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "offset can't be negative"); return; } MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR(__php_gobject_ptr(getThis())); zend_bool result = midgard_query_executor_set_offset(executor, offset); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_executor_set_offset, 0, 0, 1) ZEND_ARG_INFO(0, offset) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_executor, set_limit) { long limit = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &limit) == FAILURE) { return; } if (limit < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "limit can't be negative"); return; } MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR(__php_gobject_ptr(getThis())); zend_bool result = midgard_query_executor_set_limit(executor, limit); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_executor_set_limit, 0, 0, 1) ZEND_ARG_INFO(0, limit) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_executor, add_order) { zval *z_property = NULL; long direction = PHP_SORT_ASC; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|l", &z_property, php_midgard_query_holder_class, &direction) == FAILURE) { return; } if (direction != PHP_SORT_ASC && direction != PHP_SORT_DESC) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "direction should be either SORT_ASC or SORT_DESC"); return; } MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR(__php_gobject_ptr(getThis())); MidgardQueryHolder *holder = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(z_property)); const gchar *g_direction = (direction == PHP_SORT_ASC) ? "ASC" : "DESC"; zend_bool result = midgard_query_executor_add_order(executor, holder, g_direction); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_executor_add_order, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, property, midgard_query_holder, 0) ZEND_ARG_INFO(0, direction) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_executor, add_join) { char *join_type = NULL; int join_type_len = 0; zval *z_property_left = NULL; zval *z_property_right = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sOO", &join_type, &join_type_len, &z_property_left, php_midgard_query_holder_class, &z_property_right, php_midgard_query_holder_class ) == FAILURE ) { return; } MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR(__php_gobject_ptr(getThis())); MidgardQueryHolder *left_property = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(z_property_left)); MidgardQueryHolder *right_property = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(z_property_right)); zend_bool result = midgard_query_executor_add_join(executor, join_type, MIDGARD_QUERY_HOLDER(left_property), MIDGARD_QUERY_HOLDER(right_property)); RETURN_BOOL(result); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_executor_add_join, 0, 0, 3) ZEND_ARG_INFO(0, join_type) ZEND_ARG_OBJ_INFO(0, left_property, midgard_query_holder, 0) ZEND_ARG_OBJ_INFO(0, right_property, midgard_query_holder, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_executor, execute) { if (zend_parse_parameters_none() == FAILURE) return; MidgardExecutable *executor = MIDGARD_EXECUTABLE(__php_gobject_ptr(getThis())); GError *error = NULL; midgard_executable_execute(executor, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to execute statement: %s", error->message); g_error_free(error); } RETURN_TRUE; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_executor_execute, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_executor, get_results_count) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR(__php_gobject_ptr(getThis())); guint count = midgard_query_executor_get_results_count(executor); RETURN_LONG(count); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_executor_get_results_count, 0, 0, 0) ZEND_END_ARG_INFO() // midgard_query_select static PHP_METHOD(midgard_query_select, __construct) { zval *z_storage = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_storage, php_midgard_query_storage_class) == FAILURE) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to create Select executor"); return; } MidgardConnection *mgd = mgd_handle(TSRMLS_C); if (!mgd) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "midgard_query_select object requires active midgard_connection"); return; } MidgardQueryStorage *storage = MIDGARD_QUERY_STORAGE(__php_gobject_ptr(z_storage)); MidgardQuerySelect *executor = midgard_query_select_new(mgd, storage); if (!executor) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create Select executor"); return; } MGD_PHP_SET_GOBJECT(getThis(), executor); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_select___construct, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, storage, midgard_query_storage, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_select, toggle_readonly) { zend_bool readonly; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &readonly) == FAILURE) { return; } MidgardQuerySelect *select = MIDGARD_QUERY_SELECT(__php_gobject_ptr(getThis())); midgard_query_select_toggle_read_only(select, readonly); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_select_toggle_readonly, 0, 0, 1) ZEND_ARG_INFO(0, read_only) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_select, include_deleted) { zend_bool include_deleted; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &include_deleted) == FAILURE) { return; } MidgardQuerySelect *select = MIDGARD_QUERY_SELECT(__php_gobject_ptr(getThis())); midgard_query_select_include_deleted(select, include_deleted); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_select_include_deleted, 0, 0, 1) ZEND_ARG_INFO(0, include_deleted) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_select, list_objects) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQuerySelect *select = MIDGARD_QUERY_SELECT(__php_gobject_ptr(getThis())); guint n_objects; MidgardDBObject **objects = midgard_query_select_list_objects(select, &n_objects); array_init(return_value); php_midgard_array_from_unknown_objects((GObject **)objects, n_objects, return_value TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_select_list_objects, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_select, connect) { php_midgard_gobject_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_select_connect, 0, 0, 2) ZEND_ARG_INFO(0, signal) ZEND_ARG_INFO(0, callback) ZEND_ARG_INFO(0, user_data) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_query_executors) { static zend_function_entry midgard_query_executor_methods[] = { PHP_ME(midgard_query_executor, set_constraint, arginfo_midgard_query_executor_set_constraint, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_executor, set_offset, arginfo_midgard_query_executor_set_offset, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_executor, set_limit, arginfo_midgard_query_executor_set_limit, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_executor, add_order, arginfo_midgard_query_executor_add_order, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_executor, add_join, arginfo_midgard_query_executor_add_join, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_executor, execute, arginfo_midgard_query_executor_execute, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_executor, get_results_count, arginfo_midgard_query_executor_get_results_count, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_executor_class_entry; INIT_CLASS_ENTRY(php_midgard_query_executor_class_entry, "MidgardQueryExecutor", midgard_query_executor_methods); php_midgard_query_executor_class = zend_register_internal_class(&php_midgard_query_executor_class_entry TSRMLS_CC); php_midgard_query_executor_class->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; php_midgard_query_executor_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_executor_class, strdup("Base, abstract class for queries executions")); zend_register_class_alias("midgard_query_executor", php_midgard_query_executor_class); static zend_function_entry midgard_query_select_methods[] = { PHP_ME(midgard_query_select, __construct, arginfo_midgard_query_select___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_query_select, toggle_readonly, arginfo_midgard_query_select_toggle_readonly, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_select, include_deleted, arginfo_midgard_query_select_include_deleted, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_select, list_objects, arginfo_midgard_query_select_list_objects, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_select, connect, arginfo_midgard_query_select_connect, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_select_class_entry; INIT_CLASS_ENTRY(php_midgard_query_select_class_entry, "MidgardQuerySelect", midgard_query_select_methods); php_midgard_query_select_class = zend_register_internal_class_ex(&php_midgard_query_select_class_entry, php_midgard_query_executor_class, "midgard_query_executor" TSRMLS_CC); php_midgard_query_select_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_select_class, strdup("SQL SELECT queries generator and executor")); zend_register_class_alias("midgard_query_select", php_midgard_query_select_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_view.c0000664000175000017500000001072611730073440015532 0ustar pppp/* * Copyright (C) 2009 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard_object.h" #include "php_midgard__helpers.h" #include #include zend_class_entry *php_midgard_view_class = NULL; #define __THROW_EXCEPTION \ if (EG(exception)) { \ return_value = zend_throw_exception(Z_OBJCE_P(EG(exception)), "", 0 TSRMLS_CC); \ return; \ } #define _GET_VIEW_OBJECT \ zval *zval_object = getThis(); \ MgdView *object = MIDGARD_VIEW(__php_gobject_ptr(zval_object)); \ if (!object) \ php_error(E_ERROR, "Can not find underlying midgard view instance"); /* Object constructor */ static PHP_FUNCTION(php_midgard_view_constructor) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zval_object = getThis(); GObject *gobject; gobject = __php_gobject_ptr(zval_object); if (!gobject) { if (zend_parse_parameters_none() == FAILURE) return; MidgardView *view = g_object_new(g_type_from_name(Z_OBJCE_P(zval_object)->name), NULL); if (!view) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } MGD_PHP_SET_GOBJECT(zval_object, view); } else { // we already have gobject injected } } static void __register_view_php_classes(const gchar *class_name, zend_class_entry *parent TSRMLS_DC) { zend_class_entry *mgdclass, *mgdclass_ptr; /* lcn is freed in zend_register_internal_class */ gchar *lcn = g_ascii_strdown(class_name, strlen(class_name)); zend_function_entry __functions[2]; __functions[0].fname = "__construct"; __functions[0].handler = ZEND_FN(php_midgard_view_constructor); __functions[0].arg_info = NULL; __functions[0].num_args = 0; __functions[0].flags = ZEND_ACC_PUBLIC | ZEND_ACC_CTOR; __functions[1].fname = NULL; __functions[1].handler = NULL; __functions[1].arg_info = NULL; __functions[1].num_args = 0; __functions[1].flags = 0; mgdclass = g_new0(zend_class_entry, 1); mgdclass->name = lcn; mgdclass->name_length = strlen(class_name); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 mgdclass->info.internal.builtin_functions = __functions; #else mgdclass->builtin_functions = __functions; #endif mgdclass->constructor = NULL; mgdclass->destructor = NULL; mgdclass->clone = NULL; mgdclass->create_object = NULL; mgdclass->interface_gets_implemented = NULL; mgdclass->__call = NULL; mgdclass->__get = NULL; mgdclass->__set = NULL; mgdclass->parent = parent; mgdclass->num_interfaces = 0; mgdclass->interfaces = NULL; mgdclass->get_iterator = NULL; mgdclass->iterator_funcs.funcs = NULL; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 mgdclass->info.internal.module = NULL; #else mgdclass->module = NULL; #endif mgdclass->ce_flags = 0; mgdclass_ptr = zend_register_internal_class(mgdclass TSRMLS_CC); mgdclass_ptr->ce_flags = 0; mgdclass_ptr->serialize = NULL; mgdclass_ptr->unserialize = NULL; mgdclass_ptr->create_object = php_midgard_gobject_new; g_free(mgdclass); } PHP_MINIT_FUNCTION(midgard2_view) { /* Register midgard_view class */ static zend_class_entry php_midgard_view_ce; INIT_CLASS_ENTRY(php_midgard_view_ce, "MidgardView", NULL); php_midgard_view_class = zend_register_internal_class_ex(&php_midgard_view_ce, php_midgard_dbobject_class, "MidgardDBObject" TSRMLS_CC); php_midgard_view_class->ce_flags = ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; guint n_types, i; GType *all_types = g_type_children(MIDGARD_TYPE_VIEW, &n_types); for (i = 0; i < n_types; i++) { const gchar *typename = g_type_name(all_types[i]); __register_view_php_classes(typename, php_midgard_view_class TSRMLS_CC); } zend_register_class_alias("midgard_view", php_midgard_view_class); g_free(all_types); return SUCCESS; } php5-midgard2-10.05.7/php_midgard__helpers.c0000664000175000017500000001554511730073440016365 0ustar pppp#include "php_midgard.h" #include "php_midgard__helpers.h" #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 2 zend_class_entry *php_date_get_date_ce(void) { TSRMLS_FETCH(); zend_class_entry *dt_ce = php_midgard_get_baseclass_ptr_by_name("DateTime" TSRMLS_CC); if (dt_ce == NULL) { php_error(E_ERROR, "Can not find DateTime class pointer"); } return dt_ce; } zend_class_entry *php_date_get_timezone_ce(void) { TSRMLS_FETCH(); zend_class_entry *dtz_ce = php_midgard_get_baseclass_ptr_by_name("DateTimeZone" TSRMLS_CC); if (dtz_ce == NULL) { php_error(E_ERROR, "Can not find DateTimeZone class pointer"); } return dtz_ce; } #endif /* * zend_call_method_va__mgd is a reimplementation of zend_call_method which allows to provide variable list of arguments (original is limited to 2 arguments) **/ #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 2 static zval* zend_call_method_va__mgd(zval **object_pp, zend_class_entry *obj_ce, zend_function **fn_proxy, char *function_name, int function_name_len, zval **retval_ptr_ptr, int param_count, zval*** params TSRMLS_DC) { int result; zend_fcall_info fci; zval z_fname; zval *retval; HashTable *function_table; fci.size = sizeof(fci); /*fci.function_table = NULL; will be read form zend_class_entry of object if needed */ fci.object_pp = object_pp; fci.function_name = &z_fname; fci.retval_ptr_ptr = retval_ptr_ptr ? retval_ptr_ptr : &retval; fci.param_count = param_count; fci.params = params; fci.no_separation = 1; fci.symbol_table = NULL; if (!fn_proxy && !obj_ce) { /* no interest in caching and no information already present that is * needed later inside zend_call_function. */ ZVAL_STRINGL(&z_fname, function_name, function_name_len, 0); fci.function_table = !object_pp ? EG(function_table) : NULL; result = zend_call_function(&fci, NULL TSRMLS_CC); } else { zend_fcall_info_cache fcic; fcic.initialized = 1; if (!obj_ce) { obj_ce = object_pp ? Z_OBJCE_PP(object_pp) : NULL; } if (obj_ce) { function_table = &obj_ce->function_table; } else { function_table = EG(function_table); } if (!fn_proxy || !*fn_proxy) { if (zend_hash_find(function_table, function_name, function_name_len+1, (void **) &fcic.function_handler) == FAILURE) { /* error at c-level */ zend_error(E_CORE_ERROR, "Couldn't find implementation for method %s%s%s", obj_ce ? obj_ce->name : "", obj_ce ? "::" : "", function_name); } if (fn_proxy) { *fn_proxy = fcic.function_handler; } } else { fcic.function_handler = *fn_proxy; } fcic.calling_scope = obj_ce; fcic.object_pp = object_pp; result = zend_call_function(&fci, &fcic TSRMLS_CC); } if (result == FAILURE) { /* error at c-level */ if (!obj_ce) { obj_ce = object_pp ? Z_OBJCE_PP(object_pp) : NULL; } if (!EG(exception)) { zend_error(E_CORE_ERROR, "Couldn't execute method %s%s%s", obj_ce ? obj_ce->name : "", obj_ce ? "::" : "", function_name); } } if (!retval_ptr_ptr) { if (retval) { zval_ptr_dtor(&retval); } return NULL; } return *retval_ptr_ptr; } #elif PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3 static zval* zend_call_method_va__mgd(zval **object_pp, zend_class_entry *obj_ce, zend_function **fn_proxy, char *function_name, int function_name_len, zval **retval_ptr_ptr, int param_count, zval*** params TSRMLS_DC) { int result; zend_fcall_info fci; zval z_fname; zval *retval; HashTable *function_table; fci.size = sizeof(fci); /*fci.function_table = NULL; will be read form zend_class_entry of object if needed */ fci.object_ptr = object_pp ? *object_pp : NULL; fci.function_name = &z_fname; fci.retval_ptr_ptr = retval_ptr_ptr ? retval_ptr_ptr : &retval; fci.param_count = param_count; fci.params = params; fci.no_separation = 1; fci.symbol_table = NULL; if (!fn_proxy && !obj_ce) { /* no interest in caching and no information already present that is * needed later inside zend_call_function. */ ZVAL_STRINGL(&z_fname, function_name, function_name_len, 0); fci.function_table = !object_pp ? EG(function_table) : NULL; result = zend_call_function(&fci, NULL TSRMLS_CC); } else { zend_fcall_info_cache fcic; fcic.initialized = 1; if (!obj_ce) { obj_ce = object_pp ? Z_OBJCE_PP(object_pp) : NULL; } if (obj_ce) { function_table = &obj_ce->function_table; } else { function_table = EG(function_table); } if (!fn_proxy || !*fn_proxy) { if (zend_hash_find(function_table, function_name, function_name_len+1, (void **) &fcic.function_handler) == FAILURE) { /* error at c-level */ zend_error(E_CORE_ERROR, "Couldn't find implementation for method %s%s%s", obj_ce ? obj_ce->name : "", obj_ce ? "::" : "", function_name); } if (fn_proxy) { *fn_proxy = fcic.function_handler; } } else { fcic.function_handler = *fn_proxy; } fcic.calling_scope = obj_ce; if (object_pp) { fcic.called_scope = Z_OBJCE_PP(object_pp); } else if (obj_ce && !(EG(called_scope) && instanceof_function(EG(called_scope), obj_ce TSRMLS_CC))) { fcic.called_scope = obj_ce; } else { fcic.called_scope = EG(called_scope); } fcic.object_ptr = object_pp ? *object_pp : NULL; result = zend_call_function(&fci, &fcic TSRMLS_CC); } if (result == FAILURE) { /* error at c-level */ if (!obj_ce) { obj_ce = object_pp ? Z_OBJCE_PP(object_pp) : NULL; } if (!EG(exception)) { zend_error(E_CORE_ERROR, "Couldn't execute method %s%s%s", obj_ce ? obj_ce->name : "", obj_ce ? "::" : "", function_name); } } if (!retval_ptr_ptr) { if (retval) { zval_ptr_dtor(&retval); } return NULL; } return *retval_ptr_ptr; } #endif /* * zend_call_method__mgd is a reimplementation of zend_call_method which allows to provide variable up to 4 arguments (original is limited to 2 arguments) * Internally, it uses zend_call_method_va__mgd() defined above **/ ZEND_API zval* zend_call_method__mgd(zval **object_pp, zend_class_entry *obj_ce, zend_function **fn_proxy, char *function_name, int function_name_len, zval **retval_ptr_ptr, int param_count, zval* arg1, zval* arg2, zval* arg3, zval* arg4 TSRMLS_DC) { zval **params[4]; params[0] = &arg1; params[1] = &arg2; params[2] = &arg3; params[3] = &arg4; return zend_call_method_va__mgd(object_pp, obj_ce, fn_proxy, function_name, function_name_len, retval_ptr_ptr, param_count, params TSRMLS_CC); } void php_midgard_array_from_unknown_objects(GObject **objects, guint n_objects, zval *zarray TSRMLS_DC) { if (!objects) return; size_t i; for (i = 0; i < n_objects; i++) { GObject *object = objects[i]; GType object_type = G_OBJECT_TYPE(object); const gchar *g_class_name = g_type_name(object_type); zend_class_entry *ce = zend_fetch_class((char *)g_class_name, strlen(g_class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); zval *zobject; MAKE_STD_ZVAL(zobject); php_midgard_gobject_new_with_gobject(zobject, ce, object, TRUE TSRMLS_CC); zend_hash_next_index_insert(HASH_OF(zarray), &zobject, sizeof(zval *), NULL); } } php5-midgard2-10.05.7/php_midgard_object_attachment.c0000664000175000017500000001363211730073440020235 0ustar pppp/* * Copyright (C) 2006, 2007 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" PHP_FUNCTION(_php_midgard_object_list_attachments) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; array_init(return_value); guint n_objects; MidgardObject *mobj = __midgard_object_get_ptr(getThis()); MidgardObject **objects = midgard_object_list_attachments(mobj, &n_objects); if (objects) { php_midgard_array_from_objects((GObject **)objects, "midgard_attachment", return_value TSRMLS_CC); g_free(objects); } } PHP_FUNCTION(php_midgard_object_has_attachments) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *mobj = __midgard_object_get_ptr(getThis()); zend_bool rv = (zend_bool)midgard_object_has_attachments(mobj); RETURN_BOOL(rv); } PHP_FUNCTION(_php_midgard_object_delete_attachments) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *params = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶ms) != SUCCESS) { return; } guint n_params = 0; GParameter *parameters = php_midgard_array_to_gparameter(params, &n_params TSRMLS_CC); MidgardObject *mobj = __midgard_object_get_ptr(getThis()); zend_bool rv = (zend_bool) midgard_object_delete_attachments(mobj, n_params, parameters); PHP_MGD_FREE_GPARAMETERS(parameters, n_params); RETURN_BOOL(rv); } PHP_FUNCTION(_php_midgard_object_purge_attachments) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *params = NULL; zend_bool zbool = TRUE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &zbool, ¶ms) != SUCCESS) { return; } guint n_params = 0; GParameter *parameters = php_midgard_array_to_gparameter(params, &n_params TSRMLS_CC); MidgardObject *mobj = __midgard_object_get_ptr(getThis()); zend_bool rv = (zend_bool) midgard_object_purge_attachments(mobj, (gboolean) zbool, n_params, parameters); PHP_MGD_FREE_GPARAMETERS(parameters, n_params); RETURN_BOOL(rv); } PHP_FUNCTION(_php_midgard_object_find_attachments) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *params = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", ¶ms) != SUCCESS) { return; } array_init(return_value); guint n_params = 0; GParameter *parameters = php_midgard_array_to_gparameter(params, &n_params TSRMLS_CC); MidgardObject *mobj = __midgard_object_get_ptr(getThis()); MidgardObject **objects = midgard_object_find_attachments(mobj, n_params, parameters); PHP_MGD_FREE_GPARAMETERS(parameters, n_params); if (objects) { php_midgard_array_from_objects((GObject **)objects, "midgard_attachment", return_value TSRMLS_CC); g_free(objects); } } PHP_FUNCTION(_php_midgard_object_create_attachment) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); const char *name = NULL, *title = NULL, *mimetype = NULL; int name_length, title_length, mimetype_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sss", &name, &name_length, &title, &title_length, &mimetype, &mimetype_length) != SUCCESS ) { return; } MidgardObject *mobj = __midgard_object_get_ptr(getThis()); MidgardObject *att = midgard_object_create_attachment(mobj, name, title, mimetype); if (!att) { RETURN_NULL(); } char *type_name = (char *)G_OBJECT_TYPE_NAME((GObject*)att); zend_class_entry *ce = zend_fetch_class(type_name, strlen(type_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); php_midgard_gobject_new_with_gobject(return_value, ce, G_OBJECT(att), TRUE TSRMLS_CC); } /* It's not binded from core. This is PHP specific */ PHP_FUNCTION(_php_midgard_object_serve_attachment) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); const char *guid; int guid_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &guid, &guid_length) != SUCCESS) { return; } if (!midgard_is_guid(guid)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Given parameter is not a guid"); return; } MidgardObject *att = NULL; { GValue gval = {0, }; g_value_init(&gval, G_TYPE_STRING); g_value_set_string(&gval, guid); att = midgard_object_new(mgd, "midgard_attachment", &gval); } /* error is set by core */ if (!att) return; MidgardBlob *blob = midgard_blob_new(att, NULL); if (!blob) return; { gchar *mimetype; g_object_get(G_OBJECT(att), "mimetype", &mimetype, NULL); gchar *content_type = g_strconcat("Content-type: ", mimetype, NULL); sapi_add_header(content_type, strlen(content_type), 1); g_free(content_type); } if (sapi_send_headers(TSRMLS_C) != SUCCESS) return; // FIXME: we should use streams here, instead const gchar *path = midgard_blob_get_path(blob); FILE *fp; if (!(fp = fopen(path, "r"))) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "File doesn't exist"); MIDGARD_ERRNO_SET(mgd, MGD_ERR_INTERNAL); return; } int b; char buf[1024]; while ((b = fread(buf, 1, sizeof(buf), fp)) > 0) { PHPWRITE(buf, b); } fclose(fp); RETVAL_TRUE;; } php5-midgard2-10.05.7/.gitignore0000664000175000017500000000063511730073440014044 0ustar pppp*.in *.lo .deps .libs/ autom4te.cache/ Makefile* acinclude.m4 aclocal.m4 build/ config.guess config.h* config.log config.nice config.status config.sub configure install-sh libtool ltmain.sh midgard2.la missing mkinstalldirs modules/ pakePhpExtensionTask.yaml run-tests.php tmp-php.ini /tests/midgard.log /tests/test.cfg /tests/test.db /tests/*.sh /tests/*.php /tests/*.log /tests/*.out /tests/*.exp /tests/*.diff php5-midgard2-10.05.7/php_midgard_urlwrapper.c0000664000175000017500000001266211730073440016764 0ustar pppp/* Copyright (C) 2010 Alexey Zakhlestin * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_urlwrapper.h" static php_stream_ops php_midgard2stream_ops = { php_midgard2stream_write, php_midgard2stream_read, php_midgard2stream_closer, php_midgard2stream_flush, PHP_MIDGARD2_STREAMTYPE, php_midgard2stream_seek, NULL, NULL, // php_midgard2stream_stat, NULL, }; static php_stream_wrapper_ops php_midgard2stream_wrapper_ops = { php_midgard2stream_opener, NULL, /* will call underlying closer */ NULL, NULL, NULL, PHP_MIDGARD2_WRAPPER, NULL, NULL, NULL, NULL, }; static php_stream_wrapper php_midgard2stream_wrapper = { &php_midgard2stream_wrapper_ops, NULL, 0, }; php_stream * php_midgard2stream_opener(php_stream_wrapper *wrapper, char *filename, char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC) { if (strncmp(filename, PHP_MIDGARD2_WRAPPER "://", strlen(PHP_MIDGARD2_WRAPPER) + 3) != 0) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Invalid schema. midgard:// expected"); return NULL; } if (options & STREAM_OPEN_PERSISTENT) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to open %s persistently", filename); return NULL; } const char *path = filename + (strlen(PHP_MIDGARD2_WRAPPER) + 3); // TODO: piotras says, that "MidgardQuerySelect in read only mode" can be used for speedup php_midgard2stream_data *data = emalloc(sizeof(php_midgard2stream_data)); data->obj = midgard_schema_object_factory_get_object_by_path(mgd_handle(TSRMLS_C), "midgard_snippet", path); data->position = 0; if (data->obj == NULL) { efree(data); php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Couldn't find midgard_snippet object using %s path", path); return NULL; } if (mode[0] == 'w') { data->buffer = NULL; data->size = 0; } else { const gchar *tmp_string = NULL; g_object_get(data->obj, "code", &tmp_string, NULL); data->buffer = estrdup(tmp_string); data->size = strlen(tmp_string); if (mode[0] == 'a') { data->position = data->size; } } return php_stream_alloc(&php_midgard2stream_ops, data, 0, mode); } int php_midgard2stream_closer(php_stream *stream, int close_handle TSRMLS_DC) { php_midgard2stream_data *data = stream->abstract; if (data->obj) { g_object_unref(data->obj); } if (data->buffer) { efree(data->buffer); } efree(data); return 0; } size_t php_midgard2stream_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC) { php_midgard2stream_data *data = stream->abstract; size_t new_size = data->position + count + 1; if (data->size < new_size) { data->buffer = erealloc(data->buffer, new_size); data->size = new_size; } memcpy(data->buffer + data->position, buf, count); data->position += count; data->buffer[data->position] = '\0'; return count; } size_t php_midgard2stream_read(php_stream *stream, char *buf, size_t count TSRMLS_DC) { php_midgard2stream_data *data = stream->abstract; const char *tmp = data->buffer; size_t to_read = count; if (data->position + count > data->size) { to_read = data->size - data->position; } memcpy(buf, tmp + data->position, to_read); data->position += to_read; return to_read; } int php_midgard2stream_flush(php_stream *stream TSRMLS_DC) { php_midgard2stream_data *data = stream->abstract; { GValue pval = {0, }; g_value_init(&pval, G_TYPE_STRING); g_value_set_string(&pval, data->buffer); g_object_set_property(G_OBJECT(data->obj), "code", &pval); g_value_unset(&pval); } g_signal_emit(data->obj, MIDGARD_OBJECT_GET_CLASS(data->obj)->signal_action_update_hook, 0); if (!midgard_object_update(data->obj)) { // FIXME: do something more meaningful php_error(E_WARNING, "failed to flush stream"); } return 0; } int php_midgard2stream_seek(php_stream *stream, off_t offset, int whence, off_t *newoffset TSRMLS_DC) { php_midgard2stream_data *data = stream->abstract; switch (whence) { case SEEK_SET: data->position = offset; break; case SEEK_CUR: data->position += offset; break; case SEEK_END: { GValue pval = {0, }; g_value_init(&pval, G_TYPE_STRING); g_object_get_property(G_OBJECT(data->obj), "code", &pval); data->position = strlen(g_value_get_string(&pval)) + offset; break; } } if (data->position < 0) { data->position = 0; } if (newoffset) { *newoffset = data->position; } return 0; } // int php_midgard2stream_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC) // { // return 0; // } PHP_MINIT_FUNCTION(midgard2_urlwrapper) { return php_register_url_stream_wrapper(PHP_MIDGARD2_WRAPPER, &php_midgard2stream_wrapper TSRMLS_CC); } PHP_MSHUTDOWN_FUNCTION(midgard2_urlwrapper) { return php_unregister_url_stream_wrapper(PHP_MIDGARD2_WRAPPER TSRMLS_CC); } php5-midgard2-10.05.7/php_midgard_g_mainloop.c0000664000175000017500000001267011730073440016704 0ustar pppp/* Copyright (C) 2007 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" #include /* GObject wrapper for GMainLoop */ #define MIDGARD_TYPE_G_MAIN_LOOP (midgard_g_main_loop_get_type()) #define MIDGARD_G_MAIN_LOOP(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), MIDGARD_TYPE_G_MAIN_LOOP, MidgardGMainLoop)) #define MIDGARD_G_MAIN_LOOP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), MIDGARD_TYPE_G_MAIN_LOOP, MidgardGMainLoopClass)) #define MIDGARD_IS_G_MAIN_LOOP(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MIDGARD_TYPE_G_MAIN_LOOP)) #define MIDGARD_IS_G_MAIN_LOOP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), MIDGARD_TYPE_G_MAIN_LOOP)) #define MIDGARD_G_MAIN_LOOP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), MIDGARD_TYPE_G_MAIN_LOOP, MidgardGMainLoopClass)) typedef struct _MidgardGMainLoop MidgardGMainLoop; typedef struct _MidgardGMainLoopClass MidgardGMainLoopClass; struct _MidgardGMainLoop{ GObject parent; /* private field */ GMainLoop *g_m_loop; }; struct _MidgardGMainLoopClass{ GObjectClass parent; }; GType midgard_g_main_loop_get_type(void); MidgardGMainLoop *midgard_g_main_loop_new(void) { MidgardGMainLoop *self = g_object_new(MIDGARD_TYPE_G_MAIN_LOOP, NULL); self->g_m_loop = g_main_loop_new(NULL, FALSE); return self; } static void _midgard_g_main_loop_finalize(GObject *object) { MidgardGMainLoop *self = (MidgardGMainLoop *) object; if (self->g_m_loop) g_main_loop_unref (self->g_m_loop); self->g_m_loop = NULL; } static void _midgard_g_main_loop_class_init(gpointer g_class, gpointer g_class_data) { GObjectClass *gobject_class = G_OBJECT_CLASS(g_class); gobject_class->finalize = _midgard_g_main_loop_finalize; } GType midgard_g_main_loop_get_type(void) { static GType type = 0; if (type == 0) { static const GTypeInfo info = { sizeof (MidgardGMainLoopClass), NULL, /* base_init */ NULL, /* base_finalize */ (GClassInitFunc) _midgard_g_main_loop_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof (MidgardDbus), 0, /* n_preallocs */ NULL /* instance_init */ }; type = g_type_register_static (G_TYPE_OBJECT, "midgard_g_main_loop", &info, 0); } return type; } zend_class_entry *php_midgard_g_mainloop_class; #define _GET_MAINLOOP_OBJECT \ zval *zval_object = getThis(); \ MidgardGMainLoop *mainloop = MIDGARD_G_MAIN_LOOP(__php_gobject_ptr(zval_object)); \ if (!mainloop) \ php_error(E_ERROR, "Can not find underlying main loop instance"); /* Object constructor */ static PHP_METHOD(midgard_g_mainloop, __construct) { RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; zval *zval_object = getThis(); GObject *gobject; gobject = __php_gobject_ptr(zval_object); if (!gobject) { MidgardGMainLoop *mainloop = midgard_g_main_loop_new(); MGD_PHP_SET_GOBJECT(zval_object, mainloop); } } ZEND_BEGIN_ARG_INFO(arginfo_midgard_g_mainloop___construct, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_g_mainloop, run) { if (zend_parse_parameters_none() == FAILURE) return; _GET_MAINLOOP_OBJECT; g_main_loop_run(mainloop->g_m_loop); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_g_mainloop_run, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_g_mainloop, is_running) { RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; _GET_MAINLOOP_OBJECT; RETURN_BOOL(g_main_loop_is_running(mainloop->g_m_loop)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_g_mainloop_is_running, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_g_mainloop, quit) { if (zend_parse_parameters_none() == FAILURE) return; _GET_MAINLOOP_OBJECT; g_main_loop_quit(mainloop->g_m_loop); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_g_mainloop_quit, 0) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_g_mainloop) { static zend_function_entry midgard_g_mainloop_methods[] = { PHP_ME(midgard_g_mainloop, __construct, arginfo_midgard_g_mainloop___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_g_mainloop, run, arginfo_midgard_g_mainloop_run, ZEND_ACC_PUBLIC) PHP_ME(midgard_g_mainloop, is_running, arginfo_midgard_g_mainloop_is_running, ZEND_ACC_PUBLIC) PHP_ME(midgard_g_mainloop, quit, arginfo_midgard_g_mainloop_quit, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_g_mainloop_class_entry; INIT_CLASS_ENTRY(php_midgard_g_mainloop_class_entry, "midgard_g_main_loop", midgard_g_mainloop_methods); php_midgard_g_mainloop_class = zend_register_internal_class(&php_midgard_g_mainloop_class_entry TSRMLS_CC); /* Set function to initialize underlying data */ php_midgard_g_mainloop_class->create_object = php_midgard_gobject_new; return SUCCESS; } php5-midgard2-10.05.7/LICENSE0000664000175000017500000006347611730073440013075 0ustar pppp GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! php5-midgard2-10.05.7/COPYING0000664000175000017500000006137211730073440013114 0ustar pppp GNU LIBRARY GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the library GPL. It is numbered 2 because it goes with version 2 of the ordinary GPL.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Library General Public License, applies to some specially designated Free Software Foundation software, and to any other libraries whose authors decide to use it. You can use it for your libraries, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library, or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link a program with the library, you must provide complete object files to the recipients so that they can relink them with the library, after making changes to the library and recompiling it. And you must show them these terms so they know their rights. Our method of protecting your rights has two steps: (1) copyright the library, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the library. Also, for each distributor's protection, we want to make certain that everyone understands that there is no warranty for this free library. If the library is modified by someone else and passed on, we want its recipients to know that what they have is not the original version, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that companies distributing free software will individually obtain patent licenses, thus in effect transforming the program into proprietary software. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License, which was designed for utility programs. This license, the GNU Library General Public License, applies to certain designated libraries. This license is quite different from the ordinary one; be sure to read it in full, and don't assume that anything in it is the same as in the ordinary license. The reason we have a separate public license for some libraries is that they blur the distinction we usually make between modifying or adding to a program and simply using it. Linking a program with a library, without changing the library, is in some sense simply using the library, and is analogous to running a utility program or application program. However, in a textual and legal sense, the linked executable is a combined work, a derivative of the original library, and the ordinary General Public License treats it as such. Because of this blurred distinction, using the ordinary General Public License for libraries did not effectively promote software sharing, because most developers did not use the libraries. We concluded that weaker conditions might promote sharing better. However, unrestricted linking of non-free programs would deprive the users of those programs of all benefit from the free status of the libraries themselves. This Library General Public License is intended to permit developers of non-free programs to use free libraries, while preserving your freedom as a user of such programs to change the free libraries that are incorporated in them. (We have not seen how to achieve this as regards changes in header files, but we have achieved it as regards changes in the actual functions of the Library.) The hope is that this will lead to faster development of free libraries. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, while the latter only works together with the library. Note that it is possible for a library to be covered by the ordinary General Public License rather than by this special one. GNU LIBRARY GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Library General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also compile or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. c) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. d) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Library General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU General Public License along with this library; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! php5-midgard2-10.05.7/php_midgard_object_class.c0000664000175000017500000002324111730073440017207 0ustar pppp/* Copyright (C) 2006 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" static zend_class_entry *php_midgard_object_class_class; static PHP_METHOD(midgard_object_class, factory) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *class_name; int class_name_length; zval *zvalue = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &class_name, &class_name_length, &zvalue) == FAILURE) return; zend_class_entry **pce = NULL; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 if (zend_lookup_class_ex(class_name, class_name_length, NULL, 1, &pce TSRMLS_CC) == FAILURE) { #else if (zend_lookup_class_ex(class_name, class_name_length, 1, &pce TSRMLS_CC) == FAILURE) { #endif php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can not find %s class", class_name); return; } zend_class_entry *ce = *pce; object_init_ex(return_value, ce); /* Initialize new object for which QB has been created for */ /* Call class constructor on given instance */ if (zvalue == NULL) { zend_call_method_with_0_params(&return_value, ce, &ce->constructor, "__construct", NULL); } else { zend_call_method_with_1_params(&return_value, ce, &ce->constructor, "__construct", NULL, zvalue); } } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_object_class_factory, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_ARG_INFO(0, id) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_object_class, get_object_by_guid) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *guid; int guid_length; const gchar *type_name; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &guid, &guid_length) == FAILURE) return; MidgardObject *object = midgard_schema_object_factory_get_object_by_guid(mgd, guid); if (!object) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } type_name = G_OBJECT_TYPE_NAME(G_OBJECT(object)); zend_class_entry *ce = zend_fetch_class((gchar *)type_name, strlen(type_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); if (ce == NULL) { php_error(E_WARNING, "Can not find %s class", type_name); return; } php_midgard_gobject_new_with_gobject(return_value, ce, G_OBJECT(object), TRUE TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_object_class_get_object_by_guid, 0, 0, 1) ZEND_ARG_INFO(0, guid) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_object_class, get_property_up) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; MidgardObjectClass *klass = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const gchar *classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { classname = (const gchar *)Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { classname = (const gchar *)Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(classname); if (!klass) { php_error(E_WARNING, "MidgardObjectClass not found"); return; } const gchar *property_up = midgard_reflector_object_get_property_up(classname); if (!property_up) RETURN_NULL(); RETURN_STRING((char *)property_up, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_object_class_get_property_up, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_object_class, get_property_parent) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; MidgardObjectClass *klass = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const gchar *classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { classname = (const gchar *)Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { classname = (const gchar *)Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(classname); if (!klass) { php_error(E_WARNING, "MidgardObjectClass not found"); return; } const gchar *property_parent = midgard_reflector_object_get_property_parent(classname); if (!property_parent) RETURN_NULL(); RETURN_STRING((gchar *)property_parent, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_object_class_get_property_parent, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_object_class, undelete) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *guid; int guid_length; gboolean rv; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &guid, &guid_length) == FAILURE) { return; } rv = midgard_schema_object_factory_object_undelete(mgd, (const gchar *)guid); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_object_class_undelete, 0, 0, 1) ZEND_ARG_INFO(0, guid) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_object_class, connect_default) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); php_midgard_object_class_connect_default(INTERNAL_FUNCTION_PARAM_PASSTHRU); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_object_class_connect_default, 0, 0, 3) ZEND_ARG_INFO(0, classname) ZEND_ARG_INFO(0, signal) ZEND_ARG_INFO(0, callback) ZEND_ARG_INFO(0, userdata) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_object_class, has_metadata) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(g_classname); if (!klass) { php_error(E_WARNING, "MidgardObjectClass not found"); return; } RETURN_BOOL(midgard_reflector_object_has_metadata_class(g_classname)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_object_class_has_metadata, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_object_class, get_schema_value) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; char *name; int name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &zvalue, &name, &name_length) == FAILURE) { return; } const gchar *classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { classname = (const gchar *) Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { classname = (const gchar *) Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "first argument should be object or string"); return; } MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(classname); if (!klass) { php_error(E_WARNING, "MidgardObjectClass not found"); return; } const gchar *schema_value = midgard_reflector_object_get_schema_value(classname, (const gchar *)name); if (!schema_value) RETURN_NULL(); RETURN_STRING((char *)schema_value, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_object_class_get_schema_value, 0, 0, 2) ZEND_ARG_INFO(0, classname) ZEND_ARG_INFO(0, node_name) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_object_class) { static zend_function_entry object_class_methods[] = { PHP_ME(midgard_object_class, factory, arginfo_midgard_object_class_factory, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_object_class, undelete, arginfo_midgard_object_class_undelete, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_object_class, get_object_by_guid, arginfo_midgard_object_class_get_object_by_guid, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_object_class, get_property_up, arginfo_midgard_object_class_get_property_up, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_object_class, get_property_parent, arginfo_midgard_object_class_get_property_parent, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_object_class, connect_default, arginfo_midgard_object_class_connect_default, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_object_class, has_metadata, arginfo_midgard_object_class_has_metadata, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_object_class, get_schema_value, arginfo_midgard_object_class_get_schema_value, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_object_class_class_entry; INIT_CLASS_ENTRY(php_midgard_object_class_class_entry, "midgard_object_class", object_class_methods); php_midgard_object_class_class = zend_register_internal_class(&php_midgard_object_class_class_entry TSRMLS_CC); CLASS_SET_DOC_COMMENT(php_midgard_object_class_class, strdup("Collection of static methods for operating on class-hierarchies of midgard-objects")); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_collector.c0000664000175000017500000003401411730073440016542 0ustar pppp/* Copyright (C) 2006, 2007 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" zend_class_entry *php_midgard_collector_class; #define _GET_COLLECTOR_OBJECT \ zval *zval_object = getThis(); \ MidgardCollector *collector = MIDGARD_COLLECTOR(__php_gobject_ptr(zval_object)); \ if (!collector) \ php_error(E_ERROR, "Can not find underlying collector instance"); /* Object constructor */ static PHP_METHOD(midgard_collector, __construct) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zval_object = getThis(); GObject *gobject; char *classname, *propname; int classname_length, propname_length; zval *value; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz", &classname, &classname_length, &propname, &propname_length, &value) == FAILURE) { return; } zend_class_entry *ce = zend_fetch_class(classname, classname_length, ZEND_FETCH_CLASS_AUTO TSRMLS_CC); if (ce == NULL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Didn't find %s class", classname); php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC); return; } zend_class_entry *base_ce = php_midgard_get_baseclass_ptr(ce); GType classtype = g_type_from_name((const gchar *)base_ce->name); if (!g_type_is_a(classtype, MIDGARD_TYPE_DBOBJECT)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expected %s derived class", g_type_name(MIDGARD_TYPE_DBOBJECT)); php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC); return; } gobject = __php_gobject_ptr(zval_object); if (!gobject) { GValue *gvalue = php_midgard_zval2gvalue(value TSRMLS_CC); MidgardCollector *object = midgard_collector_new(mgd, base_ce->name, propname, gvalue); if (!object) return; MGD_PHP_SET_GOBJECT(zval_object, object); } else { // we already have gobject injected } php_midgard_gobject *php_gobject = __php_objstore_object(zval_object); /* Set user defined class. We might need it when execute is invoked */ php_gobject->user_ce = ce; php_gobject->user_class_name = (char *)ce->name; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector___construct, 0, 0, 3) ZEND_ARG_INFO(0, classname) ZEND_ARG_INFO(0, property) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, set_key_property) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *propname; int propname_length; zval *zvalue; gboolean rv; GValue *gvalue = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &propname, &propname_length, &zvalue) == FAILURE) { return; } _GET_COLLECTOR_OBJECT; rv = midgard_collector_set_key_property(collector, propname, gvalue); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_set_key_property, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, add_value_property) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *propname; int propname_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &propname, &propname_length) == FAILURE) return; _GET_COLLECTOR_OBJECT; RETURN_BOOL(midgard_collector_add_value_property(collector, propname)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_add_value_property, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, set) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_TRUE; char *key, *subkey; int key_length, subkey_length; zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz", &key, &key_length, &subkey, &subkey_length, &zvalue) == FAILURE) { return; } _GET_COLLECTOR_OBJECT; GValue *gvalue = php_midgard_zval2gvalue(zvalue TSRMLS_CC); gboolean rv = midgard_collector_set(collector, key, subkey, gvalue); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_set, 0, 0, 3) ZEND_ARG_INFO(0, key) ZEND_ARG_INFO(0, subkey) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() static void __colector_update_zend_hash(GQuark key_id, gpointer data, gpointer user_data) { zval *zend_hash = (zval *) user_data; GValue *gvalue = (GValue *) data; if (gvalue == NULL) return; TSRMLS_FETCH(); zval *zvalue; MAKE_STD_ZVAL(zvalue); /* FIXME, we need to get underlying object here */ php_midgard_gvalue2zval(gvalue, zvalue TSRMLS_CC); add_assoc_zval(zend_hash, (gchar *)g_quark_to_string(key_id), zvalue); return; } static PHP_METHOD(midgard_collector, get) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *key; int key_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_length) == FAILURE) return; _GET_COLLECTOR_OBJECT; array_init(return_value); GData *keyslist = midgard_collector_get(collector, (const gchar *)key); if (keyslist != NULL) { g_datalist_foreach(&keyslist, __colector_update_zend_hash, return_value); } } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_get, 0, 0, 1) ZEND_ARG_INFO(0, key) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, get_subkey) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); const char *key, *subkey; int key_length, subkey_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &key, &key_length, &subkey, &subkey_length) == FAILURE) { return; } _GET_COLLECTOR_OBJECT; GValue *gvalue = midgard_collector_get_subkey(collector, key, subkey); if (!gvalue) return; zval *_ret; MAKE_STD_ZVAL(_ret); php_midgard_gvalue2zval(gvalue, _ret TSRMLS_CC); RETURN_ZVAL(_ret, 1, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_get_subkey, 0, 0, 2) ZEND_ARG_INFO(0, key) ZEND_ARG_INFO(0, subkey) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, remove_key) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); const char *key; int key_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_length) == FAILURE) return; _GET_COLLECTOR_OBJECT; RETURN_BOOL(midgard_collector_remove_key(collector, key)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_remove_key, 0, 0, 1) ZEND_ARG_INFO(0, key) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, merge) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; zval *zobject; zend_bool zbool = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", &zobject, php_midgard_collector_class, &zbool) == FAILURE) return; _GET_COLLECTOR_OBJECT; MidgardCollector *mc = MIDGARD_COLLECTOR(__php_gobject_ptr(zobject)); RETURN_BOOL(midgard_collector_merge(collector, mc, zbool)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_merge, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, key, midgard_collector, 0) ZEND_ARG_INFO(0, overwrite) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, list_keys) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_COLLECTOR_OBJECT; array_init(return_value); gchar **keys = midgard_collector_list_keys(collector); if (!keys) return; size_t i = 0; while (keys[i] != NULL) { add_assoc_string(return_value, (gchar *)keys[i], "", 1); i++; } g_free(keys); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_collector_list_keys, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, add_constraint) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *name, *op; int name_length, op_length; zval *value; gboolean rv; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz", &name, &name_length, &op, &op_length, &value) != SUCCESS) { return; } GValue *gvalue = php_midgard_zval2gvalue(value TSRMLS_CC); _GET_COLLECTOR_OBJECT; rv = midgard_collector_add_constraint(collector, name, op, gvalue); g_value_unset(gvalue); g_free(gvalue); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_add_constraint, 0, 0, 3) ZEND_ARG_INFO(0, property) ZEND_ARG_INFO(0, operator) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, begin_group) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; char *type; int type_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &type, &type_length) != SUCCESS) return; _GET_COLLECTOR_OBJECT; RETURN_BOOL(midgard_collector_begin_group(collector, type)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_collector_begin_group, 0) ZEND_ARG_INFO(0, type) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, end_group) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_COLLECTOR_OBJECT; RETURN_BOOL(midgard_collector_end_group(collector)); } static PHP_METHOD(midgard_collector, add_order) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); const char *field, *order = "ASC"; int field_length, order_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &field, &field_length, &order, &order_length) != SUCCESS) return; _GET_COLLECTOR_OBJECT; RETURN_BOOL(midgard_collector_add_order(collector, field, order)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_add_order, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_ARG_INFO(0, type) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, set_offset) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); long offset; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &offset) != SUCCESS) return; if (offset < 0) { php_error(E_WARNING, "Ignoring a negative query offset"); return; } _GET_COLLECTOR_OBJECT; midgard_collector_set_offset(collector, offset); RETURN_TRUE; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_set_offset, 0, 0, 1) ZEND_ARG_INFO(0, offset) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, set_limit) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); long limit; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &limit) != SUCCESS) return; if (limit < 0) { php_error(E_WARNING, "Ignoring a negative query limit"); return; } _GET_COLLECTOR_OBJECT; midgard_collector_set_limit(collector, limit); RETURN_TRUE; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_collector_set_limit, 0, 0, 1) ZEND_ARG_INFO(0, limit) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_collector, execute) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_COLLECTOR_OBJECT; RETURN_BOOL(midgard_collector_execute(collector)); } PHP_MINIT_FUNCTION(midgard2_collector) { static zend_function_entry collector_methods[] = { PHP_ME(midgard_collector, __construct, arginfo_midgard_collector___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_collector, set_key_property, arginfo_midgard_collector_set_key_property, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, add_value_property, arginfo_midgard_collector_add_value_property, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, set, arginfo_midgard_collector_set, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, get, arginfo_midgard_collector_get, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, get_subkey, arginfo_midgard_collector_get_subkey, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, merge, arginfo_midgard_collector_merge, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, list_keys, arginfo_midgard_collector_list_keys, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, remove_key, arginfo_midgard_collector_remove_key, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, add_constraint, arginfo_midgard_collector_add_constraint, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, begin_group, arginfo_midgard_collector_begin_group, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, end_group, NULL, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, add_order, arginfo_midgard_collector_add_order, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, set_offset, arginfo_midgard_collector_set_offset, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, set_limit, arginfo_midgard_collector_set_limit, ZEND_ACC_PUBLIC) PHP_ME(midgard_collector, execute, NULL, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_collector_class_entry; INIT_CLASS_ENTRY(php_midgard_collector_class_entry, "MidgardCollector", collector_methods); /* FIXME, this inheritance should be automatic once we switch to namespaces */ zend_class_entry *qbce = php_midgard_get_class_ptr_by_name("MidgardQueryBuilder"); php_midgard_collector_class = zend_register_internal_class_ex (&php_midgard_collector_class_entry, qbce, "MidgardQueryBuilder" TSRMLS_CC); php_midgard_collector_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_collector_class, strdup("Optimized database query tool, that doesn't return objects")); zend_register_class_alias("midgard_collector", php_midgard_collector_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_key_config_file_context.c0000664000175000017500000000514511730073440021437 0ustar pppp/* * Copyright (C) 2009 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" #include static zend_class_entry *php_midgard_key_config_file_context_class; /* Object constructor */ static PHP_METHOD(midgard_key_config_file_context, __construct) { RETVAL_FALSE; zval *object = getThis(); char *path; int path_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_length) == FAILURE) return; GError *error = NULL; MidgardKeyConfigFileContext *kctx = midgard_key_config_file_context_new(path, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, error && error->message ? error->message : "Unknown reason"); g_clear_error (&error); return; } MGD_PHP_SET_GOBJECT(object, kctx); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_file_context___construct, 0, 0, 1) ZEND_ARG_INFO(0, context_path) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_key_config_file_context) { static zend_function_entry midgard_key_config_file_context_methods[] = { PHP_ME(midgard_key_config_file_context, __construct, arginfo_midgard_key_config_file_context___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_key_config_file_context_class_entry; INIT_CLASS_ENTRY(php_midgard_key_config_file_context_class_entry, "midgard_key_config_file_context", midgard_key_config_file_context_methods); php_midgard_key_config_file_context_class = zend_register_internal_class_ex(&php_midgard_key_config_file_context_class_entry, NULL, "midgard_key_config_context" TSRMLS_CC); CLASS_SET_DOC_COMMENT(php_midgard_key_config_file_context_class, strdup("File based key-value (ini like) configurations")); php_midgard_key_config_file_context_class->create_object = php_midgard_gobject_new; return SUCCESS; } php5-midgard2-10.05.7/php_midgard_functions.h0000664000175000017500000000006611730073440016571 0ustar ppppPHP_FUNCTION(mgd_version); PHP_FUNCTION(mgd_is_guid); php5-midgard2-10.05.7/php_midgard_handle.h0000664000175000017500000000203611730073440016013 0ustar pppp/* Copyright (C) 2009 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" void php_midgard_handle_holder_init(MgdGHolder **mgh); void php_midgard_handle_holder_free(MgdGHolder **mgh); MidgardConnection *php_midgard_handle_lookup(MgdGHolder **mgh, GHashTable *global_cfgs TSRMLS_DC); php5-midgard2-10.05.7/tests/0000775000175000017500000000000011730073440013212 5ustar ppppphp5-midgard2-10.05.7/tests/bad.cfg0000664000175000017500000000035211730073440014421 0ustar pppp[MidgardDatabase] Type=SQLite Name=bad Username=bad Password=bad Host= Logfile= # Schema= # DefaultLanguage= Loglevel=warning TableCreate=false TableUpdate=false TestUnit=false MidgardUsername=root MidgardPassword=password # PamFile= php5-midgard2-10.05.7/tests/test.ini0000664000175000017500000000015711730073440014675 0ustar pppp[midgard2] midgard.engine = On midgard.http = Off midgard.memory_debug = Off midgard.superglobals_compat = Off php5-midgard2-10.05.7/tests/001-midgard_datetime-variation-php53.phpt0000664000175000017500000000120211730073440022612 0ustar pppp--TEST-- midgard_datetime tests (additional test for php 5.3) --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off report_memleaks = On --FILE-- setDate(2009, 06, 10)->setTime(12, 41)->setTime(12, 41, 10)->setISODate(2009, 05, 3)->modify('+1 day'); echo $date->format("Y-m-d H:i:s")."\n"; ?> ===DONE=== --EXPECTF-- 2009-01-29 12:41:10 ===DONE=== php5-midgard2-10.05.7/tests/021a-superglobals_on.phpt0000664000175000017500000000123211730073440017744 0ustar pppp--TEST-- test for superglobals_compat ini-setting --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off midgard.superglobals_compat = On display_startup_errors = On report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- %s midgard.superglobals_compat option is deprecated and might be removed in next release in %s bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests/035-mgd_version.phpt0000664000175000017500000000070111730073440016726 0ustar pppp--TEST-- mgd_version tests --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- bool(true) Warning: %s in %s on line %d NULL Warning: %s in %s on line %d NULL ===DONE=== php5-midgard2-10.05.7/tests/034-mgd_is_guid.phpt0000664000175000017500000000102111730073440016657 0ustar pppp--TEST-- mgd_is_guid tests --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- Warning: %s in %s on line %d NULL bool(false) bool(false) bool(true) bool(false) ===DONE=== php5-midgard2-10.05.7/tests/share/0000775000175000017500000000000011730073440014314 5ustar ppppphp5-midgard2-10.05.7/tests/share/MidgardObjects.xml0000664000175000017500000001723611730073440017730 0ustar pppp http://xmlns.com/foaf/0.1/Person foaf:http://xmlns.com/foaf/0.1/ Local non-replication-safe database identifier First name of the person foaf:firstName Last name of the person foaf:lastName Local non-replication-safe database identifier Filename of the attachment Title of the attachment Location of the attachment in the blob directory structure MIME type of the attachment GUID of the object the attachment is attached to Local non-replication-safe database identifier Namespace of the parameter Key of the parameter Value of the parameter GUID of the object the parameter extends Local non-replication-safe database identifier Path name of the snippetdir Snippetdir the snippetdir is under Local non-replication-safe database identifier Path name of the snippet Snippetdir the snippet is under Code of the snippet Documentation of the snippet Local non-replication-safe database identifier Quota for the sitegroup (in bytes) Disk usage of the sitegroup (in bytes) Limit of number of records for the sitegroup Number of records for the sitegroup MgdSchema type the quota applies to Quota of the type for the sitegroup (in bytes) Disk usage of the type of the sitegroup (in bytes) Limit of number of records of the type for the sitegroup Number of records of the type for the sitegroup http://xmlns.notu.be/aair#Activity aair:http://xmlns.notu.be/aair# Local non-replication-safe database identifier The person who performed the activity aair:Actor The action performed, following Atom Activity Extension URL schema (for example: http://activitystrea.ms/schema/1.0/post) aair:activityVerb The object that the action was done to aair:activityObject A human-readable description of the activity aair:summary Application the activity was performed with. In case of MidCOM, a component aair:Application php5-midgard2-10.05.7/tests/share/schema/0000775000175000017500000000000011730073440015554 5ustar ppppphp5-midgard2-10.05.7/tests/share/schema/test_tables.xml0000664000175000017500000000440711730073440020614 0ustar pppp Local non-replication-safe database identifier A-field B-field text-field parent atype Float field value1 value2 Local non-replication-safe database identifier Link to A-table X-field Y-field Local non-replication-safe database identifier Link to A-table Z1-field Z2-field php5-midgard2-10.05.7/tests/share/midgard_initial_database.xml0000664000175000017500000000157411730073440022011 0ustar pppp
php5-midgard2-10.05.7/tests/share/midgard_auth_types.xml0000664000175000017500000000211311730073440020707 0ustar pppp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 php5-midgard2-10.05.7/tests/share/views/0000775000175000017500000000000011730073440015451 5ustar ppppphp5-midgard2-10.05.7/tests/share/views/test_views.xml0000664000175000017500000000350611730073440020373 0ustar pppp php5-midgard2-10.05.7/tests/001-midgard_datetime.phpt0000664000175000017500000000136611730073440017676 0ustar pppp--TEST-- midgard_datetime tests --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off report_memleaks = On --FILE-- setDate(2009, 06, 10); echo $date->format("Y-m-d")."\n"; $date->setTime(12, 41); echo $date->format("Y-m-d H:i:s")."\n"; $date->setTime(12, 41, 10); echo $date->format("Y-m-d H:i:s")."\n"; $date->setISODate(2009, 05, 3); echo $date->format("Y-m-d H:i:s")."\n"; $date->modify('+1 day'); echo $date->format("Y-m-d H:i:s")."\n"; echo ((string)$date)."\n"; ?> ===DONE=== --EXPECTF-- 2009-06-10 2009-06-10 12:41:00 2009-06-10 12:41:10 2009-01-28 12:41:10 2009-01-29 12:41:10 2009-01-29T12:41:10+00:00 ===DONE=== php5-midgard2-10.05.7/tests/005-midgard_connection.phpt0000664000175000017500000000126011730073440020236 0ustar pppp--TEST-- test of midgard_connection in CLI-mode --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off report_memleaks = On --FILE-- read_file_at_path(dirname(__FILE__).'/test.cfg'); $mgd = midgard_connection::get_instance(); var_dump($mgd instanceof midgard_connection); var_dump($mgd->config === null); $str1 = var_export($mgd, true); $mgd = midgard_connection::get_instance(); $str2 = var_export($mgd, true); var_dump($str1 === $str2); var_dump($mgd->open_config($cfg)); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests/008-midgard_dbus.phpt0000664000175000017500000000135111730073440017040 0ustar pppp--TEST-- test of midgard_dbus class --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off report_memleaks = On --FILE-- read_file_at_path(dirname(__FILE__).'/test.cfg'); $mgd = midgard_connection::get_instance(); $mgd->open_config($cfg); try { $dbus = new midgard_dbus('/test'); echo "MISSED ERROR\n"; } catch (Exception $e) { } try { $mgd = midgard_connection::get_instance(); $dbus = new midgard_dbus('/test'); } catch (Exception $e) { echo "UNEXPECTED ERROR\n"; } ?> ===DONE=== --EXPECTF-- MISSED ERROR ===DONE=== php5-midgard2-10.05.7/tests/021b-superglobals_off.phpt0000664000175000017500000000107711730073440020112 0ustar pppp--TEST-- test for superglobals_compat ini-setting --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off midgard.superglobals_compat = Off display_startup_errors = On report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- bool(false) bool(false) bool(false) ===DONE=== php5-midgard2-10.05.7/php_midgard_key_config_context.c0000664000175000017500000000645311730073440020443 0ustar pppp/* * Copyright (C) 2009 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" static zend_class_entry *php_midgard_key_config_context_class; /* Object constructor */ // static PHP_METHOD(midgard_key_config_context, __construct) // { // RETVAL_FALSE; // // zval *object = getThis(); // char *path; // int path_length; // // if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_length) == FAILURE) // return; // // MidgardKeyConfigContext *kctx = midgard_key_config_context_new(path); // // if (!kctx) // RETURN_FALSE; // // MGD_PHP_SET_GOBJECT(object, kctx); // } // // ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_context___construct, 0, 0, 1) // ZEND_ARG_INFO(0, context_path) // ZEND_END_ARG_INFO() static PHP_METHOD(midgard_key_config_context, list_key_config) { RETVAL_FALSE; zval *zval_object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; MidgardKeyConfigContext *kctx = (MidgardKeyConfigContext *) __php_gobject_ptr(zval_object); array_init (return_value); gint n_cfgs; gchar **cfgs = midgard_key_config_context_list_key_config (kctx, &n_cfgs); if (!cfgs) return; guint i; for (i = 0; i < n_cfgs; i++) { add_assoc_string(return_value, (gchar *)cfgs[i], "", 1); } g_strfreev(cfgs); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_key_config_context_list_key_config, 0) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_key_config_context) { static zend_function_entry midgard_key_config_context_methods[] = { // PHP_ME(midgard_key_config_context, __construct, arginfo_midgard_key_config_context___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_key_config_context, list_key_config, arginfo_midgard_key_config_context_list_key_config, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_key_config_context_class_entry; INIT_CLASS_ENTRY(php_midgard_key_config_context_class_entry, "MidgardKeyConfigContext", midgard_key_config_context_methods); php_midgard_key_config_context_class = zend_register_internal_class(&php_midgard_key_config_context_class_entry TSRMLS_CC); php_midgard_key_config_context_class->ce_flags = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; CLASS_SET_DOC_COMMENT(php_midgard_key_config_context_class, strdup("Abstract class for key-value (ini like) configuration contexts")); php_midgard_key_config_context_class->create_object = php_midgard_gobject_new; zend_register_class_alias("midgard_key_config_context", php_midgard_key_config_context_class); return SUCCESS; } php5-midgard2-10.05.7/win32/0000775000175000017500000000000011730073440013012 5ustar ppppphp5-midgard2-10.05.7/win32/php_midgard.rc0000664000175000017500000000565311730073440015627 0ustar pppp//Microsoft Developer Studio generated resource script. // #include "resource.h" #define APSTUDIO_READONLY_SYMBOLS ///////////////////////////////////////////////////////////////////////////// // // Generated from the TEXTINCLUDE 2 resource. // #include "afxres.h" ///////////////////////////////////////////////////////////////////////////// #undef APSTUDIO_READONLY_SYMBOLS ///////////////////////////////////////////////////////////////////////////// // Deutsch (Deutschland) resources #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_DEU) #ifdef _WIN32 LANGUAGE LANG_GERMAN, SUBLANG_GERMAN #pragma code_page(1252) #endif //_WIN32 #ifdef APSTUDIO_INVOKED ///////////////////////////////////////////////////////////////////////////// // // TEXTINCLUDE // 1 TEXTINCLUDE DISCARDABLE BEGIN "resource.h\0" END 2 TEXTINCLUDE DISCARDABLE BEGIN "#include ""afxres.h""\r\n" "\0" END 3 TEXTINCLUDE DISCARDABLE BEGIN "\r\n" "\0" END #endif // APSTUDIO_INVOKED #endif // Deutsch (Deutschland) resources ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// // Englisch (USA) resources #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) #ifdef _WIN32 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US #pragma code_page(1252) #endif //_WIN32 #ifndef _MAC ///////////////////////////////////////////////////////////////////////////// // // Version // VS_VERSION_INFO VERSIONINFO FILEVERSION 1,4,4,1 PRODUCTVERSION 1,4,4,1 FILEFLAGSMASK 0x3fL #ifdef _DEBUG FILEFLAGS 0x1L #else FILEFLAGS 0x0L #endif FILEOS 0x40004L FILETYPE 0x1L FILESUBTYPE 0x0L BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "040704b0" BEGIN VALUE "Comments", "The Midgard Win32 port was developed by Best Off .\0" VALUE "CompanyName", "The Midgard Project Ry\0" VALUE "FileDescription", "Midgard PHP4 extension\0" VALUE "FileVersion", "1.4.4\0" VALUE "InternalName", "php_midgard\0" VALUE "LegalCopyright", "Copyright © 1998-2002 The Midgard Project Ry\0" VALUE "LegalTrademarks", "\0" VALUE "OriginalFilename", "php_midgard.dll\0" VALUE "PrivateBuild", "\0" VALUE "ProductName", "Midgard Application Server\0" VALUE "ProductVersion", "1.4.4\0" VALUE "SpecialBuild", "\0" END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x407, 1200 END END #endif // !_MAC #endif // Englisch (USA) resources ///////////////////////////////////////////////////////////////////////////// #ifndef APSTUDIO_INVOKED ///////////////////////////////////////////////////////////////////////////// // // Generated from the TEXTINCLUDE 3 resource. // ///////////////////////////////////////////////////////////////////////////// #endif // not APSTUDIO_INVOKED php5-midgard2-10.05.7/win32/php_midgard.dsp0000664000175000017500000002201211730073440015775 0ustar pppp# Microsoft Developer Studio Project File - Name="php_midgard" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** NICHT BEARBEITEN ** # TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102 CFG=php_midgard - Win32 Debug !MESSAGE Dies ist kein gültiges Makefile. Zum Erstellen dieses Projekts mit NMAKE !MESSAGE verwenden Sie den Befehl "Makefile exportieren" und führen Sie den Befehl !MESSAGE !MESSAGE NMAKE /f "php_midgard.mak". !MESSAGE !MESSAGE Sie können beim Ausführen von NMAKE eine Konfiguration angeben !MESSAGE durch Definieren des Makros CFG in der Befehlszeile. Zum Beispiel: !MESSAGE !MESSAGE NMAKE /f "php_midgard.mak" CFG="php_midgard - Win32 Debug" !MESSAGE !MESSAGE Für die Konfiguration stehen zur Auswahl: !MESSAGE !MESSAGE "php_midgard - Win32 Release" (basierend auf "Win32 (x86) Dynamic-Link Library") !MESSAGE "php_midgard - Win32 Debug" (basierend auf "Win32 (x86) Dynamic-Link Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe MTL=midl.exe RSC=rc.exe !IF "$(CFG)" == "php_midgard - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir ".\Release" # PROP Intermediate_Dir ".\tmp" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PHP_MIDGARD_EXPORTS" /Yu"stdafx.h" /FD /c # ADD CPP /nologo /MT /W3 /GX /O2 /I "..\..\lib" /I "..\..\build\expat\lib" /I "..\..\build\glib" /I "..\..\build\glib\glib" /I "..\..\build\iconv\include" /I "..\..\..\..\applications\opensa\apache\src\include" /I "..\..\..\..\applications\opensa\apache\src\os\win32" /I "..\..\..\..\applications\modules\php" /I "..\..\..\..\applications\modules\php\Zend" /I "..\..\..\..\applications\modules\php\TSRM" /I "..\..\..\..\applications\modules\php\main" /D "__G_WIN32_H__" /D "HAVE_MIDGARD_SITEGROUPS" /D "APACHE_READDIR_H" /D "APACHE_OS_H" /D "PHP_EXPORTS" /D "COMPILE_DL_MIDGARD" /D ZTS=0 /D "HAVE_MIDGARD" /D ZEND_DEBUG=0 /D "ZEND_WIN32" /D "PHP_WIN32" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PHP_MIDGARD_EXPORTS" /YX /FD /c # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 # ADD BASE RSC /l 0x407 /d "NDEBUG" # ADD RSC /l 0x407 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib php4ts.lib /nologo /dll /machine:I386 /libpath:"..\..\lib\win32\Release" /libpath:"..\..\build\glib\glib" /libpath:"..\..\..\..\applications\modules\php\Release_TS" # SUBTRACT LINK32 /pdb:none !ELSEIF "$(CFG)" == "php_midgard - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir ".\Debug" # PROP Intermediate_Dir ".\tmp" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PHP_MIDGARD_EXPORTS" /Yu"stdafx.h" /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\lib" /I "..\..\build\expat\lib" /I "..\..\build\glib" /I "..\..\build\glib\glib" /I "..\..\build\iconv\include" /I "..\..\..\..\applications\opensa\apache\src\include" /I "..\..\..\..\applications\opensa\apache\src\os\win32" /I "..\..\..\..\applications\modules\php" /I "..\..\..\..\applications\modules\php\main" /I "..\..\..\..\applications\modules\php\Zend" /I "..\..\..\..\applications\modules\php\TSRM" /D "__G_WIN32_H__" /D "HAVE_MIDGARD_SITEGROUPS" /D "APACHE_READDIR_H" /D "APACHE_OS_H" /D "PHP_EXPORTS" /D "COMPILE_DL_MIDGARD" /D ZTS=0 /D "HAVE_MIDGARD" /D ZEND_DEBUG=1 /D "ZEND_WIN32" /D "PHP_WIN32" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PHP_MIDGARD_EXPORTS" /YX /FD /I /GZ /c # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32 # ADD BASE RSC /l 0x407 /d "_DEBUG" # ADD RSC /l 0x407 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib php4ts_debug.lib /nologo /dll /debug /machine:I386 /pdbtype:sept /libpath:"..\..\lib\win32\Debug" /libpath:"..\..\build\glib\glib" /libpath:"..\..\..\..\applications\modules\php\Debug_TS" # SUBTRACT LINK32 /pdb:none !ENDIF # Begin Target # Name "php_midgard - Win32 Release" # Name "php_midgard - Win32 Debug" # Begin Group "Quellcodedateien" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=..\article.c # End Source File # Begin Source File SOURCE=..\attachment.c # End Source File # Begin Source File SOURCE=..\calendar.c # End Source File # Begin Source File SOURCE=..\element.c # End Source File # Begin Source File SOURCE=..\event.c # End Source File # Begin Source File SOURCE=..\eventmember.c # End Source File # Begin Source File SOURCE=..\file.c # End Source File # Begin Source File SOURCE=..\group.c # End Source File # Begin Source File SOURCE=..\host.c # End Source File # Begin Source File SOURCE=..\image.c # End Source File # Begin Source File SOURCE=..\mail.c # End Source File # Begin Source File SOURCE=..\member.c # End Source File # Begin Source File SOURCE=..\mgd_errno.c # End Source File # Begin Source File SOURCE=..\midgard.c # End Source File # Begin Source File SOURCE=..\oop.c # End Source File # Begin Source File SOURCE=..\page.c # End Source File # Begin Source File SOURCE=..\pageelement.c # End Source File # Begin Source File SOURCE=..\pagelink.c # End Source File # Begin Source File SOURCE=..\parameter.c # End Source File # Begin Source File SOURCE=..\person.c # End Source File # Begin Source File SOURCE=..\preferences.c # End Source File # Begin Source File SOURCE=..\preparse.c # End Source File # Begin Source File SOURCE=..\preparser.c # End Source File # Begin Source File SOURCE=..\sitegroup.c # End Source File # Begin Source File SOURCE=..\snippet.c # End Source File # Begin Source File SOURCE=..\snippetdir.c # End Source File # Begin Source File SOURCE=..\style.c # End Source File # Begin Source File SOURCE=..\topic.c # End Source File # End Group # Begin Group "Header-Dateien" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\mgd_access.h # End Source File # Begin Source File SOURCE=..\mgd_article.h # End Source File # Begin Source File SOURCE=..\mgd_attachment.h # End Source File # Begin Source File SOURCE=..\mgd_calendar.h # End Source File # Begin Source File SOURCE=..\mgd_element.h # End Source File # Begin Source File SOURCE=..\mgd_errno.h # End Source File # Begin Source File SOURCE=..\mgd_event.h # End Source File # Begin Source File SOURCE=..\mgd_eventmember.h # End Source File # Begin Source File SOURCE=..\mgd_file.h # End Source File # Begin Source File SOURCE=..\mgd_group.h # End Source File # Begin Source File SOURCE=..\mgd_host.h # End Source File # Begin Source File SOURCE=..\mgd_image.h # End Source File # Begin Source File SOURCE=..\mgd_internal.h # End Source File # Begin Source File SOURCE=..\mgd_mail.h # End Source File # Begin Source File SOURCE=..\mgd_member.h # End Source File # Begin Source File SOURCE=..\mgd_oop.h # End Source File # Begin Source File SOURCE=..\mgd_page.h # End Source File # Begin Source File SOURCE=..\mgd_pageelement.h # End Source File # Begin Source File SOURCE=..\mgd_pagelink.h # End Source File # Begin Source File SOURCE=..\mgd_person.h # End Source File # Begin Source File SOURCE=..\mgd_preferences.h # End Source File # Begin Source File SOURCE=..\mgd_preparse.h # End Source File # Begin Source File SOURCE=..\mgd_preparser.h # End Source File # Begin Source File SOURCE=..\mgd_sitegroup.h # End Source File # Begin Source File SOURCE=..\mgd_snippet.h # End Source File # Begin Source File SOURCE=..\mgd_snippetdir.h # End Source File # Begin Source File SOURCE=..\mgd_style.h # End Source File # Begin Source File SOURCE=..\mgd_topic.h # End Source File # End Group # Begin Group "Ressourcendateien" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" # Begin Source File SOURCE=.\php_midgard.rc # End Source File # Begin Source File SOURCE=.\resource.h # End Source File # End Group # End Target # End Project php5-midgard2-10.05.7/win32/resource.h0000664000175000017500000000062011730073440015010 0ustar pppp//{{NO_DEPENDENCIES}} // Microsoft Developer Studio generated include file. // Used by php_midgard.rc // // Next default values for new objects // #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS #define _APS_NEXT_RESOURCE_VALUE 101 #define _APS_NEXT_COMMAND_VALUE 40001 #define _APS_NEXT_CONTROL_VALUE 1000 #define _APS_NEXT_SYMED_VALUE 101 #endif #endif php5-midgard2-10.05.7/win32/status.txt0000664000175000017500000000300111730073440015070 0ustar ppppImplementation Status of the Win32 Midgard PHP4 extension Last update: $Date$ Copyright (C) 1999 Jukka Zitting Copyright (C) 2000 The Midgard Project ry Win32 Parts (w) 2002 Daniel S. Reichenbach See the end for copying conditions. This document gives you an overview, which features are missing on Win32 or Work in progress and is updated on regular basis. If someone is working on the section, his or her name is listed behind the entry in brackets. Issues: o The Midgard PHP4 extension is not Zend-Thread-safe. Has to be investigated if this could become a problem. Work to do: o Macros have to be modified for Win32. Lot of work, as the MS c++ compiler is a bit ugly here. ---------------------------------------------------------------------- Copyright information: Copyright (C) 1999 Jukka Zitting Copyright (C) 2000 The Midgard Project ry Win32 Parts (w) 2002 Daniel S. Reichenbach Permission is granted to anyone to make or distribute verbatim copies of this document as received, in any medium, provided that the copyright notice and this permission notice are preserved, thus giving the recipient permission to redistribute in turn. Permission is granted to distribute modified versions of this document, or of portions of it, under the above conditions, provided also that they carry prominent notices stating who last changed them. ^L Local variables: version-control: never mode: indented-text end: php5-midgard2-10.05.7/php_midgard_query_storage.c0000664000175000017500000000473311730073440017452 0ustar pppp/* Copyright (C) 2010 Alexey Zakhlestin * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" zend_class_entry *php_midgard_query_storage_class; /* Object constructor */ static PHP_METHOD(midgard_query_storage, __construct) { char *classname; int classname_length = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) { return; } const gchar *g_classname = php_class_name_to_g_class_name(classname); MidgardQueryStorage *storage = midgard_query_storage_new(g_classname); if (!storage) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Can not wrap this class in midgard_query_storage"); return; } MGD_PHP_SET_GOBJECT(getThis(), storage); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_storage___construct, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_query_storage) { static zend_function_entry midgard_query_storage_methods[] = { PHP_ME(midgard_query_storage, __construct, arginfo_midgard_query_storage___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_storage_class_entry; INIT_CLASS_ENTRY(php_midgard_query_storage_class_entry, "MidgardQueryStorage", midgard_query_storage_methods); php_midgard_query_storage_class = zend_register_internal_class(&php_midgard_query_storage_class_entry TSRMLS_CC); php_midgard_query_storage_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_storage_class, strdup("Wraps DBObject for use with midgard_query_* classes")); zend_register_class_alias("midgard_query_storage", php_midgard_query_storage_class); return SUCCESS; } php5-midgard2-10.05.7/midgard2.ini0000664000175000017500000000021611730073440014241 0ustar ppppextension=midgard2.so [midgard2] ; midgard.engine = On ; midgard.http = Off ; midgard.superglobals_compat = Off ; midgard.memory_debug = Off php5-midgard2-10.05.7/php_midgard_error.c0000664000175000017500000001136511730073440015711 0ustar pppp/* Copyright (C) 2008 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" static zend_class_entry *php_midgard_error_class; /* Object constructor */ static PHP_METHOD(midgard_error, __construct) { } ZEND_BEGIN_ARG_INFO(arginfo_midgard_error___construct, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_error, error) { char *msg; zend_bool tog = FALSE; int msg_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &msg, &msg_length, &tog) == FAILURE) return; g_error("%s", msg); return; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_error_error, 0, 0, 1) ZEND_ARG_INFO(0, message) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_error, critical) { char *msg; zend_bool tog = FALSE; int msg_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &msg, &msg_length, &tog) == FAILURE) return; php_midgard_log_enabled = tog; g_critical("%s", msg); php_midgard_log_enabled = TRUE; return; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_error_critical, 0, 0, 1) ZEND_ARG_INFO(0, message) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_error, warning) { char *msg; zend_bool tog = FALSE; int msg_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &msg, &msg_length, &tog) == FAILURE) return; php_midgard_log_enabled = tog; g_warning("%s", msg); php_midgard_log_enabled = TRUE; return; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_error_warning, 0, 0, 1) ZEND_ARG_INFO(0, message) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_error, message) { char *msg; zend_bool tog = FALSE; int msg_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &msg, &msg_length, &tog) == FAILURE) return; php_midgard_log_enabled = tog; g_message("%s", msg); php_midgard_log_enabled = TRUE; return; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_error_message, 0, 0, 1) ZEND_ARG_INFO(0, message) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_error, info) { char *msg; zend_bool tog = FALSE; int msg_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &msg, &msg_length, &tog) == FAILURE) return; php_midgard_log_enabled = tog; g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "%s", msg); php_midgard_log_enabled = TRUE; return; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_error_info, 0, 0, 1) ZEND_ARG_INFO(0, message) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_error, debug) { char *msg; zend_bool tog = FALSE; int msg_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &msg, &msg_length, &tog) == FAILURE) return; php_midgard_log_enabled = tog; g_debug("%s", msg); php_midgard_log_enabled = TRUE; return; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_error_debug, 0, 0, 1) ZEND_ARG_INFO(0, message) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_error) { static zend_function_entry midgard_error_methods[] = { PHP_ME(midgard_error, __construct, arginfo_midgard_error___construct, ZEND_ACC_PRIVATE | ZEND_ACC_CTOR) PHP_ME(midgard_error, error, arginfo_midgard_error_error, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_error, critical, arginfo_midgard_error_critical, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_error, warning, arginfo_midgard_error_warning, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_error, message, arginfo_midgard_error_message, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_error, info, arginfo_midgard_error_info, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_error, debug, arginfo_midgard_error_debug, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_error_class_entry; INIT_CLASS_ENTRY(php_midgard_error_class_entry, "midgard_error", midgard_error_methods); php_midgard_error_class = zend_register_internal_class(&php_midgard_error_class_entry TSRMLS_CC); CLASS_SET_DOC_COMMENT(php_midgard_error_class, strdup("Collection of static methods, which can be used to send core-level log-messages")); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_handle.c0000664000175000017500000001331211730073440016005 0ustar pppp/* Copyright (C) 2009 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard_handle.h" /* Get configuration name declared in vhost configuration. midgard.configuration = "midgard"; */ static const gchar *__get_configuration_name(TSRMLS_D) { const gchar *name = MGDG(midgard_configuration); if (!name || *name == '\0') return NULL; return (const gchar *) name; } /* Get configuration file path. Shoul dbe declaored in vhost configuration midgard.configuration_file = "/home/user/config/midgard.conf" */ static const gchar *__get_configuration_filepath(TSRMLS_D) { const gchar *path = MGDG(midgard_configuration_file); if (!path || *path == '\0') return NULL; return (const gchar *) path; } struct _MgdGHolder { GHashTable *names; GHashTable *files; }; /* Initialize global midgard handle holder */ void php_midgard_handle_holder_init(MgdGHolder **mgh) { if (*mgh != NULL) return; *mgh = g_new(MgdGHolder, 1); (*mgh)->names = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref); (*mgh)->files = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref); return; } /* Free handle holder */ void php_midgard_handle_holder_free(MgdGHolder **mgh) { if ((*mgh)->names != NULL) g_hash_table_destroy((*mgh)->names); if ((*mgh)->files != NULL) g_hash_table_destroy((*mgh)->files); g_free(*mgh); *mgh = NULL; return; } /* Initialize per request copy. Early sets loghandler so we can log messages. */ MidgardConnection *__handle_set(MidgardConnection *mgd TSRMLS_DC) { g_assert(mgd != NULL); MidgardConnection *copy = midgard_connection_copy(mgd); guint loghandler = g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK, php_midgard_log_errors, (gpointer)copy); midgard_connection_set_loghandler(copy, loghandler); if (MGDG(midgard_memory_debug)) { php_printf("---> midgard_connection_set_loghandler(%d)\n", loghandler); } return copy; } static MidgardConnection *__handle_from_global_config(MgdGHolder *mgh, GHashTable *global_cfgs, const gchar *config_name TSRMLS_DC) { if (global_cfgs == NULL) return NULL; /* This is per process connection handler */ MidgardConnection *mgd = NULL; /* This is per request connection handler */ MidgardConnection *mgd_copy = NULL; /* First, let's check if given configuration name already eixts in global holder. If it exists, get a pointer */ mgd = g_hash_table_lookup(mgh->names, config_name); if (mgd != NULL) { if (!midgard_connection_reopen(mgd)) { php_error(E_WARNING, "Failed to reopen lost connection"); return NULL; } mgd_copy = __handle_set(mgd TSRMLS_CC); return mgd_copy; } /* Check if configuration exists in system config directory. */ MidgardConfig *config = g_hash_table_lookup(global_cfgs, config_name); if (config == NULL) return NULL; mgd = midgard_connection_new(); if (!midgard_connection_open_config(mgd, config)) { php_error(E_WARNING, "Failed to open connection using given '%s' configuration", config_name); g_object_unref(mgd); return NULL; } mgd_copy = __handle_set(mgd TSRMLS_CC); /* Insert connection in process' pool */ g_hash_table_insert(mgh->names, g_strdup(config_name), mgd); return mgd_copy; } static MidgardConnection *__handle_from_filepath(MgdGHolder *mgh, const gchar *config_path TSRMLS_DC) { /* This is per process connection handler */ MidgardConnection *mgd = NULL; /* This is per request connection handler */ MidgardConnection *mgd_copy = NULL; /* First, let's check if given configuration path already eixts in global holder. If it exists, get a pointer */ mgd = g_hash_table_lookup(mgh->files, config_path); if (mgd != NULL) { if (!midgard_connection_reopen(mgd)) { php_error(E_WARNING, "Failed to reopen lost connection"); return NULL; } mgd_copy = __handle_set(mgd TSRMLS_CC); return mgd_copy; } /* Open configuration from given filepath */ mgd = midgard_connection_new(); GError *err = NULL; if (!midgard_connection_open_from_file(mgd, config_path, &err)) { php_error(E_WARNING, "Failed to open connection using given '%s' configuration file: %s", config_path, err && err->message ? err->message : "Unknown reason"); g_error_free(err); g_object_unref(mgd); return NULL; } mgd_copy = __handle_set(mgd TSRMLS_CC); /* Insert connection in process' pool */ g_hash_table_insert(mgh->files, g_strdup(config_path), mgd); return mgd_copy; } MidgardConnection *php_midgard_handle_lookup(MgdGHolder **mgh, GHashTable *global_cfgs TSRMLS_DC) { if (*mgh == NULL) php_midgard_handle_holder_init(mgh); const gchar *config_path = __get_configuration_filepath(TSRMLS_C); if (config_path != NULL) { MidgardConnection *handle = __handle_from_filepath(*mgh, config_path TSRMLS_CC); if (handle != NULL) { return handle; } // handle is NULL. falling back to file-based search of config } const gchar *config_name = __get_configuration_name(TSRMLS_C); if (config_name == NULL) return NULL; return __handle_from_global_config(*mgh, global_cfgs, config_name TSRMLS_CC); } php5-midgard2-10.05.7/php_midgard__helpers.h0000664000175000017500000000566111730073440016370 0ustar pppp#include #ifndef zend_call_method_with_3_params ZEND_API zval* zend_call_method__mgd(zval **object_pp, zend_class_entry *obj_ce, zend_function **fn_proxy, char *function_name, int function_name_len, zval **retval_ptr_ptr, int param_count, zval* arg1, zval* arg2, zval* arg3, zval* arg4 TSRMLS_DC); # define zend_call_method_with_3_params(obj, obj_ce, fn_proxy, function_name, retval, arg1, arg2, arg3) \ zend_call_method__mgd(obj, obj_ce, fn_proxy, function_name, sizeof(function_name)-1, retval, 3, arg1, arg2, arg3, NULL TSRMLS_CC) # define zend_call_method_with_4_params(obj, obj_ce, fn_proxy, function_name, retval, arg1, arg2, arg3, arg4) \ zend_call_method__mgd(obj, obj_ce, fn_proxy, function_name, sizeof(function_name)-1, retval, 3, arg1, arg2, arg3, arg4 TSRMLS_CC) #endif // zend_call_method_with_3_params /* These macros are available since 5.3, so we add them in 5.2 */ #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 2 # define E_DEPRECATED E_NOTICE # define Z_SET_ISREF_P(ptr) (ptr)->is_ref = 1 # define Z_REFCOUNT_P(ptr) (ptr)->refcount # define Z_ADDREF_P(ptr) (ptr)->refcount++ # define Z_ADDREF_PP(pptr) Z_ADDREF_P(*(pptr)) # define Z_DELREF_P(ptr) (ptr)->refcount-- # define Z_DELREF_PP(pptr) Z_DELREF_P(*(pptr)) # define zend_parse_parameters_none() zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") # define PHP_SORT_DESC 3 # define PHP_SORT_ASC 4 ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem); zend_class_entry *php_date_get_date_ce(void); zend_class_entry *php_date_get_timezone_ce(void); #endif #if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3) || PHP_MAJOR_VERSION > 5 # define MGD_IS_CALLABLE(a, b, c) zend_is_callable(a, b, c TSRMLS_CC) #else # define MGD_IS_CALLABLE(a, b, c) zend_is_callable(a, b, c) #endif /* This macro frees GParameter structure */ #define PHP_MGD_FREE_GPARAMETERS(parameters, n_params) \ { \ guint _i; \ for (_i = 0; _i < n_params; _i++) { \ g_value_unset(¶meters[_i].value); \ } \ g_free(parameters); \ } void php_midgard_docs_add_class (const gchar *classname); void php_midgard_docs_add_method_comment (const char *classname, const char *method, const char *comment); const gchar *php_midgard_docs_get_method_comment (const gchar *classname, const gchar *method); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 #define php_mgd_register_auto_global(name) zend_register_auto_global(#name, sizeof(#name)-1, 0, NULL TSRMLS_CC); #else #define php_mgd_register_auto_global(name) zend_register_auto_global(#name, sizeof(#name)-1, NULL TSRMLS_CC); #endif #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 # define CLASS_SET_DOC_COMMENT(_cptr, __comment) \ _cptr->info.user.doc_comment = __comment; \ _cptr->info.user.doc_comment_len = strlen(__comment); #else # define CLASS_SET_DOC_COMMENT(_cptr, __comment) \ _cptr->doc_comment = __comment; #endif void php_midgard_array_from_unknown_objects(GObject **objects, guint n_objects, zval *zarray TSRMLS_DC); php5-midgard2-10.05.7/php_midgard_reflector_property.c0000664000175000017500000002641511730073440020513 0ustar pppp/* Copyright (C) 2006, 2007, 2011 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" zend_class_entry *php_midgard_reflector_property_class; #define _GET_MRP_OBJECT \ zval *zval_object = getThis(); \ MidgardReflectorProperty *mrp = MIDGARD_REFLECTOR_PROPERTY(__php_gobject_ptr(zval_object)); \ if (!mrp) \ php_error(E_ERROR, "Can not find underlying reflector instance"); #define _NOSCHEMA_CLASS_ERR \ { php_error(E_WARNING,"%s method can not be called."\ "midgard_reflector_property initialized with non schema class", \ get_active_function_name(TSRMLS_C));\ RETURN_FALSE; } /* Object constructor */ static PHP_METHOD(midgard_reflector_property, __construct) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *php_classname = NULL; int php_classname_length; zend_class_entry *ce_base; zval *zval_object = getThis(); GObject *gobject; gobject = __php_gobject_ptr(zval_object); if (!gobject) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &php_classname, &php_classname_length) == FAILURE) return; { gboolean __isderived = php_midgard_is_derived_from_class(php_classname, MIDGARD_TYPE_DBOBJECT, TRUE, &ce_base TSRMLS_CC); if (!__isderived) { php_error(E_WARNING, "Expected %s derived class", g_type_name(MIDGARD_TYPE_DBOBJECT)); php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC); return; } } const gchar *g_classname = php_class_name_to_g_class_name(ce_base->name); MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(g_classname); if (!klass) { php_error(E_WARNING, "%s is not registered Midgard schema class", g_classname); return; } MidgardReflectorProperty *mrp = midgard_reflector_property_new(g_classname); if (!mrp) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } MGD_PHP_SET_GOBJECT(zval_object, mrp); } else { // we already have gobject injected } } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp___construct, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, get_midgard_type) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_LONG(midgard_reflector_property_get_midgard_type(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_get_midgard_type, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, is_link) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_BOOL(midgard_reflector_property_is_link(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_is_link, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, is_linked) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_BOOL(midgard_reflector_property_is_linked(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_is_linked, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, get_link_name) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; const gchar *linkname = midgard_reflector_property_get_link_name(mrp, property_name); if (linkname) RETURN_STRING((gchar *)linkname, 1); RETURN_NULL(); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_get_link_name, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, get_link_target) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *property_name; int property_name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; const gchar *linktarget = midgard_reflector_property_get_link_target(mrp, property_name); if (linktarget) RETURN_STRING((gchar *)linktarget, 1); RETURN_FALSE; } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_get_link_target, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, description) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; const gchar *description = midgard_reflector_property_description(mrp, property_name); if (description) RETURN_STRING((char *)description, 1); RETURN_NULL(); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_description, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, get_user_value) { char *property_name, *name; int property_name_length, name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &property_name, &property_name_length, &name, &name_length) == FAILURE) return; _GET_MRP_OBJECT; const gchar *value = midgard_reflector_property_get_user_value(mrp, property_name, name); if (value) RETURN_STRING((gchar *)value, 1); RETURN_NULL(); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_get_user_value, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_ARG_INFO(0, name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, is_private) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_BOOL(midgard_reflector_property_is_private(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_is_private, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, is_unique) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_BOOL(midgard_reflector_property_is_unique(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_is_unique, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, is_primary) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_BOOL(midgard_reflector_property_is_primary(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_is_primary, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, has_default_value) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_BOOL(midgard_reflector_property_has_default_value(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_has_default_value, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_property, get_default_value) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; GValue *val = midgard_reflector_property_get_default_value(mrp, property_name); if (val == NULL) return; php_midgard_gvalue2zval(val, return_value TSRMLS_CC); g_value_unset (val); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_get_default_value, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_reflector_property) { static zend_function_entry reflector_property_methods[] = { PHP_ME(midgard_reflector_property, __construct, arginfo_mrp___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_reflector_property, get_midgard_type, arginfo_mrp_get_midgard_type, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, is_link, arginfo_mrp_is_link, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, is_linked, arginfo_mrp_is_linked, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, get_link_name, arginfo_mrp_get_link_name, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, get_link_target, arginfo_mrp_get_link_target, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, description, arginfo_mrp_description, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, get_user_value, arginfo_mrp_get_user_value, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, is_private, arginfo_mrp_is_private, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, is_unique, arginfo_mrp_is_unique, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, is_primary, arginfo_mrp_is_primary, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, has_default_value,arginfo_mrp_has_default_value,ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_property, get_default_value,arginfo_mrp_get_default_value,ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry reflector_property_class_entry; INIT_CLASS_ENTRY(reflector_property_class_entry, "MidgardReflectorProperty", reflector_property_methods); php_midgard_reflector_property_class = zend_register_internal_class(&reflector_property_class_entry TSRMLS_CC); php_midgard_reflector_property_class->create_object = php_midgard_gobject_new; zend_register_class_alias("midgard_reflector_property", php_midgard_reflector_property_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_query.c0000664000175000017500000000223511730073440015721 0ustar pppp/* Copyright (C) 2010 Alexey Zakhlestin * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_query.h" /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_query) { PHP_MINIT(midgard2_query_storage)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_query_holders)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_query_constraints)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_query_executors)(INIT_FUNC_ARGS_PASSTHRU); return SUCCESS; } php5-midgard2-10.05.7/docs/0000775000175000017500000000000011730073440013000 5ustar ppppphp5-midgard2-10.05.7/docs/style.css0000664000175000017500000000514511730073440014657 0ustar pppp/* copy and pasted from gtk-doc */ .synopsis, .classsynopsis { background: #eeeeee; border: solid 1px #aaaaaa; padding: 0.5em; } .programlisting { background: #eeeeff; border: solid 1px #aaaaff; padding: 0.5em; } .variablelist { padding: 4px; margin-left: 3em; } .variablelist td:first-child { vertical-align: top; } span.reserved_word { color: #00A821; } div.navigation { background: #ffeeee; border: solid 1px #ffaaaa; margin: 0; padding: 5px; top: 0; left: 0; height: 2em; z-index: 1; } /* this is needed so that the local anchors are displayed below the naviagtion */ @media screen { sup a.footnote { position: relative; top: 0em ! important; } div.refnamediv a[name], div.refsect1 a[name] { position: relative; top: -4.5em; } div.navigation#top { background: #ffeeee; border: solid 1px #ffaaaa; margin-top: 0; margin-bottom: 0; position: fixed; top: 0; left: 0; height: 2em; z-index: 1; } .navigation a { color: #770000; } .navigation a:visited { color: #550000; } td.shortcuts { color: #770000; font-size: 80%; white-space: nowrap; } div.refentry, div.chapter, div.reference, div.part, div.book, div.glossary, div.sect1, div.appendix, div.preface { position: relative; top: 3em; z-index: 0; } div.glossary, div.index { position: relative; top: 2em; z-index: 0; } div.refnamediv { margin-top: 2em; } body { padding-bottom: 20em; } } @media print { table.navigation { visibility: collapse; display: none; } div.titlepage table.navigation { visibility: visible; display: table; background: #ffeeee; border: solid 1px #ffaaaa; margin-top: 0; margin-bottom: 0; top: 0; left: 0; height: 2em; } } .navigation .title { font-size: 200%; } div.gallery-float { float: left; padding: 10px; } div.gallery-float img { border-style: none; } div.gallery-spacer { clear: both; } a { text-decoration: none; } a:hover { text-decoration: underline; color: #FF0000; } div.table table { border-collapse: collapse; border-spacing: 0px; border-style: solid; border-color: #777777; border-width: 1px; } div.table table td, div.table table th { border-style: solid; border-color: #777777; border-width: 1px; padding: 3px; vertical-align: top; } div.table table th { background-color: #eeeeee; } hr { color: #777777; background: #777777; border: 0; height: 1px; clear: both; } .footer { padding-top: 3.5em; color: #777777; text-align: center; font-size: 80%; } php5-midgard2-10.05.7/docs/make_html.php0000664000175000017500000000171711730073440015460 0ustar ppppget_index_buffer(); if (!file_exists(HTML_DIR)) mkdir(HTML_DIR); file_put_contents(HTML_DIR . "/index.html", $idx_buffer); $classes = midgard_documentor::get_classes(); if (empty($classes)) { return; } foreach ($classes as $refclass) { $mpdc = new midgard_php_doc_class ($refclass->getName()); $class_filename = HTML_DIR . "/" . $mpdc->get_filename(); $md->create_page ($class_filename, $mpdc->get_buffer()); $methods = $refclass->getMethods(); foreach ($methods as $refmethod) { $mpdm = new midgard_php_doc_method ($refclass->getName(), $refmethod->getName()); $method_filename = HTML_DIR . "/" . $mpdm->get_filename(); $md->create_page ($method_filename, $mpdm->get_buffer()); } } ?> php5-midgard2-10.05.7/docs/midgard_php_doc_interface.php0000664000175000017500000000030211730073440020627 0ustar pppp php5-midgard2-10.05.7/docs/midgard_php_doc_class.php0000664000175000017500000000513611730073440020006 0ustar pppprefclass = new midgard_reflection_class ($classname); } public function get_doc_method ($method) { return new midgard_php_doc_method ($this->refclass->getName(), $method); } public function get_doc_buffer () { $buffer = "

Class: ". $this->refclass->getName () . "

"; $buffer .= "

" . $this->refclass->getDocComment () . "

"; $buffer .= "

Methods

"; $methods = $this->refclass->getMethods(); foreach ($methods as $refmethod) { $isstatic = $refmethod->isStatic() ? "static" : ""; $ispublic = $refmethod->isPublic() ? "public" : ""; $parameters = ""; $i = 0; $params = $refmethod->getParameters(); $required = $refmethod->getNumberOfRequiredParameters(); foreach($params as $param) { if ($i > 0) { $parameters .= ", "; } if ($i >= $required) $parameters .= "["; $parameters .= $param->getName(); if ($i >= $required) $parameters .= "]"; $i++; } $mpdm = $this->get_doc_method ($refmethod->getName()); $buffer .= "" . $ispublic . " " . $isstatic . " get_filename ($refmethod) . "\">" . $refmethod->getName() . " (" . $parameters . ")
\n"; } $buffer .= "

Signals

"; $signals = $this->refclass->listSignals(); foreach($signals as $signal) { $buffer .= $signal . "
"; } return $buffer; } protected function get_navi_buffer() { $buffer = "Home"; return $buffer; } public function get_navigation_buffer() { $buffer = "
"; $buffer .= $this->get_navi_buffer(); $buffer .= "
\n"; return $buffer; } public function get_buffer() { $buffer = $this->get_navigation_buffer() . $this->get_doc_buffer(); return $buffer; } public function get_filename() { $filename = $this->refclass->getName() . ".html"; return $filename; } } ?> php5-midgard2-10.05.7/docs/midgard_documentor.php0000664000175000017500000001336411730073440017366 0ustar pppprelease = $release; $this->release_name = $release_name; } public static function get_classes() { $classes = array(); $re = new ReflectionExtension("midgard2"); $classes = $re->getClasses(); foreach ($classes as $refclass) { $mrcs[] = new midgard_reflection_class ($refclass->getName()); } return $mrcs; } public static function get_midgard_object_classes() { $classes = array(); $all_classes = self::get_classes(); if (empty($all_classes)) return $classes; foreach ($all_classes as $refclass) { $parent_class = $refclass->getParentClass(); if (!$parent_class) { continue; } if ($parent_class->getName() == "midgard_object") { $classes[] = $refclass; } } asort($classes); return $classes; } public static function get_midgard_dbobject_classes() { $classes = array(); $all_classes = self::get_classes(); if (empty($all_classes)) return $classes; foreach ($all_classes as $refclass) { $parent_class = $refclass->getParentClass(); if (!$parent_class) { continue; } if ($parent_class->getName() == "midgard_dbobject") { $classes[] = $refclass; } } return $classes; } public static function get_midgard_base_classes() { $classes = array(); $all_classes = self::get_classes(); if (empty($all_classes)) return $classes; foreach ($all_classes as $refclass) { $parent_class = $refclass->getParentClass(); if ($parent_class) { if ($parent_class->getName() == "midgard_object" || $parent_class->getName() == "midgard_dbobject") { continue; } } $classes[] = $refclass; } return $classes; } public static function get_midgard_abstract_classes() { $classes = array(); $all_classes = self::get_classes(); if (empty($all_classes)) return $classes; foreach ($all_classes as $refclass) { if ($refclass->isAbstract() === false) { continue; } $classes[] = $refclass; } return $classes; } public static function get_midgard_interfaces() { $classes = array(); $all_classes = self::get_classes(); if (empty($all_classes)) return $classes; foreach ($all_classes as $refclass) { if ($refclass->isInterface() === false) { continue; } $classes[] = $refclass; } return $classes; } public function create_footer() { } private function add_to_index(ReflectionClass $refclass) { $classname = $refclass->getName(); $this->index_buffer .= "" . $classname . "
"; } public function get_index_buffer() { $this->index_buffer .= "

Base classes

"; $midgard_base_classes = self::get_midgard_base_classes(); foreach ($midgard_base_classes as $refclass) { $this->add_to_index($refclass); } $this->index_buffer .= "

Abstract classes

"; $midgard_abstract_classes = self::get_midgard_abstract_classes(); foreach ($midgard_abstract_classes as $refclass) { $this->add_to_index($refclass); } $this->index_buffer .= "

Interfaces

"; $midgard_interfaces = self::get_midgard_interfaces(); foreach ($midgard_interfaces as $refclass) { $this->add_to_index($refclass); } $this->index_buffer .= "

Database access classes

"; $midgard_dbobject_classes = self::get_midgard_dbobject_classes(); foreach ($midgard_dbobject_classes as $refclass) { $this->add_to_index($refclass); } $this->index_buffer .= "

User defined (MgdSchema) classes

"; $midgard_object_classes = self::get_midgard_object_classes(); foreach ($midgard_object_classes as $refclass) { $this->add_to_index($refclass); } return $this->index_buffer; } private function get_page_header() { $header = "\n"; $header .= "\n"; $header .= "
\n"; $header .= "\n"; $header .= "\n"; $header .= "\n"; return $header; } private function get_page_footer() { $footer = "\n"; $footer .= "\n"; } public function create_page ($filepath = null, $buffer = null) { $page_buffer = self::get_page_header(); $page_buffer .= $buffer; $page_buffer .= self::get_page_footer(); file_put_contents ($filepath, $page_buffer); } } ?> php5-midgard2-10.05.7/docs/midgard_php_doc_method.php0000664000175000017500000000464111730073440020161 0ustar pppprefclass = new midgard_reflection_class ($classname); $this->refmethod = new midgard_reflection_method ($classname, $method); } public function get_doc_buffer() { $buffer = "

" . $this->refclass->getName() . "

"; $buffer .= "

Method: ". $this->refmethod->getName() . "

"; $buffer .= "

" . $this->refmethod->getDocComment() . "

"; $isstatic = $this->refmethod->isStatic() ? "static" : ""; $ispublic = $this->refmethod->isPublic() ? "public" : ""; $parameters = ""; $i = 0; $params = $this->refmethod->getParameters(); $required = $this->refmethod->getNumberOfRequiredParameters(); foreach($params as $param) { if ($i > 0) { $parameters .= ", "; } if ($i >= $required) $parameters .= "["; $parameters .= $param->getName(); if ($i >= $required) $parameters .= "]"; $i++; } $buffer .= "" . $ispublic . " " . $isstatic . " " . $this->refmethod->getName() . " (" . $parameters . ")
\n"; $rr = $this->refmethod->returnsReference(); $rrstr = $rr ? "yes" : "no"; $buffer .= "Returns reference: " . $rrstr; return $buffer; } protected function get_navi_buffer() { $buffer = parent::get_navi_buffer(); $buffer .= "
"; $mpdc = new midgard_php_doc_class ($this->refclass->getName()); $buffer .= "Class: get_filename() . "\">" . $this->refclass->getName() . ""; return $buffer; } public function get_navigation_buffer() { return parent::get_navigation_buffer(); } public function get_buffer() { return parent::get_buffer(); } public function get_filename() { $filename = $this->refclass->getName() . "_" . $this->refmethod->getName() . ".html"; return $filename; } } ?> php5-midgard2-10.05.7/tests_templates/0000775000175000017500000000000011730073440015270 5ustar ppppphp5-midgard2-10.05.7/tests_templates/048-midgard_user_person_refcount.phpt0000664000175000017500000000165011730073440024440 0ustar pppp--TEST-- test for proper memory management of $user->get_person/set_person --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- create(); $user = new midgard_user(); $user->login = 'hi'; $user->authtype = 'Plaintext'; $user->active = true; $user->set_person($person); unset($person); var_dump($user->create()); $person = $user->get_person(); var_dump($person instanceof midgard_person); $person2 = $user->get_person(); var_dump($person2 instanceof midgard_person); $person3 = $user->get_person(); var_dump($person3 instanceof midgard_person); unset($person2, $person3); // cleanup $user->delete(); $person->delete(); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/002-midgard_config.phpt0000664000175000017500000000171211730073440021421 0ustar pppp--TEST-- midgard_config tests --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off --FILE-- read_file_at_path('[[CFG_FILE]]')); var_dump($cfg->dbtype === '[[DB_TYPE]]'); var_dump($cfg->database === '[[DB_NAME]]'); var_dump($cfg->logfilename === '[[PATH]]/midgard.log'); var_dump($cfg->loglevel === 'warn'); var_dump($cfg->tablecreate === true); var_dump($cfg->tableupdate === true); var_dump($cfg->testunit === false); var_dump($cfg->blobdir); var_dump($cfg->sharedir); var_dump($cfg->vardir === 'test'); var_dump($cfg->cachedir); var_dump($cfg->midgardusername === 'root'); var_dump($cfg->midgardpassword === 'password'); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) string(%d) "%s" string(%d) "%s" bool(true) string(%d) "%s" bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/020-query_builder-autoload.phpt0000664000175000017500000000170211730073440023145 0ustar pppp--TEST-- test midgard_object_class --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- Autoloading! bool(true) Autoloading! bool(true) No class :( Fatal error: Class 'myclass3' not found in %s on line %d php5-midgard2-10.05.7/tests_templates/022-bug1460.phpt0000664000175000017500000000175211730073440017563 0ustar pppp--TEST-- test for bug#1460 --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- login = $login; $user->authtype = $authtype; $user->create(); var_dump($user->login === $login); var_dump($user->authtype === $authtype); $params = array("login" => $login, "authtype" => $authtype); $user2 = new midgard_user($params); $user2->login(); var_dump($user2->guid === $user->guid); $mgd = midgard_connection::get_instance(); $u = $mgd->get_user(); $str1 = var_export($u, true); var_dump($u instanceof midgard_user); $u = $mgd->get_user(); $str2 = var_export($u, true); var_dump($u instanceof midgard_user); var_dump($str1 === $str2); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/047-bug_gh26.phpt0000664000175000017500000000115711730073440020104 0ustar pppp--TEST-- test for gh-bug #26 (metadata problem, when calling isset) --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- create(); $obj = new atype($a->guid); var_dump(isset($obj->metadata)); var_dump(property_exists($obj->metadata, 'schedulestart')); var_dump(property_exists($obj->metadata, 'does_not_exist')); // cleanup $a->delete(); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(false) ===DONE=== php5-midgard2-10.05.7/tests_templates/012b-inherited_querybuilder-signals.phpt0000664000175000017500000000325411730073440025040 0ustar pppp--TEST-- test of query_builder class --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file = [[CFG_FILE]] report_memleaks = On --FILE-- connect('action-update', array($this, 'test_callback'), array('update')); $this->connect('action-update-hook', array($this, 'test_callback'), array('update-hook')); $this->connect('action-updated', array($this, 'test_callback'), array('updated')); $this->connect('action-create', array($this, 'test_callback'), array('create')); $this->connect('action-create-hook', array($this, 'test_callback'), array('create-hook')); $this->connect('action-created', array($this, 'test_callback'), array('created')); } public function test_callback($obj, $action) { global $signals; $signals[$action] = true; } } $signals = array ( 'update' => false, 'update-hook' => false, 'updated' => false, 'create' => false, 'create-hook' => false, 'created' => false ); // This should turn all create hook flags to true $t = new extend_atype(); $t->create(); $qb = new midgard_query_builder('extend_atype'); $res = $qb->execute(); foreach ($res as $r) { $r->update(); // This should turn all update flags to true } foreach ($signals as $s) { var_dump($s); } var_dump($t->delete()); // don't leave traces! ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/033-lock.phpt0000664000175000017500000000164311730073440017424 0ustar pppp--TEST-- test for midgard_object lock-methods --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'a'; $obj1->create(); var_dump($obj1->is_locked()); // false var_dump($obj1->lock()); // false (as we don't have rights) $params = array("login" => 'admin', "password" => 'password', "authtype" => 'Plaintext'); $user = new midgard_user($params); var_dump($user->login()); // true var_dump($obj1->lock()); // true (admin-user) var_dump($obj1->is_locked()); // true var_dump($obj1->unlock()); // true (still, admin-user) var_dump($obj1->is_locked()); // false var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- bool(false) bool(false) bool(true) bool(true) bool(true) bool(true) bool(false) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/032-approve.phpt0000664000175000017500000000166511730073440020153 0ustar pppp--TEST-- test for midgard_object approve-methods --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'a'; $obj1->create(); var_dump($obj1->is_approved()); // false var_dump($obj1->approve()); // false (as we don't have rights) $params = array("login" => 'admin', "password" => 'password', "authtype" => 'Plaintext'); $user = new midgard_user($params); var_dump($user->login()); // true var_dump($obj1->approve()); // true (admin-user) var_dump($obj1->is_approved()); // true var_dump($obj1->unapprove()); // true (still, admin-user) var_dump($obj1->is_approved()); // false var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- bool(false) bool(false) bool(true) bool(true) bool(true) bool(true) bool(false) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/049-midgard_user_usertype.phpt0000664000175000017500000000122111730073440023100 0ustar pppp--TEST-- test if it's possible to set usertype only to valid values --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- login = 'hi'; $user->authtype = 'Plaintext'; $user->active = true; var_dump($user->usertype = 0); var_dump($user->usertype = 1); var_dump($user->usertype = 2); var_dump($user->usertype = 3); ?> ===DONE=== --EXPECTF-- int(0) int(1) int(2) Warning: GLib: Invalid user type (3). in %s on line %d int(3) ===DONE=== php5-midgard2-10.05.7/tests_templates/053-workspaces.phpt0000664000175000017500000000104711730073440020655 0ustar pppp--TEST-- workspaces tests --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) ===DONE===php5-midgard2-10.05.7/tests_templates/018-midgard_object_class.phpt0000664000175000017500000000362011730073440022616 0ustar pppp--TEST-- test midgard_object_class --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'a'; $obj->b = 'b'; $obj->create(); $obj2 = midgard_object_class::factory('atype', $obj->id); var_dump($obj->a === $obj2->a); var_dump($obj->b === $obj2->b); var_dump($obj->guid === $obj2->guid); $obj3 = midgard_object_class::get_object_by_guid($obj->guid); var_dump($obj->a === $obj3->a); var_dump($obj->b === $obj3->b); var_dump($obj->guid === $obj3->guid); var_dump(midgard_object_class::get_property_up('atype') === 'up'); var_dump(midgard_object_class::get_property_up($obj) === 'up'); var_dump(midgard_object_class::get_property_up('xtype') === NULL); $objx = new xtype(); var_dump(midgard_object_class::get_property_parent('xtype') === 'owner'); var_dump(midgard_object_class::get_property_parent($objx) === 'owner'); var_dump(midgard_object_class::get_property_parent('atype') === NULL); $guid = $obj->guid; $obj->delete(); //var_dump(midgard_object_class::undelete($guid)); //$obj = new atype($guid); var_dump(midgard_object_class::has_metadata($obj)); var_dump(midgard_object_class::has_metadata('atype')); var_dump(midgard_object_class::has_metadata('midgard_metadata')); var_dump(midgard_object_class::get_schema_value('atype', 'meta1') === 'value1'); var_dump(midgard_object_class::get_schema_value('atype', 'meta2') === 'value2'); var_dump(midgard_object_class::get_schema_value('atype', 'meta3') === NULL); // cleanup $obj->delete(); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(false) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/037-bug1763.phpt0000664000175000017500000000161511730073440017575 0ustar pppp--TEST-- test for bug#1763 --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- email = 'mailaddress@company.com'; } public function create() { echo(__METHOD__."\n"); parent::create(); } } class inherited_person extends company_person { } $person = new inherited_person(); $person->firstname = 'Test'; $person->lastname = 'User'; $person->create(); var_dump(!empty($person->id)); // cleanup $person->delete(); ?> ===DONE=== --EXPECTF-- company_person::__construct company_person::create bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/012a-querybuilder-signals.phpt0000664000175000017500000000543711730073440023011 0ustar pppp--TEST-- test of query_builder class --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file = [[CFG_FILE]] report_memleaks = On --FILE-- false, 'update-hook' => false, 'updated' => false, 'create' => false, 'create-hook' => false, 'created' => false); class callback_holder { public function test_callback($obj, $action) { global $signals; $signals[$action] = true; } public static function test_global_callback($a, $b, $c) { var_dump(is_object($a) and $a instanceof atype); var_dump($b); var_dump($c === 'test'); } } $clbk = new callback_holder(); midgard_object_class::connect_default('atype', 'action-create', array('callback_holder', 'test_global_callback'), array('create', 'test')); midgard_object_class::connect_default('atype', 'action-update', array('callback_holder', 'test_global_callback'), array('update', 'test')); $t = new atype(); $t->connect('action-update', array($clbk, 'test_callback'), array('update')); $t->connect('action-update-hook', array($clbk, 'test_callback'), array('update-hook')); $t->connect('action-updated', array($clbk, 'test_callback'), array('updated')); $t->connect('action-create', array($clbk, 'test_callback'), array('create')); $t->connect('action-create-hook', array($clbk, 'test_callback'), array('create-hook')); $t->connect('action-created', array($clbk, 'test_callback'), array('created')); // This should turn all create hook flags to true echo "== create() ==\n"; $t->create(); $qb = new midgard_query_builder('atype'); $res = $qb->execute(); foreach ($res as $r) { // This should not turn all update flags to true, as signal is connected to specific object // But global-callback still should be called echo "== qb:update() ==\n"; $r->update(); } foreach ($signals as $s) { var_dump($s); } // This should turn all update flags to true, as signal is connected to this object // And global-callback still should be called // That means, that 2 different callbacks will be fired here echo "== update() ==\n"; $t->update(); echo "== results: ==\n"; foreach ($signals as $s) { var_dump($s); } echo "== delete() ==\n"; var_dump($t->delete()); // don't leave traces! ?> ===DONE=== --EXPECTF-- == create() == bool(true) string(6) "create" bool(true) == qb:update() == bool(true) string(6) "update" bool(true) bool(false) bool(false) bool(false) bool(true) bool(true) bool(true) == update() == bool(true) string(6) "update" bool(true) == results: == bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) == delete() == bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/009-midgard_blob.phpt0000664000175000017500000000315211730073440021101 0ustar pppp--TEST-- test of midgard_blob class --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[PATH]]/test.cfg report_memleaks = On --FILE-- read_file_at_path(dirname(__FILE__).'/test.cfg'); $cfg->blobdir = '[[BLOB_PATH]]'; $mgd = midgard_connection::get_instance(); $mgd->open_config($cfg); $att = new midgard_attachment(); $att->location = 'test.txt'; $att->name = 'test.txt'; $att->title = 'Some text-file'; $blob = new midgard_blob($att); $handler = $blob->get_handler(); fwrite($handler, 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'); fclose($handler); var_dump($blob->exists()); var_dump($blob->get_path() === '[[BLOB_PATH]]/test.txt'); $txt1 = file_get_contents('[[BLOB_PATH]]/test.txt'); $txt2 = $blob->read_content(); var_dump($txt1 === $txt2); $handler = $blob->get_handler('r'); $txt3 = stream_get_contents($handler); var_dump($txt1 === $txt3); fclose($handler); $res = $blob->remove_file(); var_dump($res); var_dump($blob->exists()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(false) ===DONE=== php5-midgard2-10.05.7/tests_templates/042-midgard_query_select.phpt0000664000175000017500000000451311730073440022666 0ustar pppp--TEST-- tests for midgard_query_select class --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'abc'; $obj1->b = 'def'; $obj1->create(); $obj2 = new atype(); $obj2->a = 'abc'; $obj2->b = 'ghi'; $obj2->create(); $obj3 = new atype(); $obj3->a = 'jkl'; $obj3->b = 'ghi'; $obj3->create(); $q = new midgard_query_select($storage); var_dump($q->execute()); var_dump($q->get_results_count() == 3); $list = $q->list_objects(); var_dump(is_array($list)); var_dump($list[0] instanceof atype); var_dump($list[1] instanceof atype); var_dump($list[2] instanceof atype); var_dump($q->set_constraint($constraint)); var_dump($q->execute()); var_dump($q->get_results_count() == 2); $list = $q->list_objects(); var_dump($list[0]->a == 'abc'); var_dump($list[1]->a == 'abc'); $group = new midgard_query_constraint_group('AND'); $group->add_constraint(new midgard_query_constraint(new midgard_query_property('a', $storage), '=', new midgard_query_value('abc'))); $group->add_constraint(new midgard_query_constraint(new midgard_query_property('b', $storage), '=', new midgard_query_value('ghi'))); var_dump($q->set_constraint($group)); var_dump($q->execute()); var_dump($q->get_results_count() == 1); $list = $q->list_objects(); var_dump($list[0]->a == 'abc'); var_dump($list[0]->b == 'ghi'); var_dump($list[0]->guid == $obj2->guid); unset($group); var_dump($q->execute()); var_dump($q->get_results_count() == 1); $list = $q->list_objects(); var_dump($list[0]->a == 'abc'); var_dump($list[0]->b == 'ghi'); var_dump($list[0]->guid == $obj2->guid); echo "==delete==\n"; var_dump($obj1->delete()); var_dump($obj2->delete()); var_dump($obj3->delete()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ==delete== bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/018-midgard_object_class-errors.phpt0000664000175000017500000000370211730073440024131 0ustar pppp--TEST-- test midgard_object_class with wrong parameters --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- Warning: midgard_object_class::factory(): Can not find non_existant_class class in %s on line %d bool(true) Warning: midgard_object_class::get_property_up(): argument should be object or string in %s on line %d bool(true) Warning: midgard_object_class::get_property_up(): argument should be object or string in %s on line %d bool(true) Warning: midgard_object_class::get_property_parent(): argument should be object or string in %s on line %d bool(true) Warning: midgard_object_class::get_property_parent(): argument should be object or string in %s on line %d bool(true) Warning: midgard_object_class::has_metadata(): argument should be object or string in %s on line %d bool(true) Warning: midgard_object_class::has_metadata(): argument should be object or string in %s on line %d bool(true) Warning: midgard_object_class::get_schema_value(): first argument should be object or string in %s on line %d bool(true) Warning: midgard_object_class::get_schema_value(): first argument should be object or string in %s on line %d bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/044-bug_gh14.phpt0000664000175000017500000000061611730073440020075 0ustar pppp--TEST-- test for gh-bug #14 --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration=doesnotexist midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- ===DONE=== php5-midgard2-10.05.7/tests_templates/036-replicator.phpt0000664000175000017500000000431511730073440020642 0ustar pppp--TEST-- test for midgard_replicator --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'a'; $obj1->create(); $xml = simplexml_load_string(midgard_replicator::serialize($obj1)); var_dump(isset($xml->atype)); var_dump($xml->atype->a == $obj1->a); $attrs = $xml->atype->attributes(); var_dump($attrs['guid'] == $obj1->guid); var_dump($attrs['action'] == 'created'); var_dump($obj1->metadata->exported->format('Y-m-d H:i:s') == '0001-01-01 00:00:00'); var_dump(midgard_replicator::export($obj1)); // should be real date, a bit in the past var_dump($obj1->metadata->exported->format('Y-m-d H:i:s') != '0001-01-01 00:00:00'); // test blob $att = new midgard_attachment(); $att->location = 'test.txt'; $att->name = 'test.txt'; $att->title = 'Some text-file'; $att->parentguid = $obj1->guid; $res = $att->create(); if (false === $res) { var_dump(midgard_connection::get_instance()->get_error_string()); } $blob = new midgard_blob($att); $handler = $blob->get_handler(); fwrite($handler, 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'); fclose($handler); $xml = simplexml_load_string(midgard_replicator::serialize_blob($att)); var_dump(isset($xml->midgard_blob)); $attrs = $xml->midgard_blob->attributes(); var_dump(isset($attrs['guid'])); var_dump($attrs['guid'] == $att->guid); echo "==delete==\n"; $blob->remove_file(); $att->delete(); var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ==delete== bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/030-setguid.phpt0000664000175000017500000000117111730073440020131 0ustar pppp--TEST-- test for midgard_dbobject::set_guid() --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = '1'; var_dump($obj1->set_guid($test_guid)); var_dump($obj1->guid === $test_guid); var_dump($obj1->create()); var_dump($obj1->guid === $test_guid); // cleanup var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/011-midgard_user.phpt0000664000175000017500000000112711730073440021132 0ustar pppp--TEST-- test of midgard_user --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file = [[CFG_FILE]] report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- object(MidgardUser)#%d (8) { ["guid"]=> string(0) "" ["login"]=> string(0) "" ["password"]=> string(0) "" ["active"]=> bool(false) ["authtype"]=> string(0) "" ["authtypeid"]=> int(0) ["usertype"]=> int(0) ["person"]=> string(0) "" } ===DONE=== php5-midgard2-10.05.7/tests_templates/043-midgard_query_select__joins.phpt0000664000175000017500000000270711730073440024233 0ustar pppp--TEST-- tests for joins midgard_query_select class --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'abc'; $obj1->b = 'def'; $obj1->create(); $obj2 = new atype(); $obj2->a = 'jkl'; $obj2->b = 'mno'; $obj2->create(); $obj3 = new xtype(); $obj3->owner = $obj1->id; $obj3->x = 'abc'; $obj3->y = 'ghi'; $obj3->create(); $obj4 = new xtype(); $obj4->owner = $obj1->id; $obj4->x = 'jkl'; $obj4->y = 'pqr'; $obj4->create(); $storage = new midgard_query_storage('atype'); $xstorage = new midgard_query_storage('xtype'); $property = new midgard_query_property('a', $storage); $xproperty = new midgard_query_property('x', $xstorage); $yproperty = new midgard_query_property('y', $xstorage); $q = new midgard_query_select($storage); $q->add_join('left', $property, $xproperty); $q->set_constraint(new midgard_query_constraint($yproperty, '=', new midgard_query_value('ghi'))); $q->execute(); var_dump($q->get_results_count() == 1); $list = $q->list_objects(); var_dump($list[0]->a == 'abc'); var_dump($list[0]->b == 'def'); echo "==delete==\n"; var_dump($obj3->delete()); var_dump($obj4->delete()); var_dump($obj1->delete()); var_dump($obj2->delete()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) ==delete== bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/017-midgard_reflection_property.phpt0000664000175000017500000000262711730073440024266 0ustar pppp--TEST-- test midgard_reflection_property --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- description('id') == 'Local non-replication-safe database identifier'); var_dump($rp1->description('a') == 'A-field'); var_dump($rp1->description('b') == 'B-field'); var_dump($rp1->get_midgard_type('id') == MGD_TYPE_UINT); var_dump($rp1->get_midgard_type('a') == MGD_TYPE_STRING); var_dump($rp1->get_midgard_type('b') == MGD_TYPE_STRING); // testing instantiation from object $obj = new atype(); $rp2 = $obj->new_reflection_property(); var_dump($rp2->description('id') == 'Local non-replication-safe database identifier'); var_dump($rp2->description('a') == 'A-field'); var_dump($rp2->description('b') == 'B-field'); var_dump($rp2->get_midgard_type('id') == MGD_TYPE_UINT); var_dump($rp2->get_midgard_type('a') == MGD_TYPE_STRING); var_dump($rp2->get_midgard_type('b') == MGD_TYPE_STRING); // testing renamed class $rp3 = new midgard_reflection_property('midgard_metadata'); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/041-midgard_query_constraint.phpt0000664000175000017500000000343111730073440023570 0ustar pppp--TEST-- tests for midgard_query_constraint classes --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- property instanceof midgard_query_property); var_dump($constraint->operator === '='); var_dump($constraint->holder instanceof midgard_query_value); var_dump($constraint->storage instanceof midgard_query_storage); unset($storage, $property, $value); var_dump($constraint->property instanceof midgard_query_property); var_dump($constraint->operator === '='); var_dump($constraint->holder instanceof midgard_query_value); var_dump($constraint->storage instanceof midgard_query_storage); echo "==group==\n"; $group = new midgard_query_constraint_group(); $list = $group->list_constraints(); var_dump(is_array($list)); var_dump(count($list) == 0); $group->add_constraint($constraint); $group->add_constraint($constraint); $list = $group->list_constraints(); var_dump(is_array($list)); var_dump(count($list) == 2); unset($constraint); $list = $group->list_constraints(); var_dump(is_array($list)); var_dump(count($list) == 2); foreach ($list as $constraint) { if (!($constraint instanceof midgard_query_constraint)) { echo 'wrong type: '.var_export($constraint, true)."\n"; } } ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ==group== bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/046-midgard_date_properties.phpt0000664000175000017500000000145111730073440023355 0ustar pppp--TEST-- test for setting values of datetime properties --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'a'; $a->create(); var_dump($a->metadata->published->format('Y-m-d') == '0001-01-01'); var_dump($a->metadata->published->format('Y-m-d') == '0001-01-01'); $a->metadata->published->setDate(2011, 01, 01); var_dump($a->metadata->published->format('Y-m-d') == '2011-01-01'); $a->metadata->published->setTimestamp(time()); var_dump($a->metadata->published->format('Y-m-d') == gmdate('Y-m-d')); $a->delete(); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/025-bug1492.phpt0000664000175000017500000000064111730073440017567 0ustar pppp--TEST-- test for bug#1492 --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration=doesnotexist midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- ===DONE=== --EXPECTF-- bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/027-is_in_tree.phpt0000664000175000017500000000114511730073440020614 0ustar pppp--TEST-- test form midgard_dbobject::is_in_tree() --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = '1'; $obj1->create(); $obj2 = new atype(); $obj2->a = '2'; $obj2->up = $obj1->id; $obj2->create(); $dummy = new atype(); var_dump($dummy->is_in_tree($obj1->id, $obj2->id)); // cleanup var_dump($obj2->delete()); var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/016-query_builder_views.phpt0000664000175000017500000000172711730073440022570 0ustar pppp--TEST-- test that query_builder returns proper objects, when query is executed against view --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'a'; $obj1->b = 'b'; $obj1->create(); $obj2 = new xtype(); $obj2->x = 'x'; $obj2->y = 'y'; $obj2->owner = $obj1->id; $obj2->create(); $query = new midgard_query_builder('vview'); var_dump($query->count()); $res = $query->execute(); var_dump($res[0]->a === $obj1->a); var_dump($res[0]->b === $obj1->b); var_dump($res[0]->x === $obj2->x); var_dump($res[0]->y === $obj2->y); var_dump($res[0]->guid === $obj1->guid); // do not leave traces! var_dump($obj2->delete()); var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- int(1) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/028-stream_wrapper.phpt0000664000175000017500000000245711730073440021537 0ustar pppp--TEST-- test form "midgard://" stream wrapper --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- name = 'directory'; $obj->create(); $obj2 = new midgard_snippet(); $obj2->snippetdir = $obj->id; $obj2->name = 'snippet'; $obj2->code = ''; $obj2->doc = 'This snippet says "Hello, world!"'; $obj2->create(); $fp = fopen('midgard:///directory/snippet', 'r'); var_dump(false !== $fp); var_dump(fgets($fp) === $obj2->code); var_dump(fclose($fp)); include 'midgard:///directory/snippet'; $fp = fopen('midgard:///directory/snippet', 'w'); var_dump(false !== $fp); var_dump(false !== fwrite($fp, "Hello, test!\n")); var_dump(fclose($fp)); include 'midgard:///directory/snippet'; $fp = fopen('midgard:///directory/snippet', 'a'); var_dump(false !== $fp); var_dump(false !== fwrite($fp, "And Again!\n")); var_dump(fclose($fp)); include 'midgard:///directory/snippet'; $obj2->delete(); $obj->delete(); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) Hello, world! bool(true) bool(true) bool(true) Hello, test! bool(true) bool(true) bool(true) Hello, test! And Again! ===DONE=== php5-midgard2-10.05.7/tests_templates/040-midgard_query_holder.phpt0000664000175000017500000000417011730073440022661 0ustar pppp--TEST-- tests for midgard_query_holder family of classes --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- $value) { $qvalue = new midgard_query_value($value); if ($qvalue->get_value() !== $value) { echo "values are note equal: ".var_export($value, true).' vs. '.var_export($qvalue->get_value(), true)."\n"; } $qvalue = new midgard_query_value(); $qvalue->set_value($value); if ($qvalue->get_value() !== $value) { echo "#2 values are note equal: ".var_export($value, true).' vs. '.var_export($qvalue->get_value(), true)."\n"; } $qvalue = new midgard_query_value('dummy'); $qvalue->set_value($value); if ($qvalue->get_value() !== $value) { echo "#3 values are note equal: ".var_export($value, true).' vs. '.var_export($qvalue->get_value(), true)."\n"; } } echo "ok\n"; // Checking midgard_query_property's $storage = new midgard_query_storage('atype'); $property = new midgard_query_property('a'); var_dump($property->property === 'a'); var_dump($property->storage === null); $property = new midgard_query_property('a', $storage); var_dump($property->property === 'a'); var_dump($property->storage instanceof midgard_query_storage); unset($storage); var_dump($property->storage instanceof midgard_query_storage); ?> ===DONE=== --EXPECTF-- ok bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/023-bug1478.phpt0000664000175000017500000000202311730073440017565 0ustar pppp--TEST-- test for bug#1478 --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- login = $login; $user->authtype = $authtype; $user->create(); unset($user); $params = array("login" => $login, "authtype" => $authtype); $user2 = new midgard_user($params); unset($login, $authtype, $params); $mgd = midgard_connection::get_instance(); $mgd->connect('auth-changed', 'my_callback', array()); unset($mgd); var_dump($user2->login()); // cleanup $user2->delete(); ?> ===DONE=== --EXPECTF-- Callback called midgard_connection bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/015-query_builder_result.phpt0000664000175000017500000000272711730073440022751 0ustar pppp--TEST-- test that query_builder really returns the proper object --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'example.com'; $obj->create(); $arr = (array)$obj; unset($arr['metadata']); ksort($arr); $string1 = var_export($arr, true); $obj = new atype($obj->id); $arr = (array)$obj; unset($arr['metadata']); ksort($arr); $string2 = var_export($arr, true); $query = new midgard_query_builder('atype'); var_dump($query->count() == 1); $res = $query->execute(); $arr = (array)$res[0]; unset($arr['metadata']); ksort($arr); $string3 = var_export($arr, true); $query2 = atype::new_query_builder(); var_dump($query2->count() == 1); $res = $query2->execute(); $arr = (array)$res[0]; unset($arr['metadata']); ksort($arr); $string4 = var_export($arr, true); var_dump($obj->delete()); var_dump($string1 === $string2); var_dump($string2 === $string3); var_dump($string3 === $string4); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/026-is_in_parent_tree.phpt0000664000175000017500000000116611730073440022167 0ustar pppp--TEST-- test form midgard_dbobject::is_in_parent_tree() --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = '1'; $obj1->create(); $obj2 = new xtype(); $obj2->x = '2'; $obj2->owner = $obj1->id; $obj2->create(); $dummy = new xtype(); var_dump($dummy->is_in_parent_tree($obj1->id, $obj2->id)); // cleanup var_dump($obj2->delete()); var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/014-signals.phpt0000664000175000017500000000403011730073440020124 0ustar pppp--TEST-- checking which callbacks are ok and which are not --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file = [[CFG_FILE]] report_memleaks = On --FILE-- connect('action-update', array(null, 'fun_callback'), array()); echo "2\n"; $obj->connect('action-update', array('dumb', null), array()); echo "3\n"; $obj->connect('action-update', array('fun_callback'), array()); echo "4\n"; $obj->connect('action-update', 'fun_callback', array()); echo "5\n"; $obj->connect('action-update', array('dumb', 'test_callback'), array('update')); echo "6\n"; $obj->connect('action-update', array($dumb_obj, 'my_callback')); echo "7\n"; midgard_object_class::connect_default('atype', 'action-update', array(null, 'test_callback'), array('test')); echo "8\n"; midgard_object_class::connect_default('atype', 'action-update', array('dumb', null)); echo "9\n"; midgard_object_class::connect_default('atype', 'action-update', array('fun_callback'), array('test')); echo "10\n"; midgard_object_class::connect_default('atype', 'action-update', 'fun_callback', array('test')); echo "11\n"; midgard_object_class::connect_default('atype', 'action-update', array('dumb', 'test_callback'), array('test')); echo "12\n"; midgard_object_class::connect_default('atype', 'action-update', array($dumb_obj, 'my_callback'), array('test')); ?> ===DONE=== --EXPECTF-- 1 Warning: atype::connect() %s in %s on line %d 2 Warning: atype::connect() %s in %s on line %d 3 Warning: atype::connect() %s in %s on line %d 4 5 6 7 Warning: midgard_object_class::connect_default() %s in %s on line %d 8 Warning: midgard_object_class::connect_default() %s in %s on line %d 9 Warning: midgard_object_class::connect_default() %s in %s on line %d 10 11 12 ===DONE=== php5-midgard2-10.05.7/tests_templates/006-midgard_connection_http.phpt0000664000175000017500000000165611730073440023365 0ustar pppp--TEST-- test of midgard_connection in HTTP-mode --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file = [[CFG_FILE]] report_memleaks = On --FILE-- read_file_at_path('[[CFG_FILE]]'); $mgd = midgard_connection::get_instance(); var_dump($mgd instanceof midgard_connection); var_dump($mgd->config instanceof midgard_config); $str1 = var_export($mgd, true); $mgd = midgard_connection::get_instance(); $str2 = var_export($mgd, true); var_dump($str1 === $str2); var_dump($mgd->open_config($cfg)); // true. as this is the same config $cfg2 = new midgard_config(); $cfg2->read_file_at_path(dirname(__FILE__).'/bad.cfg'); var_dump($mgd->open_config($cfg2)); // false. as this is the other config ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(false) ===DONE=== php5-midgard2-10.05.7/tests_templates/019-midgard_collector.phpt0000664000175000017500000000120211730073440022144 0ustar pppp--TEST-- test midgard_object_class --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'a'; $obj->b = 'b'; $obj->create(); $obj2 = new atype(); $obj2->a = 'a'; $obj2->b = 'c'; $obj2->create(); $coll = atype::new_collector('a', 'a'); $coll->set_key_property('a', 'a'); var_dump($coll->execute()); var_dump($obj->delete()); var_dump($obj2->delete()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/010-query_builder.phpt0000664000175000017500000000255211730073440021342 0ustar pppp--TEST-- test of query_builder class --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- set_limit(-1)); var_dump($query->set_offset(-1)); var_dump($query->set_limit(1)); var_dump($query->set_offset(1)); var_dump($query->add_order('thereisnosuchfield', 'ASC')); var_dump($query->add_order('a', 'asc')); var_dump($query->add_order('a', 'ASC')); var_dump($query->add_constraint('id', '>', new stdClass())); var_dump($query->add_constraint('id', '>', STDOUT)); var_dump($query->add_constraint('id', '>', 2)); var_dump($query->add_constraint_with_property('id', '>', 'a')); var_dump(gettype($query->count())); var_dump(gettype($query->execute())); ?> ===DONE=== --EXPECTF-- Warning: Ignoring a negative query limit in %s bool(false) Warning: Ingoring a negative query offset in %s bool(false) bool(true) bool(true) Warning: %s in %s on line %d Warning: %s in %s on line %d bool(false) Warning: %s in %s on line %d Warning: %s in %s on line %d bool(false) bool(true) bool(false) Warning: Got resource variable. Can not convert to glib-type in %s bool(false) bool(true) bool(true) string(7) "integer" string(5) "array" ===DONE=== php5-midgard2-10.05.7/tests_templates/039-midgard_query_storage.phpt0000664000175000017500000000176311730073440023065 0ustar pppp--TEST-- tests for midgard_query_storage class --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- dbclass); $storage2 = new midgard_query_storage('xtype'); var_dump($storage2->dbclass); // view $storage3 = new midgard_query_storage('vview'); var_dump($storage3->dbclass); ?> ===DONE=== --EXPECTF-- Warning: GLib: %s in %s ok Warning: GLib: %s in %s ok string(5) "atype" string(5) "xtype" string(5) "vview" ===DONE=== php5-midgard2-10.05.7/tests_templates/045-bug_gh20.phpt0000664000175000017500000000212511730073440020070 0ustar pppp--TEST-- test for gh-bug #20 (inconsistent constructor exceptions) --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- create(); try { $obj = new atype($a->id); $obj = null; echo "OK\n"; } catch (Exception $e) { echo "ERROR\n"; } try { $obj = new atype($a->id + 1); echo "ERROR\n"; } catch (midgard_error_exception $e) { echo "OK\n"; } // cleanup $a->delete(); ?> ===DONE=== --EXPECTF-- OK OK OK OK OK OK ===DONE=== php5-midgard2-10.05.7/tests_templates/003-reflection.phpt0000664000175000017500000000363611730073440020627 0ustar pppp--TEST-- reflection tests --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off --ENV-- MIDGARD_ENV_GLOBAL_SHAREDIR=[[SHARE_PATH]] --FILE-- getDocComment()); $cls = new midgard_reflection_class('midgard_reflection_method'); var_dump($cls->getDocComment()); /** * Hi, class */ class MyTest { /** * Hi, method */ public static function myMethod() { } } $cls = new midgard_reflection_class('MyTest'); var_dump($cls->getDocComment()); var_dump($cls->listSignals()); $cls = new midgard_reflection_method('MyTest', 'myMethod'); //var_dump($cls->getDocComment()); $cls = new midgard_reflection_method($cls, 'getDocComment'); var_dump($cls->getDocComment()); $cls = new midgard_reflection_class('midgard_connection'); var_dump($cls->listSignals()); $cls = new midgard_reflection_class('midgard_object'); var_dump(count($cls->listSignals()) > 0); $cls = new midgard_reflection_class('atype'); var_dump(count($cls->listSignals()) == 0); $parent = $cls->getParentClass(); var_dump($parent instanceof midgard_reflection_class); $methods = $cls->getMethods(); var_dump($methods[0] instanceof midgard_reflection_method); var_dump($cls->get_user_value('meta1') == 'value1'); var_dump($cls->get_user_value('meta2') == 'value2'); ?> ===DONE=== --EXPECTF-- string(%d) "Helps Midgard to show doc_comments of internal classes" string(%d) "Helps Midgard to show doc_comments of methods of internal classes" string(%d) "/** * Hi, class */" array(0) { } string(%d) "returns doc_comment of method" array(5) { [0]=> string(5) "error" [1]=> string(12) "auth-changed" [2]=> string(13) "lost-provider" [3]=> string(9) "connected" [4]=> string(12) "disconnected" } bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/007-midgard_dbobject.phpt0000664000175000017500000000226511730073440021741 0ustar pppp--TEST-- test of midgard_dbobject --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file = [[CFG_FILE]] report_memleaks = On --FILE-- a = 'test'; var_dump($obj->a); var_dump($obj->guid); $obj->create(); var_dump($obj->a); var_dump($obj->guid); $obj2 = new atype(); $obj2->up = $obj->id; $obj2->a = 'kid'; $obj2->create(); $list = $obj->list(); var_dump(count($list)); var_dump($list[0]->a === $obj2->a); var_dump($list[0]->guid === $obj2->guid); $obj3 = new xtype(); $obj3->x = 'outer'; $obj3->owner = $obj2->id; $obj3->create(); $list = $obj2->list_children('xtype'); var_dump(count($list)); var_dump($list[0]->x === $obj3->x); var_dump($list[0]->guid === $obj3->guid); // don't leave traces! var_dump($obj->delete()); // <-- this should fail because of dependency var_dump($obj3->delete()); var_dump($obj2->delete()); var_dump($obj->delete()); ?> ===DONE=== --EXPECTF-- string(4) "test" string(0) "" string(4) "test" string(36) "%s" int(1) bool(true) bool(true) int(1) bool(true) bool(true) bool(false) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/031-emit.phpt0000664000175000017500000000103611730073440017424 0ustar pppp--TEST-- test for midgard_object::emit() --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = '1'; $obj1->create(); $obj1->connect('action-update', 'fun_callback', array()); $obj1->emit('action-update'); var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- callback bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/052-parameters.phpt0000664000175000017500000000122411730073440020633 0ustar pppp--TEST-- test for setting/getting values of parameters --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- create(); var_dump($a->set_parameter('foo', 'bar', 'baz')); var_dump($a->get_parameter('foo', 'bar')); var_dump($a->parameter('foo', 'bar')); var_dump($a->parameter('foo', 'bar', null)); var_dump($a->get_parameter('foo', 'bar')); $a->delete(); ?> ===DONE=== --EXPECTF-- bool(true) string(3) "baz" string(3) "baz" bool(true) NULL ===DONE=== php5-midgard2-10.05.7/tests_templates/038-escaping.phpt0000664000175000017500000000213411730073440020266 0ustar pppp--TEST-- test that midgard doesn't do any unexpected escaping --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = $str; $obj->t = $str; $obj->create(); var_dump($obj->a === $str); // instant check var_dump($obj->t === $str); // instant check $obj2 = new atype($obj->id); var_dump($obj2->a === $str); // check after load from database var_dump($obj2->t === $str); // check after load from database // cleanup var_dump($obj->delete()); unset($obj2, $obj); } ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/024-bug1484.phpt0000664000175000017500000000116111730073440017565 0ustar pppp--TEST-- test for bug#1484 --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- flt = 0.12345; $a->create(); $a2 = new atype($a->guid); var_dump($a2->flt); unset($a2); $qb = atype::new_query_builder(); $qb->add_constraint('guid', '=', $a->guid); $items = $qb->execute(); $a3 = $items[0]; var_dump($a3->flt); var_dump($a->delete()); ?> ===DONE=== --EXPECTF-- float(0.12345) float(0.12345) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/029-parent.phpt0000664000175000017500000000133111730073440017764 0ustar pppp--TEST-- test for midgard_dbobject::parent() and midgard_dbobject::get_parent() methods --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = '1'; $obj1->create(); $obj2 = new xtype(); $obj2->x = '2'; $obj2->owner = $obj1->id; $obj2->create(); var_dump($obj2->parent() == 'atype'); var_dump($obj2->get_parent() instanceof atype); var_dump($obj2->get_parent()->a == '1'); // cleanup var_dump($obj2->delete()); var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/tests_templates/004-work_without_connection.phpt0000664000175000017500000000070011730073440023447 0ustar pppp--TEST-- test for an error, which should happen in absence of connection. --SKIPIF-- --INI-- midgard.engine = On midgard.http = Off midgard.memory_debug = Off --ENV-- MIDGARD_ENV_GLOBAL_SHAREDIR=[[SHARE_PATH]] --FILE-- getMessage()."\n"; } ?> ===DONE=== --EXPECTF-- Failed to get connection ===DONE=== php5-midgard2-10.05.7/tests_templates/test.cfg0000664000175000017500000000057511730073440016737 0ustar pppp[MidgardDatabase] Type=[[DB_TYPE]] Name=[[DB_NAME]] DatabaseDir=[[PATH]] Username=[[DB_USER]] Password=[[DB_PASS]] Host=[[DB_HOST]] Logfile=[[PATH]]/midgard.log # Schema= # DefaultLanguage= Loglevel=warn TableCreate=true TableUpdate=true TestUnit=false MidgardUsername=root MidgardPassword=password # PamFile= [MidgardDir] BlobDir=[[BLOB_PATH]] ShareDir=[[SHARE_PATH]] VarDir=test php5-midgard2-10.05.7/tests_templates/051-view_without_guid.phpt0000664000175000017500000000143111730073440022234 0ustar pppp--TEST-- test if views without guids work fine --SKIPIF-- --INI-- midgard.engine = On midgard.http = On midgard.memory_debug = Off midgard.configuration= midgard.configuration_file=[[CFG_FILE]] report_memleaks = On --FILE-- a = 'a'; $obj1->b = 'b'; $obj1->create(); $obj2 = new xtype(); $obj2->x = 'x'; $obj2->y = 'y'; $obj2->owner = $obj1->id; $obj2->create(); $storage = new midgard_query_storage('noguidview'); $q = new midgard_query_select($storage); var_dump($q->execute()); $list = $q->list_objects(); var_dump(count($list) == 1); // do not leave traces! var_dump($obj2->delete()); var_dump($obj1->delete()); ?> ===DONE=== --EXPECTF-- bool(true) bool(true) bool(true) bool(true) ===DONE=== php5-midgard2-10.05.7/php_midgard_reflector_object.c0000664000175000017500000003537011730073440020075 0ustar pppp/* Copyright (C) 2011 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" zend_class_entry *php_midgard_reflector_object_class; #define __CHECK_GTYPE_NAME(__name) \ GType type_from_name = g_type_from_name(__name); \ if (type_from_name == G_TYPE_INVALID) { \ php_error(E_WARNING, "Type '%s' is not registered in Gtype system", __name); \ return; \ } static PHP_METHOD(midgard_reflector_object, get_property_primary) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); const gchar *property_primary = midgard_reflector_object_get_property_primary(g_classname); if (!property_primary) RETURN_NULL(); RETURN_STRING((char *)property_primary, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_get_property_primary, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, get_property_up) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); const gchar *property_up = midgard_reflector_object_get_property_up(g_classname); if (!property_up) RETURN_NULL(); RETURN_STRING((char *)property_up, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_get_property_up, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, get_property_parent) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); const gchar *property_parent = midgard_reflector_object_get_property_parent(g_classname); if (!property_parent) RETURN_NULL(); RETURN_STRING((char *)property_parent, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_get_property_parent, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, get_property_unique) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); const gchar *property_unique = midgard_reflector_object_get_property_unique(g_classname); if (!property_unique) RETURN_NULL(); RETURN_STRING((char *)property_unique, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_get_property_unique, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, list_children) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); guint n_children; gchar **children = midgard_reflector_object_list_children(g_classname, &n_children); array_init(return_value); if (children == NULL) return; guint i; for (i = 0; i < n_children; i++) { add_assoc_string(return_value, (gchar *)children[i], "", 1); } g_free(children); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_list_children, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, has_metadata_class) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); RETURN_BOOL(midgard_reflector_object_has_metadata_class(g_classname)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_has_metadata_class, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, get_metadata_class) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); const gchar *metadata_class = midgard_reflector_object_get_metadata_class(g_classname); if (!metadata_class) RETURN_NULL(); RETURN_STRING((char *)metadata_class, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_get_metadata_class, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, get_schema_value) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; char *name; int name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &zvalue, &name, &name_length) == FAILURE) { return; } const gchar *classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { classname = (const gchar *) Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { classname = (const gchar *) Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "first argument should be object or string"); return; } const gchar *schema_value = midgard_reflector_object_get_schema_value(classname, (const gchar *)name); if (!schema_value) RETURN_NULL(); RETURN_STRING((char *)schema_value, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_get_schema_value, 0, 0, 2) ZEND_ARG_INFO(0, classname) ZEND_ARG_INFO(0, node_name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, is_mixin) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); RETURN_BOOL(midgard_reflector_object_is_mixin(g_classname)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_is_mixin, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, is_interface) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); RETURN_BOOL(midgard_reflector_object_is_interface(g_classname)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_is_interface, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, is_abstract) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); RETURN_BOOL(midgard_reflector_object_is_abstract(g_classname)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_is_abstract, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflector_object, list_defined_properties) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) { return; } const char *php_classname = NULL; if (Z_TYPE_P(zvalue) == IS_STRING) { php_classname = Z_STRVAL_P(zvalue); } else if (Z_TYPE_P(zvalue) == IS_OBJECT) { php_classname = Z_OBJCE_P(zvalue)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string"); return; } const gchar *g_classname = php_class_name_to_g_class_name(php_classname); __CHECK_GTYPE_NAME(g_classname); guint n_prop; gchar **properties = midgard_reflector_object_list_defined_properties(g_classname, &n_prop); array_init(return_value); if (properties == NULL) return; guint i; for (i = 0; i < n_prop; i++) { add_assoc_string(return_value, (gchar *)properties[i], "", 1); } g_free(properties); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_reflector_object_list_defined_properties, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_reflector_object) { static zend_function_entry object_class_methods[] = { PHP_ME(midgard_reflector_object, get_property_primary, arginfo_midgard_reflector_object_get_property_primary, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, get_property_up, arginfo_midgard_reflector_object_get_property_up, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, get_property_parent, arginfo_midgard_reflector_object_get_property_parent, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, get_property_unique, arginfo_midgard_reflector_object_get_property_unique, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, list_children, arginfo_midgard_reflector_object_list_children, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, has_metadata_class, arginfo_midgard_reflector_object_has_metadata_class, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, get_metadata_class, arginfo_midgard_reflector_object_get_metadata_class, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, get_schema_value, arginfo_midgard_reflector_object_get_schema_value, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, is_mixin, arginfo_midgard_reflector_object_is_mixin, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, is_interface, arginfo_midgard_reflector_object_is_interface, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, is_abstract, arginfo_midgard_reflector_object_is_abstract, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(midgard_reflector_object, list_defined_properties, arginfo_midgard_reflector_object_list_defined_properties, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_reflector_object_class_entry; INIT_CLASS_ENTRY(php_midgard_reflector_object_class_entry, "MidgardReflectorObject", object_class_methods); php_midgard_reflector_object_class = zend_register_internal_class(&php_midgard_reflector_object_class_entry TSRMLS_CC); CLASS_SET_DOC_COMMENT(php_midgard_reflector_object_class, strdup("Collection of static methods which provide reflection for MgdSchema classes")); zend_register_class_alias("midgard_reflector_object", php_midgard_reflector_object_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_base_interface.c0000664000175000017500000001010011730073440017474 0ustar pppp/* Copyright (C) 2011 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" zend_class_entry *php_midgard_base_interface_class; zend_class_entry * __get_interface_entry (const gchar *name) { int iface_name_length = strlen(name); char *lower_iface_name = g_ascii_strdown(name, iface_name_length); zend_class_entry **ce; if (zend_hash_find(CG(class_table), (char *)lower_iface_name, iface_name_length + 1, (void **) &ce) != SUCCESS) { return NULL; } g_free(lower_iface_name); return *ce; } /* This is done without zend_lookup_clas(_ex) because we register interfaces * during MINIT phase, so EG(class_table) is not yet initialized. * If interfaces are loaded later, after RINIT phase, zend_lookup_class might be * easier choice */ static zend_bool __is_interface_registered (const gchar *name) { if (__get_interface_entry(name) == NULL) return FALSE; return TRUE; } static void __register_php_interface (const char *name) { /* Silently return if interface is already registered */ if (__is_interface_registered(name)) { return; } GType iface_type = g_type_from_name(name); /* If given type is not interface, silently gnore */ if (!G_TYPE_IS_INTERFACE (iface_type)) return; guint n_types; guint i; /* Get prerequisites and chain up. * Gtype system doesn't provde any reflection for "derived" interfaces. */ GType *prqs = g_type_interface_prerequisites (iface_type, &n_types); for (i = 0; i < n_types; i++) { const gchar *parent_name = g_type_name(prqs[i]); if (!__is_interface_registered (parent_name)) __register_php_interface(parent_name); } zend_class_entry *php_iface, *php_iface_ptr; /* Create interface template */ php_iface = g_new0(zend_class_entry, 1); php_iface->name = g_strdup (name); php_iface->name_length = strlen(name); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 php_iface->info.internal.builtin_functions = NULL; #else php_iface->builtin_functions = NULL; #endif php_iface->constructor = NULL; php_iface->destructor = NULL; php_iface->clone = NULL; php_iface->create_object = NULL; php_iface->interface_gets_implemented = NULL; php_iface->__call = NULL; php_iface->__get = NULL; php_iface->__set = NULL; php_iface->parent = NULL; php_iface->num_interfaces = 0; php_iface->interfaces = NULL; php_iface->get_iterator = NULL; php_iface->iterator_funcs.funcs = NULL; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 php_iface->info.internal.module = NULL; #else php_iface->module = NULL; #endif php_iface->ce_flags = 0; /* Register interface */ php_iface_ptr = zend_register_internal_interface(php_iface TSRMLS_CC); /* Implement prerequisites */ for (i = 0; i < n_types; i++) { if (!G_TYPE_IS_INTERFACE(prqs[i])) /* GObject prerequisite, most likely */ continue; zend_class_entry *prqs_iface = __get_interface_entry(g_type_name(prqs[i])); zend_class_implements(php_iface_ptr TSRMLS_CC, 1, prqs_iface); } g_free(prqs); /* freeing interface-template (it is not needed anymore) */ g_free(php_iface); } PHP_MINIT_FUNCTION(midgard2_base_interface) { /* TODO, if needed, base, fundamental GType interface could be registered as well */ guint n_types, i; GType *all_types = g_type_children(G_TYPE_INTERFACE, &n_types); const gchar *typename; for (i = 0; i < n_types; i++) { typename = g_type_name(all_types[i]); __register_php_interface(typename); } g_free(all_types); return SUCCESS; } php5-midgard2-10.05.7/INSTALL0000664000175000017500000000577011730073440013112 0ustar pppp 1 - To install midgard-php5 module, you'll first need to have the version 5.2 or later of PHP, as well as the matching php-devel package (or install PHP from source). 2 - Then run: ./mkall If pkg-config is not in system's PATH, use --with-pkg-config argument. Full path including pkg-config executable is required in such case. ./mkall --with-pkg-config=/usr/local/bin/pkg-config If php-config is not in system's PATH, use --with-php-config argument. Full path including php-config executable is required in such case. ./mkall --with-php-config=/opt/bin/php-config 3 - Edit your php.ini to add: extension=midgard.so midgard.http=On and make sure that extension_dir at least contains the output of `php-config --extension-dir` Read 'HTTP SERVER NOTES' section for more details. 4 - Stop and start httpd. You may stop and start httpd server when midgard-data is already configured and installed. ######################################################## ########### PHP ini configuration directives ########### ######################################################## midgard.configuration Name of midgard unified configuration file. Default is ''. It's not used if midgard.http is 'Off'. It's set when module is loaded, and you can change it later, during runtime. Usable with virtual hosts. ( For example: php_admin_value midgard.configuration midgard ) midgard.configuration_file Full path (including file name) to midgard unified configuration file. It's not used if midgard.http is 'Off'. It's set when module is loaded, and you can change it later, during runtime. Usable with virtual hosts. ( For example: php_admin_value midgard.configuration_file /home/john/.midgard2/midgard.conf ) midgard.http Switch which forces midgard module to initialize all system configurations when module is loaded. All connections to all defined databases are made at once. It should not be set for cli applications. This configuration should be set in main php.ini which is used only by php http server module. It can not be changed during runtime. Default is 'Off'. midgard.engine Disable or enable midgard engine. Default is 'On'. You can change it between requests and also use in .htaccess files. midgard.quota Disable or enable quota check. Default is 'Off'. You can change it between requests and also use in .htaccess files. midgard.glib_loghandler Propagate GLib and GLib-GObject domains errors as PHP ones. Default is 'Off'. Enable or disable when module is loaded. ######################################################## ############# HTTP SERVER NOTES ###################### ######################################################## 1. APACHE In php.ini or in midgard2.ini configuration file these config keys must be added: midgard.http On midgard.engine On In virtual host configuration: php_admin_value midgard.configuration 'midgard' 2. LIGHTTPD In php.ini these config keys must be added: midgard.http Off midgard.engine On midgard.configuration_file "/absolute/path/to/configuration" 3. NGINX php5-midgard2-10.05.7/php_midgard_object.c0000664000175000017500000012657011730073440016033 0ustar pppp/* * Copyright (C) 2007, 2008 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard_object.h" #include "php_midgard__helpers.h" #include #include zend_class_entry *php_midgard_dbobject_class = NULL; zend_class_entry *php_midgard_object_class = NULL; zend_class_entry *php_midgard_base_abstract_class = NULL; #define __THROW_EXCEPTION \ if (EG(exception)) { \ return_value = zend_throw_exception(Z_OBJCE_P(EG(exception)), "", 0 TSRMLS_CC); \ return; \ } static zend_bool init_php_midgard_object_from_id(zval *instance, const char *php_classname, zval *objid TSRMLS_DC) { MidgardObject *gobject = NULL; MidgardConnection *mgd = mgd_handle(TSRMLS_C); const gchar *g_classname = php_class_name_to_g_class_name(php_classname); if (objid == NULL) { /* Initialize empty MidgardObject */ gobject = midgard_object_new(mgd, (const gchar *) g_classname, NULL); } else { /* There is one parameter , so we get object by id or guid */ if (Z_TYPE_P(objid) == IS_LONG) { // ok } else if (Z_TYPE_P(objid) == IS_STRING) { // if it is short and numeric, then it is id! if (Z_STRLEN_P(objid) < 10 && is_numeric_string(Z_STRVAL_P(objid), Z_STRLEN_P(objid), NULL, NULL, 0)) { convert_to_long(objid); } else if (!midgard_is_guid(Z_STRVAL_P(objid))) { zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "'%s' is not a valid guid", Z_STRVAL_P(objid)); return FALSE; } } else { zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Wrong id-type for '%s' constructor. Expecting number or guid", php_classname); return FALSE; } GValue *value = php_midgard_zval2gvalue(objid TSRMLS_CC); gobject = midgard_object_new(mgd, (const gchar *) g_classname, value); g_value_unset(value); g_free(value); } if (!gobject) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return FALSE; } MGD_PHP_SET_GOBJECT(instance, gobject); return TRUE; } /* Object constructor */ PHP_FUNCTION(_midgard_php_object_constructor) { zval *zval_object = getThis(); zend_class_entry *zce = php_midgard_get_mgdschema_class_ptr(Z_OBJCE_P(zval_object)); const char *zend_classname = zce->name; GObject *gobject; if (MGDG(midgard_memory_debug)) { php_printf("[%p] %s::__construct() \n", zval_object, zend_classname); } MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); gobject = __php_gobject_ptr(zval_object); if (!gobject) { // this is a normal constructing process (we don't have assigned gobject yet) zval *objid = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!", &objid) == FAILURE) return; if (init_php_midgard_object_from_id(zval_object, zend_classname, objid TSRMLS_CC) == FALSE) return; gobject = __php_gobject_ptr(zval_object); } else { // we already have gobject injected } php_midgard_object_connect_class_closures(gobject, zval_object TSRMLS_CC); g_signal_emit(gobject, MIDGARD_OBJECT_GET_CLASS(gobject)->signal_action_loaded_hook, 0); if (MGDG(midgard_memory_debug)) { php_printf("[%p] <= %s::__construct() \n", zval_object, zend_classname); } } PHP_FUNCTION(_midgard_php_object_create) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); g_signal_emit(object, MIDGARD_OBJECT_GET_CLASS(object)->signal_action_create_hook, 0); __THROW_EXCEPTION if (midgard_object_create(object)) RETVAL_TRUE; } PHP_FUNCTION(_midgard_php_object_update) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); g_signal_emit(object, MIDGARD_OBJECT_GET_CLASS(object)->signal_action_update_hook, 0); __THROW_EXCEPTION if (midgard_object_update(object)) RETVAL_TRUE; } PHP_FUNCTION(_midgard_php_object_get_by_id) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); long id; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &id) == FAILURE) return; MidgardObject *mobj = __midgard_object_get_ptr(getThis()); if (!midgard_object_get_by_id(mobj, id)) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } g_signal_emit(mobj, MIDGARD_OBJECT_GET_CLASS(mobj)->signal_action_loaded_hook, 0); RETVAL_TRUE; } PHP_FUNCTION(_midgard_php_object_get_by_guid) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *guid; int glen; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &guid, &glen) == FAILURE) { return; } MidgardObject *mobj = __midgard_object_get_ptr(getThis()); if (!midgard_object_get_by_guid(mobj, guid)) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } g_signal_emit(mobj, MIDGARD_OBJECT_GET_CLASS(mobj)->signal_action_loaded_hook, 0); RETVAL_TRUE; } PHP_FUNCTION(_midgard_php_object_is_in_parent_tree) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); long rootid, id; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &rootid, &id) == FAILURE) return; /* Return TRUE if id or rootid is 0. */ /* FIXME: Comment says "or", but code says "and". Who's right? */ if (rootid == 0 && id == 0) RETURN_TRUE; zend_class_entry *zce = php_midgard_get_mgdschema_class_ptr(Z_OBJCE_P(getThis())); const char *php_classname = zce->name; MidgardObject *leaf_obj = NULL, *root_obj = NULL; { const gchar *g_classname = php_class_name_to_g_class_name(php_classname); GValue tmp_gval = { 0 }; g_value_init(&tmp_gval, G_TYPE_INT); g_value_set_int(&tmp_gval, id); leaf_obj = midgard_object_new(mgd, g_classname, &tmp_gval); if (!leaf_obj) { php_error(E_NOTICE, "Did not find object with id=%ld", id); return; } } { const gchar *g_parent_classname = midgard_schema_object_tree_get_parent_name(leaf_obj); GValue tmp_gval = { 0 }; g_value_init(&tmp_gval, G_TYPE_INT); g_value_set_int(&tmp_gval, rootid); root_obj = midgard_object_new(mgd, g_parent_classname, &tmp_gval); if (!root_obj) { php_error(E_NOTICE, "Did not find object with id=%ld", rootid); g_object_unref(leaf_obj); return; } } if (midgard_schema_object_tree_is_in_tree(leaf_obj, root_obj)) { RETVAL_TRUE; } g_object_unref(leaf_obj); g_object_unref(root_obj); } PHP_FUNCTION(_midgard_php_object_is_in_tree) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); long rootid, id; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &rootid, &id) == FAILURE) return; zend_class_entry *zce = php_midgard_get_mgdschema_class_ptr(Z_OBJCE_P(getThis())); const char *php_classname = zce->name; const gchar *g_classname = php_class_name_to_g_class_name(php_classname); MidgardObject *leaf_obj = NULL, *root_obj = NULL; { GValue tmp_gval = { 0 }; g_value_init(&tmp_gval, G_TYPE_INT); g_value_set_int(&tmp_gval, id); leaf_obj = midgard_object_new(mgd, g_classname, &tmp_gval); if (!leaf_obj) { php_error(E_NOTICE, "Did not find object with id=%ld", id); return; } } { GValue tmp_gval = { 0 }; g_value_init(&tmp_gval, G_TYPE_INT); g_value_set_int(&tmp_gval, rootid); root_obj = midgard_object_new(mgd, g_classname, &tmp_gval); if (!root_obj) { php_error(E_NOTICE, "Did not find object with id=%ld", rootid); g_object_unref(leaf_obj); return; } } if (midgard_schema_object_tree_is_in_tree(leaf_obj, root_obj)) { RETVAL_TRUE; } g_object_unref(leaf_obj); g_object_unref(root_obj); } PHP_FUNCTION(_midgard_php_object_delete) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zend_bool check_dependencies = TRUE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &check_dependencies) == FAILURE) return; MidgardObject *mobj = __midgard_object_get_ptr(getThis()); g_signal_emit(mobj, MIDGARD_OBJECT_GET_CLASS(mobj)->signal_action_delete_hook, 0); __THROW_EXCEPTION if (midgard_object_delete(mobj, check_dependencies)) RETVAL_TRUE; } PHP_FUNCTION(_midgard_php_object_get_parent) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *mobj = __midgard_object_get_ptr(getThis()); GObject *pobj = G_OBJECT(midgard_schema_object_tree_get_parent_object(mobj)); if (pobj) { gchar const *type_name = G_OBJECT_TYPE_NAME(pobj); zend_class_entry *pce = zend_fetch_class((char *)type_name, strlen(type_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); php_midgard_gobject_new_with_gobject(return_value, pce, pobj, TRUE TSRMLS_CC); } } PHP_FUNCTION(_midgard_php_object_list) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; array_init(return_value); zval *zval_object = getThis(); MidgardObject *mobj = __midgard_object_get_ptr(zval_object); guint i, n_objects; MidgardObject **objects = midgard_schema_object_tree_list_objects(mobj, &n_objects); if (objects) { zend_class_entry *ce = php_midgard_get_mgdschema_class_ptr(Z_OBJCE_P(zval_object)); for (i = 0; i < n_objects; i++) { zval *zobject = NULL; MAKE_STD_ZVAL(zobject); php_midgard_gobject_new_with_gobject(zobject, ce, G_OBJECT(objects[i]), TRUE TSRMLS_CC); zend_hash_next_index_insert(HASH_OF(return_value), &zobject, sizeof(zval *), NULL); } } } PHP_FUNCTION(_midgard_php_object_list_children) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *childcname; int ccnl; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &childcname, &ccnl) == FAILURE) { return; } array_init(return_value); MidgardObject *mobj = __midgard_object_get_ptr(getThis()); guint i, n_objects; MidgardObject **objects = midgard_schema_object_tree_list_children_objects(mobj, childcname, &n_objects); if (objects != NULL) { zend_class_entry *ce = php_midgard_get_mgdschema_class_ptr_by_name(childcname TSRMLS_CC); for (i = 0; i < n_objects; i++) { zval *zobject = NULL; MAKE_STD_ZVAL(zobject); php_midgard_gobject_new_with_gobject(zobject, ce, G_OBJECT(objects[i]), TRUE TSRMLS_CC); zend_hash_next_index_insert(HASH_OF(return_value), &zobject, sizeof(zval *), NULL); } } } PHP_FUNCTION(php_midgard_object_has_dependents) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); RETURN_BOOL(midgard_object_has_dependents(object)); } PHP_FUNCTION(_midgard_php_object_get_by_path) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *path; int pathl; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &pathl) == FAILURE) { return; } MidgardObject *mobj = __midgard_object_get_ptr(getThis()); RETURN_BOOL(midgard_object_get_by_path(mobj, path)); } PHP_FUNCTION(_midgard_php_object_parent) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *mobj = __midgard_object_get_ptr(getThis()); const gchar *parent_class_name = midgard_schema_object_tree_get_parent_name(mobj); if (parent_class_name) RETVAL_STRING((char *)parent_class_name, 1); } PHP_FUNCTION(_php_midgard_object_purge) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zend_bool check_dependencies = TRUE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &check_dependencies) == FAILURE) return; MidgardObject *mobj = __midgard_object_get_ptr(getThis()); g_signal_emit(mobj, MIDGARD_OBJECT_GET_CLASS(mobj)->signal_action_purge_hook, 0); __THROW_EXCEPTION if (midgard_object_purge(mobj, check_dependencies)) RETVAL_TRUE; } PHP_FUNCTION(_php_midgard_object_undelete) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *guid; int guid_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &guid, &guid_length) == FAILURE) { return; } RETURN_BOOL(midgard_schema_object_factory_object_undelete(mgd, (const gchar *)guid)); } PHP_FUNCTION(_php_midgard_object_connect) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); php_midgard_gobject_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU); } // static PHP_FUNCTION(_php_midgard_new_query_builder) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 const char *_class_name = get_active_class_name(NULL TSRMLS_CC); #else char *_class_name = get_active_class_name(NULL TSRMLS_CC); #endif MidgardQueryBuilder *builder = midgard_query_builder_new(mgd, (gchar *)_class_name); if (!builder) return; zval *this_class_name = NULL; MAKE_STD_ZVAL(this_class_name); ZVAL_STRING(this_class_name, _class_name, 1); object_init_ex(return_value, php_midgard_query_builder_class); MGD_PHP_SET_GOBJECT(return_value, builder); zend_call_method_with_1_params( &return_value, php_midgard_query_builder_class, &php_midgard_query_builder_class->constructor, "__construct", NULL, this_class_name ); zval_ptr_dtor(&this_class_name); } PHP_FUNCTION(_php_midgard_new_collector) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *propname; zval *zvalue; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &propname, &zvalue) == FAILURE) return; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 const char *_class_name = get_active_class_name(NULL TSRMLS_CC); #else char *_class_name = get_active_class_name(NULL TSRMLS_CC); #endif zval *this_class_name = NULL; MAKE_STD_ZVAL(this_class_name); ZVAL_STRING(this_class_name, _class_name, 1); object_init_ex(return_value, php_midgard_collector_class); zend_call_method_with_3_params( &return_value, // obj php_midgard_collector_class, &php_midgard_collector_class->constructor, "__construct", // ce, method, method_name NULL, // return value this_class_name, propname, zvalue // parameters ); zval_ptr_dtor(&this_class_name); } PHP_FUNCTION(_php_midgard_new_reflection_property) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 const char *_class_name = get_active_class_name(NULL TSRMLS_CC); #else char *_class_name = get_active_class_name(NULL TSRMLS_CC); #endif MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)_class_name); MidgardReflectionProperty *mrp = midgard_reflection_property_new(MIDGARD_DBOBJECT_CLASS(klass)); if (!mrp) return; php_midgard_gobject_new_with_gobject(return_value, php_midgard_reflection_property_class, G_OBJECT(mrp), TRUE TSRMLS_CC); } PHP_FUNCTION(_php_midgard_object_set_guid) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *guid = NULL; int guid_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &guid, &guid_length) == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); RETURN_BOOL(midgard_object_set_guid(object, (const gchar *)guid)); } PHP_FUNCTION(_php_midgard_object_emit) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *signal_name = NULL; int signal_name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &signal_name, &signal_name_length) == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); g_signal_emit_by_name(object, signal_name); } PHP_FUNCTION(_php_midgard_object_approve) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); RETURN_BOOL(midgard_object_approve(object)); } PHP_FUNCTION(_php_midgard_object_is_approved) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); RETURN_BOOL(midgard_object_is_approved(object)); } PHP_FUNCTION(_php_midgard_object_unapprove) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); RETURN_BOOL(midgard_object_unapprove(object)); } PHP_FUNCTION(_php_midgard_object_lock) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); RETURN_BOOL(midgard_object_lock(object)); } PHP_FUNCTION(_php_midgard_object_is_locked) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); RETURN_BOOL(midgard_object_is_locked(object)); } PHP_FUNCTION(_php_midgard_object_unlock) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); RETURN_BOOL(midgard_object_unlock(object)); } PHP_FUNCTION(_php_midgard_object_get_workspace) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; MidgardObject *object = __midgard_object_get_ptr(getThis()); MidgardWorkspace *workspace = midgard_object_get_workspace(object); if (!workspace) return; php_midgard_gobject_new_with_gobject(return_value, php_midgard_workspace_class, G_OBJECT(object), TRUE TSRMLS_CC); } static struct { char *fname; void (*handler)(INTERNAL_FUNCTION_PARAMETERS); zend_uint flags; zend_arg_info arg_info[8]; /* Keep it as reasonable high value. Or refactor so it doesn't have to be allocated statically */ zend_uint num_args; char *doc_comment; } __midgard_php_type_functions[] = { {"__construct", ZEND_FN(_midgard_php_object_constructor), ZEND_ACC_PUBLIC | ZEND_ACC_CTOR, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "guid or id", sizeof("guid or id")-1, NULL, 0, 0, 1 /* Allows NULL */, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "guid or id", sizeof("guid or id")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, #endif }, 1, "Creates new empty instance or fetch object's data from storage if argument is of integer or string type. In latter case valid guid is expected. Throws midgard_error_exception on failure" }, {"get_by_id", ZEND_FN(_midgard_php_object_get_by_id), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 1 }, { "id", sizeof("id")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 1 }, { "id", sizeof("id")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1, "Get object which is identified by given id" }, {"get_by_guid", ZEND_FN(_midgard_php_object_get_by_guid), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 1 }, { "guid", sizeof("guid")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 1 }, { "guid", sizeof("guid")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1, "Load data which is identified by given guid into current object" }, {"update", ZEND_FN(_midgard_php_object_update), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0, "Store object-changes into database" }, {"create", ZEND_FN(_midgard_php_object_create), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0, "Create object's record in database" }, {"is_in_parent_tree", ZEND_FN(_midgard_php_object_is_in_parent_tree), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "root_id", sizeof("root_id")-1, NULL, 0, 0, 0, 0 }, { "id", sizeof("id")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 2 }, { "root_id", sizeof("root_id")-1, NULL, 0, 0, 0, 0, 0, 0 }, { "id", sizeof("id")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 2, "Check if object identified by 'id' is descendant of object identified by 'root_id'. Traversing is done using 'parent' markers in schema" }, {"is_in_tree", ZEND_FN(_midgard_php_object_is_in_tree), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "root_id", sizeof("root_id")-1, NULL, 0, 0, 0, 0 }, { "id", sizeof("id")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 2 }, { "root_id", sizeof("root_id")-1, NULL, 0, 0, 0, 0, 0, 0 }, { "id", sizeof("id")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 2, "Check if object identified by 'id' is descendant of object identified by 'root_id'. Traversing is done using 'up' markers in schema" }, {"has_dependents", ZEND_FN(php_midgard_object_has_dependents), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"delete", ZEND_FN(_midgard_php_object_delete), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "check_dependencies", sizeof("check_dependencies")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "check_dependencies", sizeof("check_dependencies")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1, "Mark object's record in database as \"deleted\"" }, {"get_parent", ZEND_FN(_midgard_php_object_get_parent), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0, "returns parent-object, using 'parent' mark in schema" }, {"list", ZEND_FN(_midgard_php_object_list), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"list_children", ZEND_FN(_midgard_php_object_list_children), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "node class name", sizeof("node class name")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 1 }, { "node class name", sizeof("node class name")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1 }, {"get_by_path", ZEND_FN(_midgard_php_object_get_by_path), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "path", sizeof("path")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 1 }, { "path", sizeof("path")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1 }, {"parent", ZEND_FN(_midgard_php_object_parent), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0, "returns name of class, which is marked as 'parent' in schema" }, {"has_parameters", ZEND_FN(php_midgard_object_has_parameters), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"list_parameters", ZEND_FN(_php_midgard_object_list_parameters), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "domain", sizeof("domain")-1, NULL, 0, 0, 1 /* Allows NULL */, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "domain", sizeof("domain")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, #endif }, 1 }, {"find_parameters", ZEND_FN(_php_midgard_object_find_parameters), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, #endif }, 1 }, {"delete_parameters", ZEND_FN(_php_midgard_object_delete_parameters), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, #endif }, 1 }, {"purge_parameters", ZEND_FN(_php_midgard_object_purge_parameters), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, #endif }, 1 }, {"get_parameter", ZEND_FN(_php_midgard_object_get_parameter), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "domain", sizeof("domain")-1, NULL, 0, 0, 0, 0 }, { "name", sizeof("name")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 2 }, { "domain", sizeof("domain")-1, NULL, 0, 0, 0, 0, 0, 0 }, { "name", sizeof("name")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 2 }, {"set_parameter", ZEND_FN(_php_midgard_object_set_parameter), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "domain", sizeof("domain")-1, NULL, 0, 0, 0, 0 }, { "name", sizeof("name")-1, NULL, 0, 0, 0, 0 }, { "value", sizeof("value")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 3 }, { "domain", sizeof("domain")-1, NULL, 0, 0, 0, 0, 0, 0 }, { "name", sizeof("name")-1, NULL, 0, 0, 0, 0, 0, 0 }, { "value", sizeof("value")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 3 }, {"parameter", ZEND_FN(_php_midgard_object_parameter), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "domain", sizeof("domain")-1, NULL, 0, 0, 0, 0 }, { "name", sizeof("name")-1, NULL, 0, 0, 0, 0 }, { "value", sizeof("value")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 2 }, { "domain", sizeof("domain")-1, NULL, 0, 0, 0, 0, 0, 0 }, { "name", sizeof("name")-1, NULL, 0, 0, 0, 0, 0, 0 }, { "value", sizeof("value")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, }, {"has_attachments", ZEND_FN(php_midgard_object_has_attachments), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"list_attachments", ZEND_FN(_php_midgard_object_list_attachments), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"find_attachments", ZEND_FN(_php_midgard_object_find_attachments), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, #endif }, 1 }, {"delete_attachments", ZEND_FN(_php_midgard_object_delete_attachments), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, #endif }, 1 }, {"purge_attachments", ZEND_FN(_php_midgard_object_purge_attachments), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0 }, { "delete blob", sizeof("delete blob")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "constraints", sizeof("constraints")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, { "delete blob", sizeof("delete blob")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 2 }, {"create_attachment", ZEND_FN(_php_midgard_object_create_attachment), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "name", sizeof("name")-1, NULL, 0, 0, 1 /* Allows NULL */, 0 }, { "title", sizeof("title")-1, NULL, 0, 0, 1 /* Allows NULL */, 0 }, { "mimetype", sizeof("mimetype")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "name", sizeof("name")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, { "title", sizeof("title")-1, NULL, 0, 0, 1 /* Allows NULL */, 0, 0, 0 }, { "mimetype", sizeof("mimetype")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 3 }, {"serve_attachment", ZEND_FN(_php_midgard_object_serve_attachment), ZEND_ACC_STATIC|ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "guid", sizeof("guid")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 1 }, { "guid", sizeof("guid")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1 }, {"purge", ZEND_FN(_php_midgard_object_purge), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, { "check_dependencies", sizeof("check_dependencies")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, { "check_dependencies", sizeof("check_dependencies")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1 }, {"undelete", ZEND_FN(_php_midgard_object_undelete), ZEND_ACC_STATIC|ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "guid", sizeof("guid")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 1 }, { "guid", sizeof("guid")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1 }, {"connect", ZEND_FN(_php_midgard_object_connect), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "signal", sizeof("signal")-1, NULL, 0, 0, 0, 0 }, { "callback", sizeof("callback")-1, NULL, 0, 0, 0, 0 }, { "user_data", sizeof("user_data")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 2 }, { "signal", sizeof("signal")-1, NULL, 0, 0, 0, 0, 0, 0 }, { "callback", sizeof("callback")-1, NULL, 0, 0, 0, 0, 0, 0 }, { "user_data", sizeof("user_data")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 3 }, {"new_query_builder", ZEND_FN(_php_midgard_new_query_builder), ZEND_ACC_STATIC|ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"new_collector", ZEND_FN(_php_midgard_new_collector), ZEND_ACC_STATIC|ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"new_reflection_property", ZEND_FN(_php_midgard_new_reflection_property), ZEND_ACC_STATIC|ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"set_guid", ZEND_FN(_php_midgard_object_set_guid), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "guid", sizeof("guid")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 1 }, { "guid", sizeof("guid")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1 }, {"emit", ZEND_FN(_php_midgard_object_emit), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0 }, { "signal", sizeof("signal")-1, NULL, 0, 0, 0, 0 }, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 1 }, { "signal", sizeof("signal")-1, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 1 }, {"approve", ZEND_FN(_php_midgard_object_approve), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"is_approved", ZEND_FN(_php_midgard_object_is_approved), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"unapprove", ZEND_FN(_php_midgard_object_unapprove), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"lock", ZEND_FN(_php_midgard_object_lock), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"is_locked", ZEND_FN(_php_midgard_object_is_locked), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"unlock", ZEND_FN(_php_midgard_object_unlock), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0 }, {"get_workspace", ZEND_FN(_php_midgard_object_get_workspace), ZEND_ACC_PUBLIC, { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 { NULL, 0, NULL, 0, 0, 0, 0}, #else { NULL, 0, NULL, 0, 0, 0, 0, 0, 0 }, #endif }, 0, "Get workspace associated with object. Returned workspace is valid per method call." }, { NULL, NULL } }; int php_midgard_serialize_dbobject_hook(zval *zobject, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC) { php_midgard_gobject *php_gobject = __php_objstore_object(zobject); if (!php_gobject) return FAILURE; if (!php_gobject->gobject) return FAILURE; GObject *gobject = php_gobject->gobject; GType object_type = G_OBJECT_TYPE(gobject); GType parent_object_type = g_type_parent(object_type); if (parent_object_type != MIDGARD_TYPE_DBOBJECT && parent_object_type != MIDGARD_TYPE_OBJECT) { return FAILURE; } gchar *xml = midgard_replicator_serialize(gobject); if (!xml) return FAILURE; guint xml_length = strlen(xml)+1; *buffer = (unsigned char *)estrndup((const char*)xml, xml_length); *buf_len = xml_length; g_free(xml); return SUCCESS; } int php_midgard_unserialize_dbobject_hook(zval **zobject, zend_class_entry *ce, const unsigned char *buffer, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC) { if (buffer == NULL) return FAILURE; if (buf_len < 2) return FAILURE; GObject **objects = midgard_replicator_unserialize(mgd_handle(TSRMLS_C), (const gchar *)buffer, TRUE); if (!objects) return FAILURE; php_midgard_gobject_new_with_gobject(*zobject, ce, objects[0], TRUE TSRMLS_CC); g_free(objects); return SUCCESS; } static zend_class_entry * __find_class_by_name (const gchar *name) { int iface_name_length = strlen(name); char *lower_iface_name = g_ascii_strdown(name, iface_name_length); zend_class_entry **ce; if (zend_hash_find(CG(class_table), (char *)lower_iface_name, iface_name_length + 1, (void **) &ce) != SUCCESS) { return NULL; } g_free(lower_iface_name); return *ce; } static void __add_method_comments(const char *class_name) { /* guint j; FIXME, Rewrite for PHP 5.4 for (j = 0; __midgard_php_type_functions[j].fname != NULL; j++) { php_midgard_docs_add_method_comment(class_name, __midgard_php_type_functions[j].fname, __midgard_php_type_functions[j].doc_comment); } */ } static void __register_php_class(const gchar *class_name, zend_class_entry *parent TSRMLS_DC) { zend_class_entry *mgdclass, *mgdclass_ptr; gint j; guint _am = 0; zend_class_entry *ce = __find_class_by_name(class_name); if (ce != NULL) return; for (j = 0; __midgard_php_type_functions[j].fname; j++) { _am++; } zend_function_entry __functions[_am+1]; __functions[0].fname = "__construct"; __functions[0].handler = ZEND_FN(_midgard_php_object_constructor); __functions[0].arg_info = __midgard_php_type_functions[0].arg_info; __functions[0].num_args = __midgard_php_type_functions[0].num_args; __functions[0].flags = ZEND_ACC_PUBLIC | ZEND_ACC_CTOR; for (j = 1; __midgard_php_type_functions[j].fname; j++) { __functions[j].fname = __midgard_php_type_functions[j].fname; __functions[j].handler = __midgard_php_type_functions[j].handler; __functions[j].arg_info = __midgard_php_type_functions[j].arg_info; __functions[j].num_args = __midgard_php_type_functions[j].num_args; __functions[j].flags = __midgard_php_type_functions[j].flags; } __functions[_am].fname = NULL; __functions[_am].handler = NULL; __functions[_am].arg_info = NULL; __functions[_am].num_args = 0; __functions[_am].flags = 0; // creating class-template int class_name_length = strlen(class_name); mgdclass = g_new0(zend_class_entry, 1); mgdclass->name = g_strdup (class_name); mgdclass->name_length = class_name_length; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 mgdclass->info.internal.builtin_functions = __functions; #else mgdclass->builtin_functions = __functions; #endif mgdclass->constructor = NULL; mgdclass->destructor = NULL; mgdclass->clone = NULL; mgdclass->create_object = NULL; mgdclass->interface_gets_implemented = NULL; mgdclass->__call = NULL; mgdclass->__get = NULL; mgdclass->__set = NULL; mgdclass->parent = parent; mgdclass->num_interfaces = 0; mgdclass->interfaces = NULL; mgdclass->get_iterator = NULL; mgdclass->iterator_funcs.funcs = NULL; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 mgdclass->info.internal.module = NULL; #else mgdclass->module = NULL; #endif mgdclass->ce_flags = 0; // registering class-template as class mgdclass_ptr = zend_register_internal_class(mgdclass TSRMLS_CC); mgdclass_ptr->ce_flags = 0; mgdclass_ptr->serialize = php_midgard_serialize_dbobject_hook; mgdclass_ptr->unserialize = php_midgard_unserialize_dbobject_hook; mgdclass_ptr->create_object = php_midgard_gobject_new; /* Get class interfaces and add php ones */ guint n_types; guint i; GType *iface_types = g_type_interfaces(g_type_from_name(class_name), &n_types); for (i = 0; i < n_types; i++) { zend_class_entry *iface_ce = __find_class_by_name(g_type_name(iface_types[i])); zend_class_implements(mgdclass_ptr TSRMLS_CC, 1, iface_ce); } g_free(iface_types); // freeing class-template (it is not needed anymore) g_free(mgdclass); /* Register all derived classes */ GType *derived = g_type_children(g_type_from_name(class_name), &n_types); for (i = 0; i < n_types; i++) { const gchar *typename = g_type_name(derived[i]); __register_php_class(typename, mgdclass_ptr); __add_method_comments(typename); } } PHP_MINIT_FUNCTION(midgard2_object) { /* Register midgard_dbobject class */ static zend_class_entry php_midgard_dbobject_ce; INIT_CLASS_ENTRY(php_midgard_dbobject_ce, "MidgardDBObject", NULL); php_midgard_dbobject_class = zend_register_internal_class(&php_midgard_dbobject_ce TSRMLS_CC); php_midgard_dbobject_class->ce_flags = ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; zend_register_class_alias("midgard_dbobject", php_midgard_dbobject_class); /* Register midgard_object class */ static zend_class_entry php_midgard_object_ce; INIT_CLASS_ENTRY(php_midgard_object_ce, "MidgardObject", NULL); php_midgard_object_class = zend_register_internal_class_ex(&php_midgard_object_ce, php_midgard_dbobject_class, "MidgardDBObject" TSRMLS_CC); php_midgard_object_class->ce_flags = ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; zend_register_class_alias ("midgard_object", php_midgard_object_class); guint n_types, i; GType *all_types = g_type_children(MIDGARD_TYPE_OBJECT, &n_types); for (i = 0; i < n_types; i++) { const gchar *typename = g_type_name(all_types[i]); __register_php_class(typename, php_midgard_object_class TSRMLS_CC); __add_method_comments(typename); } g_free(all_types); return SUCCESS; } static void __register_abstract_php_classes(const gchar *class_name, zend_class_entry *parent TSRMLS_DC) { zend_class_entry *mgdclass, *mgdclass_ptr; /* lcn is freed in zend_register_internal_class */ gchar *lcn = g_ascii_strdown(class_name, strlen(class_name)); // creating class-template mgdclass = g_new0(zend_class_entry, 1); mgdclass->name = lcn; mgdclass->name_length = strlen(class_name); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 mgdclass->info.internal.builtin_functions = NULL; #else mgdclass->builtin_functions = NULL; #endif mgdclass->constructor = NULL; mgdclass->destructor = NULL; mgdclass->clone = NULL; mgdclass->create_object = NULL; mgdclass->interface_gets_implemented = NULL; mgdclass->__call = NULL; mgdclass->__get = NULL; mgdclass->__set = NULL; mgdclass->parent = parent; mgdclass->num_interfaces = 0; mgdclass->interfaces = NULL; mgdclass->get_iterator = NULL; mgdclass->iterator_funcs.funcs = NULL; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 mgdclass->info.internal.module = NULL; #else mgdclass->module = NULL; #endif mgdclass->ce_flags = 0; /* registering class-template as class * From this class we need nothing but properties, so no need to define * object initialization routine or other ones */ mgdclass_ptr = zend_register_internal_class(mgdclass TSRMLS_CC); mgdclass_ptr->ce_flags = ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; /* Register default properties */ guint n_prop; guint i; GObjectClass *klass = g_type_class_peek (g_type_from_name (class_name)); GParamSpec **pspecs = g_object_class_list_properties (klass, &n_prop); for (i = 0; i < n_prop; i++) { /* By default, register string property */ zend_declare_property_string (mgdclass_ptr, (char*) pspecs[i]->name, strlen (pspecs[i]->name), "", ZEND_ACC_PUBLIC TSRMLS_CC); } g_free(pspecs); // freeing class-template (it is not needed anymore) g_free(mgdclass); } PHP_MINIT_FUNCTION(midgard2_base_abstract) { /* Register MidgardBaseAbstract class */ static zend_class_entry php_midgard_base_abstract_ce; INIT_CLASS_ENTRY(php_midgard_base_abstract_ce, "MidgardBaseAbstract", NULL); php_midgard_base_abstract_class = zend_register_internal_class(&php_midgard_base_abstract_ce TSRMLS_CC); guint n_types, i; GType *all_types = g_type_children(MIDGARD_TYPE_BASE_ABSTRACT, &n_types); for (i = 0; i < n_types; i++) { const gchar *typename = g_type_name(all_types[i]); __register_abstract_php_classes(typename, php_midgard_base_abstract_class TSRMLS_CC); } g_free(all_types); return SUCCESS; } php5-midgard2-10.05.7/midgard.c0000664000175000017500000005222511730073440013631 0ustar pppp/* Copyright (C) 2000 The Midgard Project ry Copyright (C) 2005, 2006, 2007, 2008 Piotr Pokora, This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include "php_midgard.h" #include "php_ini.h" #include "php_midgard_timestamp.h" #include "php_midgard_gobject.h" #include "php_midgard_handle.h" #include "php_midgard__helpers.h" #include #include #include #include #include #include PHPAPI ZEND_DECLARE_MODULE_GLOBALS(midgard2); /* True global resources - no need for thread safety here */ static MidgardSchema *midgard_global_schema = NULL; static zend_class_entry *midgard_metadata_class; zend_class_entry *ce_midgard_error_exception; guint global_loghandler = 0; zend_class_entry *zend_datetime_class_ptr = NULL; zend_class_entry *zend_date_timezone_class_ptr = NULL; gboolean php_midgard_log_enabled = TRUE; zend_object_handlers php_midgard_gobject_handlers; GHashTable *mgdg_config_names = NULL; GHashTable *mgdg_config_files = NULL; /* End of true globals */ /* Every user visible function must have an entry in midgard_functions[]. */ #include "php_midgard_functions.h" zend_function_entry midgard2_functions[] = { PHP_FE(mgd_version, NULL) PHP_FE(mgd_is_guid, NULL) /* Undocumented */ {NULL, NULL, NULL} /* Must be the last line in midgard2_functions[] */ }; void php_midgard_error_exception_force_throw(MidgardConnection *mgd, gint errcode TSRMLS_DC) { midgard_connection_set_error(mgd, errcode); php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } gboolean php_midgard_error_exception_throw(MidgardConnection *mgd TSRMLS_DC) { if (mgd->errnum != MGD_ERR_OK) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, mgd->errstr); return TRUE; } return FALSE; } /* TODO , Check how msg memory (re)allocation works if msg is passed * to php_error already */ void php_midgard_log_errors(const gchar *domain, GLogLevelFlags level, const gchar *msg, gpointer userdata) { MidgardConnection *mgd = (MidgardConnection*) userdata; guint mlevel = G_LOG_LEVEL_WARNING; if (mgd != NULL && MIDGARD_IS_CONNECTION(mgd)) { mlevel = midgard_connection_get_loglevel(mgd); } g_assert(msg != NULL); if (mlevel >= level && mgd != NULL) { midgard_error_default_log(domain, level, msg, MIDGARD_IS_CONNECTION(mgd) ? mgd : NULL); } if (!php_midgard_log_enabled) return; switch (level) { case G_LOG_FLAG_RECURSION: // level_ad = "RECURSION"; break; case G_LOG_FLAG_FATAL: // level_ad = "FATAL! "; break; case G_LOG_LEVEL_ERROR: // level_ad = "ERROR"; php_error(E_ERROR, "GLib: %s", msg); return; break; case G_LOG_LEVEL_CRITICAL: // level_ad = "CRITICAL "; php_error(E_WARNING, "GLib: %s", msg); return; break; case G_LOG_LEVEL_WARNING: // level_ad = "WARNING"; php_error(E_WARNING, "GLib: %s", msg); return; break; case G_LOG_LEVEL_MESSAGE: // level_ad = "MESSAGE"; php_error(E_NOTICE, "GLib: %s", msg); return; break; case G_LOG_LEVEL_INFO: // level_ad = "info"; break; case G_LOG_LEVEL_DEBUG: // level_ad = "DEBUG"; break; default: // level_ad = "Unknown level"; break; } } /* pre-declaring */ static PHP_GINIT_FUNCTION(midgard2); static zend_module_dep midgard2_deps[] = { ZEND_MOD_REQUIRED("date") ZEND_MOD_REQUIRED("spl") {NULL, NULL, NULL} }; zend_module_entry midgard2_module_entry = { STANDARD_MODULE_HEADER_EX, NULL, midgard2_deps, PHP_MIDGARD2_EXTNAME, midgard2_functions, PHP_MINIT(midgard2), PHP_MSHUTDOWN(midgard2), PHP_RINIT(midgard2), PHP_RSHUTDOWN(midgard2), PHP_MINFO(midgard2), PHP_MIDGARD2_EXTVER, /* extension version number (string) */ PHP_MODULE_GLOBALS(midgard2), PHP_GINIT(midgard2), NULL, NULL, STANDARD_MODULE_PROPERTIES_EX }; PHP_INI_BEGIN() STD_PHP_INI_ENTRY("midgard.configuration", "", PHP_INI_SYSTEM, OnUpdateString, midgard_configuration, zend_midgard2_globals, midgard2_globals) STD_PHP_INI_ENTRY("midgard.configuration_file", "", PHP_INI_SYSTEM, OnUpdateString, midgard_configuration_file, zend_midgard2_globals, midgard2_globals) STD_PHP_INI_BOOLEAN("midgard.http", "0", PHP_INI_SYSTEM, OnUpdateBool, midgard_http, zend_midgard2_globals, midgard2_globals) STD_PHP_INI_BOOLEAN("midgard.engine", "1", PHP_INI_ALL, OnUpdateBool, midgard_engine, zend_midgard2_globals, midgard2_globals) STD_PHP_INI_BOOLEAN("midgard.memory_debug", "0", PHP_INI_ALL, OnUpdateBool, midgard_memory_debug, zend_midgard2_globals, midgard2_globals) STD_PHP_INI_BOOLEAN("midgard.superglobals_compat", "0", PHP_INI_SYSTEM, OnUpdateBool, superglobals_compat, zend_midgard2_globals, midgard2_globals) STD_PHP_INI_BOOLEAN("midgard.valgrind_friendly", "0", PHP_INI_SYSTEM, OnUpdateBool, valgrind_friendly, zend_midgard2_globals, midgard2_globals) STD_PHP_INI_BOOLEAN("midgard.glib_loghandler", "0", PHP_INI_SYSTEM, OnUpdateBool, glib_loghandler, zend_midgard2_globals, midgard2_globals) PHP_INI_END() static zend_bool php_midgard_engine_is_enabled(TSRMLS_D) { return MGDG(midgard_engine); } static zend_bool php_midgard_is_http_env(TSRMLS_D) { return MGDG(midgard_http); } /* populates global hash with "file => MidgardConfig" pairs. called from MINIT */ static zend_bool php_midgard_initialize_configs(TSRMLS_D) { if (MGDG(all_configs) != NULL) return TRUE; gchar **files = midgard_config_list_files(FALSE); if (!files) { php_error(E_WARNING, "Didn't find any config file"); return FALSE; } MGDG(all_configs) = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref); guint i = 0; while (files[i] != NULL) { MidgardConfig *config = midgard_config_new(); GError *err = NULL; if (!midgard_config_read_file(config, files[i], FALSE, &err)) { php_error(E_WARNING, "Failed to read %s config file. %s", files[i], err->message ? err->message : ""); g_object_unref(config); return FALSE; } g_hash_table_insert(MGDG(all_configs), g_strdup(files[i]), config); i++; } g_strfreev(files); return TRUE; } static void php_midgard_initialize_schema(TSRMLS_D) { if (midgard_global_schema != NULL) { return; } const char *conf_file = MGDG(midgard_configuration_file); const char *conf_name = MGDG(midgard_configuration); zend_bool initialized = FALSE; gchar *share_dir = NULL; // trying midgard.configuration_file if (conf_file && conf_file[0] != '\0') { MidgardConfig *config = midgard_config_new(); if (midgard_config_read_file_at_path(config, conf_file, NULL)) { share_dir = g_strdup(config->sharedir); if (share_dir) { initialized = TRUE; } } g_object_unref(config); } // trying midgard.configuration if (initialized == FALSE && conf_name && conf_name[0] != '\0') { MidgardConfig *config = midgard_config_new(); if (midgard_config_read_file(config, conf_name, FALSE, NULL)) { share_dir = g_strdup(config->sharedir); if (share_dir) { initialized = TRUE; } } g_object_unref(config); } if (initialized == FALSE) { // init from core-defaults midgard_global_schema = g_object_new(MIDGARD_TYPE_SCHEMA, NULL); midgard_schema_init(midgard_global_schema, NULL); midgard_schema_read_dir(midgard_global_schema, NULL); } else { gchar *path = g_build_path(G_DIR_SEPARATOR_S, share_dir, "MidgardObjects.xml", NULL); midgard_global_schema = g_object_new(MIDGARD_TYPE_SCHEMA, NULL); midgard_schema_init(midgard_global_schema, path); zend_bool success = midgard_schema_read_dir(midgard_global_schema, share_dir); if (FALSE == success) { // FIXME: die in pain } g_free(share_dir); g_free(path); } } PHP_MINIT_FUNCTION(midgard2) { if (zend_get_extension("midgard") != NULL) { php_error(E_ERROR, "Module midgard (1.x) already loaded"); return FAILURE; } if (zend_get_extension(MIDGARD_PACKAGE_NAME) != NULL) { php_error(E_NOTICE, "Module %s already loaded. It's recommended to load it via php.ini", MIDGARD_PACKAGE_NAME); return SUCCESS; } if (PHP_MINIT(midgard2_urlwrapper)(INIT_FUNC_ARGS_PASSTHRU) == FAILURE) { return FAILURE; } global_loghandler = g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK, midgard_error_default_log, NULL); //g_log_set_always_fatal(G_LOG_LEVEL_CRITICAL); //g_log_set_fatal_mask("GLib-GObject", G_LOG_LEVEL_WARNING); /* Get DateTime class pointer and set global */ zend_datetime_class_ptr = php_date_get_date_ce(); zend_date_timezone_class_ptr = php_date_get_timezone_ce(); midgard_init(); REGISTER_INI_ENTRIES(); /* register Gtype types from schemas */ php_midgard_initialize_schema(TSRMLS_C); /* Initialize handlers */ memcpy(&php_midgard_gobject_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); /* Custom handlers hooks */ php_midgard_gobject_handlers.clone_obj = NULL; php_midgard_gobject_handlers.read_property = php_midgard_gobject_read_property; php_midgard_gobject_handlers.get_property_ptr_ptr = php_midgard_gobject_get_property_ptr_ptr; php_midgard_gobject_handlers.write_property = php_midgard_gobject_write_property; php_midgard_gobject_handlers.get_properties = php_midgard_zendobject_get_properties; php_midgard_gobject_handlers.has_property = php_midgard_gobject_has_property; /* Register midgard_exception class */ zend_class_entry ce; INIT_CLASS_ENTRY(ce, "midgard_error_exception", NULL); zend_class_entry *exc_ce = zend_exception_get_default(TSRMLS_C); ce_midgard_error_exception = zend_register_internal_class_ex(&ce, exc_ce, NULL TSRMLS_CC); // Init various classes PHP_MINIT(midgard2_reflection_workaround)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_reflection_property)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_query_builder)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_config)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_blob)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_object_class)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_collector)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_connection)(INIT_FUNC_ARGS_PASSTHRU); if (midgard_dbus_is_enabled()) { PHP_MINIT(midgard2_dbus)(INIT_FUNC_ARGS_PASSTHRU); } PHP_MINIT(midgard2_replicator)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_datetime)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_error)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_transaction)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_storage)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_key_config_context)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_key_config_file_context)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_key_config)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_key_config_file)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_query)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_g_mainloop)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_workspaces)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_base_interface)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_base_abstract)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_object)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_user)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_view)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_reflector_object)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_reflector_property)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_repligard)(INIT_FUNC_ARGS_PASSTHRU); PHP_MINIT(midgard2_query_selectors)(INIT_FUNC_ARGS_PASSTHRU); /* Register midgard_metadata class */ static zend_class_entry midgard_metadata_class_entry; INIT_CLASS_ENTRY(midgard_metadata_class_entry, "MidgardMetadata", NULL); midgard_metadata_class = zend_register_internal_class(&midgard_metadata_class_entry TSRMLS_CC); midgard_metadata_class->create_object = php_midgard_gobject_new; zend_register_class_alias("midgard_metadata", midgard_metadata_class); #define MGD_PHP_REGISTER_CONSTANT(name) \ REGISTER_LONG_CONSTANT(#name, name, CONST_CS | CONST_PERSISTENT) /* Register midgard_user types */ MGD_PHP_REGISTER_CONSTANT(MIDGARD_USER_TYPE_NONE); MGD_PHP_REGISTER_CONSTANT(MIDGARD_USER_TYPE_USER); MGD_PHP_REGISTER_CONSTANT(MIDGARD_USER_TYPE_ADMIN); /* Register properties' midgard types */ MGD_PHP_REGISTER_CONSTANT(MGD_TYPE_NONE); MGD_PHP_REGISTER_CONSTANT(MGD_TYPE_STRING); MGD_PHP_REGISTER_CONSTANT(MGD_TYPE_INT); MGD_PHP_REGISTER_CONSTANT(MGD_TYPE_UINT); MGD_PHP_REGISTER_CONSTANT(MGD_TYPE_FLOAT); MGD_PHP_REGISTER_CONSTANT(MGD_TYPE_BOOLEAN); MGD_PHP_REGISTER_CONSTANT(MGD_TYPE_TIMESTAMP); MGD_PHP_REGISTER_CONSTANT(MGD_TYPE_LONGTEXT); MGD_PHP_REGISTER_CONSTANT(MGD_TYPE_GUID); /* Register errcode constants */ MGD_PHP_REGISTER_CONSTANT(MGD_ERR_OK); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_ERROR); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_ACCESS_DENIED); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_NO_METADATA); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_NOT_OBJECT); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_NOT_EXISTS); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_INVALID_NAME); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_DUPLICATE); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_HAS_DEPENDANTS); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_RANGE); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_NOT_CONNECTED); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_SG_NOTFOUND); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_INVALID_OBJECT); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_QUOTA); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_INTERNAL); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_OBJECT_NAME_EXISTS); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_OBJECT_NO_STORAGE); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_OBJECT_NO_PARENT); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_INVALID_PROPERTY_VALUE); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_INVALID_PROPERTY); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_USER_DATA); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_OBJECT_DELETED); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_OBJECT_PURGED); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_OBJECT_EXPORTED); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_OBJECT_IMPORTED); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_MISSED_DEPENDENCE); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_TREE_IS_CIRCULAR); MGD_PHP_REGISTER_CONSTANT(MGD_ERR_OBJECT_IS_LOCKED); #undef MGD_PHP_REGISTER_CONSTANT if (MGDG(superglobals_compat)) { php_error(E_DEPRECATED, "midgard.superglobals_compat option is deprecated and might be removed in next release"); php_mgd_register_auto_global(_MIDGARD); php_mgd_register_auto_global(_MIDCOM); php_mgd_register_auto_global(_MIDGARD_CONNECTION); } /* midgard.http is on so we populate list of all available configs */ if (php_midgard_is_http_env(TSRMLS_C)) { if (!php_midgard_initialize_configs(TSRMLS_C)) { php_error(E_WARNING, "[Midgard2 minit] Failed to initialize configs"); return FAILURE; } } if (global_loghandler) { g_log_remove_handler(G_LOG_DOMAIN, global_loghandler); global_loghandler = 0; } /* g_log_set_always_fatal(G_LOG_LEVEL_WARNING); g_log_set_fatal_mask("GLib-GObject", G_LOG_LEVEL_WARNING); g_log_set_fatal_mask("GLib", G_LOG_LEVEL_WARNING); g_log_set_fatal_mask("GLib-GObject", G_LOG_LEVEL_CRITICAL); g_log_set_fatal_mask("GLib", G_LOG_LEVEL_CRITICAL); */ php_midgard_log_enabled = TRUE; if (MGDG(glib_loghandler)) { g_log_set_handler("GLib", G_LOG_LEVEL_MASK, php_midgard_log_errors, NULL); g_log_set_handler("GLib-GObject", G_LOG_LEVEL_MASK, php_midgard_log_errors, NULL); } if (MGDG(midgard_memory_debug)) { php_printf("MINIT done (pid = %d)\n", getpid()); } return SUCCESS; } static PHP_GINIT_FUNCTION(midgard2) { midgard2_globals->can_deliver_signals = FALSE; midgard2_globals->connection_established = FALSE; midgard2_globals->all_configs = NULL; midgard2_globals->midgard_global_holder = NULL; } /* static void __free_connections(gpointer key, gpointer val, gpointer ud) { MidgardConnection *cnc = MIDGARD_CONNECTION(val); g_object_unref(cnc); } */ PHP_MSHUTDOWN_FUNCTION(midgard2_urlwrapper); PHP_MSHUTDOWN_FUNCTION(midgard2) { UNREGISTER_INI_ENTRIES(); if (PHP_MSHUTDOWN(midgard2_urlwrapper)(INIT_FUNC_ARGS_PASSTHRU) == FAILURE) { return FAILURE; } // next line is a hack. we do not free resources return SUCCESS; /* Free schema */ if (midgard_global_schema != NULL) { g_object_unref(midgard_global_schema); midgard_global_schema = NULL; } /* Free connections */ php_midgard_handle_holder_free(&MGDG(midgard_global_holder)); /* if (all_configs != NULL) { g_hash_table_foreach(all_configs, __free_connections, NULL); } else { MidgardConnection *mgd = mgd_handle(TSRMLS_C); if (mgd != NULL) g_object_unref(mgd); }*/ return SUCCESS; } PHP_RINIT_FUNCTION(midgard2) { if (!php_midgard_engine_is_enabled(TSRMLS_C)) return FAILURE; if (MGDG(midgard_memory_debug)) { php_printf("RINIT\n"); } if (php_midgard_is_http_env(TSRMLS_C)) { /* all_configs is set during MINIT */ if (MGDG(all_configs) == NULL) { php_error(E_ERROR, "[Midgard2 rinit] Can not handle request without midgard connection"); return FAILURE; } // preinitialization of connection (in the future it won't be needed) zval *instance; zend_call_method_with_0_params(NULL, php_midgard_connection_class, NULL, "get_instance", &instance); if (MGDG(midgard_memory_debug)) { php_printf("---> got connection: %p, refcount=%d\n", instance, Z_REFCOUNT_P(instance)); } #if PHP_MAJOR_VERSION > 5 || PHP_MINOR_VERSION >= 3 // 5.2 doesn't add reference, no need to take it away zval_ptr_dtor(&instance); #endif } if (MGDG(connection_established) == FALSE) { global_loghandler = g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK, midgard_error_default_log, NULL); if (MGDG(midgard_memory_debug)) { php_printf("---> g_log_set_handler() => %d\n", global_loghandler); } } /* Initialize closure hash */ php_midgard_gobject_closure_hash_new(); if (MGDG(midgard_memory_debug)) { php_printf("<= RINIT\n"); } MGDG(can_deliver_signals) = 1; return SUCCESS; } PHP_RSHUTDOWN_FUNCTION(midgard2) { MGDG(can_deliver_signals) = 0; if (MGDG(midgard_memory_debug)) { php_printf("RSHUTDOWN\n"); } if (global_loghandler) { // connection's destructor is not called, if exception happened // we need to enforce logging-destructor in this case if (MGDG(midgard_memory_debug)) { php_printf("---> g_log_remove_handler(..., %d)\n", global_loghandler); } g_log_remove_handler(G_LOG_DOMAIN, global_loghandler); global_loghandler = 0; if (mgd_handle(TSRMLS_C)) midgard_connection_set_loghandler (mgd_handle(TSRMLS_C), 0); } /* Free all closures * We can not keep them persistant as all data changes per request. */ if (MGDG(midgard_memory_debug)) { php_printf("---> php_midgard_gobject_closure_hash_free()\n"); } php_midgard_gobject_closure_hash_free(); if (MGDG(valgrind_friendly)) { /* It's not safe, but allow valgrind to print function names. * It simply forces Zend to not unload midgard module */ zend_module_entry *module; int rv = zend_hash_find(&module_registry, MIDGARD_PACKAGE_NAME, strlen(MIDGARD_PACKAGE_NAME) + 1, (void**)&module); if (rv == SUCCESS) { module->handle = 0; } } if (MGDG(midgard_memory_debug)) { php_printf("<= RSHUTDOWN\n"); } return SUCCESS; } PHP_MINFO_FUNCTION(midgard2) { size_t i = 0; /* first block */ php_info_print_table_start(); php_info_print_table_header(2, "Midgard2 Support", "enabled"); php_info_print_table_row(2, "Midgard2 version", midgard_version()); while (midgard2_module_entry.functions[i].fname) { php_info_print_table_row(2, "", midgard2_module_entry.functions[i].fname); i++; } php_info_print_table_end(); /* second block */ php_info_print_table_start(); php_info_print_table_header(2, "MgdSchema technology support", "enabled"); php_info_print_table_row(2, "Midgard2 version", midgard_version()); php_info_print_table_end(); /* third block */ /* TODO: we shouldn't output HTML in CLI-mode */ php_info_print_box_start(0); PUTS("

"); PUTS("The Midgard Project

\n"); php_printf("This program makes use of the Midgard Content Management engine:
"); php_printf("© 1998-2001 The Midgard Project Ry
\n"); php_printf("© 2002-2009 The Midgard Community
\n"); php_info_print_box_end(); /* ini-settings block */ DISPLAY_INI_ENTRIES(); } /* Fetch static globals. Unfortunately these need to be here since the module globals are declared static by the Zend macros */ MidgardConnection *mgd_handle(TSRMLS_D) { zval *instance; if (!php_midgard_is_connected()) return NULL; zend_call_method_with_0_params(NULL, php_midgard_connection_class, NULL, "get_instance", &instance); MidgardConnection *connection = __midgard_connection_get_ptr(instance); #if PHP_MAJOR_VERSION > 5 || PHP_MINOR_VERSION >= 3 // 5.2 doesn't add reference, no need to take it away zval_ptr_dtor(&instance); #endif return connection; } ZEND_GET_MODULE(midgard2) /* * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: */ php5-midgard2-10.05.7/php_midgard_key_config_file.c0000664000175000017500000000540511730073440017672 0ustar pppp/* * Copyright (C) 2009 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" #include static zend_class_entry *php_midgard_key_config_file_class; /* Object constructor */ static PHP_METHOD(midgard_key_config_file, __construct) { RETVAL_FALSE; zval *object = getThis(); char *path; int path_length; zval *ctx_object; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "os", &ctx_object, &path, &path_length) == FAILURE) return; GError *error = NULL; MidgardKeyConfigFileContext *mkcf_ctx = (MidgardKeyConfigFileContext *) __php_gobject_ptr(ctx_object); MidgardKeyConfigFile *mkcf = midgard_key_config_file_new(mkcf_ctx, path, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, error && error->message ? error->message : "Unknown reason"); g_clear_error (&error); return; } MGD_PHP_SET_GOBJECT(object, mkcf); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_key_config_file___construct, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, context_object, midgard_key_config_file_context, 0) ZEND_ARG_INFO(0, path) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_key_config_file) { static zend_function_entry midgard_key_config_file_methods[] = { PHP_ME(midgard_key_config_file, __construct, arginfo_midgard_key_config_file___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_key_config_file_class_entry; INIT_CLASS_ENTRY(php_midgard_key_config_file_class_entry, "MidgardKeyConfigFile", midgard_key_config_file_methods); php_midgard_key_config_file_class = zend_register_internal_class_ex(&php_midgard_key_config_file_class_entry, NULL, "midgard_key_config" TSRMLS_CC); CLASS_SET_DOC_COMMENT(php_midgard_key_config_file_class, strdup("File based key-value (ini like) configurations")); php_midgard_key_config_file_class->create_object = php_midgard_gobject_new; zend_register_class_alias("midgard_key_config_file", php_midgard_key_config_file_class); return SUCCESS; } php5-midgard2-10.05.7/ChangeLog0000664000175000017500000001355711730073440013635 0ustar pppp2002-05-17 12:56 torben * Switched default back to Non-MMP, so that the automatically built packages work. This can be reversed if MMP works finally. 2002-05-02 15:08 torben * Backported the new PHP UDF Functions from MMP to non-MMP non-MMP now uses the same set of functions * During this I've explicitly removed all the old udf-functions from the php4 module 2001-01-30 10:07 emile * MidgardClassWhatever renamed to MidgardWhatever 2001-01-26 02:09 david * httpd.error_log.tgz: this is the httpd error_log associated with the backtrace (see bt.txt). 2001-01-26 02:05 david * bt.txt: backtrace of an Asgard request (running out of memory). 2001-01-26 02:04 david * preparser-parser.y, preparser-scanner.l, preparser.c: debug version. Lots of log, in httpd error_log and in the browser. 2001-01-25 18:25 david * preparser-parser.y, preparser-scanner.l, preparser.c: oops, forgot default rule when in eval'ed quoted strings... 2001-01-25 15:18 david * article.c: removed some useless logging in mgd_get_article. 2001-01-25 15:15 david * Makefile.in, access.c, article.c, attachment.c, config.m4, element.c, host.c, mgd_access.h, midgard.c, page.c, pageelement.c, pagelink.c, preparser.c, style.c, topic.c: Eliminated the warnings at compile, and cleaned the code. 2001-01-25 04:38 david * ab_config.m4, ab_mgd_preparser.h, ab_preparser-parser.y, ab_preparser-scanner.l, ab_preparser.c, config.m4, mgd_preparser.h, mkall, preparser-parser.y, preparser-scanner.l, preparser.c: added Alexander's memory management modifications. changed the lexer to be more readable (easier to debug). Status: old admin and VMUC still working, Asgard has the same problem 2001-01-24 21:45 david * preparser-parser.y, preparser-scanner.l, preparser.c: Syncing. Asgard still crashing on form-template snippet but this is not a mgd_include_snippet problem 2001-01-24 20:46 david * parameter.c, snippet.c: little bug on parameters oop members. 2001-01-24 20:01 ab * ab_mgd_preparser.h: Example site now works with dynamic memory management. Old Admin site has problems with authentication (?) 2001-01-24 19:22 david * test-db.tar.gz: My test DB, Asgard was modified in order to fix some PHP3/PHP4 incompatibilities so everybody can test it. 2001-01-24 19:09 david * mgd_preparser.h, midgard.c, preparser-parser.y, preparser-scanner.l, preparser.c: Preparser modifications, Asgard is working almost fine, I'm on the way... 2001-01-24 12:05 david * preparser-parser.y, preparser.c: just syncing... added the call to zend_eval_string that seems to work on the snippets... need to implement it in variables and template elements. 2001-01-24 02:24 david * ab_config.m4, ab_mgd_preparser.h, ab_preparser-parser.y, ab_preparser-scanner.l, ab_preparser.c, php_midgard.h: Alexander's patch to the memory management in the preparser. Doesn't work yet. 2001-01-23 21:12 david * BUGS, mgd_preparser.h, preparser-parser.y, preparser-scanner.l, preparser.c: Fixed the variable handling, the VMUC example site now runs fine. 2001-01-23 18:51 david * mgd_oop.h, midgard.c, preparser-parser.y, preparser.c: little fix on snippets, MidgardClassSitegroup fix from marius and misc sync. 2001-01-23 15:47 david * host.c, parameter.c, preparser-parser.y, preparser.c, sitegroup.c, snippet.c, snippetdir.c: Several bugs on php3/Zend differences fixed. 2001-01-23 11:34 david * preparser-parser.y, preparser-scanner.l, preparser.c: Modification on mgd_include_snippet handling in the preparser. 2001-01-23 10:36 david * preparser-scanner.l, preparser.c: Fixed snippet bug, doesn't work with Asgard yet though (something like snippet too big). 2001-01-23 09:48 david * BUGS, oop.c: Bug on object instanciating fixed. Now the old admin work !!! 2001-01-23 09:09 david * BUGS: Known bugs updated. 2001-01-23 03:13 david * article.c, attachment.c, mgd_oop.h, midgard.c, oop.c, parameter.c, preparser-scanner.l, sitegroup.c, topic.c: some more bug fixing and code cleaning. 2001-01-23 00:39 david * mgd_internal.h: fixing differences between different Zend API versions (at least between php-4.0.4-1.src.rpm and the current zend CVS) 2001-01-22 19:55 david * mgd_internal.h, preparser.c: fixed a bug with variable as array 2001-01-22 19:11 david * BUGS, access.c, article.c, element.c, event.c, group.c, host.c, mgd_internal.h, mgd_preparser.h, oop.c, pagelink.c, person.c, preparser-scanner.l, preparser.c, sitegroup.c, snippetdir.c, topic.c: corrected a lot of (maybe) harmful warnings. added the file BUGS 2001-01-22 16:15 david * Makefile.in, config.m4, mgd_internal.h, preparser-parser.y, preparser.c: one of the reasons it segfaults fixed. it still segfaults on the old admin... 2001-01-22 02:15 david * mgd_internal.h, mgd_preparser.h, preparser-scanner.l, preparser.c: Some work done on memory management in the preparser. 2001-01-21 21:01 david * midgard-root.php: midgard-root.php used instead of midgard-root.php3 2001-01-21 20:51 david * .cvsignore, Makefile.in, access.c, article.c, attachment.c, calendar.c, config.m4, element.c, event.c, eventmember.c, file.c, fudge, genentry.pl, group.c, host.c, image.c, mail.c, member.c, mgd_access.h, mgd_article.h, mgd_attachment.h, mgd_calendar.h, mgd_element.h, mgd_errno.c, mgd_errno.h, mgd_errno.pl, mgd_event.h, mgd_eventmember.h, mgd_file.h, mgd_group.h, mgd_host.h, mgd_image.h, mgd_internal.h, mgd_mail.h, mgd_member.h, mgd_midgard.h, mgd_oop.h, mgd_page.h, mgd_pageelement.h, mgd_pagelink.h, mgd_person.h, mgd_preferences.h, mgd_preparser.h, mgd_sitegroup.h, mgd_snippet.h, mgd_snippetdir.h, mgd_style.h, mgd_topic.h, midgard.c, mkall, oop.c, page.c, pageelement.c, pagelink.c, parameter.c, person.c, php_midgard.h, preferences.c, preparser-parser.y, preparser-scanner.l, preparser.c, sitegroup.c, snippet.c, snippetdir.c, style.c, topic.c: PHP4+preparser self contained module source. php5-midgard2-10.05.7/php_midgard_gobject_generic.c0000664000175000017500000007612311730073440017674 0ustar pppp/* Copyright (C) 2007 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard_gobject_closures.h" #include #include #include #include "php_midgard_timestamp.h" #include "php_midgard__helpers.h" #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2 #define Z_OBJ_P(zval_p) \ ((zend_object*)(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(zval_p)].bucket.obj.object)) #endif /* GVALUE ROUTINES */ static zend_bool php_midgard_gvalue_from_zval(const zval *zvalue, GValue *gvalue TSRMLS_DC) { g_assert(zvalue != NULL); if (MGDG(midgard_memory_debug)) { printf("php_midgard_gvalue_from_zval(z=%p [refcount=%d], g=%p)\n", zvalue, Z_REFCOUNT_P((zval *)zvalue), gvalue); } HashTable *zhash; GValueArray *array; zval **value; HashPosition iterator; GValue *tmpval; zval*date_zval; gchar *lstring; switch (Z_TYPE_P(zvalue)) { case IS_ARRAY: zhash = Z_ARRVAL_P(zvalue); array = g_value_array_new(zend_hash_num_elements(zhash)); zend_hash_internal_pointer_reset_ex(zhash, &iterator); while (zend_hash_get_current_data_ex( zhash, (void **)&value, &iterator) == SUCCESS) { tmpval = php_midgard_zval2gvalue(*value TSRMLS_CC); g_value_array_append(array, tmpval); g_value_unset(tmpval); g_free(tmpval); zend_hash_move_forward_ex(zhash, &iterator); } g_value_init(gvalue, G_TYPE_VALUE_ARRAY); g_value_take_boxed(gvalue, array); break; case IS_BOOL: g_value_init(gvalue, G_TYPE_BOOLEAN); g_value_set_boolean(gvalue, Z_BVAL_P(zvalue)); break; case IS_LONG: g_value_init(gvalue, G_TYPE_INT); g_value_set_int(gvalue, Z_LVAL_P(zvalue)); break; case IS_DOUBLE: g_value_init(gvalue, G_TYPE_FLOAT); lstring = setlocale(LC_NUMERIC, "0"); setlocale(LC_NUMERIC, "C"); g_value_set_float(gvalue, (gfloat)Z_DVAL_P(zvalue)); setlocale(LC_ALL, lstring); break; case IS_STRING: g_value_init(gvalue, G_TYPE_STRING); g_value_set_string(gvalue, Z_STRVAL_P(zvalue)); break; case IS_OBJECT: /* DateTime object, convert to string value */ if (Z_OBJCE_P(zvalue) == zend_datetime_class_ptr || Z_OBJCE_P(zvalue)->parent == zend_datetime_class_ptr) { date_zval = php_midgard_datetime_get_timestamp(zvalue TSRMLS_CC); GValue str_val = {0, }; g_value_init(&str_val, G_TYPE_STRING); g_value_set_string(&str_val, Z_STRVAL_P(date_zval)); g_value_init(gvalue, MGD_TYPE_TIMESTAMP); g_value_transform(&str_val, gvalue); g_value_unset(&str_val); zval_dtor(date_zval); } else { php_midgard_gobject *php_gobject = __php_objstore_object(zvalue); if (php_gobject && php_gobject->magic == PHP_MIDGARD_GOBJ_MAGIC && php_gobject->gobject) { g_value_init(gvalue, G_TYPE_OBJECT); g_value_set_object(gvalue, php_gobject->gobject); } else { // NOT GOBJECT. Don't know what to do with it return FALSE; } } break; case IS_RESOURCE: /* There's no way to handle resource gracefully */ php_error(E_WARNING, "Got resource variable. Can not convert to glib-type"); return FALSE; break; case IS_NULL: /* FIXME, we can not fallback to string type */ g_value_init(gvalue, G_TYPE_STRING); g_value_set_string(gvalue, ""); break; default: php_error(E_WARNING, "Got variable of unknown type. Can not convert to glib-type"); return FALSE; } return TRUE; } GValue *php_midgard_zval2gvalue(const zval *zvalue TSRMLS_DC) { g_assert(zvalue != NULL); GValue *gvalue = g_new0(GValue, 1); if (!php_midgard_gvalue_from_zval(zvalue, gvalue TSRMLS_CC)) { g_free(gvalue); return NULL; } return gvalue; } zend_bool php_midgard_gvalue2zval(const GValue *gvalue, zval *zvalue TSRMLS_DC) { g_assert(gvalue); g_assert(zvalue); gchar *tmpstr; double f, dpval, tmp_val; GValueArray *array; GValue *arr_val; zval *zarr_val; /* Generic GValue */ GType g_gtype = G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(gvalue)); switch (g_gtype) { case G_TYPE_STRING: tmpstr = (gchar *)g_value_get_string(gvalue); if (!tmpstr) tmpstr = ""; ZVAL_STRING(zvalue, tmpstr, 1); return TRUE; break; case G_TYPE_INT: ZVAL_LONG(zvalue, g_value_get_int(gvalue)); return TRUE; break; case G_TYPE_UINT: ZVAL_LONG(zvalue, g_value_get_uint(gvalue)); return TRUE; break; case G_TYPE_BOOLEAN: ZVAL_BOOL(zvalue, g_value_get_boolean(gvalue)); return TRUE; break; case G_TYPE_DOUBLE: /* I follow code from PHP_ROUND_WITH_FUZZ macro. * If You find better way to add double property value, * fell free to change this code. We do not have to worry * about locale settings at this point ( I hope so ) */ dpval = g_value_get_double(gvalue); tmp_val = dpval; f = pow(10.0, (double) 6); tmp_val *= f; if (tmp_val >= 0.0) { tmp_val = floor(tmp_val + 0.50000000001); } else { tmp_val = ceil(tmp_val - 0.50000000001); } tmp_val /= f; dpval = !zend_isnan(tmp_val) ? tmp_val : dpval; ZVAL_DOUBLE(zvalue, dpval); return TRUE; break; case G_TYPE_FLOAT: /* I follow code from PHP_ROUND_WITH_FUZZ macro. * If You find better way to add double property value, * fell free to change this code. We do not have to worry * about locale settings at this point ( I hope so ) */ dpval = (gdouble)g_value_get_float(gvalue); tmp_val = dpval; f = pow(10.0, (double) 6); tmp_val *= f; if (tmp_val >= 0.0) { tmp_val = floor(tmp_val + 0.50000000001); } else { tmp_val = ceil(tmp_val - 0.50000000001); } tmp_val /= f; dpval = !zend_isnan(tmp_val) ? tmp_val : dpval; ZVAL_DOUBLE(zvalue, dpval); return TRUE; break; case G_TYPE_OBJECT: case G_TYPE_INTERFACE: { GObject *gobject_property = g_value_get_object(gvalue); if (gobject_property) { const gchar *gclass_name = G_OBJECT_TYPE_NAME(gobject_property); if (!gclass_name) return FALSE; g_object_ref(gobject_property); php_midgard_gobject_init(zvalue, gclass_name, gobject_property, TRUE TSRMLS_CC); if (MGDG(midgard_memory_debug)) { printf("php_midgard_gvalue2zval: [%p] refcount=%d, gobj=%p, glib refcount=%d\n", zvalue, Z_REFCOUNT_P(zvalue), gobject_property, gobject_property->ref_count); } return TRUE; } else { ZVAL_NULL(zvalue); /* TODO, implement this, currently we do not * handle such case */ /*zvalue->value.obj = php_midgard_gobject_new(*ce TSRMLS_CC); //zend_objects_new(&zobject, *ce TSRMLS_CC); Z_OBJ_HT_P(zvalue) = &php_midgard_gobject_handlers; zend_object_std_init(zobject, *ce TSRMLS_CC); */ } } break; case G_TYPE_BOXED: if (G_VALUE_TYPE(gvalue) == G_TYPE_VALUE_ARRAY) { array_init(zvalue); array = (GValueArray *) g_value_get_boxed(gvalue); if (array == NULL) return TRUE; guint i; for (i = 0; i < array->n_values; i++) { arr_val = g_value_array_get_nth(array, i); MAKE_STD_ZVAL(zarr_val); php_midgard_gvalue2zval(arr_val, zarr_val TSRMLS_CC); add_index_zval(zvalue, i, zarr_val); } } if (G_VALUE_TYPE(gvalue) == MGD_TYPE_TIMESTAMP) { php_midgard_datetime_from_gvalue(gvalue, zvalue TSRMLS_CC); return TRUE; } break; default: php_error(E_WARNING, "Don't know how to handle '%s' type. returning NULL instead", g_type_name(g_gtype)); ZVAL_NULL(zvalue); break; } return FALSE; } /* OBJECTS ROUTINES */ /* check if there is glib-property of object linked to zval */ #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 int php_midgard_gobject_has_property(zval *zobject, zval *prop, int check_type, const zend_literal *key TSRMLS_DC) #else int php_midgard_gobject_has_property(zval *zobject, zval *prop, int check_type TSRMLS_DC) #endif { php_midgard_gobject *php_gobject = __php_objstore_object(zobject); char *prop_name = Z_STRVAL_P(prop); if (prop_name == NULL) { php_error(E_WARNING, "Can not check property with NULL name"); return 0; } if (g_str_equal(prop_name, "")) { php_error(E_WARNING, "Can not check property with empty name"); return 0; } if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_gobject_has_property(%s, check_type=%d). object's refcount=%d\n", zobject, prop_name, check_type, Z_REFCOUNT_P(zobject)); printf("[%p] ----> gobject: %p, ref_count = %d\n", zobject, php_gobject, php_gobject->gobject->ref_count); } GObjectClass *klass = G_OBJECT_GET_CLASS(php_gobject->gobject); GParamSpec *pspec = g_object_class_find_property(klass, prop_name); int result = -1; if (check_type == 2) { // key exists, value is not important if (pspec != NULL) { return TRUE; } } else { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 zval *value = php_midgard_gobject_read_property(zobject, prop, BP_VAR_IS, key TSRMLS_CC); #else zval *value = php_midgard_gobject_read_property(zobject, prop, BP_VAR_IS TSRMLS_CC); #endif Z_ADDREF_P(value); if (MGDG(midgard_memory_debug)) { printf("[%p] ----> property: %p, ref_count = %d\n", zobject, value, Z_REFCOUNT_P(value)); } if (check_type == 0) { // value is not null result = (Z_TYPE_P(value) != IS_NULL); } else { // value can be casted to TRUE result = zend_is_true(value); } zval_ptr_dtor(&value); } if (-1 == result) { zend_object *zobj = Z_OBJ_P(zobject); zend_object_handlers *std_hnd = zend_get_std_object_handlers(); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 if (zobj->properties != NULL && zobj->properties_table != NULL) { result = std_hnd->has_property(zobject, prop, check_type, key TSRMLS_CC); } else { return 0; } #else result = std_hnd->has_property(zobject, prop, check_type TSRMLS_CC); #endif } return result; } /* Read Zend object property using underlying GObject's one */ #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 zval *php_midgard_gobject_read_property(zval *zobject, zval *prop, int type, const zend_literal *key TSRMLS_DC) #else zval *php_midgard_gobject_read_property(zval *zobject, zval *prop, int type TSRMLS_DC) #endif { zval *_retval = NULL; gboolean is_native_property = FALSE; GParamSpec *pspec = NULL; GObjectClass *klass = NULL; int silent = (type == BP_VAR_IS); const gchar *propname = Z_STRVAL_P(prop); int proplen = Z_STRLEN_P(prop) + 1; if (propname == NULL || *propname == '\0') php_error(E_ERROR, "Can not read empty property name"); if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_gobject_read_property(%s)\n", zobject, propname); } GObject *gobject = __php_gobject_ptr(zobject); if (gobject && Z_STRVAL_P(prop) != NULL) { klass = G_OBJECT_GET_CLASS(gobject); /* Find GObject property */ if (G_IS_OBJECT_CLASS(klass)) { pspec = g_object_class_find_property(klass, propname); if (pspec != NULL) { is_native_property = TRUE; if (!(pspec->flags & G_PARAM_READABLE)) { MAKE_STD_ZVAL(_retval); ZVAL_NULL(_retval); Z_DELREF_P(_retval); // we don't have local reference, so need to decrement refcount return _retval; } } } } /* If found, get property's gvalue. Create zval from it and return */ if (is_native_property) { gboolean is_datetime_property = FALSE; if (MIDGARD_IS_DBOBJECT_CLASS(klass)) { is_datetime_property = php_midgard_is_property_timestamp(MIDGARD_DBOBJECT_CLASS(klass), propname); } GType prop_type = G_PARAM_SPEC_VALUE_TYPE(pspec); if (is_datetime_property) { /* Datetime property. $obj->metadata->created for example. */ if (MGDG(midgard_memory_debug)) { php_printf("==========> DateTime\n"); } _retval = php_midgard_datetime_object_from_property(zobject, propname TSRMLS_CC); Z_DELREF_P(_retval); //remove extra reference if (MGDG(midgard_memory_debug)) { printf("[%p] property's tmp-var refcount: %d [%s]\n", zobject, Z_REFCOUNT_P(_retval), propname); } } else if (G_TYPE_IS_OBJECT(prop_type) || G_TYPE_IS_INTERFACE(prop_type)) { /* Property of object type. $obj->metadata for example. */ if (MGDG(midgard_memory_debug)) { php_printf("==========> G_TYPE_OBJECT\n"); } zval **property; int hf_ret = zend_hash_find(Z_OBJPROP_P(zobject), propname, proplen, (void **) &property); if (hf_ret == SUCCESS) { _retval = *property; // zval_add_ref(property); if (MGDG(midgard_memory_debug)) { printf("==========> found\n"); printf("==========> property's tmp-var refcount: %d [%s]\n", Z_REFCOUNT_P(_retval), propname); GObject *gobj = __php_gobject_ptr(_retval); printf("==========> property's gobject: %p [refcount: %d]\n", gobj, gobj->ref_count); } } else { if (MGDG(midgard_memory_debug)) { php_printf("==========> NOT found\n"); } MAKE_STD_ZVAL(_retval); ZVAL_NULL(_retval); Z_DELREF_P(_retval); // we don't have local reference, so need to decrement refcount return _retval; } } else { /* Property of generic type. String, int, float, etc */ if (MGDG(midgard_memory_debug)) { php_printf("==========> scalar\n"); } GValue pval = {0, }; g_value_init(&pval, pspec->value_type); g_object_get_property(gobject, propname, &pval); MAKE_STD_ZVAL(_retval); php_midgard_gvalue2zval(&pval, _retval TSRMLS_CC); Z_DELREF_P(_retval); // we don't have local reference, so need to decrement refcount g_value_unset(&pval); if (MGDG(midgard_memory_debug)) { printf("[%p] property's tmp-var refcount: %d [%s]\n", zobject, Z_REFCOUNT_P(_retval), propname); } } /* Fallback to zend. */ } else { /* Property is not found. Fallback to zend's property handler * Piotras: I have no idea what type should be passed instead * of BP_VAR_NA. The point is to throw warning when property * is not registered for (sub)class. */ zend_object_handlers *std_hnd = zend_get_std_object_handlers(); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 _retval = std_hnd->read_property(zobject, prop, silent ? BP_VAR_IS : BP_VAR_NA, key TSRMLS_CC); #else _retval = std_hnd->read_property(zobject, prop, silent ? BP_VAR_IS : BP_VAR_NA TSRMLS_CC); #endif } return _retval; } #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 zval **php_midgard_gobject_get_property_ptr_ptr(zval *object, zval *member, const zend_literal *key TSRMLS_DC) #else zval **php_midgard_gobject_get_property_ptr_ptr(zval *object, zval *member TSRMLS_DC) #endif { if (MGDG(midgard_memory_debug)) { const gchar *propname = Z_STRVAL_P(member); printf("[%p] php_midgard_gobject_get_property_ptr_ptr(%s)\n", object, propname); } // we don't want to provide direct access to underlying properties return NULL; } /* convert zval to type described by glib-type */ static void _convert_value(zval *value, GType vtype) { switch (vtype) { case G_TYPE_STRING: if (Z_TYPE_P(value) != IS_STRING) convert_to_string(value); break; case G_TYPE_UINT: case G_TYPE_INT: if (Z_TYPE_P(value) != IS_LONG) convert_to_long(value); break; case G_TYPE_BOOLEAN: if (Z_TYPE_P(value) != IS_BOOL) convert_to_boolean(value); break; case G_TYPE_FLOAT: case G_TYPE_DOUBLE: if (Z_TYPE_P(value) != IS_DOUBLE) convert_to_double(value); break; case G_TYPE_OBJECT: if (Z_TYPE_P(value) == IS_NULL) return; //if (Z_TYPE_P(value) != IS_OBJECT) // convert_to_object(value); break; } return; } #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 void php_midgard_gobject_write_property(zval *zobject, zval *prop, zval *value, const zend_literal *key TSRMLS_DC) #else void php_midgard_gobject_write_property(zval *zobject, zval *prop, zval *value TSRMLS_DC) #endif { if (MGDG(midgard_memory_debug)) { const gchar *propname = Z_STRVAL_P(prop); printf("[%p] php_midgard_gobject_write_property(%s)\n", zobject, propname); } GObject *gobject = __php_gobject_ptr(zobject); /* Find GObject property */ GParamSpec *pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(gobject), Z_STRVAL_P(prop)); /* If found, set property's gvalue.*/ if (pspec) { /* Property type might be initialized with IS_STRING or unset type. * Check property's type and convert if needed. */ _convert_value(value, pspec->value_type); GValue *gvalue = php_midgard_zval2gvalue(value TSRMLS_CC); if (gvalue) { /* Transform int to uint */ if (pspec->value_type == G_TYPE_UINT && G_VALUE_HOLDS_INT (gvalue)) { GValue uintval = {0, }; g_value_init (&uintval, G_TYPE_UINT); g_value_transform ((const GValue *) gvalue, &uintval); g_object_set_property (gobject, Z_STRVAL_P (prop), &uintval); g_value_unset (&uintval); } else { g_object_set_property(gobject, Z_STRVAL_P(prop), gvalue); } if (Z_TYPE_P(value) != IS_OBJECT) { g_value_unset(gvalue); } g_free(gvalue); } } else { /* Fallback to zend */ #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 //std_hnd->write_property(zobject, prop, value, 1 TSRMLS_CC); #else zend_object_handlers *std_hnd = zend_get_std_object_handlers(); std_hnd->write_property(zobject, prop, value TSRMLS_CC); #endif } return; } void php_midgard_gobject_unset_property(zval *object, zval *member TSRMLS_DC) { zend_class_entry *ce = Z_OBJCE_P(object); SEPARATE_ARG_IF_REF(member); zend_call_method_with_1_params(&object, ce, &ce->__unset, ZEND_UNSET_FUNC_NAME, NULL, member); zval_ptr_dtor(&member); } /* Get object's properties */ HashTable *php_midgard_zendobject_get_properties(zval *zobject TSRMLS_DC) { if (zobject == NULL) return NULL; php_midgard_gobject *php_gobject = __php_objstore_object(zobject); if (!G_IS_OBJECT(php_gobject->gobject)) php_error(E_ERROR, "Underlying object is not GObject"); if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_zendobject_get_properties(%s)\n", zobject, Z_OBJCE_P(zobject)->name); printf("[%p] ----> gobject: %p, ref_count = %d\n", zobject, php_gobject->gobject, php_gobject->gobject->ref_count); } GObject *gobject = php_gobject->gobject; guint propn, i; GParamSpec **props = g_object_class_list_properties(G_OBJECT_GET_CLASS(gobject), &propn); for (i = 0; i < propn; i++) { if (props[i]->flags & G_PARAM_CONSTRUCT_ONLY) { continue; } if (!(props[i]->flags & G_PARAM_READABLE)) { // not readable continue; } if (php_gobject->has_properties) { if (G_TYPE_IS_OBJECT(props[i]->value_type) || G_TYPE_IS_INTERFACE(props[i]->value_type)) { // do not reinit objects continue; } if (props[i]->value_type == MGD_TYPE_TIMESTAMP) { // do not reinit datetime objects (to keep var_dump() happy) continue; } } GValue pval = {0, }; g_value_init(&pval, props[i]->value_type); g_object_get_property(gobject, (gchar*)props[i]->name, &pval); zval *tmp; if (props[i]->value_type == MGD_TYPE_TIMESTAMP) { // link it to object tmp = php_midgard_datetime_object_from_property(zobject, props[i]->name TSRMLS_CC); } else { MAKE_STD_ZVAL(tmp); php_midgard_gvalue2zval(&pval, tmp TSRMLS_CC); } zend_hash_update(php_gobject->zo.properties, props[i]->name, strlen(props[i]->name)+1, (void *)&tmp, sizeof(zval *), NULL); g_value_unset(&pval); } g_free(props); if (MGDG(midgard_memory_debug)) { printf("[%p] <= php_midgard_zendobject_get_properties()\n", zobject); } php_gobject->has_properties = TRUE; return php_gobject->zo.properties; } static void __object_properties_dtor(zend_object *zo TSRMLS_DC) { HashPosition iterator; zval **zvalue = NULL; HashTable *props = zo->properties; if (MGDG(midgard_memory_debug)) { printf("[%p] __object_properties_dtor()\n", zo); } zend_hash_internal_pointer_reset_ex(props, &iterator); while (zend_hash_get_current_data_ex(props, (void **)&zvalue, &iterator) == SUCCESS) { char *str_index; uint str_len; ulong num_index; zend_hash_get_current_key_ex(props, &str_index, &str_len, &num_index, 0, &iterator); if (MGDG(midgard_memory_debug)) { printf("[%p] property's [%p] refcount: %d (before) [%s]\n", zo, *zvalue, Z_REFCOUNT_P(*zvalue), str_index); } zend_hash_del(props, str_index, str_len); // first element was deleted, need to start over zend_hash_internal_pointer_reset_ex(props, &iterator); } if (MGDG(midgard_memory_debug)) { printf("[%p] <= __object_properties_dtor()\n", zo); } } /* Object destructor */ static void __php_midgard_gobject_dtor(void *object TSRMLS_DC) { if (!object) return; php_midgard_gobject *php_gobject = (php_midgard_gobject *) object; if (MGDG(midgard_memory_debug)) { zend_class_entry *obj_ce = php_gobject->zo.ce; printf("[%p] __php_midgard_gobject_dtor(%s)\n", php_gobject, obj_ce->name); } if (&php_gobject->zo == NULL) return; if (php_gobject->gobject == NULL) { /* This may be disabled, it's just for debugging purpose */ /* php_error(E_NOTICE, "__php_midgard_gobject_dtor. Underlying GObject is NULL"); */ } else if (G_IS_OBJECT(php_gobject->gobject)) { if (MGDG(midgard_memory_debug)) { printf("[%p] =========> G_IS_OBJECT\n", object); } if (G_OBJECT_TYPE_NAME(php_gobject->gobject) != NULL) { if (MGDG(midgard_memory_debug)) { printf("[%p] =========> ..._TYPE_NAME != NULL\n", object); } if (MGDG(midgard_memory_debug)) { printf("[%p] =========> gobject's refcount = %d (before unref)\n", object, php_gobject->gobject->ref_count); } /*php_error(E_NOTICE, "%s DTOR (%p)", G_OBJECT_TYPE_NAME(php_gobject->gobject), (void*)php_gobject->gobject); */ /* TODO, find a way to destroy properties of object type. * Memory usage will be a bit abused, but I really have no idea how it should be implemented */ __object_properties_dtor(&php_gobject->zo TSRMLS_CC); g_object_unref(php_gobject->gobject); php_gobject->gobject = NULL; } } zend_object_std_dtor(&php_gobject->zo TSRMLS_CC); php_gobject->gobject = NULL; efree(php_gobject); if (MGDG(midgard_memory_debug)) { printf("[%p] <= __php_midgard_gobject_dtor()\n", php_gobject); } php_gobject = NULL; object = NULL; } /* Object constructor */ zend_object_value php_midgard_gobject_new(zend_class_entry *class_type TSRMLS_DC) { php_midgard_gobject *php_gobject; zend_object_value retval; php_gobject = ecalloc(1, sizeof(php_midgard_gobject)); zend_object_std_init(&php_gobject->zo, class_type TSRMLS_CC); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 ALLOC_HASHTABLE((&php_gobject->zo)->properties); zend_hash_init((&php_gobject->zo)->properties, 0, NULL, ZVAL_PTR_DTOR, 0); #endif if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_gobject_new(%s)\n", &php_gobject->zo, class_type->name); } /* php_error(E_NOTICE, "CONSTRUCTOR %s", class_type->name); */ php_gobject->gobject = NULL; php_gobject->has_properties = FALSE; php_gobject->magic = PHP_MIDGARD_GOBJ_MAGIC; /* Do not free these members. Those are owned by Zend. We just re use them. */ php_gobject->user_ce = NULL; php_gobject->user_class_name = NULL; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 /* Not sure if this is required, we need to initialize 'properties' hash, which this function * initializes properties_table array */ object_properties_init(&(php_gobject->zo), class_type); #else zval *tmp; zend_hash_copy(php_gobject->zo.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *)); #endif retval.handle = zend_objects_store_put(php_gobject, (zend_objects_store_dtor_t)zend_objects_destroy_object, __php_midgard_gobject_dtor, NULL TSRMLS_CC); retval.handlers = &php_midgard_gobject_handlers; if (MGDG(midgard_memory_debug)) { printf("[%p] <= php_midgard_gobject_new()\n", &php_gobject->zo); } return retval; } void php_midgard_gobject_init(zval *zvalue, const char *php_classname, GObject *gobject, gboolean dtor TSRMLS_DC) { zend_class_entry *ce = NULL; if (zvalue == NULL) MAKE_STD_ZVAL(zvalue); if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_gobject_init(%s, %p [gobject refcount = %d])\n", zvalue, php_classname, gobject, gobject->ref_count); } ce = php_midgard_get_class_ptr_by_name(php_classname TSRMLS_CC); if (ce == NULL) php_error(E_ERROR, "Class '%s' is not registered", php_classname); php_midgard_gobject_new_with_gobject(zvalue, ce, gobject, dtor TSRMLS_CC); } void php_midgard_gobject_new_with_gobject(zval *zvalue, zend_class_entry *ce, GObject *gobject, gboolean dtor TSRMLS_DC) { if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_gobject_new_with_gobject(%s)\n", zvalue, ce->name); } object_init_ex(zvalue, ce); MGD_PHP_SET_GOBJECT_G(zvalue, gobject); if (MIDGARD_IS_OBJECT(gobject) && ce->constructor) { zend_call_method_with_0_params(&zvalue, ce, &ce->constructor, "__construct", NULL); } if (MGDG(midgard_memory_debug)) { printf("[%p] <= php_midgard_gobject_new_with_gobject(%s)\n", zvalue, ce->name); } } /* Other routines */ zend_class_entry *php_midgard_get_baseclass_ptr(zend_class_entry *ce) { g_assert(ce); if (ce->parent == NULL) { return ce; } GType g_class_type = g_type_from_name(ce->name); if (g_class_type != G_TYPE_INVALID) { if (g_type_is_a (g_class_type, MIDGARD_TYPE_DBOBJECT)) { return ce; } } if (ce->parent == php_midgard_dbobject_class || ce->parent == php_midgard_object_class || ce->parent == php_midgard_view_class ) { return ce; } return php_midgard_get_baseclass_ptr(ce->parent); } zend_class_entry *php_midgard_get_mgdschema_class_ptr(zend_class_entry *ce) { g_assert(ce != NULL); zend_class_entry *tmp = ce; GType g_class_type = g_type_from_name(ce->name); if (g_class_type != G_TYPE_INVALID) { if (g_type_is_a (g_class_type, MIDGARD_TYPE_DBOBJECT)) { return tmp; } } while ( tmp->parent && tmp->parent != php_midgard_object_class && tmp->parent != php_midgard_dbobject_class ) { tmp = tmp->parent; } return tmp; } zend_class_entry *php_midgard_get_mgdschema_class_ptr_by_name(const char *name TSRMLS_DC) { g_assert(name != NULL); zend_class_entry *ce = php_midgard_get_class_ptr_by_name(name TSRMLS_CC); if (ce == NULL) { return NULL; } return php_midgard_get_mgdschema_class_ptr(ce); } zend_class_entry *php_midgard_get_baseclass_ptr_by_name(const char *name TSRMLS_DC) { g_assert(name != NULL); zend_class_entry *ce = php_midgard_get_class_ptr_by_name(name TSRMLS_CC); if (NULL == ce) { return NULL; } return php_midgard_get_baseclass_ptr(ce); } // Can fetch class even if EG() is not available (before request started) zend_class_entry *php_midgard_get_class_ptr_by_name(const char *name TSRMLS_DC) { g_assert(name != NULL); size_t name_length = strlen(name); if (PG(modules_activated) == 1 && EG(class_table)) { // request is started return zend_fetch_class((char *)name, name_length, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); } // request is not started. we have to act on our own gchar *lower_class_name = g_ascii_strdown(name, name_length); zend_class_entry **ce; if (zend_hash_find(CG(class_table), (char *)lower_class_name, name_length + 1, (void **) &ce) != SUCCESS) { *ce = NULL; } g_free(lower_class_name); return *ce; } gboolean php_midgard_is_derived_from_class(const char *classname, GType basetype, gboolean check_parent, zend_class_entry **base_class TSRMLS_DC) { if (classname == NULL || *classname == '\0') return FALSE; zend_class_entry *ce = php_midgard_get_baseclass_ptr_by_name(classname TSRMLS_CC); if (ce == NULL) { php_error(E_WARNING, "Can not find zend class pointer for given %s class name", classname); return FALSE; } *base_class = ce; const gchar *g_classname = php_class_name_to_g_class_name(ce->name); GType classtype = g_type_from_name(g_classname); if (classtype == basetype) return TRUE; if (check_parent == TRUE) return g_type_is_a(classtype, basetype); return FALSE; } void php_midgard_array_from_objects(GObject **objects, const gchar *class_name, zval *zarray TSRMLS_DC) { if (!objects) return; zend_class_entry *ce = zend_fetch_class((char *)class_name, strlen(class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); size_t i = 0; while (objects[i] != NULL) { zval *zobject; MAKE_STD_ZVAL(zobject); php_midgard_gobject_new_with_gobject(zobject, ce, objects[i], TRUE TSRMLS_CC); zend_hash_next_index_insert(HASH_OF(zarray), &zobject, sizeof(zval *), NULL); i++; } return; } /* SIGNALS */ void php_midgard_gobject_connect(INTERNAL_FUNCTION_PARAMETERS) { zend_fcall_info fci; zend_fcall_info_cache fci_cache; char *sname = NULL; uint sname_length; zval *zval_object = getThis(); zval *zval_array = NULL; GClosure *closure = NULL; /* Keep '!' as passed object parameter ( or params array ) can be NULL */ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sf|a!", &sname, &sname_length, &fci, &fci_cache, &zval_array) == FAILURE) { return; } /* Get underlying GObject instance */ GObject *object = __php_gobject_ptr(zval_object); guint signal_id; GQuark signal_detail; if (!g_signal_parse_name(sname, G_OBJECT_TYPE(object), &signal_id, &signal_detail, TRUE)) { php_error(E_WARNING, "%s signal name is invalid", sname); RETURN_NULL(); /* TODO , should we handle exception here? */ } closure = php_midgard_closure_new_default(fci, fci_cache, zval_object, zval_array TSRMLS_CC); if (!closure) { php_error(E_WARNING, "Can not create new closure"); RETURN_NULL(); } g_signal_connect_closure_by_id(object, signal_id, signal_detail, closure, FALSE); } GParameter *php_midgard_array_to_gparameter(zval *params, guint *n_params TSRMLS_DC) { if (params == NULL) return NULL; HashTable *zht = Z_ARRVAL_P(params); /* count hash elements to set number of parameters */ *n_params = (guint)zend_hash_num_elements(zht); if (*n_params == 0) return NULL; /* Initialize parameters vector */ GParameter *parameters = g_new0(GParameter, *n_params); HashPosition pos; zval **value; char *key; uint key_len, i = 0, k; ulong num_index; /* reset array and set pointer at first position */ zend_hash_internal_pointer_reset_ex(zht, &pos); /* iterate over array and set parameters' names and values */ while (zend_hash_get_current_data_ex(zht, (void **) &value, &pos) == SUCCESS) { if (zend_hash_get_current_key_ex(zht, &key, &key_len, &num_index, 0, &pos) == HASH_KEY_IS_STRING) { parameters[i].name = (const gchar *)key; GValue gval = {0, }; if (!php_midgard_gvalue_from_zval(*value, &gval TSRMLS_CC)) goto CLEAN_AND_RETURN_NULL; parameters[i].value = gval; } else { php_error(E_WARNING, "Parameter key must be valid string!"); goto CLEAN_AND_RETURN_NULL; } i++; zend_hash_move_forward_ex(zht, &pos); } return parameters; CLEAN_AND_RETURN_NULL: for (k = i ; k > -1; k--) { g_value_unset(¶meters[i].value); } g_free(parameters); return NULL; } const gchar* php_class_name_to_g_class_name(const char *php_class_name) { zend_class_entry *ce = php_midgard_get_class_ptr_by_name(php_class_name TSRMLS_CC); if (ce) return ce->name; return php_class_name; } php5-midgard2-10.05.7/php_midgard_gobject_closures.h0000664000175000017500000000021311730073440020107 0ustar ppppGClosure *php_midgard_closure_new_default(zend_fcall_info fci, zend_fcall_info_cache fci_cache, zval *zobject, zval *zval_array TSRMLS_DC);php5-midgard2-10.05.7/php_midgard_query.h0000664000175000017500000000065111730073440015726 0ustar ppppextern zend_class_entry *php_midgard_query_holder_class; extern zend_class_entry *php_midgard_query_property_class; extern zend_class_entry *php_midgard_query_storage_class; extern zend_class_entry *php_midgard_query_constraint_simple_class; PHP_MINIT_FUNCTION(midgard2_query_storage); PHP_MINIT_FUNCTION(midgard2_query_holders); PHP_MINIT_FUNCTION(midgard2_query_constraints); PHP_MINIT_FUNCTION(midgard2_query_executors); php5-midgard2-10.05.7/php_midgard_reflection_property.c0000664000175000017500000002013311730073440020647 0ustar pppp/* Copyright (C) 2006,2007 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" zend_class_entry *php_midgard_reflection_property_class; #define _GET_MRP_OBJECT \ zval *zval_object = getThis(); \ MidgardReflectionProperty *mrp = MIDGARD_REFLECTION_PROPERTY(__php_gobject_ptr(zval_object)); \ if (!mrp) \ php_error(E_ERROR, "Can not find underlying reflector instance"); #define _NOSCHEMA_CLASS_ERR \ { php_error(E_WARNING,"%s method can not be called."\ "midgard_reflection_property initialized with non schema class", \ get_active_function_name(TSRMLS_C));\ RETURN_FALSE; } /* Object constructor */ static PHP_METHOD(midgard_reflection_property, __construct) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *php_classname = NULL; int php_classname_length; zend_class_entry *ce_base; zval *zval_object = getThis(); GObject *gobject; gobject = __php_gobject_ptr(zval_object); if (!gobject) { if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &php_classname, &php_classname_length) == FAILURE) return; { gboolean __isderived = php_midgard_is_derived_from_class(php_classname, MIDGARD_TYPE_DBOBJECT, TRUE, &ce_base TSRMLS_CC); if (!__isderived) { php_error(E_WARNING, "Expected %s derived class", g_type_name(MIDGARD_TYPE_DBOBJECT)); php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC); return; } } const gchar *g_classname = php_class_name_to_g_class_name(ce_base->name); MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(g_classname); if (!klass) { php_error(E_WARNING, "%s is not registered Midgard schema class", g_classname); return; } MidgardReflectionProperty *mrp = midgard_reflection_property_new(MIDGARD_DBOBJECT_CLASS(klass)); if (!mrp) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } MGD_PHP_SET_GOBJECT(zval_object, mrp); } else { // we already have gobject injected } } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp___construct, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflection_property, get_midgard_type) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_LONG(midgard_reflection_property_get_midgard_type(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_get_midgard_type, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflection_property, is_link) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_BOOL(midgard_reflection_property_is_link(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_is_link, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflection_property, get_link_name) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; const gchar *linkname = midgard_reflection_property_get_link_name(mrp, property_name); if (linkname) RETURN_STRING((gchar *)linkname, 1); RETURN_NULL(); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_get_link_name, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflection_property, get_link_target) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *property_name; int property_name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; const gchar *linktarget = midgard_reflection_property_get_link_target(mrp, property_name); if (linktarget) RETURN_STRING((gchar *)linktarget, 1); RETURN_FALSE; } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_get_link_target, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflection_property, description) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; const gchar *description = midgard_reflection_property_description(mrp, property_name); if (description) RETURN_STRING((char *)description, 1); RETURN_NULL(); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_description, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflection_property, get_user_value) { char *property_name, *name; int property_name_length, name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &property_name, &property_name_length, &name, &name_length) == FAILURE) return; _GET_MRP_OBJECT; const gchar *value = midgard_reflection_property_get_user_value(mrp, property_name, name); if (value) RETURN_STRING((gchar *)value, 1); RETURN_NULL(); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_get_user_value, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_ARG_INFO(0, name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_reflection_property, is_private) { char *property_name; int property_name_length; RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &property_name, &property_name_length) == FAILURE) return; _GET_MRP_OBJECT; RETURN_BOOL(midgard_reflection_property_is_private(mrp, property_name)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_mrp_is_private, 0, 0, 1) ZEND_ARG_INFO(0, property) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_reflection_property) { static zend_function_entry reflection_property_methods[] = { PHP_ME(midgard_reflection_property, __construct, arginfo_mrp___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_reflection_property, get_midgard_type, arginfo_mrp_get_midgard_type, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflection_property, is_link, arginfo_mrp_is_link, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflection_property, get_link_name, arginfo_mrp_get_link_name, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflection_property, get_link_target, arginfo_mrp_get_link_target, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflection_property, description, arginfo_mrp_description, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflection_property, get_user_value, arginfo_mrp_get_user_value, ZEND_ACC_PUBLIC) PHP_ME(midgard_reflection_property, is_private, arginfo_mrp_is_private, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry reflection_property_class_entry; INIT_CLASS_ENTRY(reflection_property_class_entry, "midgard_reflection_property", reflection_property_methods); php_midgard_reflection_property_class = zend_register_internal_class(&reflection_property_class_entry TSRMLS_CC); php_midgard_reflection_property_class->create_object = php_midgard_gobject_new; return SUCCESS; } php5-midgard2-10.05.7/php_midgard_gobject_closures.c0000664000175000017500000002234211730073440020111 0ustar pppp#include "php_midgard.h" #include "php_midgard__helpers.h" #include "php_midgard_gobject.h" typedef struct { GClosure closure; zend_fcall_info fci; zend_fcall_info_cache fci_cache; zval *args; zval *zval_array; guint argc; guint type; zval *zobject; zval *connected; } php_mgd_closure; static void php_midgard_closure_invalidate(gpointer data, GClosure *closure) { TSRMLS_FETCH(); if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_closure_invalidate(data = %p)\n", closure, data); } php_mgd_closure *mgdclosure = (php_mgd_closure *) closure; zval_ptr_dtor(&(mgdclosure->fci.function_name)); if (mgdclosure->args != NULL) { zval_ptr_dtor(&mgdclosure->args); mgdclosure->args = NULL; } if (MGDG(midgard_memory_debug)) { printf("[%p] ----> done with args\n", closure); } mgdclosure->zobject = NULL; mgdclosure->connected = NULL; if (MGDG(midgard_memory_debug)) { printf("[%p] <= php_midgard_closure_invalidate()\n", closure); } } /* CLASS CLOSURES */ static GHashTable *__classes_hash = NULL; void php_midgard_gobject_closure_hash_new() { if (__classes_hash == NULL) __classes_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); } static php_mgd_closure * __class_closure_lookup(GType class_type, guint signal_id) { if (signal_id == 0) return NULL; if (__classes_hash == NULL) return NULL; GHashTable *closures_hash; closures_hash = g_hash_table_lookup(__classes_hash, g_type_name(class_type)); if (!closures_hash) return NULL; gchar *sname = g_strdup(g_signal_name(signal_id)); g_strdelimit (sname, G_STR_DELIMITERS ":^", '_'); php_mgd_closure *pmc = g_hash_table_lookup(closures_hash, sname); g_free(sname); return pmc; } static void __php_midgard_closure_free(gpointer data) { TSRMLS_FETCH(); if (MGDG(midgard_memory_debug)) { printf("[%p] __php_midgard_closure_free()\n", data); } GClosure *closure = (GClosure *) data; if (closure) { g_closure_unref(closure); } } void __free_hash_foreach(gpointer key, gpointer val, gpointer ud) { GHashTable *hash = (GHashTable *) val; if (hash) g_hash_table_destroy(hash); } void php_midgard_gobject_closure_hash_free() { if (__classes_hash != NULL) { g_hash_table_foreach(__classes_hash, __free_hash_foreach, NULL); g_hash_table_destroy(__classes_hash); __classes_hash = NULL; } return; } static void __register_class_closure(const gchar *class_name, const gchar *signal, php_mgd_closure *closure) { if (__classes_hash == NULL) return; gchar *sname = g_strdup(signal); g_strdelimit (sname, G_STR_DELIMITERS ":^", '_'); /* FIXME, it should be fast, so no conversion here */ guint signal_id = g_signal_lookup(sname, g_type_from_name(class_name)); if (signal_id == 0) { php_error(E_WARNING, "'%s' is not registered as event for '%s'", sname, class_name); g_free(sname); return; } GHashTable *closures_hash = g_hash_table_lookup(__classes_hash, class_name); if (!closures_hash) { closures_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, __php_midgard_closure_free); } g_hash_table_insert(closures_hash, (gpointer) sname, closure); g_hash_table_insert(__classes_hash, (gpointer) g_strdup(class_name), closures_hash); } static void php_midgard_closure_default_marshal(GClosure *closure, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer invocation_hint, gpointer marshal_data) { php_mgd_closure *mgdclosure = (php_mgd_closure *) closure; TSRMLS_FETCH(); if (MGDG(can_deliver_signals) == 0) return; // engine is not in sane state if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_closure_default_marshal(args = %p)\n", closure, mgdclosure->args); } zval *params = NULL; MAKE_STD_ZVAL(params); array_init(params); // "10000" on next line is a HACK. Just took a number which is slightly above normal, but still doesn't look like invalid if (mgdclosure->zobject != NULL && Z_REFCOUNT_P(mgdclosure->zobject) < 10000) { if (MGDG(midgard_memory_debug)) { printf("[%p] ---> zobject (%p) refcount = %d\n", closure, mgdclosure->zobject, Z_REFCOUNT_P(mgdclosure->zobject)); } Z_ADDREF_P(mgdclosure->zobject); zend_hash_next_index_insert(Z_ARRVAL_P(params), &(mgdclosure->zobject), sizeof(zval *), NULL); } else { zval *dummy = NULL; MAKE_STD_ZVAL(dummy); ZVAL_NULL(dummy); zend_hash_next_index_insert(Z_ARRVAL_P(params), &dummy, sizeof(zval *), NULL); } if (mgdclosure->args != NULL) { // + params HashTable *args_hash = Z_ARRVAL_P(mgdclosure->args); zend_uint argc = 1 + zend_hash_num_elements(args_hash); zend_hash_internal_pointer_reset(args_hash); size_t i; for (i = 1; i < argc; i++) { zval **ptr; zend_hash_get_current_data(args_hash, (void **)&ptr); zend_hash_move_forward(args_hash); if (MGDG(midgard_memory_debug)) { printf("[%p] ----> got ptr = %p, *ptr = %p [refcount = %d]\n", closure, ptr, *ptr, Z_REFCOUNT_P(*ptr)); } Z_ADDREF_PP(ptr); zend_hash_next_index_insert(Z_ARRVAL_P(params), ptr, sizeof(zval *), NULL); } } zval *retval = NULL; zend_fcall_info_args(&(mgdclosure->fci), params TSRMLS_CC); mgdclosure->fci.retval_ptr_ptr = &retval; zend_call_function(&(mgdclosure->fci), &(mgdclosure->fci_cache) TSRMLS_CC); zend_fcall_info_args_clear(&(mgdclosure->fci), 1); if (retval) zval_ptr_dtor(&retval); zval_ptr_dtor(¶ms); } GClosure *php_midgard_closure_new_default(zend_fcall_info fci, zend_fcall_info_cache fci_cache, zval *zobject, zval *zval_array TSRMLS_DC) { GClosure *closure; if (zobject == NULL || !g_type_from_name(php_class_name_to_g_class_name(Z_OBJCE_P(zobject)->name))) { closure = g_closure_new_simple(sizeof(php_mgd_closure), NULL); } else { closure = g_closure_new_object(sizeof(php_mgd_closure), __php_gobject_ptr(zobject)); } if (!closure) { php_error(E_ERROR, "Couldn't create new closure"); return NULL; } if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_closure_new_default(zobject = %p, zval_array = %p)\n", closure, zobject, zval_array); } php_mgd_closure *mgdclosure = (php_mgd_closure*) closure; Z_ADDREF_P(fci.function_name); mgdclosure->fci = fci; mgdclosure->fci_cache = fci_cache; mgdclosure->zobject = zobject; // we do not add reference here, as closure would be destroyed when object destroyed mgdclosure->args = NULL; if (zval_array) { Z_ADDREF_P(zval_array); mgdclosure->args = zval_array; } g_closure_add_invalidate_notifier(closure, NULL, php_midgard_closure_invalidate); g_closure_set_marshal((GClosure *)mgdclosure, php_midgard_closure_default_marshal); return (GClosure *)mgdclosure; } void php_midgard_object_class_connect_default(INTERNAL_FUNCTION_PARAMETERS) { zend_fcall_info fci; zend_fcall_info_cache fci_cache; char *sname = NULL, *class_name = NULL; int sname_length, class_name_length; zval *zval_array = NULL; /* Keep '!' as passed object parameter ( or params array ) can be NULL */ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssf|a!", &class_name, &class_name_length, &sname, &sname_length, &fci, &fci_cache, &zval_array) == FAILURE) { return; } GType class_type = g_type_from_name((const gchar *)class_name); if (class_type == 0) { php_error(E_WARNING, "Class %s is not registered in GType system", class_name); return; } guint signal_id; GQuark signal_detail; if (!g_signal_parse_name(sname, class_type, &signal_id, &signal_detail, TRUE)) { php_error(E_WARNING, "%s signal name is invalid", sname); return; /* TODO , should we handle exception here? */ } GClosure *closure = php_midgard_closure_new_default(fci, fci_cache, NULL, zval_array TSRMLS_CC); if (!closure) { php_error(E_WARNING, "Can not create new closure"); return; } php_mgd_closure *dclosure = (php_mgd_closure *) closure; dclosure->zval_array = zval_array; __register_class_closure(class_name, sname, dclosure); } void php_midgard_object_connect_class_closures(GObject *object, zval *zobject TSRMLS_DC) { /* TODO, add error handling , IS_OBJECT , etc */ if (zobject == NULL) { php_error(E_WARNING, "Connect to class closure: failed to get zend object"); return; } if (object == NULL) { php_error(E_WARNING, "Connect to class closure: failed to get underlying object"); return; } if (MGDG(midgard_memory_debug)) { printf("[%p] php_midgard_object_connect_class_closures(zobject = %p)\n", object, zobject); } /* Use MIDGARD_TYPE_OBJECT type explicitly! * Ancestor type is not taken into account in GLib's list_ids! */ guint n_ids; guint *ids = g_signal_list_ids(MIDGARD_TYPE_OBJECT, &n_ids); if (n_ids == 0) return; guint i = 0; for (i = 0; i < n_ids; i++) { php_mgd_closure *closure = __class_closure_lookup(G_OBJECT_TYPE(object), ids[i]); if (closure) { if (MGDG(midgard_memory_debug)) { printf("[%p] ----> found \"default\" closure = %p\n", object, closure); } php_mgd_closure *dclosure = (php_mgd_closure *) php_midgard_closure_new_default(closure->fci, closure->fci_cache, zobject, closure->zval_array TSRMLS_CC); if (MGDG(midgard_memory_debug)) { printf("[%p] ----> created closure = %p\n", object, dclosure); } g_signal_connect_closure(object, g_signal_name(ids[i]), (GClosure *)dclosure, FALSE); } } g_free(ids); if (MGDG(midgard_memory_debug)) { printf("[%p] <= php_midgard_object_connect_class_closures(zobject = %p)\n", object, zobject); } return; } php5-midgard2-10.05.7/phpunit/0000775000175000017500000000000011730073440013537 5ustar ppppphp5-midgard2-10.05.7/phpunit/phpunit_sqlite.xml.dist0000664000175000017500000000226111730073440020274 0ustar pppp tests/ ../ ../tests . php5-midgard2-10.05.7/phpunit/midgard_init.php0000664000175000017500000000155211730073440016705 0ustar ppppdbtype = $GLOBALS['midgard2.configuration.db.type']; $config->database = $GLOBALS['midgard2.configuration.db.name']; $config->dbdir = $GLOBALS['midgard2.configuration.db.dir']; $config->blobdir = $GLOBALS['midgard2.configuration.db.blobdir']; $config->loglevel = $GLOBALS['midgard2.configuration.loglevel']; $mgd = midgard_connection::get_instance(); var_dump($mgd->open_config ($config)); class MidgardTest extends PHPUnit_Framework_TestCase { } php5-midgard2-10.05.7/phpunit/tests/0000775000175000017500000000000011730073440014701 5ustar ppppphp5-midgard2-10.05.7/phpunit/tests/010_Query/0000775000175000017500000000000011730073440016366 5ustar ppppphp5-midgard2-10.05.7/phpunit/tests/010_Query/SqlQueryColumnTest.php0000664000175000017500000000232611730073440022705 0ustar ppppcolumn === null) { $this->queryProperty = new MidgardQueryProperty("title"); $this->column = new MidgardSqlQueryColumn($this->queryProperty, "t1", "The name"); } } public function testInheritance() { $this->assertInstanceOf("MidgardSqlQueryColumn", $this->column); $this->assertInstanceOf("MidgardQueryColumn", $this->column); } public function testGetQueryProperty() { $this->assertEquals($this->column->get_query_property(), $this->queryProperty); $this->assertInstanceOf("MidgardQueryProperty", $this->column->get_query_property()); } public function testGetName() { /* writable only property */ $this->assertEquals($this->column->name, null); $this->assertEquals($this->column->get_name(), "The name"); } public function testGetQualifier() { /* writable only property */ $this->assertEquals($this->column->qualifier, null); $this->assertEquals($this->column->get_qualifier(), "t1"); } } ?> php5-midgard2-10.05.7/phpunit/tests/010_Query/SqlQuerySelectDataConstraintGroupTest.php0000664000175000017500000000316311730073440026543 0ustar ppppmgd = midgard_connection::get_instance(); if ($this->select === null) { $this->select = new MidgardSqlQuerySelectData(midgard_connection::get_instance()); } } public function tearDown() { unset($this->select); } public function testInheritance() { $cg = new MidgardQueryConstraintGroup("AND"); $this->assertInstanceOf("MidgardQueryConstraintSimple", $cg); } public function testQueryConstraintGroup() { $storage = new MidgardQueryStorage("midgard_snippet"); $columnA = new MidgardSqlQueryColumn( new MidgardQueryProperty("name", $storage), "tbl1", "a" ); $columnB = new MidgardSqlQueryColumn( new MidgardQueryProperty("code", $storage), "tbl1", "b" ); $this->select->add_column($columnA); $this->select->add_column($columnB); $cg = new MidgardQueryConstraintGroup("AND"); $cg->add_constraint( new MidgardSqlQueryConstraint( $columnA, "<>", new MidgardQueryValue("") ) ); $cg->add_constraint( new MidgardSqlQueryConstraint( $columnB, "<>", new MidgardQueryValue("") ) ); $this->select->set_constraint($cg); $this->select->execute(); } } ?> php5-midgard2-10.05.7/phpunit/tests/010_Query/SqlQuerySelectDataConstraintsTest.php0000664000175000017500000003753711730073440025725 0ustar ppppname = self::SNIPPETDIR_NAME; $this->assertTrue($sdirA->create()); $this->assertEquals($this->mgd->get_error_string(), "MGD_ERR_OK"); $sA = new midgard_snippet(); $sA->name = self::SNIPPET_NAME_A; $sA->doc = "Doc A"; $sA->snippetdir = $sdirA->id; $this->assertTrue($sA->create()); $this->assertEquals($this->mgd->get_error_string(), "MGD_ERR_OK"); $sB = new midgard_snippet(); $sB->name = self::SNIPPET_NAME_B; $sB->doc = "Doc B"; $sB->snippetdir = $sdirA->id; $this->assertTrue($sB->create()); $this->assertEquals($this->mgd->get_error_string(), "MGD_ERR_OK"); $sC = new midgard_snippet(); $sC->name = self::SNIPPET_NAME_C; $sC->doc = "Doc C"; $sC->snippetdir = $sdirA->id; $this->assertTrue($sC->create()); $this->assertEquals($this->mgd->get_error_string(), "MGD_ERR_OK"); } public function setUp() { $this->mgd = midgard_connection::get_instance(); if ($this->select === null) { $this->select = new MidgardSqlQuerySelectData(midgard_connection::get_instance()); } if ($this->default_snippet_storage === null) { $this->default_snippet_storage = new MidgardQueryStorage("midgard_snippet"); } if ($this->default_sdir_storage === null) { $this->default_sdir_storage = new MidgardQueryStorage("midgard_snippetdir"); } $this->createSnippetDir(); } public function tearDown() { $q = new MidgardQuerySelect($this->default_snippet_storage); $q->execute(); foreach ($q->list_objects() as $s) { $s->purge(false); } $q = new MidgardQuerySelect($this->default_sdir_storage); $q->execute(); foreach ($q->list_objects() as $s) { $s->purge(false); } unset($this->select); } private function addColumns() { $storage = $this->default_snippet_storage; $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("name", $storage), self::SNIPPET_QUALIFIER, self::SNIPPET_NAME ); $this->select->add_column($column); $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("id", $storage), self::SNIPPET_QUALIFIER, self::SNIPPET_ID ); $this->select->add_column($column); } private function addSdirColumns() { $this->addColumns(); $storage = $this->default_sdir_storage; $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("name", $storage), self::SNIPPETDIR_QUALIFIER, self::SNIPPETDIR_NAME_COLUMN ); $this->select->add_column($column); } public function testInheritance() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $this->assertInstanceOf("MidgardSqlQueryResult", $result); $this->assertInstanceOf("MidgardQueryResult", $result); } public function testExecuteInvalidQuery() { $this->addColumns(); $this->select->set_constraint( new MidgardSqlQueryConstraint( new MidgardSqlQueryColumn( new MidgardQueryProperty("title"), self::SNIPPET_QUALIFIER ), "=", new MidgardQueryValue("A") ) ); try { $this->select->execute(); } catch (Exception $e) { } } public function testGetRowsLimit() { $this->addColumns(); $this->select->set_limit(1); $this->select->execute(); $result = $this->select->get_query_result(); $rows = $result->get_rows(); // There should be one snippet $this->assertCount(1, $rows); } public function testGetRowsOffset() { $this->addColumns(); $this->select->set_limit(1); $this->select->set_offset(1); $this->select->execute(); $result = $this->select->get_query_result(); $rows = $result->get_rows(); // There should be one snippet $this->assertCount(1, $rows); } public function testGetRowsWithSnippetA() { $this->addColumns(); $this->select->set_constraint( new MidgardSqlQueryConstraint( new MidgardSqlQueryColumn( new MidgardQueryProperty("name", $this->default_snippet_storage), self::SNIPPET_QUALIFIER ), "=", new MidgardQueryValue(self::SNIPPET_NAME_A) ) ); $this->select->execute(); $result = $this->select->get_query_result(); $rows = $result->get_rows(); $this->assertCount(1, $rows); } public function testGetRowsWithAllSnippets() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $rows = $result->get_rows(); $this->assertCount(3, $rows); } public function testGetColumns() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $columns = $result->get_columns(); $this->assertCount(2, $columns); } public function testGetColumnNamesWithSnippets() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $columns = $result->get_columns(); $this->assertCount(2, $columns); $names = $result->get_column_names(); $this->assertCount(2, $names); $colnames = array(self::SNIPPET_NAME, self::SNIPPET_ID); foreach ($names as $name) { $this->assertContains($names[0], $colnames); $this->assertContains($names[1], $colnames); } } public function testGetColumnNamesWithSnippetsAndSdir() { $this->addSdirColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $columns = $result->get_columns(); $this->assertCount(3, $columns); $names = $result->get_column_names(); $this->assertCount(3, $names); $colnames = array(self::SNIPPET_NAME, self::SNIPPET_ID, self::SNIPPETDIR_NAME_COLUMN); foreach ($names as $name) { $this->assertContains($names[0], $colnames); $this->assertContains($names[1], $colnames); $this->assertContains($names[2], $colnames); } } public function testGetColumnQualifiers() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $columns = $result->get_columns(); $this->assertCount(2, $columns); foreach ($columns as $column) { $this->assertEquals($column->get_qualifier(), self::SNIPPET_QUALIFIER); } } public function testGetColumnPropertyName() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $columns = $result->get_columns(); $this->assertCount(2, $columns); $names = array("name", "id"); foreach ($columns as $column) { $this->assertContains($column->get_query_property()->property, $names); } } private function prepareJoin() { $this->addSdirColumns(); // snippetdir_q.id AS snippetdir_id $sdir_storage = $this->default_sdir_storage; $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("id", $sdir_storage), self::SNIPPETDIR_QUALIFIER, self::SNIPPETDIR_ID ); $this->select->add_column($column); // snippet_q.snippetdir AS snippets_sdir_id $storage = $this->default_snippet_storage; $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("snippetdir", $storage), self::SNIPPET_QUALIFIER, self::SNIPPET_SDIR_ID ); $this->select->add_column($column); // JOIN ON (snippetdir_q.id = snippet_q.snippetdir) $this->select->add_join( "INNER", new MidgardSqlQueryColumn( new MidgardQueryProperty("snippetdir", $storage), self::SNIPPET_QUALIFIER, self::SNIPPET_SDIR_ID ), new MidgardSqlQueryColumn( new MidgardQueryProperty("id", $sdir_storage), self::SNIPPETDIR_QUALIFIER, self::SNIPPETDIR_ID ) ); } private function addSnippetNameConstraint() { $this->select->set_constraint( new MidgardSqlQueryConstraint( new MidgardSqlQueryColumn( new MidgardQueryProperty("name", $this->default_snippet_storage), self::SNIPPET_QUALIFIER ), "=", new MidgardQueryValue(self::SNIPPET_NAME_A) ) ); } public function testAddJoin() { $this->prepareJoin(); $this->addSnippetNameConstraint(); $this->select->execute(); //echo $this->select->get_query_string(); $result = $this->select->get_query_result(); $rows = $result->get_rows(); $this->assertCount(1, $rows); $values = $rows[0]->get_values(); $this->assertCount(5, $values); $this->assertEquals($values[0], self::SNIPPET_NAME_A); // DO not test ids, those depends on provider $this->assertEquals($values[2], self::SNIPPETDIR_NAME); // snippet.snippetdir = snippetdir.id $this->assertEquals($values[3], $values[4]); } public function testAddJoinAddOrderASC() { /* SELECT snippet_q.name AS sname, snippet_q.id AS snippet_id, snippetdir_q.name AS snippetdir_name, snippetdir_q.id AS snippetdir_id, snippet_q.snippetdir AS snippets_sdir_id FROM snippet AS snippet_q INNER JOIN snippetdir AS snippetdir_q ON (snippet_q.snippetdir = snippetdir_q.id) WHERE 1=1 AND 0<1 ORDER BY snippet_q.name ASC */ $this->prepareJoin(); $this->select->add_order( new MidgardSqlQueryColumn( new MidgardQueryProperty("name", $this->default_snippet_storage), self::SNIPPET_QUALIFIER ), SORT_ASC ); $this->select->execute(); //echo $this->select->get_query_string(); $result = $this->select->get_query_result(); $rows = $result->get_rows(); $this->assertCount(3, $rows); $this->assertEquals($rows[0]->get_value(self::SNIPPET_NAME), self::SNIPPET_NAME_A); $this->assertEquals($rows[0]->get_value(self::SNIPPETDIR_NAME_COLUMN), self::SNIPPETDIR_NAME); $this->assertEquals($rows[1]->get_value(self::SNIPPET_NAME), self::SNIPPET_NAME_B); $this->assertEquals($rows[1]->get_value(self::SNIPPETDIR_NAME_COLUMN), self::SNIPPETDIR_NAME); $this->assertEquals($rows[2]->get_value(self::SNIPPET_NAME), self::SNIPPET_NAME_C); $this->assertEquals($rows[2]->get_value(self::SNIPPETDIR_NAME_COLUMN), self::SNIPPETDIR_NAME); try { $rows[0]->get_value("Doesntexist"); } catch (Exception $e) { //expected } } public function testAddJoinAddOrderDESC() { /* SELECT snippet_q.name AS sname, snippet_q.id AS snippet_id, snippetdir_q.name AS snippetdir_name, snippetdir_q.id AS snippetdir_id, snippet_q.snippetdir AS snippets_sdir_id FROM snippet AS snippet_q INNER JOIN snippetdir AS snippetdir_q ON (snippet_q.snippetdir = snippetdir_q.id) WHERE 1=1 AND 0<1 ORDER BY snippet_q.name DESC */ $this->prepareJoin(); $this->select->add_order( new MidgardSqlQueryColumn( new MidgardQueryProperty("name", $this->default_snippet_storage), self::SNIPPET_QUALIFIER ), SORT_DESC ); $this->select->execute(); $result = $this->select->get_query_result(); $rows = $result->get_rows(); $this->assertCount(3, $rows); $this->assertEquals($rows[0]->get_value(self::SNIPPET_NAME), self::SNIPPET_NAME_C); $this->assertEquals($rows[0]->get_value(self::SNIPPETDIR_NAME_COLUMN), self::SNIPPETDIR_NAME); $this->assertEquals($rows[1]->get_value(self::SNIPPET_NAME), self::SNIPPET_NAME_B); $this->assertEquals($rows[1]->get_value(self::SNIPPETDIR_NAME_COLUMN), self::SNIPPETDIR_NAME); $this->assertEquals($rows[2]->get_value(self::SNIPPET_NAME), self::SNIPPET_NAME_A); $this->assertEquals($rows[2]->get_value(self::SNIPPETDIR_NAME_COLUMN), self::SNIPPETDIR_NAME); try { $rows[0]->get_value("Doesntexist"); } catch (Exception $e) { //expected } } public function testAddJoinAddOrderDESCASC() { /* SELECT snippet_q.name AS sname, snippet_q.id AS snippet_id, snippetdir_q.name AS snippetdir_name, snippetdir_q.id AS snippetdir_id, snippet_q.snippetdir AS snippets_sdir_id FROM snippet AS snippet_q INNER JOIN snippetdir AS snippetdir_q ON (snippet_q.snippetdir = snippetdir_q.id) WHERE 1=1 AND 0<1 ORDER BY snippet_q.name DESC, snippet_q.id ASC */ $this->prepareJoin(); $this->select->add_order( new MidgardSqlQueryColumn( new MidgardQueryProperty("name", $this->default_snippet_storage), self::SNIPPET_QUALIFIER ), SORT_DESC ); $this->select->add_order( new MidgardSqlQueryColumn( new MidgardQueryProperty("id", $this->default_snippet_storage), self::SNIPPET_QUALIFIER ), SORT_ASC ); $this->select->execute(); //echo $this->select->get_query_string(); $result = $this->select->get_query_result(); $rows = $result->get_rows(); $this->assertCount(3, $rows); $this->assertEquals($rows[0]->get_value(self::SNIPPET_NAME), self::SNIPPET_NAME_C); $this->assertEquals($rows[0]->get_value(self::SNIPPETDIR_NAME_COLUMN), self::SNIPPETDIR_NAME); $this->assertEquals($rows[1]->get_value(self::SNIPPET_NAME), self::SNIPPET_NAME_B); $this->assertEquals($rows[1]->get_value(self::SNIPPETDIR_NAME_COLUMN), self::SNIPPETDIR_NAME); $this->assertEquals($rows[2]->get_value(self::SNIPPET_NAME), self::SNIPPET_NAME_A); $this->assertEquals($rows[2]->get_value(self::SNIPPETDIR_NAME_COLUMN), self::SNIPPETDIR_NAME); try { $rows[0]->get_value("Doesntexist"); } catch (Exception $e) { //expected } } } ?> php5-midgard2-10.05.7/phpunit/tests/010_Query/SqlQuerySelectDataTest.php0000664000175000017500000000555711730073440023472 0ustar ppppselect === null) { $this->select = new MidgardSqlQuerySelectData(midgard_connection::get_instance()); } } public function testInheritance() { $this->assertInstanceOf("MidgardSqlQuerySelectData", $this->select); $this->assertInstanceOf("MidgardQueryExecutor", $this->select); } public function testAddColumn() { $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("title"), "t1", "title_a" ); $this->select->add_column($column); } public function testGetColumns() { // t1.property_a AS name_a $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("property_a"), "t1", "name_a" ); $this->select->add_column($column); // t2.property_b AS name_b $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("property_b"), "t2", "name_b" ); $this->select->add_column($column); // t3.property_c AS name_c $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("property_c"), "t3", "name_c" ); $this->select->add_column($column); $columns = $this->select->get_columns(); $this->assertInternalType('array', $columns); $this->assertCount(3, $columns); $names = array("name_a", "name_b","name_c"); $qualifiers = array("t1", "t2", "t3"); foreach ($columns as $column) { $this->assertNotNull($column->get_name()); $this->assertContains($column->get_name(), $names); $this->assertNotNull($column->get_qualifier()); $this->assertContains($column->get_qualifier(), $qualifiers); } } private function addColumns() { $storage = new MidgardQueryStorage("midgard_person"); $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("firstname", $storage), "p", "fname" ); $this->select->add_column($column); $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("lastname", $storage), "p", "lname" ); $this->select->add_column($column); } public function testExecute() { $this->addColumns(); $this->select->execute(); } public function testGetQueryResult() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $this->assertInstanceOf("MidgardQueryResult", $result); $this->assertInstanceOf("MidgardSqlQueryResult", $result); } } ?> php5-midgard2-10.05.7/phpunit/tests/010_Query/SqlQueryResultTest.php0000664000175000017500000000672711730073440022737 0ustar ppppselect === null) { $this->select = new MidgardSqlQuerySelectData(midgard_connection::get_instance()); } } private function addColumns() { $storage = new MidgardQueryStorage("midgard_person"); $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("firstname", $storage), "p", "fname" ); $this->select->add_column($column); $column = new MidgardSqlQueryColumn( new MidgardQueryProperty("lastname", $storage), "p", "lname" ); $this->select->add_column($column); } public function testInheritance() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $this->assertInstanceOf("MidgardSqlQueryResult", $result); $this->assertInstanceOf("MidgardQueryResult", $result); } public function testGetRows() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $rows = $result->get_rows(); $this->assertInstanceOf("MidgardQueryRow", $rows[0]); $this->assertInstanceOf("MidgardSqlQueryRow", $rows[0]); // Expect default admin person only $this->assertCount(1, $rows); } public function testGetColumns() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $columns = $result->get_columns(); $this->assertInstanceOf("MidgardQueryColumn", $columns[0]); $this->assertInstanceOf("MidgardSqlQueryColumn", $columns[0]); // Expect firstname AS fname, lastname AS lname $this->assertCount(2, $columns); } public function testGetColumnsQualifier() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $columns = $result->get_columns(); $this->assertInstanceOf("MidgardQueryColumn", $columns[0]); $this->assertInstanceOf("MidgardSqlQueryColumn", $columns[0]); foreach ($columns as $column) { $this->assertEquals($column->get_qualifier(), "p"); } } public function testGetColumnPropertyName() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $columns = $result->get_columns(); $this->assertInstanceOf("MidgardQueryColumn", $columns[0]); $this->assertInstanceOf("MidgardSqlQueryColumn", $columns[0]); $names = array("firstname", "lastname"); foreach ($columns as $column) { $qprop = $column->get_query_property(); $this->assertInstanceOf("MidgardQueryProperty", $qprop); $this->assertContains($qprop->property, $names); } } public function testGetColumnNames() { $this->addColumns(); $this->select->execute(); $result = $this->select->get_query_result(); $names = $result->get_column_names(); // firstname AS fname, lastname AS lname $this->assertCount(2, $names); $columns = array("fname", "lname"); $this->assertContains($names[0], $columns); $this->assertContains($names[1], $columns); $this->assertEquals($columns, $names); } } ?> php5-midgard2-10.05.7/phpunit/tests/003_Storage/0000775000175000017500000000000011730073440016667 5ustar ppppphp5-midgard2-10.05.7/phpunit/tests/003_Storage/StorageTest.php0000664000175000017500000000135111730073440021644 0ustar ppppassertTrue(MidgardStorage::create_base_storage()); } public function testCreateTypesStorage() { $re = new ReflectionExtension('midgard2'); $classes = $re->getClasses(); foreach ($classes as $refclass) { if ($refclass->isAbstract() || $refclass->isInterface()) { continue; } $type = $refclass->getName(); if (!is_subclass_of($type, 'MidgardDBObject')) { continue; } $this->assertTrue(MidgardStorage::create_class_storage($type)); } } } ?> php5-midgard2-10.05.7/phpunit/midgard2.ini0000664000175000017500000000050711730073440015733 0ustar ppppextension=midgard2.so [midgard2] midgard.engine = On ;midgard.http = On ;midgard.superglobals_compat = On ;midgard.configuration = "openpsa2" ;midgard.configuration_file="/etc/midgard2/conf.d/midgard2" ;midgard.memory_debug = On ;midgard.valgrind_friendly = On midgard.glib_loghandler = On include_path = ".:/usr/share/php" php5-midgard2-10.05.7/php_midgard_query_selectors.c0000664000175000017500000006312311730073440020007 0ustar pppp/* Copyright (C) 2010 Alexey Zakhlestin * Copyright (C) 2012 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_query.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" #include /* midgard core interfaces */ zend_class_entry *php_midgard_query_column_class; zend_class_entry *php_midgard_query_row_class; zend_class_entry *php_midgard_query_selector_class; zend_class_entry *php_midgard_query_result_class; /* midgard core sql classes */ zend_class_entry *php_midgard_sql_query_column_class; zend_class_entry *php_midgard_sql_query_row_class; zend_class_entry *php_midgard_sql_query_constraint_class; zend_class_entry *php_midgard_sql_query_result_class; zend_class_entry *php_midgard_sql_query_select_data_class; /* QueryColumn */ static PHP_METHOD(midgard_query_column, get_name) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryColumn *column = MIDGARD_QUERY_COLUMN(__php_gobject_ptr(getThis())); const gchar *name = midgard_query_column_get_name(column, NULL); if (name == NULL) RETURN_NULL(); RETURN_STRING(name, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_column_get_name, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_column, get_qualifier) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryColumn *column = MIDGARD_QUERY_COLUMN(__php_gobject_ptr(getThis())); const gchar *qualifier = midgard_query_column_get_qualifier(column, NULL); if (qualifier == NULL) RETURN_NULL(); RETURN_STRING(qualifier, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_column_get_qualifier, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_column, get_query_property) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryColumn *column = MIDGARD_QUERY_COLUMN(__php_gobject_ptr(getThis())); MidgardQueryProperty *property = midgard_query_column_get_query_property(column, NULL); if (property == NULL) RETURN_NULL(); php_midgard_gobject_new_with_gobject(return_value, php_midgard_query_property_class, G_OBJECT(property), TRUE TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_column_get_query_property, 0, 0, 0) ZEND_END_ARG_INFO() /* QueryRow */ static PHP_METHOD(midgard_query_row, get_object) { char *name; int name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_length) == FAILURE) return; MidgardQueryRow *row = MIDGARD_QUERY_ROW(__php_gobject_ptr(getThis())); GObject *object = midgard_query_row_get_object(row, (const gchar *)name, NULL); MGD_PHP_SET_GOBJECT(return_value, g_object_ref(object)); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_row_get_object, 0, 0, 1) ZEND_ARG_INFO(0, name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_row, get_value) { char *name; int name_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_length) == FAILURE) return; MidgardQueryRow *row = MIDGARD_QUERY_ROW(__php_gobject_ptr(getThis())); GError *error = NULL; const GValue *value = midgard_query_row_get_value(row, (const gchar *)name, &error); if (error || value == NULL) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to get value. %s", error && error->message ? error->message : "Unknown reason"); return; } php_midgard_gvalue2zval(value, return_value TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_row_get_value, 0, 0, 1) ZEND_ARG_INFO(0, name) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_row, get_values) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQueryRow *row = MIDGARD_QUERY_ROW(__php_gobject_ptr(getThis())); GValueArray *varray = midgard_query_row_get_values(row, NULL); array_init (return_value); if (varray == NULL) return; guint i; for (i = 0; i < varray->n_values; i++) { GValue *val = g_value_array_get_nth(varray, i); zval *z_val; MAKE_STD_ZVAL(z_val); php_midgard_gvalue2zval(val, z_val TSRMLS_CC); add_index_zval(return_value, i, z_val); } g_value_array_free (varray); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_row_get_values, 0, 0, 1) ZEND_ARG_INFO(0, name) ZEND_END_ARG_INFO() /* QuerySelector */ static PHP_METHOD(midgard_query_selector, get_connection) { } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_selector_get_connection, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_selector, get_query_result) { } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_selector_get_query_result, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_selector, get_query_string) { } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_selector_get_query_string, 0, 0, 0) ZEND_END_ARG_INFO() /* QueryResult */ static PHP_METHOD(midgard_query_result, get_columns) { if (zend_parse_parameters_none() == FAILURE) return; guint n_objects; MidgardQueryResult *result = MIDGARD_QUERY_RESULT(__php_gobject_ptr(getThis())); MidgardQueryColumn **columns = midgard_query_result_get_columns(result, &n_objects, NULL); array_init(return_value); php_midgard_array_from_unknown_objects((GObject **)columns, n_objects, return_value TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_result_get_columns, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_result, get_objects) { if (zend_parse_parameters_none() == FAILURE) return; guint n_objects; MidgardQueryResult *result = MIDGARD_QUERY_RESULT(__php_gobject_ptr(getThis())); GObject **objects = midgard_query_result_get_objects(result, &n_objects, NULL); array_init(return_value); php_midgard_array_from_unknown_objects(objects, n_objects, return_value TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_result_get_objects, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_result, get_rows) { if (zend_parse_parameters_none() == FAILURE) return; guint n_objects; MidgardQueryResult *result = MIDGARD_QUERY_RESULT(__php_gobject_ptr(getThis())); MidgardQueryRow **rows = midgard_query_result_get_rows(result, &n_objects, NULL); array_init(return_value); php_midgard_array_from_unknown_objects((GObject **)rows, n_objects, return_value TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_result_get_rows, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_query_result, get_column_names) { if (zend_parse_parameters_none() == FAILURE) return; guint n_names; MidgardQueryResult *result = MIDGARD_QUERY_RESULT(__php_gobject_ptr(getThis())); gchar **names = midgard_query_result_get_column_names(result, &n_names, NULL); array_init(return_value); if (names == NULL) return; guint i; for (i = 0; i < n_names; i++) { add_index_string(return_value, i, (gchar *)names[i], 1); } g_free(names); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_query_result_get_column_names, 0, 0, 0) ZEND_END_ARG_INFO() /* SqlQueryColumn */ static PHP_METHOD(midgard_sql_query_column, __construct) { zval *z_qprop = NULL; char *name = NULL; char *qualifier = NULL; int name_length = 0; int qualifier_length = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os|s", &z_qprop, php_midgard_query_property_class, &qualifier, &qualifier_length, &name, &name_length ) == FAILURE ) { return; } MidgardQueryProperty *queryproperty = MIDGARD_QUERY_PROPERTY(__php_gobject_ptr(z_qprop)); MidgardSqlQueryColumn *column = midgard_sql_query_column_new(queryproperty, qualifier, name); if (!column) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create SqlQueryColumn"); return; } MGD_PHP_SET_GOBJECT(getThis(), column); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_column___construct, 0, 0, 3) ZEND_ARG_OBJ_INFO(0, queryproperty, midgard_query_property, 0) ZEND_ARG_INFO(0, name) ZEND_ARG_INFO(0, qualifier) ZEND_END_ARG_INFO() /* SqlQueryConstraint */ static PHP_METHOD(midgard_sql_query_constraint, __construct) { zval *z_column = NULL; char *operator = NULL; int op_length = 0; zval *z_holder = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO", &z_column, php_midgard_sql_query_column_class, &operator, &op_length, &z_holder, php_midgard_query_holder_class ) == FAILURE ) { return; } MidgardSqlQueryColumn *column = MIDGARD_SQL_QUERY_COLUMN(__php_gobject_ptr(z_column)); MidgardQueryHolder *holder = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(z_holder)); MidgardSqlQueryConstraint *constraint = midgard_sql_query_constraint_new(column, operator, holder); if (!column) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create SqlQueryColumn"); return; } MGD_PHP_SET_GOBJECT(getThis(), constraint); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_constraint___construct, 0, 0, 3) ZEND_ARG_OBJ_INFO(0, column, midgard_sql_query_column, 0) ZEND_ARG_INFO(0, operator) ZEND_ARG_OBJ_INFO(0, holder, midgard_query_holder, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_constraint, get_column) { if (zend_parse_parameters_none() == FAILURE) return; MidgardSqlQueryConstraint *constraint = MIDGARD_SQL_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); MidgardSqlQueryColumn *column = midgard_sql_query_constraint_get_column(constraint); MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(column))); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_constraint_get_column, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_constraint, get_holder) { if (zend_parse_parameters_none() == FAILURE) return; MidgardSqlQueryConstraint *constraint = MIDGARD_SQL_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); MidgardQueryHolder *holder = midgard_sql_query_constraint_get_holder(constraint); MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(holder))); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_constraint_get_holder, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_constraint, get_operator) { if (zend_parse_parameters_none() == FAILURE) return; MidgardSqlQueryConstraint *constraint = MIDGARD_SQL_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); const gchar *operator = midgard_sql_query_constraint_get_operator(constraint); if (operator == NULL) RETURN_NULL(); RETURN_STRING(operator, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_constraint_get_operator, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_constraint, set_operator) { char *operator; int op_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &operator, &op_length) == FAILURE) return; MidgardSqlQueryConstraint *constraint = MIDGARD_SQL_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); GError *error = NULL; midgard_sql_query_constraint_set_operator(constraint, operator, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to set operator: %s", error->message); g_error_free(error); } } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_constraint_set_operator, 0, 0, 1) ZEND_ARG_INFO(0, operator) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_constraint, set_column) { zval *z_column = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_column, &php_midgard_sql_query_column_class) == FAILURE) return; MidgardSqlQueryConstraint *constraint = MIDGARD_SQL_QUERY_CONSTRAINT(__php_gobject_ptr(getThis())); MidgardSqlQueryColumn *column = MIDGARD_SQL_QUERY_COLUMN(__php_gobject_ptr(z_column)); GError *error = NULL; midgard_sql_query_constraint_set_column(constraint, column, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to set operator: %s", error->message); g_error_free(error); } } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_constraint_set_column, 0, 0, 1) ZEND_ARG_INFO(0, operator) ZEND_END_ARG_INFO() /* SqlQueryResult */ /* SqlQueryRow */ /* SqlQuerySelectData */ static PHP_METHOD(midgard_sql_query_select_data, __construct) { zval *z_mgd = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_mgd, php_midgard_connection_class) == FAILURE) { return; } MidgardConnection *_mgd = MIDGARD_CONNECTION(__php_gobject_ptr(z_mgd)); MidgardSqlQuerySelectData *select = midgard_sql_query_select_data_new(_mgd); if (!select) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create SqlQuerySelectData"); return; } MGD_PHP_SET_GOBJECT(getThis(), select); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_select_data___construct, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, connection, midgard_connection, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_select_data, get_columns) { if (zend_parse_parameters_none() == FAILURE) return; guint n_objects; MidgardSqlQuerySelectData *select = MIDGARD_SQL_QUERY_SELECT_DATA(__php_gobject_ptr(getThis())); MidgardSqlQueryColumn **columns = midgard_sql_query_select_data_get_columns(select, &n_objects, NULL); array_init(return_value); php_midgard_array_from_unknown_objects((GObject **)columns, n_objects, return_value TSRMLS_CC); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_select_data_get_columns, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_select_data, add_column) { zval *z_column = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_column, php_midgard_sql_query_column_class) == FAILURE) return; MidgardSqlQuerySelectData *select = MIDGARD_SQL_QUERY_SELECT_DATA(__php_gobject_ptr(getThis())); MidgardSqlQueryColumn *column = MIDGARD_SQL_QUERY_COLUMN(__php_gobject_ptr(z_column)); midgard_sql_query_select_data_add_column(select, column); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_select_data_add_column, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, operator, midgard_sql_query_column, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_select_data, get_query_result) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQuerySelector *selector = MIDGARD_QUERY_SELECTOR(__php_gobject_ptr(getThis())); GError *error = NULL; MidgardQueryResult *result = midgard_query_selector_get_query_result(selector, &error); if (!result) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to get result. %s", error && error->message ? error->message : ""); g_clear_error(&error); return; } object_init_ex(return_value, php_midgard_sql_query_result_class); MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(result))); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_select_data_get_query_result, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_select_data, get_connection) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQuerySelector *selector = MIDGARD_QUERY_SELECTOR(__php_gobject_ptr(getThis())); MidgardConnection *mgd = midgard_query_selector_get_connection(selector); MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(mgd))); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_select_data_get_connection, 0, 0, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_sql_query_select_data, get_query_string) { if (zend_parse_parameters_none() == FAILURE) return; MidgardQuerySelector *selector = MIDGARD_QUERY_SELECTOR(__php_gobject_ptr(getThis())); const gchar *query_string = midgard_query_selector_get_query_string(selector); if (query_string == NULL) RETURN_NULL(); RETURN_STRING(query_string, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_sql_query_select_data_get_query_string, 0, 0, 0) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_query_selectors) { /* QueryColumn */ static zend_function_entry midgard_query_column_methods[] = { PHP_ME(midgard_query_column, get_name, arginfo_midgard_query_column_get_name, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_column, get_qualifier, arginfo_midgard_query_column_get_qualifier, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_column, get_query_property, arginfo_midgard_query_column_get_query_property, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_column_class_entry; INIT_CLASS_ENTRY(php_midgard_query_column_class_entry, "MidgardQueryColumn", midgard_query_column_methods); php_midgard_query_column_class = zend_register_internal_class(&php_midgard_query_column_class_entry TSRMLS_CC); php_midgard_query_column_class->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; php_midgard_query_column_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_column_class, strdup("Base, abstract class for column in query result")); zend_register_class_alias("midgard_query_column", php_midgard_query_column_class); /* QueryRow */ static zend_function_entry midgard_query_row_methods[] = { PHP_ME(midgard_query_row, get_object, arginfo_midgard_query_row_get_object, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_row, get_value, arginfo_midgard_query_row_get_value, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_row, get_values, arginfo_midgard_query_row_get_values, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_row_class_entry; INIT_CLASS_ENTRY(php_midgard_query_row_class_entry, "MidgardQueryRow", midgard_query_row_methods); php_midgard_query_row_class = zend_register_internal_class(&php_midgard_query_row_class_entry TSRMLS_CC); php_midgard_query_row_class->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; php_midgard_query_row_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_row_class, strdup("Base, abstract class for a row in query result")); zend_register_class_alias("midgard_query_row", php_midgard_query_row_class); /* QuerySelector */ static zend_function_entry midgard_query_selector_methods[] = { PHP_ME(midgard_query_selector, get_connection, arginfo_midgard_query_selector_get_connection, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT) PHP_ME(midgard_query_selector, get_query_result, arginfo_midgard_query_selector_get_query_result, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT) PHP_ME(midgard_query_selector, get_query_string, arginfo_midgard_query_selector_get_query_string, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_selector_class_entry; INIT_CLASS_ENTRY(php_midgard_query_selector_class_entry, "MidgardQuerySelector", midgard_query_selector_methods); php_midgard_query_selector_class = zend_register_internal_class(&php_midgard_query_selector_class_entry TSRMLS_CC); php_midgard_query_selector_class->ce_flags |= ZEND_ACC_INTERFACE; php_midgard_query_selector_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_selector_class, strdup("Base, abstract class for a query selector")); zend_register_class_alias("midgard_query_selector", php_midgard_query_selector_class); /* QueryResult */ static zend_function_entry midgard_query_result_methods[] = { PHP_ME(midgard_query_result, get_objects, arginfo_midgard_query_result_get_objects, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_result, get_columns, arginfo_midgard_query_result_get_columns, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_result, get_rows, arginfo_midgard_query_result_get_rows, ZEND_ACC_PUBLIC) PHP_ME(midgard_query_result, get_column_names, arginfo_midgard_query_result_get_column_names, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_query_result_class_entry; INIT_CLASS_ENTRY(php_midgard_query_result_class_entry, "MidgardQueryResult", midgard_query_result_methods); php_midgard_query_result_class = zend_register_internal_class(&php_midgard_query_result_class_entry TSRMLS_CC); php_midgard_query_result_class->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; php_midgard_query_result_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_result_class, strdup("Base, abstract class for a query result")); zend_register_class_alias("midgard_query_result", php_midgard_query_result_class); /* SqlQueryResult */ static zend_class_entry php_midgard_sql_query_result_class_entry; INIT_CLASS_ENTRY(php_midgard_sql_query_result_class_entry, "MidgardSqlQueryResult", NULL); php_midgard_sql_query_result_class = zend_register_internal_class_ex(&php_midgard_sql_query_result_class_entry, php_midgard_query_result_class, "MidgardQueryResult" TSRMLS_CC); php_midgard_sql_query_result_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_result_class, strdup("SQL query result")); zend_register_class_alias("midgard_sql_query_result", php_midgard_query_result_class); /* SqlQueryColumn */ static zend_function_entry midgard_sql_query_column_methods[] = { PHP_ME(midgard_sql_query_column, __construct, arginfo_midgard_sql_query_column___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_sql_query_column_class_entry; INIT_CLASS_ENTRY(php_midgard_sql_query_column_class_entry, "MidgardSqlQueryColumn", midgard_sql_query_column_methods); php_midgard_sql_query_column_class = zend_register_internal_class_ex(&php_midgard_sql_query_column_class_entry, php_midgard_query_holder_class, "MidgardSqlQueryColumn" TSRMLS_CC); php_midgard_sql_query_column_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_column_class, strdup("SQL query column")); zend_class_implements(php_midgard_sql_query_column_class TSRMLS_CC, 1, php_midgard_query_column_class); zend_register_class_alias("midgard_sql_query_column", php_midgard_query_column_class); /* SqlQueryRow */ static zend_class_entry php_midgard_sql_query_row_class_entry; INIT_CLASS_ENTRY(php_midgard_sql_query_row_class_entry, "MidgardSqlQueryRow", NULL); php_midgard_sql_query_row_class = zend_register_internal_class_ex(&php_midgard_sql_query_row_class_entry, php_midgard_query_row_class, "MidgardSqlQueryRow" TSRMLS_CC); php_midgard_sql_query_row_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_query_row_class, strdup("SQL query row")); zend_register_class_alias("midgard_sql_query_row", php_midgard_query_row_class); /* SqlQueryConstraint */ static zend_function_entry midgard_sql_query_constraint_methods[] = { PHP_ME(midgard_sql_query_constraint, __construct, arginfo_midgard_sql_query_constraint___construct, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_constraint, get_column, arginfo_midgard_sql_query_constraint_get_column, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_constraint, get_holder, arginfo_midgard_sql_query_constraint_get_holder, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_constraint, get_operator, arginfo_midgard_sql_query_constraint_get_operator, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_constraint, set_column, arginfo_midgard_sql_query_constraint_set_column, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_constraint, set_operator, arginfo_midgard_sql_query_constraint_set_operator, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_sql_query_constraint_class_entry; INIT_CLASS_ENTRY(php_midgard_sql_query_constraint_class_entry, "MidgardSqlQueryConstraint", midgard_sql_query_constraint_methods); php_midgard_sql_query_constraint_class = zend_register_internal_class_ex(&php_midgard_sql_query_constraint_class_entry, php_midgard_query_constraint_simple_class, "MidgardQueryConstraintSimple" TSRMLS_CC); php_midgard_sql_query_constraint_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_sql_query_constraint_class, strdup("SQL query constraint")); zend_register_class_alias("midgard_sql_query_constraint", php_midgard_sql_query_constraint_class); /* SqlQuerySelectData */ static zend_function_entry midgard_sql_query_select_data_methods[] = { PHP_ME(midgard_sql_query_select_data, __construct, arginfo_midgard_sql_query_select_data___construct, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_select_data, get_columns, arginfo_midgard_sql_query_select_data_get_columns, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_select_data, add_column, arginfo_midgard_sql_query_select_data_add_column, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_select_data, get_query_result, arginfo_midgard_sql_query_select_data_get_query_result, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_select_data, get_query_string, arginfo_midgard_sql_query_select_data_get_query_string, ZEND_ACC_PUBLIC) PHP_ME(midgard_sql_query_select_data, get_connection, arginfo_midgard_sql_query_select_data_get_connection, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_sql_query_select_data_class_entry; INIT_CLASS_ENTRY(php_midgard_sql_query_select_data_class_entry, "MidgardSqlQuerySelectData", midgard_sql_query_select_data_methods); php_midgard_sql_query_select_data_class = zend_register_internal_class_ex(&php_midgard_sql_query_select_data_class_entry, php_midgard_query_executor_class, "MidgardQueryExecutor" TSRMLS_CC); php_midgard_sql_query_select_data_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_sql_query_select_data_class, strdup("SQL data selector")); zend_class_implements(php_midgard_sql_query_select_data_class TSRMLS_CC, 1, php_midgard_query_selector_class); zend_register_class_alias("midgard_sql_query_select_data", php_midgard_sql_query_select_data_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_dbus.c0000664000175000017500000000757411730073440015524 0ustar pppp/* Copyright (C) 2008 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" #include static zend_class_entry *php_midgard_dbus_class; /* Object constructor */ static PHP_METHOD(midgard_dbus, __construct) { char *path; int path_length; zend_bool use_session = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &path, &path_length, &use_session) == FAILURE) return; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); MidgardDbus *mbus = midgard_dbus_new(mgd, path, (gboolean)use_session); if (!mbus) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to init dbus subsystem"); return; } MGD_PHP_SET_GOBJECT(getThis(), mbus); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_dbus___construct, 0, 0, 1) ZEND_ARG_INFO(0, path) ZEND_ARG_INFO(0, use_session) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_dbus, send) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *path, *msg; int path_length, msg_length; zend_bool use_session = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &path, &path_length, &msg, &msg_length, &use_session) == FAILURE) return; midgard_dbus_send(mgd, path, msg, (gboolean)use_session); return; } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_dbus_send, 0, 0, 2) ZEND_ARG_INFO(0, path) ZEND_ARG_INFO(0, message) ZEND_ARG_INFO(0, use_session) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_dbus, connect) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); php_midgard_gobject_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_dbus_connect, 0, 0, 2) ZEND_ARG_INFO(0, signal) ZEND_ARG_INFO(0, callback) ZEND_ARG_INFO(0, user_data) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_dbus, get_message) { if (zend_parse_parameters_none() == FAILURE) return; MidgardDbus *mbus = MIDGARD_DBUS(__php_gobject_ptr(getThis())); const gchar *msg = midgard_dbus_get_message(mbus); if (msg) RETURN_STRING((char*)msg, 1); RETURN_NULL(); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_dbus_get_message, 0, 0, 0) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_dbus) { static zend_function_entry midgard_dbus_methods[] = { PHP_ME(midgard_dbus, __construct, arginfo_midgard_dbus___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_dbus, send, arginfo_midgard_dbus_send, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_dbus, connect, arginfo_midgard_dbus_connect, ZEND_ACC_PUBLIC) PHP_ME(midgard_dbus, get_message, arginfo_midgard_dbus_get_message, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_dbus_class_entry; INIT_CLASS_ENTRY(php_midgard_dbus_class_entry, "MidgardDbus", midgard_dbus_methods); php_midgard_dbus_class = zend_register_internal_class(&php_midgard_dbus_class_entry TSRMLS_CC); php_midgard_dbus_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_dbus_class, strdup("Sender of DBUS messages")); zend_register_class_alias("midgard_dbus", php_midgard_dbus_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_transaction.c0000664000175000017500000001217611730073440017106 0ustar pppp/* Copyright (C) 2009 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" static zend_class_entry *php_midgard_transaction_class; #define _GET_TRNS_OBJECT \ zval *zval_object = getThis(); \ if (!zval_object) \ php_error(E_ERROR, "NULL this_ptr for given midgard_transaction"); \ php_midgard_gobject *php_gobject = __php_objstore_object(zval_object); \ if (!php_gobject && !php_gobject->gobject) \ php_error(E_ERROR, "Can not find underlying zend object structure"); \ MidgardTransaction *trns = MIDGARD_TRANSACTION(php_gobject->gobject); \ if (!trns) \ php_error(E_ERROR, "Can not find underlying midgard_transaction instance"); /* Object constructor */ static PHP_METHOD(midgard_transaction, __construct) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); MidgardTransaction *trns; zval *zval_object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; trns = midgard_transaction_new(mgd); if (!trns) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } MGD_PHP_SET_GOBJECT(zval_object, trns); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_transaction___construct, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_transaction, begin) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); gboolean rv; if (zend_parse_parameters_none() == FAILURE) return; _GET_TRNS_OBJECT rv = midgard_transaction_begin(trns); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_transaction_begin, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_transaction, commit) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); gboolean rv; if (zend_parse_parameters_none() == FAILURE) return; _GET_TRNS_OBJECT rv = midgard_transaction_commit(trns); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_transaction_commit, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_transaction, rollback) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); gboolean rv; if (zend_parse_parameters_none() == FAILURE) return; _GET_TRNS_OBJECT rv = midgard_transaction_rollback(trns); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_transaction_rollback, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_transaction, get_status) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); gboolean rv; if (zend_parse_parameters_none() == FAILURE) return; _GET_TRNS_OBJECT rv = midgard_transaction_get_status(trns); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_transaction_get_status, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_transaction, get_name) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_TRNS_OBJECT const gchar *name = midgard_transaction_get_name(trns); RETURN_STRING((gchar *)name, 1); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_transaction_get_name, 0) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_transaction) { static zend_function_entry transaction_methods[] = { PHP_ME(midgard_transaction, __construct, arginfo_midgard_transaction___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_transaction, begin, arginfo_midgard_transaction_begin, ZEND_ACC_PUBLIC) PHP_ME(midgard_transaction, commit, arginfo_midgard_transaction_commit, ZEND_ACC_PUBLIC) PHP_ME(midgard_transaction, rollback, arginfo_midgard_transaction_rollback, ZEND_ACC_PUBLIC) PHP_ME(midgard_transaction, get_status, arginfo_midgard_transaction_get_status, ZEND_ACC_PUBLIC) PHP_ME(midgard_transaction, get_name, arginfo_midgard_transaction_get_name, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_transaction_class_entry; INIT_CLASS_ENTRY(php_midgard_transaction_class_entry, "MidgardTransaction", transaction_methods); php_midgard_transaction_class = zend_register_internal_class(&php_midgard_transaction_class_entry TSRMLS_CC); /* Set function to initialize underlying data */ php_midgard_transaction_class->create_object = php_midgard_gobject_new; php_midgard_transaction_class->serialize = NULL; /* FIXME, set (un)serialize for some explicit error if needed */ php_midgard_transaction_class->unserialize = NULL; CLASS_SET_DOC_COMMENT(php_midgard_transaction_class, strdup("Transaction manager")); zend_register_class_alias("midgard_transaction", php_midgard_transaction_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_replicator.c0000664000175000017500000002007311730073440016720 0ustar pppp/* Copyright (C) 2006 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" static zend_class_entry *php_midgard_replicator_class; static PHP_METHOD(midgard_replicator, export) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zobject; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobject) == FAILURE) return; gboolean exported = midgard_replicator_export(__midgard_dbobject_get_ptr(zobject)); RETURN_BOOL(exported); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_replicator_export, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, object, midgard_dbobject, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_replicator, export_by_guid) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *guid; int guid_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &guid, &guid_length) == FAILURE) return; gboolean rv = midgard_replicator_export_by_guid(mgd, (const gchar *) guid); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_replicator_export_by_guid, 0, 0, 1) ZEND_ARG_INFO(0, guid) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_replicator, export_purged) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *startdate = NULL, *enddate = NULL; int start_length, end_length; zval *ook; /* Object Or Klass name zval */ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|ss", &ook, &startdate, &start_length, &enddate, &end_length) == FAILURE) { return; } const gchar *classname; if (Z_TYPE_P(ook) == IS_STRING) { classname = (const gchar *)Z_STRVAL_P(ook); } else if (Z_TYPE_P(ook) == IS_OBJECT) { classname = (const gchar *)Z_OBJCE_P(ook)->name; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "first parameter should be object or string"); return; } MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(classname); if (!klass) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s class is not found", classname); return; } char *xml = midgard_replicator_export_purged(mgd, classname, startdate, enddate); if (xml == NULL) RETURN_NULL(); RETVAL_STRING(xml, 1); g_free(xml); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_replicator_export_purged, 0, 0, 1) ZEND_ARG_INFO(0, class) ZEND_ARG_INFO(0, startdate) ZEND_ARG_INFO(0, enddate) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_replicator, serialize) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); gchar *xml; zval *zobject; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobject) == FAILURE) return; GObject *object = __php_gobject_ptr(zobject); xml = midgard_replicator_serialize(object); if (xml == NULL) RETURN_NULL(); RETVAL_STRING(xml, 1); g_free(xml); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_replicator_serialize, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, object, midgard_dbobject, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_replicator, serialize_blob) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zobject; zend_class_entry *midgard_attachment_ce = zend_fetch_class("midgard_attachment", strlen("midgard_attachment"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zobject, midgard_attachment_ce) == FAILURE) return; gchar *xml = midgard_replicator_serialize_blob(__midgard_object_get_ptr(zobject)); if (xml == NULL) RETURN_NULL(); RETVAL_STRING(xml, 1); g_free(xml); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_replicator_serialize_blob, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, object, midgard_attachment, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_replicator, unserialize) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *xml = NULL; int xml_length; zend_bool force = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &xml, &xml_length, &force) == FAILURE) return; array_init(return_value); GObject **objects = midgard_replicator_unserialize(mgd, (const gchar *)xml, (gboolean)force); if (!objects) return; size_t i = 0; zend_class_entry *ce; while (objects[i] != NULL) { zval *zobject; MAKE_STD_ZVAL(zobject); char *class_name = (char *)G_OBJECT_TYPE_NAME(G_OBJECT(objects[i])); ce = zend_fetch_class(class_name, strlen(class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); php_midgard_gobject_new_with_gobject(zobject, ce, objects[i], TRUE TSRMLS_CC); zend_hash_next_index_insert(HASH_OF(return_value), &zobject, sizeof(zval *), NULL); i++; }; g_free(objects); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_replicator_unserialize, 0, 0, 1) ZEND_ARG_INFO(0, xml) ZEND_ARG_INFO(0, force) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_replicator, import_object) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); zval *zobject; zend_bool force = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|b", &zobject, &force) == FAILURE) return; gboolean imported = midgard_replicator_import_object(__midgard_dbobject_get_ptr(zobject), force); RETURN_BOOL(imported); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_replicator_import_object, 0, 0, 1) ZEND_ARG_INFO(0, object) ZEND_ARG_INFO(0, force) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_replicator, import_from_xml) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *xml = NULL; int xml_length; zend_bool force = FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &xml, &xml_length, &force) == FAILURE) return; midgard_replicator_import_from_xml(mgd, (const gchar *)xml, force); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_replicator_import_from_xml, 0, 0, 1) ZEND_ARG_INFO(0, xml) ZEND_ARG_INFO(0, force) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_replicator) { static zend_function_entry replicator_methods[] = { PHP_ME(midgard_replicator, export, arginfo_midgard_replicator_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_replicator, export_by_guid, arginfo_midgard_replicator_export_by_guid, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_replicator, export_purged, arginfo_midgard_replicator_export_purged, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_replicator, serialize, arginfo_midgard_replicator_serialize, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_replicator, serialize_blob, arginfo_midgard_replicator_serialize_blob, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_replicator, unserialize, arginfo_midgard_replicator_unserialize, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_replicator, import_object, arginfo_midgard_replicator_import_object, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(midgard_replicator, import_from_xml, arginfo_midgard_replicator_import_from_xml, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_replicator_class_entry; INIT_CLASS_ENTRY(php_midgard_replicator_class_entry, "MidgardReplicator", replicator_methods); php_midgard_replicator_class = zend_register_internal_class(&php_midgard_replicator_class_entry TSRMLS_CC); CLASS_SET_DOC_COMMENT(php_midgard_replicator_class, strdup("Collection of static methods for serializing, unserializing data to XML; importing and exporting it")); zend_register_class_alias("midgard_replicator", php_midgard_replicator_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_timestamp.c0000664000175000017500000002202011730073440016551 0ustar pppp/* * Copyright (C) 2009 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of\ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_timestamp.h" #include #include #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" zend_class_entry *php_midgard_datetime_class; zval * get_UTC_timezone(TSRMLS_D) { zval *timezone_object; zval *tz_str; MAKE_STD_ZVAL(tz_str); ZVAL_STRING(tz_str, "UTC", 1); MAKE_STD_ZVAL(timezone_object); object_init_ex(timezone_object, zend_date_timezone_class_ptr); zend_call_method_with_1_params(&timezone_object, zend_date_timezone_class_ptr, &zend_date_timezone_class_ptr->constructor, "__construct", NULL, tz_str); zval_ptr_dtor(&tz_str); return timezone_object; } /* Object constructor */ static PHP_METHOD(midgard_datetime, __construct) { char *time_str = "now"; int time_str_len; zval *self = getThis(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &time_str, &time_str_len) == FAILURE) return; zval *timezone_object = get_UTC_timezone(TSRMLS_C); /* Copy of time-string */ zval *dt_str; MAKE_STD_ZVAL(dt_str); ZVAL_STRING(dt_str, time_str, 1); /* Call parent constructor - parent::__construct */ zend_call_method_with_2_params(&self, zend_datetime_class_ptr, &zend_datetime_class_ptr->constructor, "__construct", NULL, dt_str, timezone_object); zval_ptr_dtor(&dt_str); zval_ptr_dtor(&timezone_object); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_datetime___construct, 0, 0, 1) ZEND_ARG_INFO(0, date) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_datetime, setTimezone) { php_error(E_WARNING, "midgard_datetime object already initialized for UTC timezone"); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_datetime_settimezone, 0, 0, 1) ZEND_ARG_INFO(0, timezone) ZEND_END_ARG_INFO() static void _set_gobject_timestamp_property(zval *zobject TSRMLS_DC) { g_assert(zobject != NULL); zval *_object = zend_read_property(php_midgard_datetime_class, zobject, "object", sizeof("object")-1, 0 TSRMLS_CC); zval *_propname = zend_read_property(php_midgard_datetime_class, zobject, "property", sizeof("property")-1, 0 TSRMLS_CC); if (Z_TYPE_P(_object) == IS_STRING && Z_STRLEN_P(_object) == 0) { return; } /* Prepare DateTime::format argument */ zval *fmt; MAKE_STD_ZVAL(fmt); ZVAL_STRING(fmt, "Y-m-d H:i:sO", 1); /* Invoke Datetime::format */ zval *_retval = NULL; zend_call_method_with_1_params(&zobject, Z_OBJCE_P(zobject), NULL, "format", &_retval, fmt); zval_ptr_dtor(&fmt); zval *date_str; MAKE_STD_ZVAL(date_str); ZVAL_STRINGL(date_str, Z_STRVAL_P(_retval), Z_STRLEN_P(_retval) - 2, 1); zval_ptr_dtor(&_retval); /* Find underlying GObject */ GObject *gobject = __php_gobject_ptr(_object); /* GObject is found, sets it property */ if (gobject) { GValue *prop_val = php_midgard_zval2gvalue(date_str TSRMLS_CC); g_object_set_property(gobject, (const gchar *) Z_STRVAL_P(_propname), prop_val); g_value_unset(prop_val); g_free(prop_val); } zval_ptr_dtor(&date_str); return; } static PHP_METHOD(midgard_datetime, setDate) { zval *this; zval *arg1, *arg2, *arg3; zval *retval; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &arg1, &arg2, &arg3) == FAILURE) { return; } this = getThis(); zend_call_method_with_3_params(&this, zend_datetime_class_ptr, (zend_function **)NULL, "setdate", &retval, arg1, arg2, arg3); zval_ptr_dtor(&retval); _set_gobject_timestamp_property(this TSRMLS_CC); RETURN_ZVAL(this, 1, 0); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_datetime_setdate, 0, 0, 3) ZEND_ARG_INFO(0, year) ZEND_ARG_INFO(0, month) ZEND_ARG_INFO(0, day) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_datetime, setTime) { zval *this; zval *retval, *arg1, *arg2, *arg3 = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &arg1, &arg2, &arg3) == FAILURE) { return; } this = getThis(); if (arg3) { zend_call_method_with_3_params(&this, zend_datetime_class_ptr, (zend_function **)NULL, "settime", &retval, arg1, arg2, arg3); } else { zend_call_method_with_2_params(&this, zend_datetime_class_ptr, (zend_function **)NULL, "settime", &retval, arg1, arg2); } zval_ptr_dtor(&retval); _set_gobject_timestamp_property(this TSRMLS_CC); RETURN_ZVAL(this, 1, 0); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_datetime_settime, 0, 0, 2) ZEND_ARG_INFO(0, hour) ZEND_ARG_INFO(0, minute) ZEND_ARG_INFO(0, second) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_datetime, setISODate) { zval *this; zval *retval, *arg1, *arg2, *arg3 = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &arg1, &arg2, &arg3) == FAILURE) { return; } this = getThis(); if (arg3) { zend_call_method_with_3_params(&this, zend_datetime_class_ptr, (zend_function **)NULL, "setisodate", &retval, arg1, arg2, arg3); } else { zend_call_method_with_2_params(&this, zend_datetime_class_ptr, (zend_function **)NULL, "setisodate", &retval, arg1, arg2); } zval_ptr_dtor(&retval); _set_gobject_timestamp_property(this TSRMLS_CC); RETURN_ZVAL(this, 1, 0); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_datetime_setisodate, 0, 0, 2) ZEND_ARG_INFO(0, year) ZEND_ARG_INFO(0, week) ZEND_ARG_INFO(0, day) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_datetime, setTimestamp) { zval *this; zval *retval, *arg1 = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg1) == FAILURE) { return; } this = getThis(); zend_call_method_with_1_params(&this, zend_datetime_class_ptr, (zend_function **)NULL, "settimestamp", &retval, arg1); zval_ptr_dtor(&retval); _set_gobject_timestamp_property(this TSRMLS_CC); RETURN_ZVAL(this, 1, 0); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_datetime_settimestamp, 0, 0, 1) ZEND_ARG_INFO(0, setTimestamp) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_datetime, modify) { zval *this; zval *arg1, *retval; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg1) == FAILURE) { return; } this = getThis(); zend_call_method_with_1_params(&this, zend_datetime_class_ptr, (zend_function **)NULL, "modify", &retval, arg1); _set_gobject_timestamp_property(this TSRMLS_CC); RETURN_ZVAL(retval, 1, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_datetime_modify, 0, 0, 1) ZEND_ARG_INFO(0, date) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_datetime, __toString) { if (zend_parse_parameters_none() == FAILURE) return; zval *zend_object = getThis(); /* Prepare DateTime::format argument */ zval *fmt; MAKE_STD_ZVAL(fmt); ZVAL_STRING(fmt, "c", 1); /* Invoke Datetime::format */ zval *retval = NULL; zend_call_method_with_1_params(&zend_object, Z_OBJCE_P(zend_object), NULL, "format", &retval, fmt); zval_ptr_dtor(&fmt); RETURN_ZVAL(retval, 1, 1); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_datetime___tostring, 0, 0, 0) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_datetime) { static zend_function_entry midgard_datetime_methods[] = { PHP_ME(midgard_datetime, __construct, arginfo_midgard_datetime___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_datetime, setTimezone, arginfo_midgard_datetime_settimezone, ZEND_ACC_PUBLIC) PHP_ME(midgard_datetime, setTime, arginfo_midgard_datetime_settime, ZEND_ACC_PUBLIC) PHP_ME(midgard_datetime, setDate, arginfo_midgard_datetime_setdate, ZEND_ACC_PUBLIC) PHP_ME(midgard_datetime, setISODate, arginfo_midgard_datetime_setisodate, ZEND_ACC_PUBLIC) PHP_ME(midgard_datetime, setTimestamp, arginfo_midgard_datetime_settimestamp, ZEND_ACC_PUBLIC) PHP_ME(midgard_datetime, modify, arginfo_midgard_datetime_modify, ZEND_ACC_PUBLIC) PHP_ME(midgard_datetime, __toString, arginfo_midgard_datetime___tostring, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_datetime_class_entry; INIT_CLASS_ENTRY(php_midgard_datetime_class_entry, "MidgardDatetime", midgard_datetime_methods); php_midgard_datetime_class = zend_register_internal_class_ex(&php_midgard_datetime_class_entry, zend_datetime_class_ptr, "DateTime" TSRMLS_CC); CLASS_SET_DOC_COMMENT(php_midgard_datetime_class, strdup("Midgard's version of DateTime class")); /* Register properties */ zend_declare_property_string(php_midgard_datetime_class, "object", sizeof("object")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC); zend_declare_property_string(php_midgard_datetime_class, "property", sizeof("property")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC); zend_register_class_alias("midgard_datetime", php_midgard_datetime_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_object.h0000664000175000017500000000465211730073440016034 0ustar pppp/* * Copyright (C) 2007 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ PHP_FUNCTION(_midgard_php_object_constructor); /* FIXME , change name */ PHP_FUNCTION(_midgard_php_object_get_by_id); PHP_FUNCTION(_midgard_php_object_get_by_guid); PHP_FUNCTION(_midgard_php_object_update); PHP_FUNCTION(_midgard_php_object_create); PHP_FUNCTION(_midgard_php_object_is_in_parent_tree); PHP_FUNCTION(_midgard_php_object_is_in_tree); PHP_FUNCTION(_midgard_php_object_get_tree); PHP_FUNCTION(_midgard_php_object_delete); PHP_FUNCTION(_midgard_php_object_get_parent); PHP_FUNCTION(_midgard_php_object_list); PHP_FUNCTION(_midgard_php_object_list_children); PHP_FUNCTION(_midgard_php_object_get_by_path); PHP_FUNCTION(_midgard_php_object_parent); PHP_FUNCTION(_php_midgard_object_get_languages); PHP_FUNCTION(_php_midgard_object_purge); PHP_FUNCTION(_php_midgard_object_undelete); PHP_FUNCTION(_php_midgard_object_export); PHP_FUNCTION(_php_midgard_object_parameter); /* parameters */ PHP_FUNCTION(php_midgard_object_has_parameters); PHP_FUNCTION(_php_midgard_object_parameter); PHP_FUNCTION(_php_midgard_object_get_parameter); PHP_FUNCTION(_php_midgard_object_set_parameter); PHP_FUNCTION(_php_midgard_object_list_parameters); PHP_FUNCTION(_php_midgard_object_delete_parameters); PHP_FUNCTION(_php_midgard_object_purge_parameters); PHP_FUNCTION(_php_midgard_object_find_parameters); /* attachments */ PHP_FUNCTION(php_midgard_object_has_attachments); PHP_FUNCTION(_php_midgard_object_create_attachment); PHP_FUNCTION(_php_midgard_object_serve_attachment); PHP_FUNCTION(_php_midgard_object_list_attachments); PHP_FUNCTION(_php_midgard_object_delete_attachments); PHP_FUNCTION(_php_midgard_object_purge_attachments); PHP_FUNCTION(_php_midgard_object_find_attachments); php5-midgard2-10.05.7/php_midgard_storage.c0000664000175000017500000001105011730073440016213 0ustar pppp/* Copyright (C) 2009 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" static zend_class_entry *php_midgard_storage_class; static PHP_METHOD(midgard_storage, create_base_storage) { RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; zend_bool rv = (zend_bool) midgard_storage_create_base_storage(mgd_handle(TSRMLS_C)); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_storage_create_base_storage, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_storage, create_class_storage) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); gchar *classname; gint classname_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) { return; } zend_bool rv = (zend_bool) midgard_storage_create(mgd, php_class_name_to_g_class_name(classname)); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_storage_create_class_storage, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_storage, update_class_storage) { RETVAL_FALSE; gchar *classname; gint classname_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) { return; } zend_bool rv = (zend_bool) midgard_storage_update(mgd_handle(TSRMLS_C), php_class_name_to_g_class_name(classname)); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_storage_update_class_storage, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_storage, delete_class_storage) { RETVAL_FALSE; gchar *classname; gint classname_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) { return; } zend_bool rv = (zend_bool) midgard_storage_delete(mgd_handle(TSRMLS_C), php_class_name_to_g_class_name(classname)); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_storage_delete_class_storage, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_storage, class_storage_exists) { RETVAL_FALSE; gchar *classname; gint classname_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) { return; } zend_bool rv = (zend_bool) midgard_storage_exists(mgd_handle(TSRMLS_C), php_class_name_to_g_class_name(classname)); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_storage_class_storage_exists, 0, 0, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() /* Initialize ZEND&PHP class */ PHP_MINIT_FUNCTION(midgard2_storage) { static zend_function_entry midgard_storage_methods[] = { PHP_ME(midgard_storage, create_base_storage, arginfo_midgard_storage_create_base_storage, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_storage, create_class_storage, arginfo_midgard_storage_create_class_storage, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_storage, update_class_storage, arginfo_midgard_storage_update_class_storage, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_storage, delete_class_storage, arginfo_midgard_storage_delete_class_storage, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_ME(midgard_storage, class_storage_exists, arginfo_midgard_storage_class_storage_exists, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_storage_class_entry; INIT_CLASS_ENTRY(php_midgard_storage_class_entry, "MidgardStorage", midgard_storage_methods); php_midgard_storage_class = zend_register_internal_class(&php_midgard_storage_class_entry TSRMLS_CC); php_midgard_storage_class->create_object = NULL; CLASS_SET_DOC_COMMENT(php_midgard_storage_class, strdup("Collection of static methods for managing underlying data storage")); zend_register_class_alias("midgard_storage", php_midgard_storage_class); return SUCCESS; } php5-midgard2-10.05.7/php_midgard_urlwrapper.h0000664000175000017500000000270111730073440016762 0ustar pppp/* Copyright (C) 2010 Alexey Zakhlestin * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ php_stream * php_midgard2stream_opener(php_stream_wrapper *wrapper, char *filename, char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC); int php_midgard2stream_closer(php_stream *stream, int close_handle TSRMLS_DC); size_t php_midgard2stream_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC); size_t php_midgard2stream_read(php_stream *stream, char *buf, size_t count TSRMLS_DC); int php_midgard2stream_flush(php_stream *stream TSRMLS_DC); int php_midgard2stream_seek(php_stream *stream, off_t offset, int whence, off_t *newoffset TSRMLS_DC); int php_midgard2stream_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC); php5-midgard2-10.05.7/php_midgard_timestamp.h0000664000175000017500000000266611730073440016574 0ustar pppp/* * Copyright (C) 2009 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of\ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef PHP_MIDGARD_TIMESAMP_H #define PHP_MIDGARD_TIMESTAMP_H /* GLOBALS */ extern zend_class_entry *zend_datetime_class_ptr; extern zend_class_entry *zend_date_timezone_class_ptr; /* ROUTINES */ gboolean php_midgard_is_property_timestamp(MidgardDBObjectClass *klass, const gchar *property); void php_midgard_datetime_from_gvalue(const GValue *gval, zval *zvalue TSRMLS_DC); zval *php_midgard_datetime_object_from_property(zval *object, const gchar *property TSRMLS_DC); zval *php_midgard_datetime_get_timestamp(const zval *object TSRMLS_DC); zval *php_midgard_datetime_get_timestamp_from_gval(const GValue *gval TSRMLS_DC); #endif /* PHP_MIDGARD_TIMESTAMP_H */ php5-midgard2-10.05.7/pake/0000775000175000017500000000000011730073440012770 5ustar ppppphp5-midgard2-10.05.7/pake/create_database.php0000664000175000017500000000320211730073440016565 0ustar ppppread_file_at_path($_SERVER['PAKE_MIDGARD_CFG']); $cfg->create_blobdir(); $mgd = midgard_connection::get_instance(); $res = $mgd->open_config($cfg); if (false === $res) { throw new RuntimeException('connection failed: '.$mgd->get_error_string()); } echo "midgard_storage: create_base_storage\n"; midgard_storage::create_base_storage(); $re = new ReflectionExtension("midgard2"); foreach ($re->getClasses() as $class_ref) { $class_mgd_ref = new midgard_reflection_class($class_ref->getName()); $parent_class = $class_mgd_ref->getParentClass(); $name = $class_mgd_ref->getName(); if (!is_subclass_of ($name, 'MidgardDBObject') || $class_mgd_ref->isAbstract()) { continue; } echo 'midgard_storage: create_class_storage('.$name.")\n"; if (true !== midgard_storage::create_class_storage($name)) { throw new Exception('Failed to create storage for "'.$name.': "'.midgard_connection::get_instance()->get_error_string()); } } exit(0); php5-midgard2-10.05.7/php_midgard_blob.c0000664000175000017500000001505011730073440015471 0ustar pppp/* Copyright (C) 2007, 2008 Piotr Pokora * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" #include #include static zend_class_entry *php_midgard_blob_class; #define _GET_BLOB_OBJECT \ zval *zval_object = getThis(); \ MidgardBlob *blob = MIDGARD_BLOB(__php_gobject_ptr(zval_object)); \ if (!blob) \ php_error(E_ERROR, "Can not find underlying blob instance"); static PHP_METHOD(midgard_blob, __construct) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); MidgardBlob *blob = NULL; zval *param_object = NULL; zval *zval_object = getThis(); char *encoding = NULL; int encoding_length; zend_class_entry *midgard_attachment_ce = zend_fetch_class("midgard_attachment", strlen("midgard_attachment"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|s", ¶m_object, midgard_attachment_ce, &encoding, &encoding_length) == FAILURE) return; php_midgard_gobject *ppo = __php_objstore_object(param_object); if (!ppo) { zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Attachment seems to be uninitialized"); return; } MidgardObject *att = MIDGARD_OBJECT(ppo->gobject); blob = midgard_blob_new(att, encoding); if (!blob) { php_midgard_error_exception_throw(mgd TSRMLS_CC); return; } MGD_PHP_SET_GOBJECT(zval_object, blob); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_blob___construct, 0, 0, 1) ZEND_ARG_OBJ_INFO(0, attachment, midgard_attachment, 0) ZEND_ARG_INFO(0, encoding) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_blob, read_content) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); gchar *content; gsize bytes_read = 0; if (zend_parse_parameters_none() == FAILURE) return; _GET_BLOB_OBJECT; content = midgard_blob_read_content(blob, &bytes_read); if (content == NULL) { php_error(E_WARNING, "Failed to get blob-contents: %s", mgd->errstr); RETURN_NULL(); } RETURN_STRINGL(content, bytes_read, 1); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_blob_read_content, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_blob, write_content) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *content; int content_length; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &content, &content_length) == FAILURE) return; _GET_BLOB_OBJECT; gboolean rv = midgard_blob_write_content(blob, (const gchar *)content); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_blob_write_content, 0, 0, 1) ZEND_ARG_INFO(0, content) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_blob, remove_file) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_BLOB_OBJECT; gboolean rv = midgard_blob_remove_file(blob, NULL); RETURN_BOOL(rv); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_blob_remove_file, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_blob, get_handler) { MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); char *mode = "w"; int mode_length = 1; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &mode, &mode_length) == FAILURE) return; _GET_BLOB_OBJECT; const gchar *path = midgard_blob_get_path(blob); /* php_streams require paths so no filehandler or channel here */ /* GIOChannel *channel = midgard_blob_get_handler(blob); */ php_stream *stream = php_stream_open_wrapper_ex( (char *)path, mode, IGNORE_PATH | IGNORE_URL | STREAM_DISABLE_OPEN_BASEDIR, NULL, NULL ); if (stream == NULL) { php_error_docref1(NULL TSRMLS_CC, mode, E_WARNING, "Failed to open stream. Might be permissions issue"); return; } php_stream_to_zval(stream, return_value); } ZEND_BEGIN_ARG_INFO_EX(arginfo_midgard_blob_get_handler, 0, 0, 0) ZEND_ARG_INFO(0, mode) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_blob, get_path) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_BLOB_OBJECT; const gchar *path = midgard_blob_get_path(blob); if (!path) RETURN_NULL(); RETURN_STRING((gchar *)path, 1); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_blob_get_path, 0) ZEND_END_ARG_INFO() static PHP_METHOD(midgard_blob, exists) { RETVAL_FALSE; MidgardConnection *mgd = mgd_handle(TSRMLS_C); CHECK_MGD(mgd); if (zend_parse_parameters_none() == FAILURE) return; _GET_BLOB_OBJECT; RETURN_BOOL(midgard_blob_exists(blob)); } ZEND_BEGIN_ARG_INFO(arginfo_midgard_blob_exists, 0) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_blob) { static zend_function_entry blob_methods[] = { PHP_ME(midgard_blob, __construct, arginfo_midgard_blob___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(midgard_blob, read_content, arginfo_midgard_blob_read_content, ZEND_ACC_PUBLIC) PHP_ME(midgard_blob, write_content, arginfo_midgard_blob_write_content, ZEND_ACC_PUBLIC) PHP_ME(midgard_blob, remove_file, arginfo_midgard_blob_remove_file, ZEND_ACC_PUBLIC) PHP_ME(midgard_blob, get_handler, arginfo_midgard_blob_get_handler, ZEND_ACC_PUBLIC) PHP_ME(midgard_blob, get_path, arginfo_midgard_blob_get_path, ZEND_ACC_PUBLIC) PHP_ME(midgard_blob, exists, arginfo_midgard_blob_exists, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry php_midgard_blob_class_entry; INIT_CLASS_ENTRY(php_midgard_blob_class_entry, "MidgardBlob", blob_methods); php_midgard_blob_class = zend_register_internal_class(&php_midgard_blob_class_entry TSRMLS_CC); php_midgard_blob_class->create_object = php_midgard_gobject_new; CLASS_SET_DOC_COMMENT(php_midgard_blob_class, strdup("Wrapper around midgard_attachment object, which provides high-level API for working with larget binary entities")); zend_register_class_alias("midgard_blob", php_midgard_blob_class); return SUCCESS; } php5-midgard2-10.05.7/Pakefile.php0000664000175000017500000001235111730073440014303 0ustar pppp injecting dependencies pakePhpExtensionTask::$tasks['test'][1][] = 'init_tests'; pakePhpExtensionTask::$tasks['test'][1][] = 'init_test_db'; pakePhpExtensionTask::$tasks['clean'][1][] = 'clean_test_db'; pakePhpExtensionTask::$tasks['clean'][1][] = 'clean_tests'; // -> registering tasks pakePhpExtensionTask::import_default_tasks(); // DONE function run_init_test_db() { $cfg = _get_midgard_config(); pake_echo_comment('Creating empty database for tests… (be patient, it takes time)'); putenv('MIDGARD_ENV_GLOBAL_SHAREDIR='._SRC_DIR_.'/tests/share'.''); putenv('PAKE_MIDGARD_CFG='._SRC_DIR_.'/tests/test.cfg'); pake_sh(_get_php_executable().' -c '.escapeshellarg(_SRC_DIR_.'/tests').' '.escapeshellarg(_SRC_DIR_.'/pake/create_database.php'), false); } function run_init_tests($task, $args, $long_args) { pake_echo_comment('Creating tests from templates'); $path = _SRC_DIR_.'/tests'; $src_path = _SRC_DIR_.'/tests_templates'; $tokens = array( 'PATH' => $path, 'SHARE_PATH' => $path.'/share', 'BLOB_PATH' => $path.'/blobs', 'CFG_FILE' => $path.'/test.cfg' ); if (isset($long_args['mysql'])) { $tokens['DB_TYPE'] = 'MySQL'; $tokens['DB_NAME'] = pake_input('Database name?', 'midgard'); $tokens['DB_USER'] = pake_input('Database user?', 'midgard'); $tokens['DB_PASS'] = pake_input('Database password?', 'midgard'); $tokens['DB_HOST'] = pake_input('Database host?', 'localhost'); } else { $tokens['DB_TYPE'] = 'SQLite'; $tokens['DB_NAME'] = 'test'; $tokens['DB_USER'] = ''; $tokens['DB_PASS'] = ''; $tokens['DB_HOST'] = ''; } $files = pakeFinder::type('file')->ignore_version_control()->relative()->in($src_path); pake_replace_tokens_to_dir($files, $src_path, $path, '[[', ']]', $tokens); } function run_clean_tests() { $path = _SRC_DIR_.'/tests'; $src_path = _SRC_DIR_.'/tests_templates'; // clean runtime-generated files $finder = pakeFinder::type('file')->ignore_version_control()->name('*.php', '*.exp', '*.out', '*.log', '*.diff', '*.sh', '*.mem'); pake_remove($finder, $path); // clean "generated" tests $_files = pakeFinder::type('file')->ignore_version_control()->relative()->in($src_path); $finder = pakeFinder::type('file')->ignore_version_control(); call_user_func_array(array($finder, 'name'), $_files); pake_remove($finder, $path); pake_remove(pakeFinder::type('file')->name('tmp-php.ini'), _SRC_DIR_); } function run_clean_test_db($task, $args, $long_args) { if (isset($long_args['mysql'])) { $db_name = pake_input('Database name?', 'midgard'); $db_user = pake_input('Database user?', 'midgard'); $db_pass = pake_input('Database password?', 'midgard'); $db_host = pake_input('Database host?', 'localhost'); $db = new pakeMySQL($db_user, $db_pass, $db_host); $db->dropDatabase($db_name); $db->createDatabase($db_name); } else { $file = _SRC_DIR_.'/tests/'._get_midgard_config()->database.'.db'; if (file_exists($file)) pake_remove($file, ''); } } function run_enable_midgard() { pake_echo_comment('Enabling midgard2 extension'); if (extension_loaded('midgard2')) { throw new LogicException('Please disable midgard2-extension in php.ini. test-suite will enable it automatically'); } if (ini_get('enable_dl') != 1) { throw new LogicException('Please enable "enable_dl" setting in php.ini. it is required for proper work of tests'); } ini_set('midgard.http', 'Off'); dl('midgard2.so'); } // Support tools function _get_midgard_config() { static $cfg = null; if (null === $cfg) { $cfg = new midgard_config(); $cfg->read_file_at_path(_SRC_DIR_.'/tests/test.cfg'); } return $cfg; } function _get_php_executable() { static $php_exec = null; if (null === $php_exec) { if (!file_exists(_SRC_DIR_.'/Makefile')) { throw new LogicException("Makefile is missing. You have to build extension before testing it!"); } $makefile = file(_SRC_DIR_.'/Makefile'); foreach ($makefile as $row) { if (strpos($row, 'PHP_EXECUTABLE = ') !== 0) continue; $row = rtrim($row); $parts = explode(' = ', $row); if (!isset($parts[1]) or strlen($parts[1]) == 0) continue; $php_exec = $parts[1]; break; } unset($makefile); } if (!$php_exec) { // Fallback $php_exec = 'php'; } return $php_exec; } php5-midgard2-10.05.7/config.m40000664000175000017500000000620611730073440013563 0ustar ppppdnl Copyright (C) 2007 Piotr Pokora dnl Copyright (C) 2010 Alexey Zakhlestin dnl dnl This program is free software; you can redistribute it and/or modify it dnl under the terms of the GNU Lesser General Public License as published dnl by the Free Software Foundation; either version 2 of the License, or dnl (at your option) any later version. dnl dnl This program is distributed in the hope that it will be useful, dnl but WITHOUT ANY WARRANTY; without even the implied warranty of dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the dnl GNU General Public License for more details. dnl dnl You should have received a copy of the GNU General Public License dnl along with this program; if not, write to the Free Software dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA PHP_ARG_WITH(midgard2, for midgard2 support, [ --with-midgard2 Enable midgard2 support], yes) if test "$PHP_MIDGARD2" != "no"; then if test -z "$PKG_CONFIG"; then AC_PATH_PROG(PKG_CONFIG, pkg-config, no) fi if test -f "$PKG_CONFIG"; then if $PKG_CONFIG --atleast-version=10.05.6 midgard2; then MIDGARD2_INCLINE=`$PKG_CONFIG --cflags midgard2` MIDGARD2_LIBLINE=`$PKG_CONFIG --libs midgard2` else AC_MSG_ERROR([Midgard2 version 10.05.6 or greater required.]) fi PHP_EVAL_INCLINE($MIDGARD2_INCLINE) PHP_EVAL_LIBLINE($MIDGARD2_LIBLINE, MIDGARD2_SHARED_LIBADD) CFLAGS="$CFLAGS -Wall -fno-strict-aliasing" if test "$php_always_shared" = "yes"; then AC_DEFINE(MGD_INCLUDE_PHP_CONFIG, 1, [ ]) fi PHP_SUBST(MIDGARD2_SHARED_LIBADD) AC_DEFINE(HAVE_MIDGARD, 1, [ ]) PHP_NEW_EXTENSION(midgard2, \ midgard.c query_builder.c \ php_midgard_reflection_property.c php_midgard_collector.c php_midgard_object_parameter.c \ php_midgard_object_attachment.c php_midgard_config.c php_midgard_gobject_closures.c \ php_midgard_gobject_generic.c php_midgard_user.c php_midgard_blob.c php_midgard_object_class.c \ php_midgard_functions.c php_midgard_connection.c php_midgard_object.c php_midgard_replicator.c \ php_midgard_dbus.c php_midgard_timestamp.c php_midgard_timestamp_api.c php_midgard_error.c \ php_midgard_handle.c php_midgard_transaction.c php_midgard__helpers.c php_midgard_view.c \ php_midgard_storage.c php_reflection_workaround.c php_midgard_key_config_context.c \ php_midgard_key_config_file_context.c php_midgard_key_config.c php_midgard_key_config_file.c \ php_midgard_urlwrapper.c php_midgard_query.c php_midgard_query_storage.c php_midgard_query_holders.c \ php_midgard_query_constraints.c php_midgard_reflector_object.c php_midgard_reflector_property.c \ php_midgard_query_executors.c php_midgard_g_mainloop.c php_midgard_workspace_storage.c php_midgard_base_interface.c \ php_midgard_repligard.c php_midgard_query_selectors.c, $ext_shared) PHP_ADD_EXTENSION_DEP(midgard2, spl) else AC_MSG_ERROR(Ooops ! no pkg-config found .... ) fi fi php5-midgard2-10.05.7/php_reflection_workaround.c0000664000175000017500000003035311730073440017474 0ustar pppp/* * Copyright (C) 2009 Piotr Pokora * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of\ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include "php_midgard.h" #include "php_midgard_gobject.h" #include "php_midgard__helpers.h" /* ReflectionMethod::getDocComment workaround */ static GHashTable *midgard_classes = NULL; void __initialize_midgard_classes_hash (void) { if (midgard_classes == NULL) midgard_classes = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify)g_hash_table_destroy); return; } void php_midgard_docs_add_class (const gchar *classname) { GHashTable *class_methods = g_hash_table_lookup (midgard_classes, (gpointer) classname); if (!class_methods) { class_methods = g_hash_table_new (g_str_hash, g_str_equal); /* Do not copy classname, it's available till module unload */ g_hash_table_insert (midgard_classes, (gpointer)classname, (gpointer)class_methods); } } void php_midgard_docs_add_method_comment (const gchar *classname, const gchar *method, const gchar *comment) { php_midgard_docs_add_class (classname); GHashTable *class_methods = g_hash_table_lookup (midgard_classes, (gpointer) classname); /* Do not copy, comment is static */ g_hash_table_insert (class_methods, (gpointer)method, (gpointer)comment); } const char* php_midgard_docs_get_method_comment (const gchar *classname, const gchar *method) { GHashTable *class_methods = g_hash_table_lookup (midgard_classes, (gpointer) classname); if (!class_methods) return ""; const char *comment = (const char *) g_hash_table_lookup (class_methods, method); return comment ? comment : ""; } /* End of ReflectionMethod::getDocComment workaround */ /* copypasted from php_reflection.c {{{ */ typedef enum { REF_TYPE_OTHER = 0, /* Must be 0 */ REF_TYPE_FUNCTION, REF_TYPE_PARAMETER, REF_TYPE_PROPERTY } reflection_type_t; typedef struct { zend_object zo; void *ptr; reflection_type_t ref_type; zval *obj; zend_class_entry *ce; } reflection_object; #define GET_REFLECTION_OBJECT_PTR(target) \ intern = (reflection_object *) zend_object_store_get_object(getThis() TSRMLS_CC); \ if (intern == NULL || intern->ptr == NULL) { \ zend_error(E_ERROR, "Internal error: Failed to retrieve the reflection object"); \ } \ target = intern->ptr; \ /* }}} */ static zend_class_entry *php_midgard_reflection_method_class = NULL; static zend_class_entry *php_midgard_reflection_class_class = NULL; static zend_class_entry *zend_reflection_function_class = NULL; static zend_class_entry *zend_reflection_class_class = NULL; static PHP_METHOD(php_midgard_reflection_method, __construct) { zval *this = getThis(); zval *arg1, *arg2; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &arg1, &arg2) == FAILURE) return; zend_call_method_with_2_params(&this, zend_reflection_function_class, &zend_reflection_function_class->constructor, "__construct", NULL, arg1, arg2); } static PHP_METHOD(php_midgard_reflection_method, getDocComment) { reflection_object *intern; zend_function *fptr; RETVAL_FALSE; if (zend_parse_parameters_none() == FAILURE) return; GET_REFLECTION_OBJECT_PTR(fptr); if (fptr->type == ZEND_USER_FUNCTION) { #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 RETURN_FALSE; #endif if (fptr->op_array.doc_comment) { RETURN_STRINGL(fptr->op_array.doc_comment, fptr->op_array.doc_comment_len, 1); } else { RETURN_FALSE; } } else { zval *ref_class = zend_read_property(php_midgard_reflection_class_class, getThis(), "class", sizeof("class")-1, 0 TSRMLS_CC); \ zval *ref_method = zend_read_property(php_midgard_reflection_class_class, getThis(), "name", sizeof("name")-1, 0 TSRMLS_CC); \ if (!ref_class || !ref_method) RETURN_FALSE; const char *comment = php_midgard_docs_get_method_comment((const gchar *) Z_STRVAL_P(ref_class), (const gchar *) Z_STRVAL_P(ref_method)); RETURN_STRING ((char *)comment, 1); } } /* ReflectionClass */ #define _GET_RC_CE \ zval *_ref_class; \ zend_class_entry *ce = NULL; \ _ref_class = zend_read_property(php_midgard_reflection_class_class, getThis(), "name", sizeof("name")-1, 0 TSRMLS_CC); \ if (_ref_class) { \ ce = zend_fetch_class(Z_STRVAL_P(_ref_class), Z_STRLEN_P(_ref_class), ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); \ } \ static PHP_METHOD(php_midgard_reflection_class, __construct) { zval *classname = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &classname) == FAILURE) return; zval *this = getThis(); zend_call_method_with_1_params(&this, zend_reflection_class_class, &zend_reflection_class_class->constructor, "__construct", NULL, classname); } ZEND_BEGIN_ARG_INFO_EX(php_midgard_reflection_class___construct, ZEND_SEND_BY_VAL, ZEND_RETURN_VALUE, 1) ZEND_ARG_INFO(0, classname) ZEND_END_ARG_INFO() static PHP_METHOD(php_midgard_reflection_class, getDocComment) { if (zend_parse_parameters_none() == FAILURE) { return; } _GET_RC_CE; if (ce == NULL) RETURN_NULL(); #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 3 RETURN_STRING(ce->info.user.doc_comment ? ce->info.user.doc_comment : "", 1); #else RETURN_STRING(ce->doc_comment ? ce->doc_comment : "", 1); #endif } static PHP_METHOD(php_midgard_reflection_class, listSignals) { if (zend_parse_parameters_none() == FAILURE) { return; } _GET_RC_CE; if (ce == NULL) return; array_init(return_value); GType classtype = g_type_from_name(php_class_name_to_g_class_name(ce->name)); if (!classtype) { return; } guint n_ids = 0; guint *ids = g_signal_list_ids(classtype, &n_ids); if (ids == NULL) { return; } size_t i; for (i = 0; i < n_ids; i++) { zval *signalname; MAKE_STD_ZVAL(signalname); ZVAL_STRING(signalname, (char *) g_signal_name(ids[i]), 1); zend_hash_next_index_insert(HASH_OF(return_value), &signalname, sizeof(zval *), NULL); } g_free(ids); } static PHP_METHOD(php_midgard_reflection_class, getParentClass) { if (zend_parse_parameters_none() == FAILURE) { return; } zval *this = getThis(); zval *parent_class = NULL; zend_call_method_with_0_params(&this, zend_reflection_class_class, NULL, "getparentclass", &parent_class); if (Z_TYPE_P(parent_class) == IS_BOOL) { zval_ptr_dtor(&parent_class); RETURN_FALSE; } zval *class_name = NULL; zend_call_method_with_0_params(&parent_class, zend_reflection_class_class, NULL, "getname", &class_name); zval_ptr_dtor(&parent_class); object_init_ex(return_value, php_midgard_reflection_class_class); zend_call_method_with_1_params(&return_value, php_midgard_reflection_class_class, &php_midgard_reflection_class_class->constructor, "__construct", NULL, class_name ); zval_ptr_dtor(&class_name); } static PHP_METHOD(php_midgard_reflection_class, getMethods) { zval *filter = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &filter) == FAILURE) return; zval *this = getThis(); zval *class_name = NULL; zend_call_method_with_0_params(&this, zend_reflection_class_class, NULL, "getname", &class_name); zval *result = NULL; if (filter) { zend_call_method_with_1_params(&this, zend_reflection_class_class, NULL, "getmethods", &result, filter); } else { zend_call_method_with_0_params(&this, zend_reflection_class_class, NULL, "getmethods", &result); } array_init(return_value); HashTable *parent_ht = Z_ARRVAL_P(result); for( zend_hash_internal_pointer_reset(parent_ht); zend_hash_has_more_elements(parent_ht) == SUCCESS; zend_hash_move_forward(parent_ht) ) { zval **ppzval = NULL; zend_hash_get_current_data(parent_ht, (void**)&ppzval); zval *method_name = NULL; zend_call_method_with_0_params(ppzval, zend_reflection_function_class, NULL, "getname", &method_name); zval *new_obj = NULL; MAKE_STD_ZVAL(new_obj); object_init_ex(new_obj, php_midgard_reflection_method_class); zend_call_method_with_2_params(&new_obj, php_midgard_reflection_method_class, &php_midgard_reflection_method_class->constructor, "__construct", NULL, class_name, method_name ); zval_ptr_dtor(&method_name); add_next_index_zval(return_value, new_obj); } zval_ptr_dtor(&result); zval_ptr_dtor(&class_name); } ZEND_BEGIN_ARG_INFO_EX(php_midgard_reflection_class_getMethods, 0, 0, 0) ZEND_ARG_INFO(0, filter) ZEND_END_ARG_INFO() static PHP_METHOD(php_midgard_reflection_class, get_user_value) { char *field_name = NULL; int field_name_len = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &field_name, &field_name_len) == FAILURE) return; zval *this = getThis(); zval *class_name = NULL; zend_call_method_with_0_params(&this, zend_reflection_class_class, NULL, "getname", &class_name); const gchar *value = midgard_reflector_object_get_schema_value(Z_STRVAL_P(class_name), field_name); zval_ptr_dtor(&class_name); if (value) RETURN_STRING(value, 1); RETURN_NULL(); } ZEND_BEGIN_ARG_INFO_EX(php_midgard_reflection_class_get_user_value, 0, 0, 1) ZEND_ARG_INFO(0, fieldname) ZEND_END_ARG_INFO() PHP_MINIT_FUNCTION(midgard2_reflection_workaround) { __initialize_midgard_classes_hash (); zend_reflection_function_class = php_midgard_get_class_ptr_by_name("reflectionmethod" TSRMLS_CC); zend_reflection_class_class = php_midgard_get_class_ptr_by_name("reflectionclass" TSRMLS_CC); /* Extend ReflectionMethod */ static zend_function_entry midgard_reflection_method_methods[] = { PHP_ME(php_midgard_reflection_method, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(php_midgard_reflection_method, getDocComment, NULL, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; /* Extend ReflectionClass */ static zend_function_entry midgard_reflection_class_methods[] = { PHP_ME(php_midgard_reflection_class, __construct, php_midgard_reflection_class___construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(php_midgard_reflection_class, getDocComment, NULL, ZEND_ACC_PUBLIC) PHP_ME(php_midgard_reflection_class, listSignals, NULL, ZEND_ACC_PUBLIC) PHP_ME(php_midgard_reflection_class, getParentClass, NULL, ZEND_ACC_PUBLIC) PHP_ME(php_midgard_reflection_class, getMethods, php_midgard_reflection_class_getMethods, ZEND_ACC_PUBLIC) PHP_ME(php_midgard_reflection_class, get_user_value, php_midgard_reflection_class_get_user_value, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; static zend_class_entry _reflection_ce; INIT_CLASS_ENTRY(_reflection_ce, "midgard_reflection_method", midgard_reflection_method_methods); php_midgard_reflection_method_class = zend_register_internal_class_ex(&_reflection_ce, zend_reflection_function_class, NULL TSRMLS_CC); CLASS_SET_DOC_COMMENT(php_midgard_reflection_method_class, strdup("Helps Midgard to show doc_comments of methods of internal classes")); php_midgard_docs_add_method_comment("midgard_reflection_method", "getDocComment", "returns doc_comment of method"); INIT_CLASS_ENTRY(_reflection_ce, "midgard_reflection_class", midgard_reflection_class_methods); php_midgard_reflection_class_class = zend_register_internal_class_ex(&_reflection_ce, zend_reflection_class_class, NULL TSRMLS_CC); CLASS_SET_DOC_COMMENT(php_midgard_reflection_class_class, strdup("Helps Midgard to show doc_comments of internal classes")); return SUCCESS; }