PyMODINIT_FUNC
PyInit__gdbm(void) {
PyObject *m, *d, *s;
if (PyType_Ready(&Dbmtype) < 0)
return NULL;
m = PyModule_Create(&_gdbmmodule);
if (m == NULL)
return NULL;
d = PyModule_GetDict(m);
DbmError = PyErr_NewException("_gdbm.error", PyExc_IOError, NULL);
if (DbmError != NULL) {
PyDict_SetItemString(d, "error", DbmError);
s = PyUnicode_FromString(dbmmodule_open_flags);
PyDict_SetItemString(d, "open_flags", s);
Py_DECREF(s);
}
return m;
}
PyMODINIT_FUNC
initumemcache(void)
{
PyObject* m;
m = Py_InitModule3("umemcache", methods, "");
if (m == NULL)
return;
ClientType.tp_new = PyType_GenericNew;
if (PyType_Ready(&ClientType) < 0)
return;
Py_INCREF(&ClientType);
PyModule_AddObject(m, "Client", (PyObject *)&ClientType);
umemcache_MemcachedError = PyErr_NewException("umemcache.MemcachedError",
PyExc_RuntimeError, NULL);
PyModule_AddObject(m, "MemcachedError", (PyObject *)umemcache_MemcachedError);
}
PyMODINIT_FUNC
initVmMngr(void)
{
PyObject *m;
if (PyType_Ready(&VmMngrType) < 0)
return;
m = Py_InitModule("VmMngr", VmMngr_Methods);
if (m == NULL)
return;
Vm_Mngr_Error = PyErr_NewException("VmMngr.error", NULL, NULL);
Py_INCREF(Vm_Mngr_Error);
PyModule_AddObject(m, "error", Vm_Mngr_Error);
Py_INCREF(&VmMngrType);
PyModule_AddObject(m, "Vm", (PyObject *)&VmMngrType);
}
PyObject *PyInit__minpack(void)
{
PyObject *m, *d, *s;
m = PyModule_Create(&moduledef);
import_array();
d = PyModule_GetDict(m);
s = PyUnicode_FromString(" 1.10 ");
PyDict_SetItemString(d, "__version__", s);
Py_DECREF(s);
minpack_error = PyErr_NewException ("minpack.error", NULL, NULL);
PyDict_SetItemString(d, "error", minpack_error);
if (PyErr_Occurred())
Py_FatalError("can't initialize module minpack");
return m;
}
PyMODINIT_FUNC
initpyhook(void) {
PyObject *m;
pyhook_StreetAddressLookupType.tp_members = StreetAddressLookup_members;
if (PyType_Ready(&pyhook_StreetAddressLookupType) < 0)
return;
m = Py_InitModule("pyhook", PyhookMethods);
if (m == NULL)
return;
PyhookError = PyErr_NewException("pyhook.error", NULL, NULL);
Py_INCREF(PyhookError);
PyModule_AddObject(m, "error", PyhookError);
Py_INCREF(&pyhook_StreetAddressLookupType);
PyModule_AddObject(m, "StreetAddressLookup", StreetAddressLookup_new(&pyhook_StreetAddressLookupType, NULL, NULL));
}
PyMODINIT_FUNC
initrtaudio(void)
{
PyEval_InitThreads();
if (PyType_Ready(&RtAudio_type) < 0)
return;
PyObject* module = Py_InitModule3("rtaudio", NULL, "RtAudio wrapper.");
if (module == NULL)
return;
Py_INCREF(&RtAudio_type);
PyModule_AddObject(module, "RtAudio", (PyObject *)&RtAudio_type);
RtAudioError = PyErr_NewException("rtaudio.RtError", NULL, NULL);
Py_INCREF(RtAudioError);
PyModule_AddObject(module, "RtError", RtAudioError);
}
/* Initialization function for the module */
void initrrdtool(
void)
{
PyObject *m, *d, *t;
/* Create the module and add the functions */
m = Py_InitModule("rrdtool", _rrdtool_methods);
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
SET_STRCONSTANT(d, __version__);
ErrorObject = PyErr_NewException("rrdtool.error", NULL, NULL);
PyDict_SetItemString(d, "error", ErrorObject);
/* Check for errors */
if (PyErr_Occurred())
Py_FatalError("can't initialize the rrdtool module");
}
PyMODINIT_FUNC
initlibmtp(void) {
PyObject *m;
DeviceType.tp_new = PyType_GenericNew;
if (PyType_Ready(&DeviceType) < 0)
return;
m = Py_InitModule3("libmtp", libmtp_methods, "Interface to libmtp.");
if (m == NULL) return;
MTPError = PyErr_NewException("libmtp.MTPError", NULL, NULL);
if (MTPError == NULL) return;
PyModule_AddObject(m, "MTPError", MTPError);
// Redirect stdout to get rid of the annoying message about mtpz. Really,
// who designs a library without anyway to control/redirect the debugging
// output, and hardcoded paths that cannot be changed? Compiling libmtp without the crypt use flag disables mtpz support in libmtp
/* int bak, new; */
/* fprintf(stdout, "\n"); // This is needed, without it, for some odd reason the code below causes stdout to buffer all output after it is restored, rather than using line buffering, and setlinebuf does not work. */
/* fflush(stdout); */
/* bak = dup(STDOUT_FILENO); */
/* new = open("/dev/null", O_WRONLY); */
/* dup2(new, STDOUT_FILENO); */
/* close(new); */
LIBMTP_Init();
/* fflush(stdout); */
/* dup2(bak, STDOUT_FILENO); */
/* close(bak); */
LIBMTP_Set_Debug(LIBMTP_DEBUG_NONE);
Py_INCREF(&DeviceType);
PyModule_AddObject(m, "Device", (PyObject *)&DeviceType);
PyModule_AddStringMacro(m, LIBMTP_VERSION_STRING);
PyModule_AddIntMacro(m, LIBMTP_DEBUG_NONE);
PyModule_AddIntMacro(m, LIBMTP_DEBUG_PTP);
PyModule_AddIntMacro(m, LIBMTP_DEBUG_PLST);
PyModule_AddIntMacro(m, LIBMTP_DEBUG_USB);
PyModule_AddIntMacro(m, LIBMTP_DEBUG_DATA);
PyModule_AddIntMacro(m, LIBMTP_DEBUG_ALL);
}
PyMODINIT_FUNC
init_sophia(void)
#endif
{
static char *sophia_constant_names[] = {"SPGT", "SPGTE", "SPLT", "SPLTE",
"SPCMP", "SPPAGE", "SPMERGEWM", "SPGC", "SPMERGE", "SPGCF", "SPGROW", NULL};
static int sophia_constant_values[] = {SPGT, SPGTE, SPLT, SPLTE,
SPCMP, SPPAGE, SPMERGEWM, SPGC, SPMERGE, SPGCF, SPGROW, 0};
if (PyType_Ready(&SophiaDBType) == -1)
return PSP_NOTHING;
SophiaError = PyErr_NewException("sophia.Error", NULL, NULL);
if (!SophiaError)
return PSP_NOTHING;
#if PY_MAJOR_VERSION >= 3
PyObject *module = PyModule_Create(&_sophiamodule);
#else
PyObject *module = Py_InitModule("_sophia", NULL);
#endif
if (!module)
return PSP_NOTHING;
char **names = sophia_constant_names;
int *values = sophia_constant_values;
while (*names) {
if (PyModule_AddIntConstant(module, *names++, *values++) == -1)
return PSP_NOTHING;
}
Py_INCREF(&SophiaDBType);
Py_INCREF(SophiaError);
if (PyModule_AddObject(module, "Database", (PyObject *)&SophiaDBType) == -1 ||
PyModule_AddObject(module, "Error", SophiaError) == -1)
return PSP_NOTHING;
#if PY_MAJOR_VERSION >= 3
return module;
#endif
}
static int
psyco_errors_init(void)
{
/* the names of the exceptions here reflect the organization of the
psycopg2 module and not the fact the the original error objects
live in _psycopg */
int i;
PyObject *dict = NULL;
PyObject *str = NULL;
int rv = -1;
/* 'Error' has been defined elsewhere: only init the other classes */
Error = (PyObject *)&errorType;
for (i = 1; exctable[i].name; i++) {
if (!(dict = PyDict_New())) { goto exit; }
if (exctable[i].docstr) {
if (!(str = Text_FromUTF8(exctable[i].docstr))) { goto exit; }
if (0 != PyDict_SetItemString(dict, "__doc__", str)) { goto exit; }
Py_CLEAR(str);
}
/* can't put PyExc_StandardError in the static exctable:
* windows build will fail */
if (!(*exctable[i].exc = PyErr_NewException(
exctable[i].name,
exctable[i].base ? *exctable[i].base : PyExc_StandardError,
dict))) {
goto exit;
}
Py_CLEAR(dict);
}
rv = 0;
exit:
Py_XDECREF(str);
Py_XDECREF(dict);
return rv;
}
initsound(void)
{
Py_Initialize();
PyObject *m= Py_InitModule(MODULE_NAME, pysound_methods);
// Initialize tables
PyModule_AddStringConstant(m, "__doc__", PYMODULEDOC );
PyModule_AddStringConstant(m, "version", PYSNDVERSION );
PyModule_AddIntConstant(m, "build", PYSNDBUILD );
_EXPORT_INT(m, AFMT_MU_LAW);
_EXPORT_INT(m, AFMT_A_LAW);
_EXPORT_INT(m, AFMT_IMA_ADPCM);
_EXPORT_INT(m, AFMT_U8);
_EXPORT_INT(m, AFMT_S16_LE);
_EXPORT_INT(m, AFMT_S16_BE);
_EXPORT_INT(m, AFMT_S8);
_EXPORT_INT(m, AFMT_U16_LE);
_EXPORT_INT(m, AFMT_U16_BE);
_EXPORT_INT(m, AFMT_MPEG);
_EXPORT_INT(m, AFMT_AC3);
_EXPORT_INT(m, AFMT_S16_NE);
g_cErr = PyErr_NewException(MODULE_NAME".SoundError", NULL, NULL);
if( g_cErr != NULL)
PyModule_AddObject(m, "SoundError", g_cErr );
PyISoundType.ob_type = &PyType_Type;
Py_INCREF((PyObject *)&PyISoundType);
PyModule_AddObject(m, INPUT_NAME, (PyObject *)&PyISoundType);
PySoundType.ob_type = &PyType_Type;
Py_INCREF((PyObject *)&PySoundType);
PyModule_AddObject(m, OUTPUT_NAME, (PyObject *)&PySoundType);
ResamplerType.ob_type = &PyType_Type;
Py_INCREF((PyObject *)&ResamplerType);
PyModule_AddObject(m, RESAMPLER_NAME, (PyObject *)&ResamplerType);
AnalyzerType.ob_type = &PyType_Type;
Py_INCREF((PyObject *)&AnalyzerType);
PyModule_AddObject(m, ANALYZER_NAME, (PyObject *)&AnalyzerType);
MixerType.ob_type = &PyType_Type;
Py_INCREF((PyObject *)&MixerType);
PyModule_AddObject(m, MIXER_NAME, (PyObject *)&MixerType);
}
PyMODINIT_FUNC
PyInit_zlib(void)
{
PyObject *m, *ver;
Comptype.ob_type = &PyType_Type;
Decomptype.ob_type = &PyType_Type;
m = Py_InitModule4("zlib", zlib_methods,
zlib_module_documentation,
(PyObject*)NULL,PYTHON_API_VERSION);
if (m == NULL)
return;
ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
if (ZlibError != NULL) {
Py_INCREF(ZlibError);
PyModule_AddObject(m, "error", ZlibError);
}
PyModule_AddIntConstant(m, "MAX_WBITS", MAX_WBITS);
PyModule_AddIntConstant(m, "DEFLATED", DEFLATED);
PyModule_AddIntConstant(m, "DEF_MEM_LEVEL", DEF_MEM_LEVEL);
PyModule_AddIntConstant(m, "Z_BEST_SPEED", Z_BEST_SPEED);
PyModule_AddIntConstant(m, "Z_BEST_COMPRESSION", Z_BEST_COMPRESSION);
PyModule_AddIntConstant(m, "Z_DEFAULT_COMPRESSION", Z_DEFAULT_COMPRESSION);
PyModule_AddIntConstant(m, "Z_FILTERED", Z_FILTERED);
PyModule_AddIntConstant(m, "Z_HUFFMAN_ONLY", Z_HUFFMAN_ONLY);
PyModule_AddIntConstant(m, "Z_DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY);
PyModule_AddIntConstant(m, "Z_FINISH", Z_FINISH);
PyModule_AddIntConstant(m, "Z_NO_FLUSH", Z_NO_FLUSH);
PyModule_AddIntConstant(m, "Z_SYNC_FLUSH", Z_SYNC_FLUSH);
PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH);
ver = PyString_FromString(ZLIB_VERSION);
if (ver != NULL)
PyModule_AddObject(m, "ZLIB_VERSION", ver);
PyModule_AddStringConstant(m, "__version__", "1.0");
#ifdef WITH_THREAD
zlib_lock = PyThread_allocate_lock();
#endif /* WITH_THREAD */
}
PyMODINIT_FUNC PyInit_cstuff(void) {
PyObject *module;
module = PyModule_Create(&cstuff_module);
if (module == NULL) {
return NULL;
}
if (PyType_Ready(&cstuff_DirectionMapType) < 0) {
return NULL;
}
CStuffError = PyErr_NewException("cstuff.CStuffError", NULL, NULL);
Py_INCREF(CStuffError);
PyModule_AddObject(module, "CStuffError", CStuffError);
Py_INCREF(&cstuff_DirectionMapType);
PyModule_AddObject(module, "DirectionMap", (PyObject *)&cstuff_DirectionMapType);
return module;
}
PyMODINIT_FUNC
PyInit__simpleaudio(void)
{
PyObject *m;
m = PyModule_Create(&_simpleaudio_module);
if (m == NULL)
return NULL;
sa_python_error = PyErr_NewException("_simpleaudio.SimpleaudioError", NULL, NULL);
Py_INCREF(sa_python_error);
PyModule_AddObject(m, "SimpleaudioError", sa_python_error);
/* initialize the list head mutex */
play_list_head.mutex = create_mutex();
dbg1("init'd list head at %p\n", &play_list_head);
return m;
}
initcd(void)
{
Py_Initialize();
g_iMaxCDROMIndex= -1;
PyObject *m = Py_InitModule("cd", pycd_methods);
PyModule_AddStringConstant( m, "__doc__", (char*)PYDOC );
PyModule_AddStringConstant( m, "version", (char*)PYCDVERSION );
PyModule_AddIntConstant( m, "build", PYCDBUILD );
INT_CONSTANT( SEEK_SET );
INT_CONSTANT( SEEK_END );
INT_CONSTANT( SEEK_CUR );
g_cErr = PyErr_NewException(MODULE_NAME".CDError", NULL, NULL);
if( g_cErr != NULL)
PyModule_AddObject(m, "CDError", g_cErr );
PyCDType.ob_type = &PyType_Type;
Py_INCREF((PyObject *)&PyCDType);
PyModule_AddObject(m, "CD", (PyObject *)&PyCDType);
}
CALIBRE_MODINIT_FUNC
inithunspell(void) {
PyObject *mod;
// Create the module
mod = Py_InitModule3("hunspell", NULL,
"A wrapper for the hunspell spell checking library");
if (mod == NULL) return;
HunspellError = PyErr_NewException((char*)"hunspell.HunspellError", NULL, NULL);
if (HunspellError == NULL) return;
PyModule_AddObject(mod, "HunspellError", HunspellError);
// Fill in some slots in the type, and make it ready
DictionaryType.tp_new = PyType_GenericNew;
if (PyType_Ready(&DictionaryType) < 0) return;
// Add the type to the module.
Py_INCREF(&DictionaryType);
PyModule_AddObject(mod, "Dictionary", (PyObject *)&DictionaryType);
}
PyMODINIT_FUNC initketama(void) {
PyObject *m;
if (PyType_Ready(&pyketama_ContinuumType) < 0) {
return;
}
if (!(m = Py_InitModule3("ketama", ketamaMethods,
"Python extension for calling libketama functions."))) {
return;
}
pyketama_error = PyErr_NewException("ketama.KetamaError", NULL, NULL);
Py_INCREF(pyketama_error);
PyModule_AddObject(m, "KetamaError", pyketama_error);
Py_INCREF(&pyketama_ContinuumType);
PyModule_AddObject(m, "Continuum", (PyObject *)&pyketama_ContinuumType);
}
PyMODINIT_FUNC initscheme(void){
PyObject *m;
m = Py_InitModule("scheme", SchemeMethods);
if (m == NULL)
return;
SchemeError = PyErr_NewException("scheme.error", NULL, NULL);
Py_INCREF(SchemeError);
PyModule_AddObject(m, "error", SchemeError);
VM_Type.tp_new = PyType_GenericNew;
if (PyType_Ready(VM_Type) < 0)
return;
Py_INCREF(&VM_Type);
PyModule_AddObject(m, "VM", (PyObject *)&VM_Type);
}
PyMODINIT_FUNC
initJitCore_x86(void)
{
PyObject *m;
if (PyType_Ready(&JitCpuType) < 0)
return;
m = Py_InitModule("JitCore_x86", JitCore_x86_Methods);
if (m == NULL)
return;
JitCore_x86_Error = PyErr_NewException("JitCore_x86.error", NULL, NULL);
Py_INCREF(JitCore_x86_Error);
PyModule_AddObject(m, "error", JitCore_x86_Error);
Py_INCREF(&JitCpuType);
PyModule_AddObject(m, "JitCpu", (PyObject *)&JitCpuType);
}
PyMODINIT_FUNC initfftpack_lite(void)
{
PyObject *m, *d;
/* Create the module and add the functions */
m = Py_InitModule4("fftpack_lite", fftpack_methods,
fftpack_module_documentation,
(PyObject*)NULL,PYTHON_API_VERSION);
/* Import the array object */
import_array();
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
ErrorObject = PyErr_NewException("fftpack.error", NULL, NULL);
PyDict_SetItemString(d, "error", ErrorObject);
/* XXXX Add constants here */
}
void
init_cpg(void)
{
int i;
PyObject *Pmodule, *Pdict;
Pmodule = Py_InitModule("_cpg", py_cpg_methods);
Pdict = PyModule_GetDict(Pmodule);
py_cpg_init_callbacks();
py_cpg_error = PyErr_NewException("corosync._cpg.Error", NULL, NULL);
PyDict_SetItemString(Pdict, "Error", py_cpg_error);
for (i=0; py_cpg_constants[i].name != NULL; i++)
{
PyDict_SetItemString(Pdict, py_cpg_constants[i].name,
PyInt_FromLong(py_cpg_constants[i].value));
}
}
PyMODINIT_FUNC
initstruct(void)
{
PyObject *m;
/* Create the module and add the functions */
m = Py_InitModule4("struct", struct_methods, struct__doc__,
(PyObject*)NULL, PYTHON_API_VERSION);
if (m == NULL)
return;
/* Add some symbolic constants to the module */
if (StructError == NULL) {
StructError = PyErr_NewException("struct.error", NULL, NULL);
if (StructError == NULL)
return;
}
Py_INCREF(StructError);
PyModule_AddObject(m, "error", StructError);
}
PyMODINIT_FUNC
PyInit_termios(void)
{
PyObject *m;
struct constant *constant = termios_constants;
m = Py_InitModule4("termios", termios_methods, termios__doc__,
(PyObject *)NULL, PYTHON_API_VERSION);
if (TermiosError == NULL) {
TermiosError = PyErr_NewException("termios.error", NULL, NULL);
}
Py_INCREF(TermiosError);
PyModule_AddObject(m, "error", TermiosError);
while (constant->name != NULL) {
PyModule_AddIntConstant(m, constant->name, constant->value);
++constant;
}
}
initcdb() {
PyObject *m, *d, *v;
CdbType.ob_type = &PyType_Type;
CdbMakeType.ob_type = &PyType_Type;
m = Py_InitModule3("cdb", module_functions, module_doc);
d = PyModule_GetDict(m);
CDBError = PyErr_NewException("cdb.error", NULL, NULL);
PyDict_SetItemString(d, "error", CDBError);
PyDict_SetItemString(d, "__version__",
v = PyString_FromString(VERSION));
PyDict_SetItemString(d, "__cdb_version__",
v = PyString_FromString(CDBVERSION));
Py_XDECREF(v);
}
PyMODINIT_FUNC inithdhomerun(void) {
PyObject *m;
m = Py_InitModule3("hdhomerun", hdhomerun_methods, hdhomerun_module_doc);
if(!m)
return;
/* Finalize the Device type object */
if (PyType_Ready(&hdhomerun_Device_type) < 0)
return;
Py_INCREF(&hdhomerun_Device_type);
if(PyModule_AddObject(m, "Device", (PyObject *)&hdhomerun_Device_type) < 0)
return;
/* Initialize the DeviceError exception class */
hdhomerun_device_error = PyErr_NewException("hdhomerun.DeviceError", PyExc_Exception, NULL);
Py_INCREF(hdhomerun_device_error);
if(PyModule_AddObject(m, "DeviceError", hdhomerun_device_error) < 0)
return;
}
init_yappi(void)
#endif
{
PyObject *m, *d;
#ifdef IS_PY3K
m = PyModule_Create(&_yappi_module);
if (m == NULL)
return NULL;
#else
m = Py_InitModule("_yappi", yappi_methods);
if (m == NULL)
return;
#endif
d = PyModule_GetDict(m);
YappiProfileError = PyErr_NewException("_yappi.error", NULL, NULL);
PyDict_SetItemString(d, "error", YappiProfileError);
// init the profiler memory and internal constants
yappinitialized = 0;
yapphavestats = 0;
yapprunning = 0;
paused = 0;
flags.builtins = 0;
flags.multithreaded = 0;
test_timings = NULL;
if (!_init_profiler()) {
PyErr_SetString(YappiProfileError, "profiler cannot be initialized.");
#ifdef IS_PY3K
return NULL;
#else
return;
#endif
}
#ifdef IS_PY3K
return m;
#endif
}
void initlinux_sgio(void)
#endif
/* ------------------------------------------------------------------------ **
* Module initialization.
* ------------------------------------------------------------------------ **
*/
{
#if PY_MAJOR_VERSION >= 3
PyObject *module = PyModule_Create(&moduledef);
#else
PyObject *module = Py_InitModule("linux_sgio", SGIOMethods);
#endif
if( module == NULL)
INITERROR;
SGIOError = PyErr_NewException( "linux_sgio.SGIOError", NULL, NULL );
Py_INCREF(SGIOError);
if ( PyModule_AddObject(module, "SGIOError", SGIOError) == -1 )
INITERROR;
/* Define some of the SGIO constants for use in the Python code. */
if ( PyModule_AddIntConstant(module, "DXFER_NONE", SG_DXFER_NONE) < 0 )
INITERROR;
if ( PyModule_AddIntConstant(module, "DXFER_TO_DEV", SG_DXFER_TO_DEV) < 0 )
INITERROR;
if ( PyModule_AddIntConstant(module, "DXFER_FROM_DEV", SG_DXFER_FROM_DEV) < 0 )
INITERROR;
if ( PyModule_AddIntConstant(module, "DXFER_TO_FROM_DEV", SG_DXFER_TO_FROM_DEV) < 0 )
INITERROR;
if (SGIOError == NULL)
{
Py_DECREF(module);
INITERROR;
}
#if PY_MAJOR_VERSION >= 3
return module;
#endif
} /* initsgio */
PyMODINIT_FUNC
initxx(void)
{
PyObject *m;
/* Due to cross platform compiler issues the slots must be filled
* here. It's required for portability to Windows without requiring
* C++. */
Null_Type.tp_base = &PyBaseObject_Type;
Null_Type.tp_new = PyType_GenericNew;
Str_Type.tp_base = &PyUnicode_Type;
/* Finalize the type object including setting type of the new type
* object; doing it here is required for portability, too. */
if (PyType_Ready(&Xxo_Type) < 0)
return;
/* Create the module and add the functions */
m = Py_InitModule3("xx", xx_methods, module_doc);
if (m == NULL)
return;
/* Add some symbolic constants to the module */
if (ErrorObject == NULL) {
ErrorObject = PyErr_NewException("xx.error", NULL, NULL);
if (ErrorObject == NULL)
return;
}
Py_INCREF(ErrorObject);
PyModule_AddObject(m, "error", ErrorObject);
/* Add Str */
if (PyType_Ready(&Str_Type) < 0)
return;
PyModule_AddObject(m, "Str", (PyObject *)&Str_Type);
/* Add Null */
if (PyType_Ready(&Null_Type) < 0)
return;
PyModule_AddObject(m, "Null", (PyObject *)&Null_Type);
}
/* Module */
PyObject *
init_fibers(void)
{
PyObject *fibers;
/* Main module */
#if PY_MAJOR_VERSION >= 3
fibers = PyModule_Create(&fibers_module);
#else
fibers = Py_InitModule("fibers", fibers_methods);
#endif
/* keys for per-thread dictionary */
#if PY_MAJOR_VERSION >= 3
current_fiber_key = PyUnicode_InternFromString("__fibers_current");
#else
current_fiber_key = PyString_InternFromString("__fibers_current");
#endif
if (current_fiber_key == NULL) {
goto fail;
}
/* Exceptions */
PyExc_FiberError = PyErr_NewException("fibers.error", NULL, NULL);
MyPyModule_AddType(fibers, "error", (PyTypeObject *)PyExc_FiberError);
/* Types */
MyPyModule_AddType(fibers, "Fiber", &FiberType);
/* Module version (the MODULE_VERSION macro is defined by setup.py) */
PyModule_AddStringConstant(fibers, "__version__", STRINGIFY(MODULE_VERSION));
return fibers;
fail:
#if PY_MAJOR_VERSION >= 3
Py_DECREF(fibers);
#endif
return NULL;
}
static void
psyco_errors_init(void)
{
/* the names of the exceptions here reflect the oranization of the
psycopg2 module and not the fact the the original error objects
live in _psycopg */
int i;
PyObject *dict;
PyObject *base;
PyObject *str;
for (i=0; exctable[i].name; i++) {
dict = PyDict_New();
if (exctable[i].docstr) {
str = Text_FromUTF8(exctable[i].docstr);
PyDict_SetItemString(dict, "__doc__", str);
}
if (exctable[i].base == 0) {
#if PY_MAJOR_VERSION < 3
base = PyExc_StandardError;
#else
/* StandardError is gone in 3.0 */
base = NULL;
#endif
}
else
base = *exctable[i].base;
*exctable[i].exc = PyErr_NewException(exctable[i].name, base, dict);
}
/* Make pgerror, pgcode and cursor default to None on psycopg
error objects. This simplifies error handling code that checks
these attributes. */
PyObject_SetAttrString(Error, "pgerror", Py_None);
PyObject_SetAttrString(Error, "pgcode", Py_None);
PyObject_SetAttrString(Error, "cursor", Py_None);
}
