summaryrefslogtreecommitdiff
path: root/share/swig/2.0.11/php/phprun.swg
diff options
context:
space:
mode:
Diffstat (limited to 'share/swig/2.0.11/php/phprun.swg')
-rw-r--r--share/swig/2.0.11/php/phprun.swg275
1 files changed, 275 insertions, 0 deletions
diff --git a/share/swig/2.0.11/php/phprun.swg b/share/swig/2.0.11/php/phprun.swg
new file mode 100644
index 0000000..a4188cc
--- /dev/null
+++ b/share/swig/2.0.11/php/phprun.swg
@@ -0,0 +1,275 @@
+/* -----------------------------------------------------------------------------
+ * phprun.swg
+ *
+ * PHP runtime library
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "zend.h"
+#include "zend_API.h"
+#include "zend_exceptions.h"
+#include "php.h"
+#include "ext/standard/php_string.h"
+#include <stdlib.h> /* for abort(), used in generated code. */
+
+#ifdef ZEND_RAW_FENTRY
+/* ZEND_RAW_FENTRY was added somewhere between 5.2.0 and 5.2.3 */
+# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_RAW_FENTRY((char*)#ZN, N, A, 0)
+#else
+/* This causes warnings from GCC >= 4.2 (assigning a string literal to char*).
+ * But this seems to be unavoidable without directly assuming knowledge of
+ * the structure, which changed between PHP4 and PHP5. */
+# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
+#endif
+
+#ifndef Z_SET_ISREF_P
+/* For PHP < 5.3 */
+# define Z_SET_ISREF_P(z) (z)->is_ref = 1
+#endif
+#ifndef Z_SET_REFCOUNT_P
+/* For PHP < 5.3 */
+# define Z_SET_REFCOUNT_P(z, rc) (z)->refcount = (rc)
+#endif
+
+#define SWIG_LONG_CONSTANT(N, V) zend_register_long_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
+#define SWIG_DOUBLE_CONSTANT(N, V) zend_register_double_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
+#define SWIG_STRING_CONSTANT(N, V) zend_register_stringl_constant((char*)#N, sizeof(#N), (char*)(V), strlen(V), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
+#define SWIG_CHAR_CONSTANT(N, V) do {\
+ static char swig_char = (V);\
+ zend_register_stringl_constant((char*)#N, sizeof(#N), &swig_char, 1, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);\
+} while (0)
+
+/* These TSRMLS_ stuff should already be defined now, but with older php under
+ redhat are not... */
+#ifndef TSRMLS_D
+#define TSRMLS_D
+#endif
+#ifndef TSRMLS_DC
+#define TSRMLS_DC
+#endif
+#ifndef TSRMLS_C
+#define TSRMLS_C
+#endif
+#ifndef TSRMLS_CC
+#define TSRMLS_CC
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/* But in fact SWIG_ConvertPtr is the native interface for getting typed
+ pointer values out of zvals. We need the TSRMLS_ macros for when we
+ make PHP type calls later as we handle php resources */
+#define SWIG_ConvertPtr(obj,pp,type,flags) SWIG_ZTS_ConvertPtr(obj,pp,type,flags TSRMLS_CC)
+
+
+#define SWIG_fail goto fail
+
+static const char *default_error_msg = "Unknown error occurred";
+static int default_error_code = E_ERROR;
+
+#define SWIG_PHP_Arg_Error_Msg(argnum,extramsg) "Error in argument " #argnum " "#extramsg
+
+#define SWIG_PHP_Error(code,msg) do { SWIG_ErrorCode() = code; SWIG_ErrorMsg() = msg; SWIG_fail; } while (0)
+
+#define SWIG_contract_assert(expr,msg) \
+ if (!(expr) ) { zend_printf("Contract Assert Failed %s\n",msg ); } else
+
+/* Standard SWIG API */
+#define SWIG_GetModule(clientdata) SWIG_Php_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) SWIG_Php_SetModule(pointer)
+
+/* used to wrap returned objects in so we know whether they are newobject
+ and need freeing, or not */
+typedef struct {
+ void * ptr;
+ int newobject;
+} swig_object_wrapper;
+
+/* empty zend destructor for types without one */
+static ZEND_RSRC_DTOR_FUNC(SWIG_landfill) { (void)rsrc; }
+
+#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d TSRMLS_CC)
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
+
+static void
+SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
+ /*
+ * First test for Null pointers. Return those as PHP native NULL
+ */
+ if (!ptr ) {
+ ZVAL_NULL(z);
+ return;
+ }
+ if (type->clientdata) {
+ swig_object_wrapper *value;
+ if (! (*(int *)(type->clientdata)))
+ zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
+ value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
+ value->ptr=ptr;
+ value->newobject=(newobject & 1);
+ if ((newobject & 2) == 0) {
+ /* Just register the pointer as a resource. */
+ ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
+ } else {
+ /*
+ * Wrap the resource in an object, the resource will be accessible
+ * via the "_cPtr" member. This is currently only used by
+ * directorin typemaps.
+ */
+ zval *resource;
+ zend_class_entry **ce = NULL;
+ const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
+ size_t type_name_len;
+ int result;
+ const char * p;
+
+ /* Namespace__Foo -> Foo */
+ /* FIXME: ugly and goes wrong for classes with __ in their names. */
+ while ((p = strstr(type_name, "__")) != NULL) {
+ type_name = p + 2;
+ }
+ type_name_len = strlen(type_name);
+
+ MAKE_STD_ZVAL(resource);
+ ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
+ if (SWIG_PREFIX_LEN > 0) {
+ char * classname = (char*)emalloc(SWIG_PREFIX_LEN + type_name_len + 1);
+ strcpy(classname, SWIG_PREFIX);
+ strcpy(classname + SWIG_PREFIX_LEN, type_name);
+ result = zend_lookup_class(classname, SWIG_PREFIX_LEN + type_name_len, &ce TSRMLS_CC);
+ efree(classname);
+ } else {
+ result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
+ }
+ if (result != SUCCESS) {
+ /* class does not exist */
+ object_init(z);
+ } else {
+ object_init_ex(z, *ce);
+ }
+ Z_SET_REFCOUNT_P(z, 1);
+ Z_SET_ISREF_P(z);
+ zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
+ }
+ return;
+ }
+ zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
+}
+
+/* This pointer conversion routine takes the native pointer p (along with
+ its type name) and converts it by calling appropriate casting functions
+ according to ty. The resultant pointer is returned, or NULL is returned
+ if the pointer can't be cast.
+
+ Sadly PHP has no API to find a type name from a type id, only from an
+ instance of a resource of the type id, so we have to pass type_name as well.
+
+ The two functions which might call this are:
+ SWIG_ZTS_ConvertResourcePtr which gets the type name from the resource
+ and the registered zend destructors for which we have one per type each
+ with the type name hard wired in. */
+static void *
+SWIG_ZTS_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty TSRMLS_DC) {
+ swig_cast_info *tc;
+ void *result = 0;
+
+ if (!ty) {
+ /* They don't care about the target type, so just pass on the pointer! */
+ return p;
+ }
+
+ if (! type_name) {
+ /* can't convert p to ptr type ty if we don't know what type p is */
+ return NULL;
+ }
+
+ /* convert and cast p from type_name to ptr as ty. */
+ tc = SWIG_TypeCheck(type_name, ty);
+ if (tc) {
+ int newmemory = 0;
+ result = SWIG_TypeCast(tc, p, &newmemory);
+ assert(!newmemory); /* newmemory handling not yet implemented */
+ }
+ return result;
+}
+
+/* This function returns a pointer of type ty by extracting the pointer
+ and type info from the resource in z. z must be a resource.
+ If it fails, NULL is returned.
+ It uses SWIG_ZTS_ConvertResourceData to do the real work. */
+static void *
+SWIG_ZTS_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags TSRMLS_DC) {
+ swig_object_wrapper *value;
+ void *p;
+ int type;
+ const char *type_name;
+
+ value = (swig_object_wrapper *) zend_list_find(z->value.lval, &type);
+ if (type==-1) return NULL;
+ if (flags & SWIG_POINTER_DISOWN) {
+ value->newobject = 0;
+ }
+ p = value->ptr;
+
+ type_name=zend_rsrc_list_get_rsrc_type(z->value.lval TSRMLS_CC);
+
+ return SWIG_ZTS_ConvertResourceData(p, type_name, ty TSRMLS_CC);
+}
+
+/* We allow passing of a RESOURCE pointing to the object or an OBJECT whose
+ _cPtr is a resource pointing to the object */
+static int
+SWIG_ZTS_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC) {
+ if (z == NULL) {
+ *ptr = 0;
+ return 0;
+ }
+
+ switch (z->type) {
+ case IS_OBJECT: {
+ zval ** _cPtr;
+ if (zend_hash_find(HASH_OF(z),(char*)"_cPtr",sizeof("_cPtr"),(void**)&_cPtr)==SUCCESS) {
+ if ((*_cPtr)->type==IS_RESOURCE) {
+ *ptr = SWIG_ZTS_ConvertResourcePtr(*_cPtr, ty, flags TSRMLS_CC);
+ return (*ptr == NULL ? -1 : 0);
+ }
+ }
+ break;
+ }
+ case IS_RESOURCE:
+ *ptr = SWIG_ZTS_ConvertResourcePtr(z, ty, flags TSRMLS_CC);
+ return (*ptr == NULL ? -1 : 0);
+ case IS_NULL:
+ *ptr = 0;
+ return 0;
+ }
+
+ return -1;
+}
+
+static char const_name[] = "swig_runtime_data_type_pointer";
+static swig_module_info *SWIG_Php_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
+ zval *pointer;
+ swig_module_info *ret = 0;
+
+ MAKE_STD_ZVAL(pointer);
+
+ TSRMLS_FETCH();
+
+ if (zend_get_constant(const_name, sizeof(const_name) - 1, pointer TSRMLS_CC)) {
+ if (pointer->type == IS_LONG) {
+ ret = (swig_module_info *) pointer->value.lval;
+ }
+ }
+ FREE_ZVAL(pointer);
+ return ret;
+}
+
+static void SWIG_Php_SetModule(swig_module_info *pointer) {
+ TSRMLS_FETCH();
+ REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, 0);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-08 13:28:51 +0000