mirror of
https://github.com/php/php-src.git
synced 2024-10-01 06:46:08 +00:00
270 lines
8.3 KiB
C
270 lines
8.3 KiB
C
/*
|
|
+----------------------------------------------------------------------+
|
|
| PHP Version 4 |
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) 1997-2003 The PHP Group |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 3.0 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available through the world-wide-web at the following url: |
|
|
| http://www.php.net/license/3_0.txt. |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
| Author: Harald Radi <h.radi@nme.at> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
#include "../rpc.h"
|
|
#include "../handler.h"
|
|
|
|
#include "skeleton.h"
|
|
|
|
/* protos */
|
|
static int skeleton_hash(rpc_string, rpc_string *, void *, int, char *, int);
|
|
static int skeleton_name(rpc_string, rpc_string *, void *, int);
|
|
static int skeleton_ctor(rpc_string, void **, int , zval ***);
|
|
static int skeleton_dtor(void *);
|
|
static int skeleton_describe(rpc_string, void *, char **, unsigned char **);
|
|
static int skeleton_call(rpc_string, void **, zval *, int, zval ***);
|
|
static int skeleton_get(rpc_string, zval *, void **);
|
|
static int skeleton_set(rpc_string, zval *, void **);
|
|
static int skeleton_compare(void **, void **);
|
|
static int skeleton_has_property(rpc_string, void **);
|
|
static int skeleton_unset_property(rpc_string, void **);
|
|
static int skeleton_get_properties(HashTable **, void **);
|
|
|
|
/* register rpc callback function */
|
|
RPC_REGISTER_HANDLERS_BEGIN(skeleton)
|
|
FALSE, /* poolable TRUE|FALSE*/
|
|
DONT_HASH, /* hash function name lookups to avoid reflection of the object for each
|
|
* method call. hashing is done either by mapping only the function name
|
|
* to a coresponding method id or by taking the whole method signature into
|
|
* account. possible values:
|
|
* DONT_HASH|HASH_AS_INT|HASH_AS_STRING|
|
|
* HASH_AS_INT_WITH_SIGNATURE|HASH_AS_STRING_WITH_SIGNATURE
|
|
*/
|
|
skeleton_hash, /* the hash function, can be NULL */
|
|
skeleton_name, /* the reverse hash function, can be NULL */
|
|
skeleton_ctor, /* constructor */
|
|
skeleton_dtor, /* destructor */
|
|
skeleton_describe, /* function to reflect methods to get information about parameter types.
|
|
* parameters can be forced to be by reference this way. can be NULL.
|
|
*/
|
|
skeleton_call, /* method call handler */
|
|
skeleton_get, /* property get handler */
|
|
skeleton_set, /* property set handler */
|
|
skeleton_compare, /* compare handler, can be NULL */
|
|
skeleton_has_property, /* reflection functions */
|
|
skeleton_unset_property, /* can be NULL */
|
|
skeleton_get_properties
|
|
RPC_REGISTER_HANDLERS_END()
|
|
|
|
/* register ini settings */
|
|
PHP_INI_BEGIN()
|
|
/* TODO: palce your ini entries here */
|
|
PHP_INI_END()
|
|
|
|
/* register userspace functions */
|
|
RPC_FUNCTION_ENTRY_BEGIN(skeleton)
|
|
/* TODO: add your userspace functions here */
|
|
ZEND_FE(skeleton_function, NULL)
|
|
RPC_FUNCTION_ENTRY_END()
|
|
|
|
/* register class methods */
|
|
RPC_METHOD_ENTRY_BEGIN(skeleton)
|
|
/* TODO: add your class methods here */
|
|
ZEND_FALIAS(method, skeleton_function, NULL)
|
|
RPC_METHOD_ENTRY_END()
|
|
|
|
zend_module_entry skeleton_module_entry = {
|
|
ZE2_STANDARD_MODULE_HEADER,
|
|
"skeleton",
|
|
RPC_FUNCTION_ENTRY(skeleton),
|
|
ZEND_MINIT(skeleton),
|
|
ZEND_MSHUTDOWN(skeleton),
|
|
NULL,
|
|
NULL,
|
|
ZEND_MINFO(skeleton),
|
|
"0.1a",
|
|
STANDARD_MODULE_PROPERTIES
|
|
};
|
|
|
|
ZEND_MINIT_FUNCTION(skeleton)
|
|
{
|
|
/* TODO: place your init stuff here */
|
|
|
|
RPC_REGISTER_LAYER(skeleton);
|
|
REGISTER_INI_ENTRIES();
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
ZEND_MSHUTDOWN_FUNCTION(skeleton)
|
|
{
|
|
/* TODO: place your shutdown stuff here */
|
|
|
|
UNREGISTER_INI_ENTRIES();
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
ZEND_MINFO_FUNCTION(skeleton)
|
|
{
|
|
DISPLAY_INI_ENTRIES();
|
|
}
|
|
|
|
#ifdef COMPILE_DL_SKELETON
|
|
ZEND_GET_MODULE(skeleton);
|
|
#endif
|
|
|
|
/* rpc handler functions */
|
|
|
|
/* {{{ skeleton_hash
|
|
*/
|
|
static int skeleton_hash(rpc_string name, rpc_string *hash, void *data, int num_args, char *arg_types, int type)
|
|
{
|
|
/* TODO: implement your hash function here. if you have specified any of the HASH_AS_INT constants, simply set
|
|
* hash->str to NULL and set hash->len to the int hash value.
|
|
* arg_types is a zend_parse_parameters() like string containing the types of the parameters passed enabling you
|
|
* to find the best match if you want to hash WITH_SIGNATURE.
|
|
* type is one of CLASS|METHOD|PROPERTY.
|
|
*/
|
|
hash->str = strdup(name.str);
|
|
hash->len = name.len;
|
|
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_name
|
|
*/
|
|
static int skeleton_name(rpc_string hash, rpc_string *name, void *data, int type)
|
|
{
|
|
/* TODO: do the opposite of what you did above */
|
|
return FAILURE;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_ctor
|
|
*/
|
|
static int skeleton_ctor(rpc_string class_name, void **data, int num_args, zval **args[])
|
|
{
|
|
/* TODO: use *data as a pointer to your internal data. if you want to enable your instances for
|
|
* pooling or to be used as singletons then you have to use malloc() and free() instead of
|
|
* emalloc() and efree() because emalloc()'ed memory will be efree()'ed on script shutdown.
|
|
* ATTENTION: take care about possible memory holes when you use malloc()
|
|
* calls to the handler functions are mutual exclusive per userspace instance, thus if you use
|
|
* the same internal datastructure accross multiple userspace instances of php objects you have
|
|
* to care for thread safety yourself (this again applies only if you want to make your instances
|
|
* poolable/singleton-able), if you have an internal data structure per instance, then you don't
|
|
* have to care for thread safety as the handler functions are locked by a mutex.
|
|
*/
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_dtor
|
|
*/
|
|
static int skeleton_dtor(void *data)
|
|
{
|
|
/* TODO: free everything you alloc'ed above */
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_describe
|
|
*/
|
|
static int skeleton_describe(rpc_string method_name, void *data, char **arg_types, unsigned char **ref_types)
|
|
{
|
|
/* TODO: return a zend_parse_parameters() like string in arg_types to describe the
|
|
* parameters taken by the specific function. if one of the parameters should be forced be reference then
|
|
* you have to set ref_types to an array describing the function parameters as you would in the
|
|
* ZEND_FE() macro as the last parameter.
|
|
*/
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_call
|
|
*/
|
|
static int skeleton_call(rpc_string method_name, void **data, zval *return_value, int num_args, zval **args[])
|
|
{
|
|
/* TODO: implement call handler. if you passed back an arg_types string in the describe function the arguments
|
|
* are already converted to the corresponding types, if there are too few or too much, a warning is already issued.
|
|
* if arg_types was NULL you have to check for the right parameter count and types yourself.
|
|
*/
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_get
|
|
*/
|
|
static int skeleton_get(rpc_string property_name, zval *return_value, void **data)
|
|
{
|
|
/* TODO: implement get handler */
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_set
|
|
*/
|
|
static int skeleton_set(rpc_string property_name, zval *value, void **data)
|
|
{
|
|
/* TODO: implement set handler */
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_compare
|
|
*/
|
|
static int skeleton_compare(void **data1, void **data2)
|
|
{
|
|
/* TODO: implement compare handler */
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_has_property
|
|
*/
|
|
static int skeleton_has_property(rpc_string property_name, void **data)
|
|
{
|
|
/* TODO: implement has property handler */
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_unset_property
|
|
*/
|
|
static int skeleton_unset_property(rpc_string property_name, void **data)
|
|
{
|
|
/* TODO: implement unset property handler */
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ skeleton_get_properties
|
|
*/
|
|
static int skeleton_get_properties(HashTable **properties, void **data)
|
|
{
|
|
/* TODO: implement get properties handler */
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
/* custom functions */
|
|
ZEND_FUNCTION(skeleton_function)
|
|
{
|
|
}
|
|
|
|
/*
|
|
* Local variables:
|
|
* c-basic-offset: 4
|
|
* tab-width: 4
|
|
* End:
|
|
* vim600: fdm=marker
|
|
* vim: sw=4 ts=4 noet
|
|
*/
|