static GnmFuncHelp const * python_function_get_gnumeric_help (PyObject *python_fn_info_dict, PyObject *python_fn, const gchar *fn_name) { gchar *help_attr_name; PyObject *cobject_help_value; help_attr_name = g_strdup_printf ("_CGnumericHelp_%s", fn_name); cobject_help_value = PyDict_GetItemString (python_fn_info_dict, help_attr_name); if (cobject_help_value == NULL) { PyObject *python_fn_help = ((PyFunctionObject *) python_fn)->func_doc; if (python_fn_help != NULL && PyString_Check (python_fn_help)) { GnmFuncHelp *new_help = g_new (GnmFuncHelp, 2); int i = 0; #if 0 new_help[i].type = GNM_FUNC_HELP_OLD; new_help[i].text = PyString_AsString (python_fn_help); i++; #endif new_help[i].type = GNM_FUNC_HELP_END; new_help[i].text = NULL; i++; cobject_help_value = PyCObject_FromVoidPtr (new_help, &g_free); PyDict_SetItemString (python_fn_info_dict, help_attr_name, cobject_help_value); } } g_free (help_attr_name); if (cobject_help_value == NULL) return NULL; return (GnmFuncHelp const *) PyCObject_AsVoidPtr (cobject_help_value); }
PyObject *xmlsec_TransformExclC14NWithCommentsId(PyObject *self, PyObject *args) { return PyCObject_FromVoidPtr((void *) xmlSecTransformExclC14NWithCommentsId, NULL); }
// Parse a Python object as a sequence of either QVector[234]D instances or a // sequence of sequence of floats and return an array that can be passed to // QGLShaderProgram::setAttributeArray(). The array is destroyed only when the // shader is garbage collected or when replaced by another array. const GLfloat *qpyopengl_attribute_array(PyObject *values, PyObject *shader, PyObject *key, int *tsize, sipErrorState *estate) { // Check the key was created correctly. if (!key) { *estate = sipErrorFail; return 0; } // Get the dict that holds the converted arrays. PyObject *dict = ((sipSimpleWrapper *)shader)->user; if (!dict) { dict = PyDict_New(); if (!dict) { Py_DECREF(key); *estate = sipErrorFail; return 0; } ((sipSimpleWrapper *)shader)->user = dict; } // Check that values is a non-empty sequence. values = PySequence_Fast(values, "an attribute array must be a sequence"); if (!values) { Py_DECREF(key); *estate = sipErrorContinue; return 0; } SIP_SSIZE_T nr_items = PySequence_Fast_GET_SIZE(values); if (nr_items < 1) { PyErr_SetString(PyExc_TypeError, "an attribute array must have at least one element"); Py_DECREF(key); Py_DECREF(values); *estate = sipErrorFail; return 0; } // The first element determines the type expected. PyObject *itm = PySequence_Fast_GET_ITEM(values, 0); const sipTypeDef *td; SIP_SSIZE_T nr_dim; if (sipCanConvertToType(itm, sipType_QVector2D, SIP_NOT_NONE)) { td = sipType_QVector2D; nr_dim = 2; } else if (sipCanConvertToType(itm, sipType_QVector3D, SIP_NOT_NONE)) { td = sipType_QVector3D; nr_dim = 3; } else if (sipCanConvertToType(itm, sipType_QVector4D, SIP_NOT_NONE)) { td = sipType_QVector4D; nr_dim = 4; } else if (PySequence_Check(itm) && (nr_dim = PySequence_Size(itm)) >= 1) { td = 0; } else { PyErr_SetString(PyExc_TypeError, "an attribute array must be a sequence of QVector2D, " "QVector3D, QVector4D, or a sequence of sequences of floats"); Py_DECREF(key); Py_DECREF(values); *estate = sipErrorFail; return 0; } // Create the array that will be returned. GLfloat *array = new GLfloat[nr_items * nr_dim]; // Convert the values. GLfloat *ap = array; for (SIP_SSIZE_T i = 0; i < nr_items; ++i) { int iserr = 0; itm = PySequence_Fast_GET_ITEM(values, i); if (td) { void *cpp; cpp = sipForceConvertToType(itm, td, 0, SIP_NOT_NONE | SIP_NO_CONVERTORS, 0, &iserr); if (iserr) { PyErr_Format(PyExc_TypeError, "attribute array elements should all be '%s', not '%s'", sipTypeAsPyTypeObject(td)->tp_name, Py_TYPE(itm)->tp_name); } else if (td == sipType_QVector2D) { QVector2D *v = reinterpret_cast<QVector2D *>(cpp); *ap++ = v->x(); *ap++ = v->y(); } else if (td == sipType_QVector3D) { QVector3D *v = reinterpret_cast<QVector3D *>(cpp); *ap++ = v->x(); *ap++ = v->y(); *ap++ = v->z(); } else if (td == sipType_QVector4D) { QVector4D *v = reinterpret_cast<QVector4D *>(cpp); *ap++ = v->x(); *ap++ = v->y(); *ap++ = v->z(); *ap++ = v->w(); } } else { itm = PySequence_Fast(itm, "attribute array elements should all be sequences"); if (itm) { if (PySequence_Fast_GET_SIZE(itm) != nr_dim) { PyErr_Format(PyExc_TypeError, "attribute array elements should all be sequences " #if PY_VERSION_HEX >= 0x02050000 "of length %zd", #else "of length %d", #endif nr_dim); Py_DECREF(itm); iserr = 1; } else { PyErr_Clear(); for (SIP_SSIZE_T j = 0; j < nr_dim; ++j) *ap++ = PyFloat_AsDouble( PySequence_Fast_GET_ITEM(itm, j)); if (PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "attribute array elements should all be " "sequences of floats"); Py_DECREF(itm); iserr = 1; } } } else { iserr = 1; } } if (iserr) { Py_DECREF(key); Py_DECREF(values); delete[] array; *estate = sipErrorFail; return 0; } } Py_DECREF(values); *tsize = nr_dim; // Wrap the array in a Python object so that it won't leak. #if defined(SIP_USE_PYCAPSULE) PyObject *array_obj = PyCapsule_New(array, 0, array_dtor); #else PyObject *array_obj = PyCObject_FromVoidPtr(array, array_dtor); #endif if (!array_obj) { Py_DECREF(key); delete[] array; *estate = sipErrorFail; return 0; } int rc = PyDict_SetItem(dict, key, array_obj); Py_DECREF(key); Py_DECREF(array_obj); if (rc < 0) { *estate = sipErrorFail; return 0; } return array; }
/* * Implement ascobject() for the type. */ static PyObject *sipVoidPtr_ascobject(sipVoidPtrObject *v, PyObject *arg) { return PyCObject_FromVoidPtr(v->voidptr, NULL); }
PyMODINIT_FUNC init_ExtensionClass(void) { PyObject *m, *s; if (pickle_setup() < 0) return; #define DEFINE_STRING(S) \ if(! (str ## S = PyString_FromString(# S))) return DEFINE_STRING(__of__); DEFINE_STRING(__get__); DEFINE_STRING(__class_init__); DEFINE_STRING(__init__); DEFINE_STRING(__bases__); DEFINE_STRING(__mro__); DEFINE_STRING(__new__); #undef DEFINE_STRING PyExtensionClassCAPI = &TrueExtensionClassCAPI; ExtensionClassType.ob_type = &PyType_Type; ExtensionClassType.tp_base = &PyType_Type; ExtensionClassType.tp_basicsize = PyType_Type.tp_basicsize; ExtensionClassType.tp_traverse = PyType_Type.tp_traverse; ExtensionClassType.tp_clear = PyType_Type.tp_clear; /* Initialize types: */ if (PyType_Ready(&ExtensionClassType) < 0) return; BaseType.ob_type = &ExtensionClassType; BaseType.tp_base = &PyBaseObject_Type; BaseType.tp_basicsize = PyBaseObject_Type.tp_basicsize; BaseType.tp_new = PyType_GenericNew; if (PyType_Ready(&BaseType) < 0) return; NoInstanceDictionaryBaseType.ob_type = &ExtensionClassType; NoInstanceDictionaryBaseType.tp_base = &BaseType; NoInstanceDictionaryBaseType.tp_basicsize = BaseType.tp_basicsize; NoInstanceDictionaryBaseType.tp_new = PyType_GenericNew; if (PyType_Ready(&NoInstanceDictionaryBaseType) < 0) return; /* Create the module and add the functions */ m = Py_InitModule3("_ExtensionClass", ec_methods, _extensionclass_module_documentation); if (m == NULL) return; s = PyCObject_FromVoidPtr(PyExtensionClassCAPI, NULL); if (PyModule_AddObject(m, "CAPI2", s) < 0) return; /* Add types: */ if (PyModule_AddObject(m, "ExtensionClass", (PyObject *)&ExtensionClassType) < 0) return; if (PyModule_AddObject(m, "Base", (PyObject *)&BaseType) < 0) return; if (PyModule_AddObject(m, "NoInstanceDictionaryBase", (PyObject *)&NoInstanceDictionaryBaseType) < 0) return; }
PyObject* wrapQObject(QObject* obj) { return PyCObject_FromVoidPtr((void*)obj, NULL); }
static PyObject* module_init(void) { PyObject *module, *ts_module, *capi; PyObject *copy_reg; if (init_strings() < 0) return NULL; #ifdef PY3K module = PyModule_Create(&moduledef); #else module = Py_InitModule3("cPersistence", cPersistence_methods, cPersistence_doc_string); #endif #ifdef PY3K ((PyObject*)&Pertype)->ob_type = &PyType_Type; #else Pertype.ob_type = &PyType_Type; #endif Pertype.tp_new = PyType_GenericNew; if (PyType_Ready(&Pertype) < 0) return NULL; if (PyModule_AddObject(module, "Persistent", (PyObject *)&Pertype) < 0) return NULL; cPersistenceCAPI = &truecPersistenceCAPI; #ifdef PY3K capi = PyCapsule_New(cPersistenceCAPI, CAPI_CAPSULE_NAME, NULL); #else capi = PyCObject_FromVoidPtr(cPersistenceCAPI, NULL); #endif if (!capi) return NULL; if (PyModule_AddObject(module, "CAPI", capi) < 0) return NULL; if (PyModule_AddIntConstant(module, "GHOST", cPersistent_GHOST_STATE) < 0) return NULL; if (PyModule_AddIntConstant(module, "UPTODATE", cPersistent_UPTODATE_STATE) < 0) return NULL; if (PyModule_AddIntConstant(module, "CHANGED", cPersistent_CHANGED_STATE) < 0) return NULL; if (PyModule_AddIntConstant(module, "STICKY", cPersistent_STICKY_STATE) < 0) return NULL; py_simple_new = PyObject_GetAttrString(module, "simple_new"); if (!py_simple_new) return NULL; #ifdef PY3K copy_reg = PyImport_ImportModule("copyreg"); #else copy_reg = PyImport_ImportModule("copy_reg"); #endif if (!copy_reg) return NULL; copy_reg_slotnames = PyObject_GetAttrString(copy_reg, "_slotnames"); if (!copy_reg_slotnames) { Py_DECREF(copy_reg); return NULL; } __newobj__ = PyObject_GetAttrString(copy_reg, "__newobj__"); if (!__newobj__) { Py_DECREF(copy_reg); return NULL; } if (!TimeStamp) { ts_module = PyImport_ImportModule("persistent.timestamp"); if (!ts_module) return NULL; TimeStamp = PyObject_GetAttrString(ts_module, "TimeStamp"); Py_DECREF(ts_module); /* fall through to immediate return on error */ } return module; }
static PyObject *PyPCAP_next(PyPCAP *self) { PyObject *result; int len; int packet_offset; // Make sure our buffer is full enough: if(self->buffer->size - self->buffer->readptr < MAX_PACKET_SIZE) { len = PyPCAP_fill_buffer(self, self->fd); if(len<0) return NULL; }; packet_offset = self->buffer->readptr; /** This is an interesting side effect of the talloc reference model: talloc_reference(context, ptr) adds a new context to ptr so ptr is now effectively parented by two parents. The two parents are not equal however because a talloc free(ptr) will remove the reference first and then the original parent. This causes problems here because we create the packet_header with self->buffer as a context. However other code takes references to it - pinning it to other parents. If we did a talloc_free(self->packet_header) here we would be removing those references _instead_ of freeing the ptr from our own self->buffer reference. This will cause both memory leaks (because we will not be freeing packet_header at all, and later crashes because important references will be removed. When references begin to be used extensively I think we need to start using talloc_unlink instead of talloc_free everywhere. */ // Free old packets: if(self->packet_header) talloc_unlink(self->buffer, self->packet_header); // Make a new packet: self->packet_header = (PcapPacketHeader)CONSTRUCT(PcapPacketHeader, Packet, super.Con, self->buffer, NULL); if(self->file_header->little_endian) { self->packet_header->super.format = self->packet_header->le_format; }; // Read the packet in: len = self->packet_header->super.Read((Packet)self->packet_header, self->buffer); // Did we finish? if(len<=0) { return PyErr_Format(PyExc_StopIteration, "Done"); }; // Make sure the new packet knows its offset and where it came from: self->packet_header->header.offset = self->pcap_offset; self->packet_header->header.pcap_file_id = self->pcap_file_id; // Keep track of our own file offset: self->pcap_offset += self->buffer->readptr - packet_offset; // CALL(self->buffer, skip, self->buffer->readptr); // Adjust the output endianess if needed switch(self->output_format) { case FORCE_BIG_ENDIAN: // FIXME - Leaks!!! self->packet_header->super.format = PCAP_PKTHEADER_STRUCT; break; case FORCE_LITTLE_ENDIAN: self->packet_header->super.format = PCAP_PKTHEADER_STRUCT_LE; break; default: // Do nothing break; }; // create a new pypacket object: result = PyObject_CallMethod(g_pypacket_module, "PyPacket", "N", PyCObject_FromVoidPtr(self->packet_header,NULL), "PcapPacketHeader"); return result; };
PyObject* Mesh_Python_New( PyObject* self, PyObject* args ) { return PyCObject_FromVoidPtr( Mesh_New(), 0 ); }
PyObject *Node_instance(PyObject *i_s, PyObject *i_oArgs) { bind_node *l_oFils = bind_node::instance(); return PyCObject_FromVoidPtr(l_oFils, NULL); }
static void python_process_event(int cpu, void *data, int size __unused, unsigned long long nsecs, char *comm) { PyObject *handler, *retval, *context, *t, *obj, *dict = NULL; static char handler_name[256]; struct format_field *field; unsigned long long val; unsigned long s, ns; struct event *event; unsigned n = 0; int type; int pid; t = PyTuple_New(MAX_FIELDS); if (!t) Py_FatalError("couldn't create Python tuple"); type = trace_parse_common_type(data); event = find_cache_event(type); if (!event) die("ug! no event found for type %d", type); pid = trace_parse_common_pid(data); sprintf(handler_name, "%s__%s", event->system, event->name); handler = PyDict_GetItemString(main_dict, handler_name); if (handler && !PyCallable_Check(handler)) handler = NULL; if (!handler) { dict = PyDict_New(); if (!dict) Py_FatalError("couldn't create Python dict"); } s = nsecs / NSECS_PER_SEC; ns = nsecs - s * NSECS_PER_SEC; scripting_context->event_data = data; context = PyCObject_FromVoidPtr(scripting_context, NULL); PyTuple_SetItem(t, n++, PyString_FromString(handler_name)); PyTuple_SetItem(t, n++, PyCObject_FromVoidPtr(scripting_context, NULL)); if (handler) { PyTuple_SetItem(t, n++, PyInt_FromLong(cpu)); PyTuple_SetItem(t, n++, PyInt_FromLong(s)); PyTuple_SetItem(t, n++, PyInt_FromLong(ns)); PyTuple_SetItem(t, n++, PyInt_FromLong(pid)); PyTuple_SetItem(t, n++, PyString_FromString(comm)); } else { PyDict_SetItemString(dict, "common_cpu", PyInt_FromLong(cpu)); PyDict_SetItemString(dict, "common_s", PyInt_FromLong(s)); PyDict_SetItemString(dict, "common_ns", PyInt_FromLong(ns)); PyDict_SetItemString(dict, "common_pid", PyInt_FromLong(pid)); PyDict_SetItemString(dict, "common_comm", PyString_FromString(comm)); } for (field = event->format.fields; field; field = field->next) { if (field->flags & FIELD_IS_STRING) { int offset; if (field->flags & FIELD_IS_DYNAMIC) { offset = *(int *)(data + field->offset); offset &= 0xffff; } else offset = field->offset; obj = PyString_FromString((char *)data + offset); } else { /* FIELD_IS_NUMERIC */ val = read_size(data + field->offset, field->size); if (field->flags & FIELD_IS_SIGNED) { if ((long long)val >= LONG_MIN && (long long)val <= LONG_MAX) obj = PyInt_FromLong(val); else obj = PyLong_FromLongLong(val); } else { if (val <= LONG_MAX) obj = PyInt_FromLong(val); else obj = PyLong_FromUnsignedLongLong(val); } } if (handler) PyTuple_SetItem(t, n++, obj); else PyDict_SetItemString(dict, field->name, obj); } if (!handler) PyTuple_SetItem(t, n++, dict); if (_PyTuple_Resize(&t, n) == -1) Py_FatalError("error resizing Python tuple"); if (handler) { retval = PyObject_CallObject(handler, t); if (retval == NULL) handler_call_die(handler_name); } else { handler = PyDict_GetItemString(main_dict, "trace_unhandled"); if (handler && PyCallable_Check(handler)) { retval = PyObject_CallObject(handler, t); if (retval == NULL) handler_call_die("trace_unhandled"); } Py_DECREF(dict); } Py_DECREF(t); }
static void python_process_tracepoint(struct perf_sample *sample, struct perf_evsel *evsel, struct thread *thread, struct addr_location *al) { PyObject *handler, *retval, *context, *t, *obj, *dict = NULL; static char handler_name[256]; struct format_field *field; unsigned long long val; unsigned long s, ns; struct event_format *event; unsigned n = 0; int pid; int cpu = sample->cpu; void *data = sample->raw_data; unsigned long long nsecs = sample->time; const char *comm = thread__comm_str(thread); t = PyTuple_New(MAX_FIELDS); if (!t) Py_FatalError("couldn't create Python tuple"); event = find_cache_event(evsel); if (!event) die("ug! no event found for type %d", (int)evsel->attr.config); pid = raw_field_value(event, "common_pid", data); sprintf(handler_name, "%s__%s", event->system, event->name); handler = PyDict_GetItemString(main_dict, handler_name); if (handler && !PyCallable_Check(handler)) handler = NULL; if (!handler) { dict = PyDict_New(); if (!dict) Py_FatalError("couldn't create Python dict"); } s = nsecs / NSECS_PER_SEC; ns = nsecs - s * NSECS_PER_SEC; scripting_context->event_data = data; scripting_context->pevent = evsel->tp_format->pevent; context = PyCObject_FromVoidPtr(scripting_context, NULL); PyTuple_SetItem(t, n++, PyString_FromString(handler_name)); PyTuple_SetItem(t, n++, context); if (handler) { PyTuple_SetItem(t, n++, PyInt_FromLong(cpu)); PyTuple_SetItem(t, n++, PyInt_FromLong(s)); PyTuple_SetItem(t, n++, PyInt_FromLong(ns)); PyTuple_SetItem(t, n++, PyInt_FromLong(pid)); PyTuple_SetItem(t, n++, PyString_FromString(comm)); } else { pydict_set_item_string_decref(dict, "common_cpu", PyInt_FromLong(cpu)); pydict_set_item_string_decref(dict, "common_s", PyInt_FromLong(s)); pydict_set_item_string_decref(dict, "common_ns", PyInt_FromLong(ns)); pydict_set_item_string_decref(dict, "common_pid", PyInt_FromLong(pid)); pydict_set_item_string_decref(dict, "common_comm", PyString_FromString(comm)); } for (field = event->format.fields; field; field = field->next) { if (field->flags & FIELD_IS_STRING) { int offset; if (field->flags & FIELD_IS_DYNAMIC) { offset = *(int *)(data + field->offset); offset &= 0xffff; } else offset = field->offset; obj = PyString_FromString((char *)data + offset); } else { /* FIELD_IS_NUMERIC */ val = read_size(event, data + field->offset, field->size); if (field->flags & FIELD_IS_SIGNED) { if ((long long)val >= LONG_MIN && (long long)val <= LONG_MAX) obj = PyInt_FromLong(val); else obj = PyLong_FromLongLong(val); } else { if (val <= LONG_MAX) obj = PyInt_FromLong(val); else obj = PyLong_FromUnsignedLongLong(val); } } if (handler) PyTuple_SetItem(t, n++, obj); else pydict_set_item_string_decref(dict, field->name, obj); } if (!handler) PyTuple_SetItem(t, n++, dict); if (_PyTuple_Resize(&t, n) == -1) Py_FatalError("error resizing Python tuple"); if (handler) { retval = PyObject_CallObject(handler, t); if (retval == NULL) handler_call_die(handler_name); } else { handler = PyDict_GetItemString(main_dict, "trace_unhandled"); if (handler && PyCallable_Check(handler)) { retval = PyObject_CallObject(handler, t); if (retval == NULL) handler_call_die("trace_unhandled"); } Py_DECREF(dict); } Py_DECREF(t); }
PyObject *xmlsec_TransformVisa3DHackId(PyObject *self, PyObject *args) { return PyCObject_FromVoidPtr((void *) xmlSecTransformVisa3DHackId, NULL); }
PyObject *xmlsec_TransformRemoveXmlTagsC14NId(PyObject *self, PyObject *args) { return PyCObject_FromVoidPtr((void *) xmlSecTransformRemoveXmlTagsC14NId, NULL); }
PyObject *xmlsec_TransformXPointerId(PyObject *self, PyObject *args) { return PyCObject_FromVoidPtr((void *) xmlSecTransformXPointerId, NULL); }
static PyObject* image_get_c_methods( PyObject* self ) { return PyCObject_FromVoidPtr( (void*)&c_methods, NULL ); }
/** * Interface for AtkUtilClass->add_global_event_listener. */ static guint _class_add_global_event_listener (GSignalEmissionHook listener, const gchar *event_type) { PyObject *dict = NULL; PyObject *cb = NULL; PyObject *key = NULL; gchar **split = g_strsplit (event_type, ":", 3); debug ("_class_add_global_event_listener\n"); if (!split) return 0; if (!_global_listeners) { _global_listeners = PyDict_New (); if (!_global_listeners) return 0; } if (!_global_signals) { _global_signals = PyDict_New (); if (!_global_signals) return 0; } #ifdef DEBUG printf ("DEBUG: Installing handler for %s\n", event_type); #endif /* Create the event mappings, which are used by the AtkObject system * and have to be implemented manually by the user. */ if (strcmp ("window", split[0]) == 0) { g_strfreev (split); /* Free string. */ /* Lookup matching dict. */ dict = PyDict_GetItemString (_global_listeners, event_type); if (!dict) { dict = _add_listener_dict (event_type); if (!dict) return 0; } /* Add listener. */ cb = PyCObject_FromVoidPtr (listener, NULL); key = PyInt_FromLong ((long) _global_listener_ids + 1); if (PyDict_SetItem (dict, key, cb) == -1) { Py_DECREF (cb); Py_DECREF (key); return 0; } Py_DECREF (cb); Py_DECREF (key); } else { /* Lookup matching dict. */ gchar *str = g_strconcat (split[1], ":", split[2], NULL); g_strfreev (split); dict = PyDict_GetItemString (_global_listeners, str); if (!dict) { dict = _add_listener_dict (str); if (!dict) { g_free (str); return 0; } } g_free (str); /* Add listener. */ cb = PyCObject_FromVoidPtr (listener, NULL); key = PyInt_FromLong ((long) _global_listener_ids + 1); if (PyDict_SetItem (dict, key, cb) == -1) { Py_DECREF (cb); Py_DECREF (key); return 0; } Py_DECREF (cb); Py_DECREF (key); } /* Increase id count upon successful addition. */ _global_listener_ids++; return _global_listener_ids; }
static PyObject* create_module (void) { # if PY_VERSION_HEX >= 0x03000000 PyObject* module = PyModule_Create(&module_definition); auto module_ = make_xsafe(module); const char* ret = "O"; # else PyObject* module = Py_InitModule3(BOB_EXT_MODULE_NAME, module_methods, module_docstr); const char* ret = "N"; # endif if (!module) return 0; if (PyModule_AddStringConstant(module, "__version__", BOB_EXT_MODULE_VERSION) < 0) return 0; if (!init_BobIpBaseGeomNorm(module)) return 0; if (!init_BobIpBaseFaceEyesNorm(module)) return 0; if (!init_BobIpBaseLBP(module)) return 0; if (!init_BobIpBaseLBPTop(module)) return 0; if (!init_BobIpBaseDCTFeatures(module)) return 0; if (!init_BobIpBaseTanTriggs(module)) return 0; if (!init_BobIpBaseGaussian(module)) return 0; if (!init_BobIpBaseMultiscaleRetinex(module)) return 0; if (!init_BobIpBaseWeightedGaussian(module)) return 0; if (!init_BobIpBaseSelfQuotientImage(module)) return 0; if (!init_BobIpBaseGaussianScaleSpace(module)) return 0; if (!init_BobIpBaseSIFT(module)) return 0; if (!init_BobIpBaseHOG(module)) return 0; if (!init_BobIpBaseGLCM(module)) return 0; if (!init_BobIpBaseWiener(module)) return 0; #if HAVE_VLFEAT if (!init_BobIpBaseVLFEAT(module)) return 0; #endif // HAVE_VLFEAT static void* PyBobIpBase_API[PyBobIpBase_API_pointers]; /* exhaustive list of C APIs */ /************** * Versioning * **************/ PyBobIpBase_API[PyBobIpBase_APIVersion_NUM] = (void *)&PyBobIpBase_APIVersion; /******************************** * Bindings for bob.ip.base.LBP * ********************************/ PyBobIpBase_API[PyBobIpBaseLBP_Type_NUM] = (void *)&PyBobIpBaseLBP_Type; PyBobIpBase_API[PyBobIpBaseLBP_Check_NUM] = (void *)&PyBobIpBaseLBP_Check; PyBobIpBase_API[PyBobIpBaseLBP_Converter_NUM] = (void *)&PyBobIpBaseLBP_Converter; #if PY_VERSION_HEX >= 0x02070000 /* defines the PyCapsule */ PyObject* c_api_object = PyCapsule_New((void *)PyBobIpBase_API, BOB_EXT_MODULE_PREFIX "." BOB_EXT_MODULE_NAME "._C_API", 0); #else PyObject* c_api_object = PyCObject_FromVoidPtr((void *)PyBobIpBase_API, 0); #endif if (!c_api_object) return 0; if (PyModule_AddObject(module, "_C_API", c_api_object) < 0) return 0; /* imports bob.ip.base's C-API dependencies */ if (import_bob_blitz() < 0) return 0; if (import_bob_core_random() < 0) return 0; if (import_bob_core_logging() < 0) return 0; if (import_bob_io_base() < 0) return 0; if (import_bob_sp() < 0) return 0; return Py_BuildValue(ret, module); }
PyMODINIT_FUNC initMMTK_pose(void) { PyObject *m, *d, *module; #ifdef WITH_MPI PyObject *mpi_module; #endif static void *PyFF_API[PyFF_API_pointers]; /* Create the module and add the functions */ m = Py_InitModule("MMTK_pose", pose_methods); /* Import the array and MPI modules */ #ifdef import_array import_array(); #endif #ifdef WITH_MPI import_mpi(); mpi_module = PyImport_ImportModule("Scientific.MPI"); if (mpi_module != NULL) { PyObject *module_dict = PyModule_GetDict(mpi_module); PyExc_MPIError = PyDict_GetItemString(module_dict, "MPIError"); } #endif /* Add C API pointer array */ PyFF_API[PyFFEnergyTerm_Type_NUM] = (void *)&PyFFEnergyTerm_Type; PyFF_API[PyFFEvaluator_Type_NUM] = (void *)&PyFFEvaluator_Type; PyFF_API[PyNonbondedList_Type_NUM] = (void *)&PyNonbondedList_Type; PyFF_API[PySparseFC_New_NUM] = (void *)&PySparseFC_New; PyFF_API[PySparseFC_Type_NUM] = (void *)&PySparseFC_Type; PyFF_API[PySparseFC_Zero_NUM] = (void *)&PySparseFC_Zero; PyFF_API[PySparseFC_Find_NUM] = (void *)&PySparseFC_Find; PyFF_API[PySparseFC_AddTerm_NUM] = (void *)&PySparseFC_AddTerm; PyFF_API[PySparseFC_CopyToArray_NUM] = (void *)&PySparseFC_CopyToArray; PyFF_API[PySparseFC_AsArray_NUM] = (void *)&PySparseFC_AsArray; PyFF_API[PySparseFC_VectorMultiply_NUM] = (void *)&PySparseFC_VectorMultiply; PyFF_API[PySparseFC_Scale_NUM] = (void *)&PySparseFC_Scale; PyFF_API[PyFFEnergyTerm_New_NUM] = (void *)&PyFFEnergyTerm_New; PyFF_API[PyFFEvaluator_New_NUM] = (void *)&PyFFEvaluator_New; PyFF_API[PyNonbondedListUpdate_NUM] = (void *)&PyNonbondedListUpdate; PyFF_API[PyNonbondedListIterate_NUM] = (void *)&PyNonbondedListIterate; #ifdef EXTENDED_TYPES if (PyType_Ready(&PyFFEnergyTerm_Type) < 0) return; if (PyType_Ready(&PyFFEvaluator_Type) < 0) return; if (PyType_Ready(&PyNonbondedList_Type) < 0) return; if (PyType_Ready(&PySparseFC_Type) < 0) return; #else PyFFEnergyTerm_Type.ob_type = &PyType_Type; PyFFEvaluator_Type.ob_type = &PyType_Type; PyNonbondedList_Type.ob_type = &PyType_Type; PySparseFC_Type.ob_type = &PyType_Type; #endif d = PyModule_GetDict(m); PyDict_SetItemString(d, "_C_API", PyCObject_FromVoidPtr((void *)PyFF_API, NULL)); PyDict_SetItemString(d, "EnergyTerm", (PyObject *)&PyFFEnergyTerm_Type); PyDict_SetItemString(d, "EnergyEvaluator", (PyObject *)&PyFFEvaluator_Type); /* Get the energy conversion factor from Units */ module = PyImport_ImportModule("MMTK.Units"); if (module != NULL) { PyObject *module_dict = PyModule_GetDict(module); PyObject *factor = PyDict_GetItemString(module_dict, "electrostatic_energy"); electrostatic_energy_factor = PyFloat_AsDouble(factor); } /* Get function pointers from _universe */ module = PyImport_ImportModule("MMTK_universe"); if (module != NULL) { PyObject *module_dict = PyModule_GetDict(module); PyObject *c_api_object = PyDict_GetItemString(module_dict, "_C_API"); PyObject *fn; if (PyCObject_Check(c_api_object)) PyUniverse_API = (void **)PyCObject_AsVoidPtr(c_api_object); fn = PyDict_GetItemString(module_dict, "infinite_universe_distance_function"); distance_vector_pointer = (distance_fn *)PyCObject_AsVoidPtr(fn); fn = PyDict_GetItemString(module_dict, "orthorhombic_universe_distance_function"); orthorhombic_distance_vector_pointer = (distance_fn *)PyCObject_AsVoidPtr(fn); fn = PyDict_GetItemString(module_dict, "parallelepipedic_universe_distance_function"); parallelepipedic_distance_vector_pointer = (distance_fn *)PyCObject_AsVoidPtr(fn); } /* Check for errors */ if (PyErr_Occurred()) Py_FatalError("can't initialize module MMTK_forcefield"); }
static PyObject * ff_create(PyObject *self, PyObject *args) { PyObject *pypfo, *pycmap, *pyim, *pysite, *pyworker; double params[N_PARAMS]; int eaa=-7, maxiter=-8, nThreads=-9; int auto_deepen, periodicity; int yflip; render_type_t render_type; pf_obj *pfo; ColorMap *cmap; IImage *im; IFractalSite *site; IFractWorker *worker; if(!PyArg_ParseTuple( args, "(ddddddddddd)iiiiOOiiiOOO", ¶ms[0],¶ms[1],¶ms[2],¶ms[3], ¶ms[4],¶ms[5],¶ms[6],¶ms[7], ¶ms[8],¶ms[9],¶ms[10], &eaa,&maxiter,&yflip,&nThreads, &pypfo,&pycmap, &auto_deepen, &periodicity, &render_type, &pyim, &pysite, &pyworker )) { return NULL; } cmap = (ColorMap *)PyCObject_AsVoidPtr(pycmap); pfo = ((pfHandle *)PyCObject_AsVoidPtr(pypfo))->pfo; im = (IImage *)PyCObject_AsVoidPtr(pyim); site = (IFractalSite *)PyCObject_AsVoidPtr(pysite); worker = (IFractWorker *)PyCObject_AsVoidPtr(pyworker); if(!cmap || !pfo || !im || !site || !worker) { return NULL; } fractFunc *ff = new fractFunc( params, eaa, maxiter, nThreads, auto_deepen, yflip, periodicity, render_type, -1, // warp_param worker, im, site); if(!ff) { return NULL; } ffHandle *ffh = new struct ffHandle; ffh->ff = ff; ffh->pyhandle = pyworker; PyObject *pyret = PyCObject_FromVoidPtr( ffh,(void (*)(void *))ff_delete); Py_INCREF(pyworker); return pyret; }
/* * Add rpm tag dictionaries to the module */ static void addRpmTags(PyObject *module) { PyObject * dict = PyDict_New(); #ifdef NOTYET PyObject *pyval, *pyname; rpmtd names = rpmtdNew(); rpmTagGetNames(names, 1); const char *tagname, *shortname; rpmTag tagval; while ((tagname = rpmtdNextString(names))) { shortname = tagname + strlen("RPMTAG_"); tagval = rpmTagGetValue(shortname); PyModule_AddIntConstant(module, tagname, tagval); pyval = PyInt_FromLong(tagval); pyname = PyString_FromString(shortname); PyDict_SetItem(dict, pyval, pyname); Py_XDECREF(pyval); Py_XDECREF(pyname); } PyModule_AddObject(module, "tagnames", dict); rpmtdFreeData(names); rpmtdFree(names); #else PyObject * d = PyModule_GetDict(module); PyObject * o; { const struct headerTagTableEntry_s * t; PyObject * to; for (t = rpmTagTable; t && t->name; t++) { PyDict_SetItemString(d, (char *) t->name, to=PyInt_FromLong(t->val)); Py_XDECREF(to); PyDict_SetItem(dict, to, o=PyString_FromString(t->name + 7)); Py_XDECREF(o); } } { headerSprintfExtension exts = rpmHeaderFormats; headerSprintfExtension ext; PyObject * to; int extNum; for (ext = exts, extNum = 0; ext != NULL && ext->type != HEADER_EXT_LAST; ext = (ext->type == HEADER_EXT_MORE ? *ext->u.more : ext+1), extNum++) { if (ext->name == NULL || ext->type != HEADER_EXT_TAG) continue; PyDict_SetItemString(d, (char *) ext->name, to=PyCObject_FromVoidPtr((void *)ext, NULL)); Py_XDECREF(to); PyDict_SetItem(dict, to, o=PyString_FromString(ext->name + 7)); Py_XDECREF(o); } } PyDict_SetItemString(d, "tagnames", dict); Py_XDECREF(dict); #endif }
static s_param * parse_params(PyObject *pyarray, int *plen) { struct s_param *params; // check and parse fractal params if(!PySequence_Check(pyarray)) { PyErr_SetString(PyExc_TypeError, "parameters argument should be an array"); return NULL; } int len = PySequence_Size(pyarray); if(len == 0) { params = (struct s_param *)malloc(sizeof(struct s_param)); params[0].t = FLOAT; params[0].doubleval = 0.0; } else if(len > PF_MAXPARAMS) { PyErr_SetString(PyExc_ValueError,"Too many parameters"); return NULL; } else { int i = 0; params = (struct s_param *)malloc(len * sizeof(struct s_param)); if(!params) return NULL; for(i = 0; i < len; ++i) { PyObject *pyitem = PySequence_GetItem(pyarray,i); if(NULL == pyitem) { return NULL; } if(PyFloat_Check(pyitem)) { params[i].t = FLOAT; params[i].doubleval = PyFloat_AsDouble(pyitem); //printf("%d = float(%g)\n",i,params[i].doubleval); } else if(PyInt_Check(pyitem)) { params[i].t = INT; params[i].intval = PyInt_AS_LONG(pyitem); //printf("%d = int(%d)\n",i,params[i].intval); } else if( PyObject_HasAttrString(pyitem,"cobject") && PyObject_HasAttrString(pyitem,"segments")) { PyObject *pycob = PyObject_GetAttrString(pyitem,"cobject"); if(pycob == Py_None) { Py_DECREF(pycob); PyObject *pysegs = PyObject_GetAttrString( pyitem,"segments"); ColorMap *cmap = cmap_from_pyobject(pysegs); Py_DECREF(pysegs); if(NULL == cmap) { return NULL; } pycob = PyCObject_FromVoidPtr( cmap, (void (*)(void *))cmap_delete); if(NULL != pycob) { PyObject_SetAttrString(pyitem,"cobject",pycob); // not quite correct, we are leaking some // cmap objects Py_XINCREF(pycob); } } params[i].t = GRADIENT; params[i].gradient = PyCObject_AsVoidPtr(pycob); //printf("%d = gradient(%p)\n",i,params[i].gradient); Py_DECREF(pycob); } else if( PyObject_HasAttrString(pyitem,"_img")) { PyObject *pycob = PyObject_GetAttrString(pyitem,"_img"); params[i].t = PARAM_IMAGE; params[i].image = PyCObject_AsVoidPtr(pycob); Py_DECREF(pycob); } else { Py_XDECREF(pyitem); PyErr_SetString( PyExc_ValueError, "All params must be floats, ints, or gradients"); free(params); return NULL; } Py_XDECREF(pyitem); } } *plen = len; return params; }
PyObject* create() { brisk::BriskDescriptorExtractor* descriptor_extractor = new brisk::BriskDescriptorExtractor(); return PyCObject_FromVoidPtr(static_cast<void*>(descriptor_extractor), NULL); }
static PyObject *mkiir_wrap(PyObject *self, PyObject *args) { double lo, hi, srate; double bwfreq, freq, h1, gain; PyObject *o; FILTER *handle; IIRSPEC *filter; if (!PyArg_ParseTuple(args, "ddd:mkiir", &lo, &hi, &srate)) { return NULL; } handle = (FILTER *)malloc(sizeof(FILTER)); handle->type = FILTER_TYPE_IIR; filter = &handle->iirspec; filter->enable = 1; filter->rate = srate; if (hi > 0. && lo > 0. && lo < hi) { filter->type = BANDPASS; filter->order = SIG_ORDER; filter->fl = lo; filter->fh = hi; } else if (hi > 0. && lo > 0. && lo > hi) { filter->type = BANDREJECT; filter->order = SIG_ORDER; filter->fl = hi; filter->fh = lo; } else if (lo > 0. && hi == 0.) { filter->type = HIGHPASS; filter->order = 2 * SIG_ORDER; filter->fl = lo; filter->fh = srate / 2.; } else if (lo == 0. && hi > 0.) { filter->type = LOWPASS; filter->order = 2 * SIG_ORDER; filter->fl = 0; filter->fh = hi; } // compute filter coefficients if (mkiir(filter) < 0) { PyErr_SetString(PyExc_RuntimeError, "mkiir() failed"); free(handle); return NULL; } // compute effective bandwidth of data filter in steps of 1 milliHz for (freq = bwfreq = 0.; freq < srate / 4.; freq += 0.001) { h1 = response(filter, srate, freq); if (h1 > M_SQRT2) { PyErr_SetString(PyExc_RuntimeError, "mkiir() failed: IIR filter is unstable for this sample rate"); free(handle); return NULL; } bwfreq += 0.001 * (h1 * h1); } // test filter for low gain gain = bwfreq / (hi - lo); if (gain < M_SQRT1_2) { printf("nominal filter bandwidth=%f\n", bwfreq); PyErr_SetString(PyExc_RuntimeError, "WARNING: IIR filter gain too low"); free(handle); return NULL; } o = PyCObject_FromVoidPtr(handle, free_filter); return o; }
init_cairo(void) { PyObject *m; /* initialise 'tp_base' here to work round problem with MinGW compiler */ PycairoContext_Type.tp_base = &PyBaseObject_Type; if (PyType_Ready(&PycairoContext_Type) < 0) return; PycairoFontFace_Type.tp_base = &PyBaseObject_Type; if (PyType_Ready(&PycairoFontFace_Type) < 0) return; PycairoToyFontFace_Type.tp_base = &PycairoFontFace_Type; if (PyType_Ready(&PycairoToyFontFace_Type) < 0) return; PycairoFontOptions_Type.tp_base = &PyBaseObject_Type; if (PyType_Ready(&PycairoFontOptions_Type) < 0) return; PycairoMatrix_Type.tp_base = &PyBaseObject_Type; if (PyType_Ready(&PycairoMatrix_Type) < 0) return; PycairoPath_Type.tp_base = &PyBaseObject_Type; if (PyType_Ready(&PycairoPath_Type) < 0) return; PycairoPathiter_Type.tp_iter=&PyObject_SelfIter; PycairoPattern_Type.tp_base = &PyBaseObject_Type; if (PyType_Ready(&PycairoPattern_Type) < 0) return; PycairoSolidPattern_Type.tp_base = &PycairoPattern_Type; if (PyType_Ready(&PycairoSolidPattern_Type) < 0) return; PycairoSurfacePattern_Type.tp_base = &PycairoPattern_Type; if (PyType_Ready(&PycairoSurfacePattern_Type) < 0) return; PycairoGradient_Type.tp_base = &PycairoPattern_Type; if (PyType_Ready(&PycairoGradient_Type) < 0) return; PycairoLinearGradient_Type.tp_base = &PycairoGradient_Type; if (PyType_Ready(&PycairoLinearGradient_Type) < 0) return; PycairoRadialGradient_Type.tp_base = &PycairoGradient_Type; if (PyType_Ready(&PycairoRadialGradient_Type) < 0) return; PycairoScaledFont_Type.tp_base = &PyBaseObject_Type; if (PyType_Ready(&PycairoScaledFont_Type) < 0) return; PycairoSurface_Type.tp_base = &PyBaseObject_Type; if (PyType_Ready(&PycairoSurface_Type) < 0) return; #ifdef CAIRO_HAS_IMAGE_SURFACE PycairoImageSurface_Type.tp_base = &PycairoSurface_Type; if (PyType_Ready(&PycairoImageSurface_Type) < 0) return; #endif #ifdef CAIRO_HAS_PDF_SURFACE PycairoPDFSurface_Type.tp_base = &PycairoSurface_Type; if (PyType_Ready(&PycairoPDFSurface_Type) < 0) return; #endif #ifdef CAIRO_HAS_PS_SURFACE PycairoPSSurface_Type.tp_base = &PycairoSurface_Type; if (PyType_Ready(&PycairoPSSurface_Type) < 0) return; #endif #ifdef CAIRO_HAS_SVG_SURFACE PycairoSVGSurface_Type.tp_base = &PycairoSurface_Type; if (PyType_Ready(&PycairoSVGSurface_Type) < 0) return; #endif #ifdef CAIRO_HAS_WIN32_SURFACE PycairoWin32Surface_Type.tp_base = &PycairoSurface_Type; if (PyType_Ready(&PycairoWin32Surface_Type) < 0) return; #endif #ifdef CAIRO_HAS_XLIB_SURFACE PycairoXlibSurface_Type.tp_base = &PycairoSurface_Type; if (PyType_Ready(&PycairoXlibSurface_Type) < 0) return; #endif m = Py_InitModule("cairo._cairo", cairo_functions); PyModule_AddStringConstant(m, "version", pycairo_version_string); PyModule_AddObject(m, "version_info", Py_BuildValue("(iii)", VERSION_MAJOR, VERSION_MINOR, VERSION_MICRO)); Py_INCREF(&PycairoContext_Type); PyModule_AddObject(m, "Context", (PyObject *)&PycairoContext_Type); Py_INCREF(&PycairoFontFace_Type); PyModule_AddObject(m, "FontFace",(PyObject *)&PycairoFontFace_Type); Py_INCREF(&PycairoToyFontFace_Type); PyModule_AddObject(m, "ToyFontFace",(PyObject *)&PycairoToyFontFace_Type); Py_INCREF(&PycairoFontOptions_Type); PyModule_AddObject(m, "FontOptions",(PyObject *)&PycairoFontOptions_Type); Py_INCREF(&PycairoMatrix_Type); PyModule_AddObject(m, "Matrix", (PyObject *)&PycairoMatrix_Type); Py_INCREF(&PycairoPath_Type); /* Don't add Path object since it is not accessed directly as 'cairo.Path' * PyModule_AddObject(m, "Path", (PyObject *)&PycairoPath_Type); */ Py_INCREF(&PycairoPattern_Type); PyModule_AddObject(m, "Pattern", (PyObject *)&PycairoPattern_Type); Py_INCREF(&PycairoSolidPattern_Type); PyModule_AddObject(m, "SolidPattern", (PyObject *)&PycairoSolidPattern_Type); Py_INCREF(&PycairoSurfacePattern_Type); PyModule_AddObject(m, "SurfacePattern", (PyObject *)&PycairoSurfacePattern_Type); Py_INCREF(&PycairoGradient_Type); PyModule_AddObject(m, "Gradient", (PyObject *)&PycairoGradient_Type); Py_INCREF(&PycairoLinearGradient_Type); PyModule_AddObject(m, "LinearGradient", (PyObject *)&PycairoLinearGradient_Type); Py_INCREF(&PycairoRadialGradient_Type); PyModule_AddObject(m, "RadialGradient", (PyObject *)&PycairoRadialGradient_Type); Py_INCREF(&PycairoScaledFont_Type); PyModule_AddObject(m, "ScaledFont", (PyObject *)&PycairoScaledFont_Type); Py_INCREF(&PycairoSurface_Type); PyModule_AddObject(m, "Surface", (PyObject *)&PycairoSurface_Type); #ifdef CAIRO_HAS_IMAGE_SURFACE Py_INCREF(&PycairoImageSurface_Type); PyModule_AddObject(m, "ImageSurface", (PyObject *)&PycairoImageSurface_Type); #endif #ifdef CAIRO_HAS_PDF_SURFACE Py_INCREF(&PycairoPDFSurface_Type); PyModule_AddObject(m, "PDFSurface", (PyObject *)&PycairoPDFSurface_Type); #endif #ifdef CAIRO_HAS_PS_SURFACE Py_INCREF(&PycairoPSSurface_Type); PyModule_AddObject(m, "PSSurface", (PyObject *)&PycairoPSSurface_Type); #endif #ifdef CAIRO_HAS_SVG_SURFACE Py_INCREF(&PycairoSVGSurface_Type); PyModule_AddObject(m, "SVGSurface", (PyObject *)&PycairoSVGSurface_Type); #endif #ifdef CAIRO_HAS_WIN32_SURFACE Py_INCREF(&PycairoWin32Surface_Type); PyModule_AddObject(m, "Win32Surface", (PyObject *)&PycairoWin32Surface_Type); #endif #ifdef CAIRO_HAS_XLIB_SURFACE Py_INCREF(&PycairoXlibSurface_Type); PyModule_AddObject(m, "XlibSurface", (PyObject *)&PycairoXlibSurface_Type); #endif PyModule_AddObject(m, "CAPI", PyCObject_FromVoidPtr(&CAPI, NULL)); /* Add 'cairo.Error' to the module */ if (CairoError == NULL) { CairoError = PyErr_NewException("cairo.Error", NULL, NULL); if (CairoError == NULL) return; } Py_INCREF(CairoError); if (PyModule_AddObject(m, "Error", CairoError) < 0) return; /* constants */ #if CAIRO_HAS_ATSUI_FONT PyModule_AddIntConstant(m, "HAS_ATSUI_FONT", 1); #else PyModule_AddIntConstant(m, "HAS_ATSUI_FONT", 0); #endif #if CAIRO_HAS_FT_FONT PyModule_AddIntConstant(m, "HAS_FT_FONT", 1); #else PyModule_AddIntConstant(m, "HAS_FT_FONT", 0); #endif #if CAIRO_HAS_GLITZ_SURFACE PyModule_AddIntConstant(m, "HAS_GLITZ_SURFACE", 1); #else PyModule_AddIntConstant(m, "HAS_GLITZ_SURFACE", 0); #endif #if CAIRO_HAS_IMAGE_SURFACE PyModule_AddIntConstant(m, "HAS_IMAGE_SURFACE", 1); #else PyModule_AddIntConstant(m, "HAS_IMAGE_SURFACE", 0); #endif #if CAIRO_HAS_PDF_SURFACE PyModule_AddIntConstant(m, "HAS_PDF_SURFACE", 1); #else PyModule_AddIntConstant(m, "HAS_PDF_SURFACE", 0); #endif #if CAIRO_HAS_PNG_FUNCTIONS PyModule_AddIntConstant(m, "HAS_PNG_FUNCTIONS", 1); #else PyModule_AddIntConstant(m, "HAS_PNG_FUNCTIONS", 0); #endif #if CAIRO_HAS_PS_SURFACE PyModule_AddIntConstant(m, "HAS_PS_SURFACE", 1); #else PyModule_AddIntConstant(m, "HAS_PS_SURFACE", 0); #endif #if CAIRO_HAS_SVG_SURFACE PyModule_AddIntConstant(m, "HAS_SVG_SURFACE", 1); #else PyModule_AddIntConstant(m, "HAS_SVG_SURFACE", 0); #endif #if CAIRO_HAS_USER_FONT PyModule_AddIntConstant(m, "HAS_USER_FONT", 1); #else PyModule_AddIntConstant(m, "HAS_USER_FONT", 0); #endif #if CAIRO_HAS_QUARTZ_SURFACE PyModule_AddIntConstant(m, "HAS_QUARTZ_SURFACE", 1); #else PyModule_AddIntConstant(m, "HAS_QUARTZ_SURFACE", 0); #endif #if CAIRO_HAS_WIN32_FONT PyModule_AddIntConstant(m, "HAS_WIN32_FONT", 1); #else PyModule_AddIntConstant(m, "HAS_WIN32_FONT", 0); #endif #if CAIRO_HAS_WIN32_SURFACE PyModule_AddIntConstant(m, "HAS_WIN32_SURFACE", 1); #else PyModule_AddIntConstant(m, "HAS_WIN32_SURFACE", 0); #endif #if CAIRO_HAS_XCB_SURFACE PyModule_AddIntConstant(m, "HAS_XCB_SURFACE", 1); #else PyModule_AddIntConstant(m, "HAS_XCB_SURFACE", 0); #endif #if CAIRO_HAS_XLIB_SURFACE PyModule_AddIntConstant(m, "HAS_XLIB_SURFACE", 1); #else PyModule_AddIntConstant(m, "HAS_XLIB_SURFACE", 0); #endif #define CONSTANT(x) PyModule_AddIntConstant(m, #x, CAIRO_##x) CONSTANT(ANTIALIAS_DEFAULT); CONSTANT(ANTIALIAS_NONE); CONSTANT(ANTIALIAS_GRAY); CONSTANT(ANTIALIAS_SUBPIXEL); CONSTANT(CONTENT_COLOR); CONSTANT(CONTENT_ALPHA); CONSTANT(CONTENT_COLOR_ALPHA); CONSTANT(EXTEND_NONE); CONSTANT(EXTEND_REPEAT); CONSTANT(EXTEND_REFLECT); CONSTANT(EXTEND_PAD); CONSTANT(FILL_RULE_WINDING); CONSTANT(FILL_RULE_EVEN_ODD); CONSTANT(FILTER_FAST); CONSTANT(FILTER_GOOD); CONSTANT(FILTER_BEST); CONSTANT(FILTER_NEAREST); CONSTANT(FILTER_BILINEAR); CONSTANT(FILTER_GAUSSIAN); CONSTANT(FONT_WEIGHT_NORMAL); CONSTANT(FONT_WEIGHT_BOLD); CONSTANT(FONT_SLANT_NORMAL); CONSTANT(FONT_SLANT_ITALIC); CONSTANT(FONT_SLANT_OBLIQUE); CONSTANT(FORMAT_ARGB32); CONSTANT(FORMAT_RGB24); CONSTANT(FORMAT_A8); CONSTANT(FORMAT_A1); CONSTANT(HINT_METRICS_DEFAULT); CONSTANT(HINT_METRICS_OFF); CONSTANT(HINT_METRICS_ON); CONSTANT(HINT_STYLE_DEFAULT); CONSTANT(HINT_STYLE_NONE); CONSTANT(HINT_STYLE_SLIGHT); CONSTANT(HINT_STYLE_MEDIUM); CONSTANT(HINT_STYLE_FULL); CONSTANT(LINE_CAP_BUTT); CONSTANT(LINE_CAP_ROUND); CONSTANT(LINE_CAP_SQUARE); CONSTANT(LINE_JOIN_MITER); CONSTANT(LINE_JOIN_ROUND); CONSTANT(LINE_JOIN_BEVEL); CONSTANT(OPERATOR_CLEAR); CONSTANT(OPERATOR_SOURCE); CONSTANT(OPERATOR_OVER); CONSTANT(OPERATOR_IN); CONSTANT(OPERATOR_OUT); CONSTANT(OPERATOR_ATOP); CONSTANT(OPERATOR_DEST); CONSTANT(OPERATOR_DEST_OVER); CONSTANT(OPERATOR_DEST_IN); CONSTANT(OPERATOR_DEST_OUT); CONSTANT(OPERATOR_DEST_ATOP); CONSTANT(OPERATOR_XOR); CONSTANT(OPERATOR_ADD); CONSTANT(OPERATOR_SATURATE); CONSTANT(PATH_MOVE_TO); CONSTANT(PATH_LINE_TO); CONSTANT(PATH_CURVE_TO); CONSTANT(PATH_CLOSE_PATH); #ifdef CAIRO_HAS_PS_SURFACE CONSTANT(PS_LEVEL_2); CONSTANT(PS_LEVEL_3); #endif CONSTANT(SUBPIXEL_ORDER_DEFAULT); CONSTANT(SUBPIXEL_ORDER_RGB); CONSTANT(SUBPIXEL_ORDER_BGR); CONSTANT(SUBPIXEL_ORDER_VRGB); CONSTANT(SUBPIXEL_ORDER_VBGR); #undef CONSTANT }
/* * Initialize SSL sub module * * Arguments: None * Returns: None */ void initSSL(void) { static void *ssl_API[ssl_API_pointers]; PyObject *ssl_api_object; PyObject *module; SSL_library_init(); ERR_load_SSL_strings(); import_crypto(); if ((module = Py_InitModule3("SSL", ssl_methods, ssl_doc)) == NULL) { return; } /* Initialize the C API pointer array */ ssl_API[ssl_Context_New_NUM] = (void *)ssl_Context_New; ssl_API[ssl_Connection_New_NUM] = (void *)ssl_Connection_New; ssl_api_object = PyCObject_FromVoidPtr((void *)ssl_API, NULL); if (ssl_api_object != NULL) PyModule_AddObject(module, "_C_API", ssl_api_object); /* Exceptions */ /* * ADD_EXCEPTION(dict,name,base) expands to a correct Exception declaration, * inserting OpenSSL.SSL.name into dict, derviving the exception from base. */ #define ADD_EXCEPTION(_name, _base) \ do { \ ssl_##_name = PyErr_NewException("OpenSSL.SSL."#_name, _base, NULL);\ if (ssl_##_name == NULL) \ goto error; \ if (PyModule_AddObject(module, #_name, ssl_##_name) != 0) \ goto error; \ } while (0) ssl_Error = PyErr_NewException("OpenSSL.SSL.Error", NULL, NULL); if (ssl_Error == NULL) goto error; if (PyModule_AddObject(module, "Error", ssl_Error) != 0) goto error; ADD_EXCEPTION(ZeroReturnError, ssl_Error); ADD_EXCEPTION(WantReadError, ssl_Error); ADD_EXCEPTION(WantWriteError, ssl_Error); ADD_EXCEPTION(WantX509LookupError, ssl_Error); ADD_EXCEPTION(SysCallError, ssl_Error); #undef ADD_EXCEPTION /* Method constants */ PyModule_AddIntConstant(module, "SSLv2_METHOD", ssl_SSLv2_METHOD); PyModule_AddIntConstant(module, "SSLv3_METHOD", ssl_SSLv3_METHOD); PyModule_AddIntConstant(module, "SSLv23_METHOD", ssl_SSLv23_METHOD); PyModule_AddIntConstant(module, "TLSv1_METHOD", ssl_TLSv1_METHOD); /* Verify constants */ PyModule_AddIntConstant(module, "VERIFY_NONE", SSL_VERIFY_NONE); PyModule_AddIntConstant(module, "VERIFY_PEER", SSL_VERIFY_PEER); PyModule_AddIntConstant(module, "VERIFY_FAIL_IF_NO_PEER_CERT", SSL_VERIFY_FAIL_IF_NO_PEER_CERT); PyModule_AddIntConstant(module, "VERIFY_CLIENT_ONCE", SSL_VERIFY_CLIENT_ONCE); /* File type constants */ PyModule_AddIntConstant(module, "FILETYPE_PEM", SSL_FILETYPE_PEM); PyModule_AddIntConstant(module, "FILETYPE_ASN1", SSL_FILETYPE_ASN1); /* SSL option constants */ PyModule_AddIntConstant(module, "OP_SINGLE_DH_USE", SSL_OP_SINGLE_DH_USE); PyModule_AddIntConstant(module, "OP_EPHEMERAL_RSA", SSL_OP_EPHEMERAL_RSA); PyModule_AddIntConstant(module, "OP_NO_SSLv2", SSL_OP_NO_SSLv2); PyModule_AddIntConstant(module, "OP_NO_SSLv3", SSL_OP_NO_SSLv3); PyModule_AddIntConstant(module, "OP_NO_TLSv1", SSL_OP_NO_TLSv1); /* More SSL option constants */ PyModule_AddIntConstant(module, "OP_MICROSOFT_SESS_ID_BUG", SSL_OP_MICROSOFT_SESS_ID_BUG); PyModule_AddIntConstant(module, "OP_NETSCAPE_CHALLENGE_BUG", SSL_OP_NETSCAPE_CHALLENGE_BUG); PyModule_AddIntConstant(module, "OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG); PyModule_AddIntConstant(module, "OP_SSLREF2_REUSE_CERT_TYPE_BUG", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG); PyModule_AddIntConstant(module, "OP_MICROSOFT_BIG_SSLV3_BUFFER", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER); PyModule_AddIntConstant(module, "OP_MSIE_SSLV2_RSA_PADDING", SSL_OP_MSIE_SSLV2_RSA_PADDING); PyModule_AddIntConstant(module, "OP_SSLEAY_080_CLIENT_DH_BUG", SSL_OP_SSLEAY_080_CLIENT_DH_BUG); PyModule_AddIntConstant(module, "OP_TLS_D5_BUG", SSL_OP_TLS_D5_BUG); PyModule_AddIntConstant(module, "OP_TLS_BLOCK_PADDING_BUG", SSL_OP_TLS_BLOCK_PADDING_BUG); PyModule_AddIntConstant(module, "OP_DONT_INSERT_EMPTY_FRAGMENTS", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS); PyModule_AddIntConstant(module, "OP_ALL", SSL_OP_ALL); PyModule_AddIntConstant(module, "OP_CIPHER_SERVER_PREFERENCE", SSL_OP_CIPHER_SERVER_PREFERENCE); PyModule_AddIntConstant(module, "OP_TLS_ROLLBACK_BUG", SSL_OP_TLS_ROLLBACK_BUG); PyModule_AddIntConstant(module, "OP_PKCS1_CHECK_1", SSL_OP_PKCS1_CHECK_1); PyModule_AddIntConstant(module, "OP_PKCS1_CHECK_2", SSL_OP_PKCS1_CHECK_2); PyModule_AddIntConstant(module, "OP_NETSCAPE_CA_DN_BUG", SSL_OP_NETSCAPE_CA_DN_BUG); PyModule_AddIntConstant(module, "OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG", SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG); /* DTLS related options. The first two of these were introduced in * 2005, the third in 2007. To accomodate systems which are still using * older versions, make them optional. */ #ifdef SSL_OP_NO_QUERY_MTU PyModule_AddIntConstant(module, "OP_NO_QUERY_MTU", SSL_OP_NO_QUERY_MTU); #endif #ifdef SSL_OP_COOKIE_EXCHANGE PyModule_AddIntConstant(module, "OP_COOKIE_EXCHANGE", SSL_OP_COOKIE_EXCHANGE); #endif #ifdef SSL_OP_NO_TICKET PyModule_AddIntConstant(module, "OP_NO_TICKET", SSL_OP_NO_TICKET); #endif /* For SSL_set_shutdown */ PyModule_AddIntConstant(module, "SENT_SHUTDOWN", SSL_SENT_SHUTDOWN); PyModule_AddIntConstant(module, "RECEIVED_SHUTDOWN", SSL_RECEIVED_SHUTDOWN); if (!init_ssl_context(module)) goto error; if (!init_ssl_connection(module)) goto error; #ifdef WITH_THREAD /* * Initialize this module's threading support structures. */ _pyOpenSSL_tstate_key = PyThread_create_key(); #endif error: ; }
PyMODINIT_FUNC INIT_MODULE(_psycopg)(void) { #if PY_VERSION_HEX < 0x03020000 static void *PSYCOPG_API[PSYCOPG_API_pointers]; PyObject *c_api_object; #endif PyObject *module = NULL, *dict; #ifdef PSYCOPG_DEBUG if (getenv("PSYCOPG_DEBUG")) psycopg_debug_enabled = 1; #endif Dprintf("initpsycopg: initializing psycopg %s", PSYCOPG_VERSION); /* initialize all the new types and then the module */ Py_TYPE(&connectionType) = &PyType_Type; if (PyType_Ready(&connectionType) == -1) goto exit; Py_TYPE(&cursorType) = &PyType_Type; if (PyType_Ready(&cursorType) == -1) goto exit; Py_TYPE(&typecastType) = &PyType_Type; if (PyType_Ready(&typecastType) == -1) goto exit; Py_TYPE(&qstringType) = &PyType_Type; if (PyType_Ready(&qstringType) == -1) goto exit; Py_TYPE(&binaryType) = &PyType_Type; if (PyType_Ready(&binaryType) == -1) goto exit; Py_TYPE(&isqlquoteType) = &PyType_Type; if (PyType_Ready(&isqlquoteType) == -1) goto exit; Py_TYPE(&pbooleanType) = &PyType_Type; if (PyType_Ready(&pbooleanType) == -1) goto exit; Py_TYPE(&pintType) = &PyType_Type; if (PyType_Ready(&pintType) == -1) goto exit; Py_TYPE(&pfloatType) = &PyType_Type; if (PyType_Ready(&pfloatType) == -1) goto exit; Py_TYPE(&pdecimalType) = &PyType_Type; if (PyType_Ready(&pdecimalType) == -1) goto exit; Py_TYPE(&asisType) = &PyType_Type; if (PyType_Ready(&asisType) == -1) goto exit; Py_TYPE(&listType) = &PyType_Type; if (PyType_Ready(&listType) == -1) goto exit; Py_TYPE(&chunkType) = &PyType_Type; if (PyType_Ready(&chunkType) == -1) goto exit; Py_TYPE(¬ifyType) = &PyType_Type; if (PyType_Ready(¬ifyType) == -1) goto exit; Py_TYPE(&xidType) = &PyType_Type; if (PyType_Ready(&xidType) == -1) goto exit; Py_TYPE(&errorType) = &PyType_Type; errorType.tp_base = (PyTypeObject *)PyExc_StandardError; if (PyType_Ready(&errorType) == -1) goto exit; Py_TYPE(&diagnosticsType) = &PyType_Type; if (PyType_Ready(&diagnosticsType) == -1) goto exit; Py_TYPE(&lobjectType) = &PyType_Type; if (PyType_Ready(&lobjectType) == -1) goto exit; /* initialize libcrypto threading callbacks */ psyco_libcrypto_threads_init(); /* import mx.DateTime module, if necessary */ #ifdef HAVE_MXDATETIME Py_TYPE(&mxdatetimeType) = &PyType_Type; if (PyType_Ready(&mxdatetimeType) == -1) goto exit; if (0 != mxDateTime_ImportModuleAndAPI()) { PyErr_Clear(); /* only fail if the mx typacaster should have been the default */ #ifdef PSYCOPG_DEFAULT_MXDATETIME PyErr_SetString(PyExc_ImportError, "can't import mx.DateTime module (requested as default adapter)"); goto exit; #endif } #endif /* import python builtin datetime module, if available */ pyDateTimeModuleP = PyImport_ImportModule("datetime"); if (pyDateTimeModuleP == NULL) { Dprintf("initpsycopg: can't import datetime module"); PyErr_SetString(PyExc_ImportError, "can't import datetime module"); goto exit; } /* Initialize the PyDateTimeAPI everywhere is used */ PyDateTime_IMPORT; if (psyco_adapter_datetime_init()) { goto exit; } Py_TYPE(&pydatetimeType) = &PyType_Type; if (PyType_Ready(&pydatetimeType) == -1) goto exit; /* initialize the module and grab module's dictionary */ #if PY_MAJOR_VERSION < 3 module = Py_InitModule("_psycopg", psycopgMethods); #else module = PyModule_Create(&psycopgmodule); #endif if (!module) { goto exit; } dict = PyModule_GetDict(module); /* initialize all the module's exported functions */ /* PyBoxer_API[PyBoxer_Fake_NUM] = (void *)PyBoxer_Fake; */ /* Create a CObject containing the API pointer array's address */ /* If anybody asks for a PyCapsule we'll deal with it. */ #if PY_VERSION_HEX < 0x03020000 c_api_object = PyCObject_FromVoidPtr((void *)PSYCOPG_API, NULL); if (c_api_object != NULL) PyModule_AddObject(module, "_C_API", c_api_object); #endif /* other mixed initializations of module-level variables */ if (!(psycoEncodings = PyDict_New())) { goto exit; } if (0 != psyco_encodings_fill(psycoEncodings)) { goto exit; } psyco_null = Bytes_FromString("NULL"); if (!(psyco_DescriptionType = psyco_make_description_type())) { goto exit; } /* set some module's parameters */ PyModule_AddStringConstant(module, "__version__", PSYCOPG_VERSION); PyModule_AddStringConstant(module, "__doc__", "psycopg PostgreSQL driver"); PyModule_AddIntConstant(module, "__libpq_version__", PG_VERSION_NUM); PyModule_AddObject(module, "apilevel", Text_FromUTF8(APILEVEL)); PyModule_AddObject(module, "threadsafety", PyInt_FromLong(THREADSAFETY)); PyModule_AddObject(module, "paramstyle", Text_FromUTF8(PARAMSTYLE)); /* put new types in module dictionary */ PyModule_AddObject(module, "connection", (PyObject*)&connectionType); PyModule_AddObject(module, "cursor", (PyObject*)&cursorType); PyModule_AddObject(module, "ISQLQuote", (PyObject*)&isqlquoteType); PyModule_AddObject(module, "Notify", (PyObject*)¬ifyType); PyModule_AddObject(module, "Xid", (PyObject*)&xidType); PyModule_AddObject(module, "Diagnostics", (PyObject*)&diagnosticsType); PyModule_AddObject(module, "AsIs", (PyObject*)&asisType); PyModule_AddObject(module, "Binary", (PyObject*)&binaryType); PyModule_AddObject(module, "Boolean", (PyObject*)&pbooleanType); PyModule_AddObject(module, "Decimal", (PyObject*)&pdecimalType); PyModule_AddObject(module, "Int", (PyObject*)&pintType); PyModule_AddObject(module, "Float", (PyObject*)&pfloatType); PyModule_AddObject(module, "List", (PyObject*)&listType); PyModule_AddObject(module, "QuotedString", (PyObject*)&qstringType); PyModule_AddObject(module, "lobject", (PyObject*)&lobjectType); PyModule_AddObject(module, "Column", psyco_DescriptionType); /* encodings dictionary in module dictionary */ PyModule_AddObject(module, "encodings", psycoEncodings); #ifdef HAVE_MXDATETIME /* If we can't find mx.DateTime objects at runtime, * remove them from the module (and, as consequence, from the adapters). */ if (0 != psyco_adapter_mxdatetime_init()) { PyDict_DelItemString(dict, "DateFromMx"); PyDict_DelItemString(dict, "TimeFromMx"); PyDict_DelItemString(dict, "TimestampFromMx"); PyDict_DelItemString(dict, "IntervalFromMx"); } #endif /* initialize default set of typecasters */ if (0 != typecast_init(dict)) { goto exit; } /* initialize microprotocols layer */ microprotocols_init(dict); if (0 != psyco_adapters_init(dict)) { goto exit; } /* create a standard set of exceptions and add them to the module's dict */ if (0 != psyco_errors_init()) { goto exit; } psyco_errors_fill(dict); Dprintf("initpsycopg: module initialization complete"); exit: #if PY_MAJOR_VERSION > 2 return module; #else return; #endif }
static GnmFuncHelp const * python_function_get_gnumeric_help (PyObject *python_fn_info_dict, PyObject *python_fn, const gchar *fn_name) { gchar *help_attr_name; PyObject *cobject_help_value; PyObject *python_arg_names; PyObject *fn_info_obj; fn_info_obj = PyDict_GetItemString (python_fn_info_dict, (gchar *) fn_name); python_arg_names = PyTuple_GetItem (fn_info_obj, 1); help_attr_name = g_strdup_printf ("_CGnumericHelp_%s", fn_name); cobject_help_value = PyDict_GetItemString (python_fn_info_dict, help_attr_name); if (cobject_help_value == NULL) { PyObject *python_fn_help = PyFunction_Check (python_fn) ? ((PyFunctionObject *) python_fn)->func_doc : NULL; if (python_fn_help != NULL && PyString_Check (python_fn_help)) { guint n = 0; GnmFuncHelp *new_help = NULL; gboolean arg_names_written = FALSE; char const *help_text = PyString_AsString (python_fn_help); if (g_str_has_prefix (help_text, "@GNM_FUNC_HELP_NAME@")) { /* New-style documentation */ gchar **items = g_strsplit (help_text, "\n", 0), **fitems = items; while (*items) { if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_NAME@")) { guint it = n; new_help = g_renew (GnmFuncHelp, new_help, ++n); new_help[it].type = GNM_FUNC_HELP_NAME; new_help[it].text = g_strdup ((*items) + strlen ("@GNM_FUNC_HELP_NAME@")); } else if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_ARG@")) { guint it = n; new_help = g_renew (GnmFuncHelp, new_help, ++n); new_help[it].type = GNM_FUNC_HELP_ARG; new_help[it].text = g_strdup ((*items) + strlen ("@GNM_FUNC_HELP_ARG@")); arg_names_written = TRUE; } else if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_DESCRIPTION@")) { guint it = n; new_help = g_renew (GnmFuncHelp, new_help, ++n); new_help[it].type = GNM_FUNC_HELP_DESCRIPTION; new_help[it].text = g_strdup ((*items) + strlen ("@GNM_FUNC_HELP_DESCRIPTION@")); } else if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_EXAMPLES@")) { guint it = n; new_help = g_renew (GnmFuncHelp, new_help, ++n); new_help[it].type = GNM_FUNC_HELP_EXAMPLES; new_help[it].text = g_strdup ((*items) + strlen ("@GNM_FUNC_HELP_EXAMPLES@")); } else if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_SEEALSO@")) { guint it = n; new_help = g_renew (GnmFuncHelp, new_help, ++n); new_help[it].type = GNM_FUNC_HELP_SEEALSO; new_help[it].text = g_strdup ((*items) + strlen ("@GNM_FUNC_HELP_SEEALSO@")); } else if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_EXTREF@")) { guint it = n; new_help = g_renew (GnmFuncHelp, new_help, ++n); new_help[it].type = GNM_FUNC_HELP_EXTREF; new_help[it].text = g_strdup ((*items) + strlen ("@GNM_FUNC_HELP_EXTREF@")); } else if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_NOTE@")) { guint it = n; new_help = g_renew (GnmFuncHelp, new_help, ++n); new_help[it].type = GNM_FUNC_HELP_NOTE; new_help[it].text = g_strdup ((*items) + strlen ("@GNM_FUNC_HELP_NOTE@")); } else if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_END@")) { /* ignore */ } else if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_EXCEL@")) { guint it = n; new_help = g_renew (GnmFuncHelp, new_help, ++n); new_help[it].type = GNM_FUNC_HELP_EXCEL; new_help[it].text = g_strdup ((*items) + strlen ("@GNM_FUNC_HELP_EXCEL@")); } else if (g_str_has_prefix (*items, "@GNM_FUNC_HELP_ODF@")) { guint it = n; new_help = g_renew (GnmFuncHelp, new_help, ++n); new_help[it].type = GNM_FUNC_HELP_ODF; new_help[it].text = g_strdup ((*items) + strlen ("@GNM_FUNC_HELP_ODF@")); } else if (n > 0) { gchar *old_text = (gchar *) new_help[n].text; new_help[n].text = g_strconcat (old_text, "\n", *items, NULL); g_free (old_text); } items++; } g_strfreev (fitems); } if (python_arg_names != NULL && !arg_names_written) { /* We only try this if we did not get argument */ /* descriptions via the new style documentation */ char const *arg_names = PyString_AsString (python_arg_names); if (arg_names != NULL && arg_names[0] != '\0') { gchar **args = g_strsplit (arg_names, ",", 0); guint nitems = g_strv_length (args), nstart = n, i; n += nitems; new_help = g_renew (GnmFuncHelp, new_help, n); for (i = 0; i < nitems; i++, nstart++) { char const *arg_name = args[i]; while (*arg_name == ' ') arg_name++; new_help[nstart].type = GNM_FUNC_HELP_ARG; new_help[nstart].text = g_strdup_printf ("%s:", arg_name); } g_strfreev (args); } } n++; new_help = g_renew (GnmFuncHelp, new_help, n); new_help[n-1].type = GNM_FUNC_HELP_END; new_help[n-1].text = NULL; cobject_help_value = PyCObject_FromVoidPtr (new_help, &g_free); PyDict_SetItemString (python_fn_info_dict, help_attr_name, cobject_help_value); } } g_free (help_attr_name); if (cobject_help_value == NULL) return NULL; return (GnmFuncHelp const *) PyCObject_AsVoidPtr (cobject_help_value); }
PyMODINIT_FUNC initgreenlet(void) #endif { PyObject* m = NULL; char** p = NULL; PyObject *c_api_object; static void *_PyGreenlet_API[PyGreenlet_API_pointers]; GREENLET_NOINLINE_INIT(); #if PY_MAJOR_VERSION >= 3 m = PyModule_Create(&greenlet_module_def); #else m = Py_InitModule("greenlet", GreenMethods); #endif if (m == NULL) { INITERROR; } if (PyModule_AddStringConstant(m, "__version__", GREENLET_VERSION) < 0) { INITERROR; } #if PY_MAJOR_VERSION >= 3 ts_curkey = PyUnicode_InternFromString("__greenlet_ts_curkey"); ts_delkey = PyUnicode_InternFromString("__greenlet_ts_delkey"); #else ts_curkey = PyString_InternFromString("__greenlet_ts_curkey"); ts_delkey = PyString_InternFromString("__greenlet_ts_delkey"); #endif if (ts_curkey == NULL || ts_delkey == NULL) { INITERROR; } if (PyType_Ready(&PyGreenlet_Type) < 0) { INITERROR; } PyExc_GreenletError = PyErr_NewException("greenlet.error", NULL, NULL); if (PyExc_GreenletError == NULL) { INITERROR; } #if PY_MAJOR_VERSION >= 3 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 5) PyExc_GreenletExit = PyErr_NewException("greenlet.GreenletExit", PyExc_BaseException, NULL); #else PyExc_GreenletExit = PyErr_NewException("greenlet.GreenletExit", NULL, NULL); #endif if (PyExc_GreenletExit == NULL) { INITERROR; } ts_current = green_create_main(); if (ts_current == NULL) { INITERROR; } Py_INCREF(&PyGreenlet_Type); PyModule_AddObject(m, "greenlet", (PyObject*) &PyGreenlet_Type); Py_INCREF(PyExc_GreenletError); PyModule_AddObject(m, "error", PyExc_GreenletError); Py_INCREF(PyExc_GreenletExit); PyModule_AddObject(m, "GreenletExit", PyExc_GreenletExit); #ifdef GREENLET_USE_GC PyModule_AddObject(m, "GREENLET_USE_GC", PyBool_FromLong(1)); #else PyModule_AddObject(m, "GREENLET_USE_GC", PyBool_FromLong(0)); #endif /* also publish module-level data as attributes of the greentype. */ for (p=copy_on_greentype; *p; p++) { PyObject* o = PyObject_GetAttrString(m, *p); if (!o) continue; PyDict_SetItemString(PyGreenlet_Type.tp_dict, *p, o); Py_DECREF(o); } /* * Expose C API */ /* types */ _PyGreenlet_API[PyGreenlet_Type_NUM] = (void *) &PyGreenlet_Type; /* exceptions */ _PyGreenlet_API[PyExc_GreenletError_NUM] = (void *) PyExc_GreenletError; _PyGreenlet_API[PyExc_GreenletExit_NUM] = (void *) PyExc_GreenletExit; /* methods */ _PyGreenlet_API[PyGreenlet_New_NUM] = (void *) PyGreenlet_New; _PyGreenlet_API[PyGreenlet_GetCurrent_NUM] = (void *) PyGreenlet_GetCurrent; _PyGreenlet_API[PyGreenlet_Throw_NUM] = (void *) PyGreenlet_Throw; _PyGreenlet_API[PyGreenlet_Switch_NUM] = (void *) PyGreenlet_Switch; _PyGreenlet_API[PyGreenlet_SetParent_NUM] = (void *) PyGreenlet_SetParent; #ifdef GREENLET_USE_PYCAPSULE c_api_object = PyCapsule_New((void *) _PyGreenlet_API, "greenlet._C_API", NULL); #else c_api_object = PyCObject_FromVoidPtr((void *) _PyGreenlet_API, NULL); #endif if (c_api_object != NULL) { PyModule_AddObject(m, "_C_API", c_api_object); } #if PY_MAJOR_VERSION >= 3 return m; #endif }
void IvrPython::run(){ FILE* fp; int retval; #ifndef IVR_PERL pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0); #endif //IVR_PERL // static PyThreadState* pyMainThreadState; fp = fopen((char*)fileName,"r"); if(fp != NULL){ #ifndef IVR_PERL PyMethodDef extIvrPython[] = { // media functions {"enqueueMediaFile", ivrEnqueueMediaFile, METH_VARARGS, "ivr: enqueue media file. " "filename: string, front : int = 1(default true) "}, {"emptyMediaQueue", ivrEmptyMediaQueue, METH_VARARGS, "ivr: empty the media queue."}, {"startRecording", ivrStartRecording, METH_VARARGS, "ivr: start recording to file. filename : string."}, {"stopRecording", ivrStopRecording, METH_VARARGS, "ivr: stop recording to file."}, #ifdef IVR_WITH_TTS {"say", ivrSay, METH_VARARGS, "ivr tts and enqueue. msg: string, front: boolean "}, #endif //IVR_WITH_TTS // DTMF functions {"enableDTMFDetection", ivrEnableDTMFDetection, METH_VARARGS, "enable DTMF detection. " "setCallback(onDTMF_FUNC, \"onDTMF\") first!"}, {"disableDTMFDetection", ivrDisableDTMFDetection, METH_VARARGS, "disable DTMF detection permanently"}, {"pauseDTMFDetection", ivrPauseDTMFDetection, METH_VARARGS, "pause DTMF detection temporarily, can be resumed"}, {"resumeDTMFDetection", ivrResumeDTMFDetection, METH_VARARGS, "resume DTMF detection"}, // informational {"getTime", ivrGetTime, METH_VARARGS, "Example Module"}, {"getFrom", ivrGetFrom, METH_VARARGS, "Example Module"}, {"getTo", ivrGetTo, METH_VARARGS, "Example Module"}, {"getFromURI", ivrGetFromURI, METH_VARARGS, "Example Module"}, {"getToURI", ivrGetToURI, METH_VARARGS, "Example Module"}, {"getDomain", ivrGetDomain, METH_VARARGS, "Example Module"}, // call transfer functions {"redirect", ivrRedirect, METH_VARARGS, "Example Module"}, {"dialout", ivrDialout, METH_VARARGS, "Example Module"}, // setting callbacks {"setCallback", setCallback, METH_VARARGS, "Example Module"}, {"sleep", ivrSleep, METH_VARARGS, "Sleep n seconds, or until wakeUp"}, {"usleep", ivrUSleep, METH_VARARGS, "Sleep n microseconds, or until wakeUp"}, {"msleep", ivrmSleep, METH_VARARGS, "Sleep n milliseconds, or until wakeUp"}, {"wakeUp", ivrWakeUp, METH_VARARGS, "wake Up from sleep"}, // legacy from old ivr: sequential functions {"play", ivrPlay, METH_VARARGS, "play and wait for the end of the file (queue empty)"}, {"record", ivrRecord, METH_VARARGS, "record maximum of time secs. Parameter: filename : string, timeout = 0 : int"}, {"playAndDetect", ivrPlayAndDetect, METH_VARARGS, "play and wait for the end of the file (queue empty) or keypress"}, {"detect", ivrDetect, METH_VARARGS, "detect until timeout Parameter: timeout = 0 : int"}, // for jitter/clock skew generation test only // DONT CALL THIS FUNCTION {"mediaThreadUSleep", ivrMediaThreadUSleep, METH_VARARGS, "let mthr sleep, dont call this function"}, {NULL, NULL, 0, NULL}, }; if(!Py_IsInitialized()){ DBG("Start" SCRIPT_TYPE "\n"); Py_Initialize(); PyEval_InitThreads(); pyMainThreadState = PyEval_SaveThread(); } DBG("Start new" SCRIPT_TYPE "interpreter\n"); PyEval_AcquireLock(); // PyThreadState* pyThreadState; if ( (mainInterpreterThreadState = Py_NewInterpreter()) != NULL){ PyObject* ivrPyInitModule = Py_InitModule(PY_MOD_NAME, extIvrPython); PyObject* ivrPythonPointer = PyCObject_FromVoidPtr((void*)this,NULL); if (ivrPythonPointer != NULL) PyModule_AddObject(ivrPyInitModule, "ivrPythonPointer", ivrPythonPointer); Py_tracefunc tmp_t = pythonTrace; PyEval_SetTrace(tmp_t, PyCObject_FromVoidPtr((void*)this,NULL)); if(!PyRun_SimpleFile(fp,(char*)fileName)){ fclose(fp); retval = 0;// true; } else{ PyErr_Print(); ERROR("IVR" SCRIPT_TYPE "Error: Failed to run \"%s\"\n", (char*)fileName); retval = -1;// false; } Py_EndInterpreter(mainInterpreterThreadState); } else{ ERROR("IVR" SCRIPT_TYPE "Error: Failed to start new interpreter.\n"); } PyEval_ReleaseLock(); #else //IVR_PERL DBG("Start" SCRIPT_TYPE ", about to alloc\n"); my_perl_interp = perl_alloc(); printf("interp is %ld\n", (long) my_perl_interp); printf("filename is %s\n", fileName); DBG("finished alloc Perl, about to construct Perl\n"); perl_construct(my_perl_interp); PL_exit_flags |= PERL_EXIT_DESTRUCT_END; char *embedding[] = { "", (char*)fileName}; DBG("finished construct Perl, about to parse Perl\n"); perl_parse(my_perl_interp, xs_init, 2, embedding, (char **)NULL); DBG("finished parse Perl, about to run Perl\n"); SV *pivr = get_sv("Ivr::__ivrpointer__", TRUE); DBG("Ivr::__ivrpointer__ is %lx.\n", (unsigned long int) pivr); sv_setuv(pivr, (unsigned int) this); perl_run(my_perl_interp); DBG("finished run Perl, about to sleep 5 seconds to let callback event catch up\n"); sleep(5); DBG("after sleep, about to destruct\n"); perl_destruct(my_perl_interp); DBG("finished destruct Perl, about to free\n"); perl_free(my_perl_interp); #endif //IVR_PERL } else{ ERROR("IVR" SCRIPT_TYPE "Error: Can not open file \"%s\"\n",(char*) fileName); retval = -1;// false; } DBG("IVR: run finished. stopping rtp stream...\n"); pAmSession->rtp_str.pause(); }