C++ PHP_FE函数代码示例

#include "php_swap.h"

#if COMPILE_DL_SWAP
ZEND_GET_MODULE(swap)
#endif

static const zend_function_entry swap_functions[] = {
  PHP_FE(swap, NULL)
  PHP_FE_END
};

zend_module_entry swap_module_entry = {
  STANDARD_MODULE_HEADER,
  "Swap",                       // your extension name
  swap_functions,               // where you define your functions
  NULL, // PHP_MINIT(swap),     // for module initialization
  NULL, // PHP_MSHUTDOWN(swap), // for module shutdown process
  NULL, // PHP_RINIT(swap)      // for request initialization
  NULL, // PHP_RSHUTDOWN(swap)  // for reqeust shutdown process
  NULL, // PHP_MINFO(swap),     // for providing module information
  "0.1",
  STANDARD_MODULE_PROPERTIES
};

// Remove the comment if you want to initiazlie something (class entry, resource entry, constants ... etc)
/*
PHP_MINIT_FUNCTION(swap) {
  return SUCCESS;
}
PHP_MSHUTDOWN_FUNCTION(swap) {
  return SUCCESS;

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_filter_has_var, 0, 0, 2)
	ZEND_ARG_INFO(0, type)
	ZEND_ARG_INFO(0, variable_name)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_filter_id, 0, 0, 1)
	ZEND_ARG_INFO(0, filtername)
ZEND_END_ARG_INFO()
/* }}} */

/* {{{ filter_functions[]
 */
static const zend_function_entry filter_functions[] = {
	PHP_FE(filter_input,		arginfo_filter_input)
	PHP_FE(filter_var,		arginfo_filter_var)
	PHP_FE(filter_input_array,	arginfo_filter_input_array)
	PHP_FE(filter_var_array,	arginfo_filter_var_array)
	PHP_FE(filter_list,		arginfo_filter_list)
	PHP_FE(filter_has_var,		arginfo_filter_has_var)
	PHP_FE(filter_id,		arginfo_filter_id)
	PHP_FE_END
};
/* }}} */

/* {{{ filter_module_entry
 */
zend_module_entry filter_module_entry = {
	STANDARD_MODULE_HEADER,
	"filter",

	ZEND_ARG_INFO(0, xml)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_add_introspection_data, 0, 0, 2)
	ZEND_ARG_INFO(0, server)
	ZEND_ARG_INFO(0, desc)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlrpc_server_register_introspection_callback, 0, 0, 2)
	ZEND_ARG_INFO(0, server)
	ZEND_ARG_INFO(0, function)
ZEND_END_ARG_INFO()
/* }}} */

const zend_function_entry xmlrpc_functions[] = {
	PHP_FE(xmlrpc_encode,									arginfo_xmlrpc_encode)
	PHP_FE(xmlrpc_decode,									arginfo_xmlrpc_decode)
	PHP_FE(xmlrpc_decode_request,							arginfo_xmlrpc_decode_request)
	PHP_FE(xmlrpc_encode_request,							arginfo_xmlrpc_encode_request)
	PHP_FE(xmlrpc_get_type,									arginfo_xmlrpc_encode)
	PHP_FE(xmlrpc_set_type,									arginfo_xmlrpc_set_type)
	PHP_FE(xmlrpc_is_fault,									arginfo_xmlrpc_is_fault)
	PHP_FE(xmlrpc_server_create,							arginfo_xmlrpc_server_create)
	PHP_FE(xmlrpc_server_destroy,							arginfo_xmlrpc_server_destroy)
	PHP_FE(xmlrpc_server_register_method,					arginfo_xmlrpc_server_register_method)
	PHP_FE(xmlrpc_server_call_method,						arginfo_xmlrpc_server_call_method)
	PHP_FE(xmlrpc_parse_method_descriptions,				arginfo_xmlrpc_parse_method_descriptions)
	PHP_FE(xmlrpc_server_add_introspection_data,			arginfo_xmlrpc_server_add_introspection_data)
	PHP_FE(xmlrpc_server_register_introspection_callback,	arginfo_xmlrpc_server_register_introspection_callback)
	PHP_FE_END
};

	ZEND_ARG_INFO(0, word)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_dict_store_replacement, 0, 0, 3)
	ZEND_ARG_INFO(0, dict)
	ZEND_ARG_INFO(0, mis)
	ZEND_ARG_INFO(0, cor)
ZEND_END_ARG_INFO()
/* }}} */

/* {{{ enchant_functions[]
 *
 * Every user visible function must have an entry in enchant_functions[].
 */
zend_function_entry enchant_functions[] = {
	PHP_FE(enchant_broker_init, 			arginfo_enchant_broker_init)
	PHP_FE(enchant_broker_free, 			arginfo_enchant_broker_free)
	PHP_FE(enchant_broker_get_error, 		arginfo_enchant_broker_free)
	PHP_FE(enchant_broker_set_dict_path,	arginfo_enchant_broker_set_dict_path)
	PHP_FE(enchant_broker_get_dict_path,	arginfo_enchant_broker_get_dict_path)
	PHP_FE(enchant_broker_list_dicts, 		arginfo_enchant_broker_free)
	PHP_FE(enchant_broker_request_dict,		arginfo_enchant_broker_request_dict)
	PHP_FE(enchant_broker_request_pwl_dict, arginfo_enchant_broker_request_pwl_dict)
	PHP_FE(enchant_broker_free_dict, 		arginfo_enchant_broker_free_dict)
	PHP_FE(enchant_broker_dict_exists, 		arginfo_enchant_broker_request_dict)
	PHP_FE(enchant_broker_set_ordering, 	arginfo_enchant_broker_set_ordering)
	PHP_FE(enchant_broker_describe, 		arginfo_enchant_broker_free)
	PHP_FE(enchant_dict_check, 				arginfo_enchant_dict_check)
	PHP_FE(enchant_dict_suggest, 			arginfo_enchant_dict_check)
	PHP_FE(enchant_dict_add_to_personal, 	arginfo_enchant_dict_check)
	PHP_FE(enchant_dict_add_to_session, 	arginfo_enchant_dict_check)

// {{{ helloworld userspace function
PHP_FUNCTION(helloworld) {
	php_printf("Hello World!\n");
}
// }}}

// {{{ Check if extension is built as shared module
#ifdef COMPILE_DL_HELLOWORLD
	ZEND_GET_MODULE(helloworld)
#endif
// }}}

// {{{ Structure telling ZE address of our function(s)
static const zend_function_entry helloworld_functions[] = {
	PHP_FE(helloworld, NULL)
	PHP_FE_END
};
// }}}

// {{{ Setup module
zend_module_entry helloworld_module_entry = {
	STANDARD_MODULE_HEADER,
	"helloworld",            // Name
	helloworld_functions,    // Functions
	NULL,                    // MINIT
	NULL,                    // MSHUTDOWN
	NULL,                    // RINIT
	NULL,                    // RSHUTDOWN
	PHP_MINFO(helloworld),   // MINFO
	NO_VERSION_YET,          // Version

ZEND_BEGIN_ARG_INFO_EX(arginfo_shmop_write, 0, 0, 3)
	ZEND_ARG_INFO(0, shmid)
	ZEND_ARG_INFO(0, data)
	ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_shmop_delete, 0, 0, 1)
	ZEND_ARG_INFO(0, shmid)
ZEND_END_ARG_INFO()
/* }}} */

/* {{{ shmop_functions[] 
 */
const zend_function_entry shmop_functions[] = {
	PHP_FE(shmop_open, 		arginfo_shmop_open)
	PHP_FE(shmop_read, 		arginfo_shmop_read)
	PHP_FE(shmop_close, 	arginfo_shmop_close)
	PHP_FE(shmop_size, 		arginfo_shmop_size)
	PHP_FE(shmop_write, 	arginfo_shmop_write)
	PHP_FE(shmop_delete, 	arginfo_shmop_delete)
	PHP_FE_END
};
/* }}} */

/* {{{ shmop_module_entry
 */
zend_module_entry shmop_module_entry = {
	STANDARD_MODULE_HEADER,
	"shmop",
	shmop_functions,

void seaslog_throw_exception_hook(zval *exception TSRMLS_DC);
static void process_event(int event_type, int type, char * error_filename, uint error_lineno, char * msg TSRMLS_DC);

ZEND_DECLARE_MODULE_GLOBALS(seaslog)

static int le_seaslog;
static char *last_logger = "default";
static char *base_path = "";
static zend_bool disting_type = 0;
static zend_bool disting_by_hour = 0;
static zend_bool use_buffer = 0;
static int buffer_size = 0;
static int level = 0;

const zend_function_entry seaslog_functions[] = {
    PHP_FE(seaslog_get_version, NULL)
    PHP_FE(seaslog_get_author,  NULL)
    {NULL, NULL, NULL}
};

const zend_function_entry seaslog_methods[] = {
    PHP_ME(SEASLOG_RES_NAME, __construct,   NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
    PHP_ME(SEASLOG_RES_NAME, __destruct,    NULL, ZEND_ACC_PUBLIC | ZEND_ACC_DTOR)

    PHP_ME(SEASLOG_RES_NAME, setBasePath,   NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(SEASLOG_RES_NAME, getBasePath,   NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(SEASLOG_RES_NAME, setLogger,     NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(SEASLOG_RES_NAME, getLastLogger, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(SEASLOG_RES_NAME, analyzerCount, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(SEASLOG_RES_NAME, analyzerDetail,NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(SEASLOG_RES_NAME, getBuffer,     NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)

#include "acseg_tree.h"
#define DD printf("debug:%d %s\n",__LINE__,__FILE__);

/* If you declare any globals in php_acfilter.h uncomment this:
ZEND_DECLARE_MODULE_GLOBALS(acfilter)
*/

/* True global resources - no need for thread safety here */
static int le_acfilter;
#define le_acfilter_name "Acfilter Index"
/* {{{ acfilter_functions[]
 *
 * Every user visible function must have an entry in acfilter_functions[].
 */
zend_function_entry acfilter_functions[] = {
	PHP_FE(confirm_acfilter_compiled,	NULL)		/* For testing, remove later. */
	PHP_FE(acfilter_new,	NULL)
	PHP_FE(acfilter_load_dict,	NULL)
	PHP_FE(acfilter_add_word,	NULL)
	PHP_FE(acfilter_prepare,	NULL)
	PHP_FE(acfilter_check_text,	NULL)
	PHP_FE(acfilter_close,	NULL)
	//PHP_FE(array_experiments,NULL)
	{NULL, NULL, NULL}	/* Must be the last line in acfilter_functions[] */
};
/* }}} */

/* {{{ acfilter_module_entry
 */
zend_module_entry acfilter_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901

	ZEND_ARG_INFO(0, value)
	ZEND_ARG_INFO(0, options)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_json_decode, 0, 0, 1)
	ZEND_ARG_INFO(0, json)
	ZEND_ARG_INFO(0, assoc)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_json_last_error, 0)
ZEND_END_ARG_INFO()
/* }}} */

/* {{{ json_functions[] */
static const function_entry json_functions[] = {
	PHP_FE(json_encode, arginfo_json_encode)
	PHP_FE(json_decode, arginfo_json_decode)
	PHP_FE(json_last_error, arginfo_json_last_error)
	{NULL, NULL, NULL}
};
/* }}} */

/* {{{ MINIT */
static PHP_MINIT_FUNCTION(json)
{
	REGISTER_LONG_CONSTANT("JSON_HEX_TAG",  PHP_JSON_HEX_TAG,  CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("JSON_HEX_AMP",  PHP_JSON_HEX_AMP,  CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("JSON_HEX_APOS", PHP_JSON_HEX_APOS, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("JSON_HEX_QUOT", PHP_JSON_HEX_QUOT, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("JSON_FORCE_OBJECT", PHP_JSON_FORCE_OBJECT, CONST_CS | CONST_PERSISTENT);

    ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()

FASTLZ_ARGINFO_STATIC
ZEND_BEGIN_ARG_INFO(php_fastlz_decompress_arginfo, 0)
    ZEND_ARG_INFO(0, compressed)
ZEND_END_ARG_INFO()
/* }}} */


/* {{{ fastlz_functions[]
 *
 * Every user visible function must have an entry in fastlz_functions[].
 */
zend_function_entry fastlz_functions[] = {
	PHP_FE(fastlz_compress,               php_fastlz_compress_arginfo)
	PHP_FE(fastlz_decompress,             php_fastlz_decompress_arginfo)
	{NULL, NULL, NULL}	/* Must be the last line in fastlz_functions[] */
};
/* }}} */

/* {{{ fastlz_module_entry
 */
zend_module_entry fastlz_module_entry = {
	STANDARD_MODULE_HEADER,
	"fastlz",
	fastlz_functions,
	PHP_MINIT(fastlz),
	PHP_MSHUTDOWN(fastlz),
	NULL,
	NULL,

                                 })

#define CP_INTERNAL_NORMAL_SEND(send_data)\
                                ({         \
                                 CP_INTERNAL_SEND_ROW(send_data,CP_SIGEVENT_TURE)\
                                 })
#define CP_SEND_EXCEPTION do{zval *str;CP_SEND_EXCEPTION_ARGS(&str);cp_zval_ptr_dtor(&str);}while(0);
#define CP_INTERNAL_NORMAL_SEND_RETURN(send_data)({CP_INTERNAL_NORMAL_SEND(send_data);return CP_TRUE;})
#define CP_INTERNAL_ERROR_SEND_RETURN(send_data) ({ CP_INTERNAL_ERROR_SEND(send_data);return CP_FALSE;})
#define CP_SEND_EXCEPTION_RETURN do{CP_SEND_EXCEPTION;return CP_FALSE;}while(0);
#define CP_TEST_RETURN_TRUE(flag) ({if(flag==CP_CONNECT_PING)return CP_TRUE;})



const zend_function_entry cp_functions[] = {
    PHP_FE(pool_server_create, NULL)
    PHP_FE(pool_server_shutdown, NULL)
    PHP_FE(pool_server_reload, NULL)
    PHP_FE(pool_server_version, NULL)
    PHP_FE_END /* Must be the last line in cp_functions[] */
};

ZEND_BEGIN_ARG_INFO_EX(__call_args, 0, 0, 2)
ZEND_ARG_INFO(0, function_name)
ZEND_ARG_INFO(0, arguments)
ZEND_END_ARG_INFO()

const zend_function_entry pdo_connect_pool_methods[] = {
    PHP_ME(pdo_connect_pool, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
    PHP_ME(pdo_connect_pool, __destruct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
    PHP_ME(pdo_connect_pool, __call, __call_args, ZEND_ACC_PUBLIC)

#include "Zend/zend_object_handlers.h"
#include "Zend/zend_interfaces.h"
#include "Zend/zend_exceptions.h"

ZEND_BEGIN_ARG_INFO_EX(twig_template_get_attribute_args, ZEND_SEND_BY_VAL, ZEND_RETURN_VALUE, 6)
	ZEND_ARG_INFO(0, template)
	ZEND_ARG_INFO(0, object)
	ZEND_ARG_INFO(0, item)
	ZEND_ARG_INFO(0, arguments)
	ZEND_ARG_INFO(0, type)
	ZEND_ARG_INFO(0, isDefinedTest)
ZEND_END_ARG_INFO()

zend_function_entry twig_functions[] = {
	PHP_FE(twig_template_get_attributes, twig_template_get_attribute_args)
	{NULL, NULL, NULL}
};


zend_module_entry twig_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
	STANDARD_MODULE_HEADER,
#endif
	"twig",
	twig_functions,
	PHP_MINIT(twig),
	PHP_MSHUTDOWN(twig),
	PHP_RINIT(twig),	
	PHP_RSHUTDOWN(twig),
	PHP_MINFO(twig),

/* True global resources - no need for thread safety here */
static int le_memc;
static int le_servers;
static zend_class_entry *memcached_entry_ptr = NULL;

static void _php_libmemcached_connection_resource_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC);
static void _php_libmemcached_create(zval *obj TSRMLS_DC);
static int _php_libmemcached_get_value(const char *, memcached_st *, zval * TSRMLS_DC);
static void _get_value_from_zval(smart_str *, zval *, uint32_t * TSRMLS_DC);

/* {{{ libmemcached_functions[]
 *
 * Every user visible function must have an entry in libmemcached_functions[].
 */
zend_function_entry libmemcached_functions[] = {
    PHP_FE(memcached_ctor, NULL)
    PHP_FE(memcached_server_add, NULL)
    PHP_FE(memcached_add, NULL)
    PHP_FE(memcached_add_by_key, NULL)
    PHP_FE(memcached_append, NULL)
    PHP_FE(memcached_append_by_key, NULL)
    PHP_FE(memcached_behavior_get, NULL)
    PHP_FE(memcached_behavior_set, NULL)
    PHP_FE(memcached_cas, NULL)
    PHP_FE(memcached_cas_by_key, NULL)
    PHP_FE(memcached_delete, NULL)
    PHP_FE(memcached_delete_by_key, NULL)
    PHP_FE(memcached_get, NULL)
    PHP_FE(memcached_get_by_key, NULL)
    PHP_FE(memcached_set, NULL)
    PHP_FE(memcached_set_by_key, NULL)

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "fizzy.h"
#include "../../fizzy.h"

static zend_function_entry fizzy_functions[] = {
    PHP_FE(fizzy, NULL)
    { NULL, NULL, NULL }
};

zend_module_entry fizzy_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
    STANDARD_MODULE_HEADER,
#endif
    PHP_FIZZY_EXTNAME,
    fizzy_functions,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
#if ZEND_MODULE_API_NO >= 20010901
    PHP_FIZZY_VERSION,
#endif
    STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_FIZZY

 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* $Id$ */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_hello.h"

static function_entry hello_functions[] = {
    PHP_FE(hello_world, NULL)
    {NULL, NULL, NULL}
};

zend_module_entry hello_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
    STANDARD_MODULE_HEADER,
#endif
    PHP_HELLO_WORLD_EXTNAME,
    hello_functions,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
#if ZEND_MODULE_API_NO >= 20010901