static void add_module_constants(PyObject* simulator)
{
// Make the GPI constants accessible from the C world
int rc = 0;
rc |= PyModule_AddIntConstant(simulator, "UNKNOWN", GPI_UNKNOWN);
rc |= PyModule_AddIntConstant(simulator, "MEMORY", GPI_MEMORY);
rc |= PyModule_AddIntConstant(simulator, "MODULE", GPI_MODULE);
rc |= PyModule_AddIntConstant(simulator, "NET", GPI_NET);
rc |= PyModule_AddIntConstant(simulator, "PARAMETER", GPI_PARAMETER);
rc |= PyModule_AddIntConstant(simulator, "REG", GPI_REGISTER);
rc |= PyModule_AddIntConstant(simulator, "NETARRAY", GPI_ARRAY);
rc |= PyModule_AddIntConstant(simulator, "ENUM", GPI_ENUM);
rc |= PyModule_AddIntConstant(simulator, "STRUCTURE", GPI_STRUCTURE);
rc |= PyModule_AddIntConstant(simulator, "REAL", GPI_REAL);
rc |= PyModule_AddIntConstant(simulator, "INTEGER", GPI_INTEGER);
rc |= PyModule_AddIntConstant(simulator, "STRING", GPI_STRING);
rc |= PyModule_AddIntConstant(simulator, "GENARRAY", GPI_GENARRAY);
rc |= PyModule_AddIntConstant(simulator, "OBJECTS", GPI_OBJECTS);
rc |= PyModule_AddIntConstant(simulator, "DRIVERS", GPI_DRIVERS);
rc |= PyModule_AddIntConstant(simulator, "LOADS", GPI_LOADS);
if (rc != 0)
fprintf(stderr, "Failed to add module constants!\n");
}
PyMODINIT_FUNC PyInit_tesserpy(void) {
#else
#define INITERROR return
PyMODINIT_FUNC inittesserpy(void) {
#endif
PyBoundingBox_Type.tp_new = PyType_GenericNew;
if (PyType_Ready(&PyBoundingBox_Type) < 0) {
INITERROR;
}
PyPageInfo_Type.tp_new = PyType_GenericNew;
if (PyType_Ready(&PyPageInfo_Type) < 0) {
INITERROR;
}
PyResult_Type.tp_new = PyType_GenericNew;
if (PyType_Ready(&PyResult_Type) < 0) {
INITERROR;
}
if (PyType_Ready(&PyResultIterator_Type) < 0) {
INITERROR;
}
if (PyType_Ready(&PyTesseract_Type) < 0) {
INITERROR;
}
#ifdef IS_PY3K
PyObject *module = PyModule_Create(&TesserPyModuleDef);
#else
PyObject *module = Py_InitModule("tesserpy", TesserPyMethods);
#endif
if (module == NULL) {
INITERROR;
}
import_array();
Py_INCREF(&PyBoundingBox_Type);
PyModule_AddObject(module, "BoundingBox", (PyObject *)&PyBoundingBox_Type);
Py_INCREF(&PyPageInfo_Type);
PyModule_AddObject(module, "PageInfo", (PyObject *)&PyPageInfo_Type);
Py_INCREF(&PyResult_Type);
PyModule_AddObject(module, "Result", (PyObject *)&PyResult_Type);
Py_INCREF(&PyResultIterator_Type);
PyModule_AddObject(module, "ResultIterator", (PyObject *)&PyResultIterator_Type);
Py_INCREF(&PyTesseract_Type);
PyModule_AddObject(module, "Tesseract", (PyObject *)&PyTesseract_Type);
// CONSTANTS
// TessOcrEngineMode
PyModule_AddIntConstant(module, "OEM_TESSERACT_ONLY", tesseract::OEM_TESSERACT_ONLY);
PyModule_AddIntConstant(module, "OEM_CUBE_ONLY", tesseract::OEM_CUBE_ONLY);
PyModule_AddIntConstant(module, "OEM_TESSERACT_CUBE_COMBINED", tesseract::OEM_TESSERACT_CUBE_COMBINED);
PyModule_AddIntConstant(module, "OEM_DEFAULT", tesseract::OEM_DEFAULT);
// TessPageSegMode
PyModule_AddIntConstant(module, "PSM_OSD_ONLY", tesseract::PSM_OSD_ONLY);
PyModule_AddIntConstant(module, "PSM_AUTO_OSD", tesseract::PSM_AUTO_OSD);
PyModule_AddIntConstant(module, "PSM_AUTO_ONLY", tesseract::PSM_AUTO_ONLY);
PyModule_AddIntConstant(module, "PSM_AUTO", tesseract::PSM_AUTO);
PyModule_AddIntConstant(module, "PSM_SINGLE_COLUMN", tesseract::PSM_SINGLE_COLUMN);
PyModule_AddIntConstant(module, "PSM_SINGLE_BLOCK_VERT_TEXT", tesseract::PSM_SINGLE_BLOCK_VERT_TEXT);
PyModule_AddIntConstant(module, "PSM_SINGLE_BLOCK", tesseract::PSM_SINGLE_BLOCK);
PyModule_AddIntConstant(module, "PSM_SINGLE_LINE", tesseract::PSM_SINGLE_LINE);
PyModule_AddIntConstant(module, "PSM_SINGLE_WORD", tesseract::PSM_SINGLE_WORD);
PyModule_AddIntConstant(module, "PSM_CIRCLE_WORD", tesseract::PSM_CIRCLE_WORD);
PyModule_AddIntConstant(module, "PSM_SINGLE_CHAR", tesseract::PSM_SINGLE_CHAR);
PyModule_AddIntConstant(module, "PSM_COUNT", tesseract::PSM_COUNT);
// PageIteratorLevel
PyModule_AddIntConstant(module, "RIL_BLOCK", tesseract::RIL_BLOCK);
PyModule_AddIntConstant(module, "RIL_PARA", tesseract::RIL_PARA);
PyModule_AddIntConstant(module, "RIL_TEXTLINE", tesseract::RIL_TEXTLINE);
PyModule_AddIntConstant(module, "RIL_WORD", tesseract::RIL_WORD);
PyModule_AddIntConstant(module, "RIL_SYMBOL", tesseract::RIL_SYMBOL);
// Orientation
PyModule_AddIntConstant(module, "ORIENTATION_PAGE_UP", tesseract::ORIENTATION_PAGE_UP);
PyModule_AddIntConstant(module, "ORIENTATION_PAGE_RIGHT", tesseract::ORIENTATION_PAGE_RIGHT);
PyModule_AddIntConstant(module, "ORIENTATION_PAGE_DOWN", tesseract::ORIENTATION_PAGE_DOWN);
PyModule_AddIntConstant(module, "ORIENTATION_PAGE_LEFT", tesseract::ORIENTATION_PAGE_LEFT);
// WritingDirection
PyModule_AddIntConstant(module, "WRITING_DIRECTION_LEFT_TO_RIGHT", tesseract::WRITING_DIRECTION_LEFT_TO_RIGHT);
PyModule_AddIntConstant(module, "WRITING_DIRECTION_RIGHT_TO_LEFT", tesseract::WRITING_DIRECTION_RIGHT_TO_LEFT);
PyModule_AddIntConstant(module, "WRITING_DIRECTION_TOP_TO_BOTTOM", tesseract::WRITING_DIRECTION_TOP_TO_BOTTOM);
// TextlineOrder
PyModule_AddIntConstant(module, "TEXTLINE_ORDER_LEFT_TO_RIGHT", tesseract::TEXTLINE_ORDER_LEFT_TO_RIGHT);
PyModule_AddIntConstant(module, "TEXTLINE_ORDER_RIGHT_TO_LEFT", tesseract::TEXTLINE_ORDER_RIGHT_TO_LEFT);
PyModule_AddIntConstant(module, "TEXTLINE_ORDER_TOP_TO_BOTTOM", tesseract::TEXTLINE_ORDER_TOP_TO_BOTTOM);
#ifdef IS_PY3K
return module;
#endif
}
PyMODINIT_FUNC
InitXBMCModule()
{
// init general xbmc modules
PyObject* pXbmcModule;
Py_INCREF(&Keyboard_Type);
Py_INCREF(&Player_Type);
Py_INCREF(&PlayList_Type);
Py_INCREF(&PlayListItem_Type);
Py_INCREF(&InfoTagMusic_Type);
Py_INCREF(&InfoTagVideo_Type);
pXbmcModule = Py_InitModule((char*)"xbmc", xbmcMethods);
if (pXbmcModule == NULL) return;
PyModule_AddObject(pXbmcModule, (char*)"Keyboard", (PyObject*)&Keyboard_Type);
PyModule_AddObject(pXbmcModule, (char*)"Player", (PyObject*)&Player_Type);
PyModule_AddObject(pXbmcModule, (char*)"PlayList", (PyObject*)&PlayList_Type);
PyModule_AddObject(pXbmcModule, (char*)"PlayListItem", (PyObject*)&PlayListItem_Type);
PyModule_AddObject(pXbmcModule, (char*)"InfoTagMusic", (PyObject*)&InfoTagMusic_Type);
PyModule_AddObject(pXbmcModule, (char*)"InfoTagVideo", (PyObject*)&InfoTagVideo_Type);
// constants
PyModule_AddStringConstant(pXbmcModule, (char*)"__author__", (char*)PY_XBMC_AUTHOR);
PyModule_AddStringConstant(pXbmcModule, (char*)"__date__", (char*)"15 November 2005");
PyModule_AddStringConstant(pXbmcModule, (char*)"__version__", (char*)"1.3");
PyModule_AddStringConstant(pXbmcModule, (char*)"__credits__", (char*)PY_XBMC_CREDITS);
PyModule_AddStringConstant(pXbmcModule, (char*)"__platform__", (char*)PY_XBMC_PLATFORM);
// playlist constants
PyModule_AddIntConstant(pXbmcModule, (char*)"PLAYLIST_MUSIC", PLAYLIST_MUSIC);
//PyModule_AddIntConstant(pXbmcModule, (char*)"PLAYLIST_MUSIC_TEMP", (char*)PLAYLIST_MUSIC_TEMP);
PyModule_AddIntConstant(pXbmcModule, (char*)"PLAYLIST_VIDEO", PLAYLIST_VIDEO);
//PyModule_AddIntConstant(pXbmcModule, (char*)"PLAYLIST_VIDEO_TEMP", PLAYLIST_VIDEO_TEMP);
// player constants
PyModule_AddIntConstant(pXbmcModule, (char*)"PLAYER_CORE_AUTO", EPC_NONE);
PyModule_AddIntConstant(pXbmcModule, (char*)"PLAYER_CORE_DVDPLAYER", EPC_DVDPLAYER);
PyModule_AddIntConstant(pXbmcModule, (char*)"PLAYER_CORE_MPLAYER", EPC_MPLAYER);
PyModule_AddIntConstant(pXbmcModule, (char*)"PLAYER_CORE_PAPLAYER", EPC_PAPLAYER);
// dvd state constants
PyModule_AddIntConstant(pXbmcModule, (char*)"TRAY_OPEN", TRAY_OPEN);
PyModule_AddIntConstant(pXbmcModule, (char*)"DRIVE_NOT_READY", DRIVE_NOT_READY);
PyModule_AddIntConstant(pXbmcModule, (char*)"TRAY_CLOSED_NO_MEDIA", TRAY_CLOSED_NO_MEDIA);
PyModule_AddIntConstant(pXbmcModule, (char*)"TRAY_CLOSED_MEDIA_PRESENT", TRAY_CLOSED_MEDIA_PRESENT);
// log levels
PyModule_AddIntConstant(pXbmcModule, (char*)"LOGDEBUG", LOGDEBUG);
PyModule_AddIntConstant(pXbmcModule, (char*)"LOGINFO", LOGINFO);
PyModule_AddIntConstant(pXbmcModule, (char*)"LOGNOTICE", LOGNOTICE);
PyModule_AddIntConstant(pXbmcModule, (char*)"LOGWARNING", LOGWARNING);
PyModule_AddIntConstant(pXbmcModule, (char*)"LOGERROR", LOGERROR);
PyModule_AddIntConstant(pXbmcModule, (char*)"LOGSEVERE", LOGSEVERE);
PyModule_AddIntConstant(pXbmcModule, (char*)"LOGFATAL", LOGFATAL);
PyModule_AddIntConstant(pXbmcModule, (char*)"LOGNONE", LOGNONE);
PyModule_AddObject(pXbmcModule, (char*)"abortRequested", PyBool_FromLong(0));
}
static void
add_compat_enums(PyObject *m)
{
PyModule_AddIntConstant(m, "ADD_WHITE_MASK",
GIMP_ADD_MASK_WHITE);
PyModule_AddIntConstant(m, "ADD_BLACK_MASK",
GIMP_ADD_MASK_BLACK);
PyModule_AddIntConstant(m, "ADD_ALPHA_MASK",
GIMP_ADD_MASK_ALPHA);
PyModule_AddIntConstant(m, "ADD_ALPHA_TRANSFER_MASK",
GIMP_ADD_MASK_ALPHA_TRANSFER);
PyModule_AddIntConstant(m, "ADD_SELECTION_MASK",
GIMP_ADD_MASK_SELECTION);
PyModule_AddIntConstant(m, "ADD_COPY_MASK",
GIMP_ADD_MASK_COPY);
PyModule_AddIntConstant(m, "ADD_CHANNEL_MASK",
GIMP_ADD_MASK_CHANNEL);
PyModule_AddIntConstant(m, "FG_BG_RGB_MODE",
GIMP_BLEND_FG_BG_RGB);
PyModule_AddIntConstant(m, "FG_BG_HSV_MODE",
GIMP_BLEND_FG_BG_HSV);
PyModule_AddIntConstant(m, "FG_TRANSPARENT_MODE",
GIMP_BLEND_FG_TRANSPARENT);
PyModule_AddIntConstant(m, "CUSTOM_MODE",
GIMP_BLEND_CUSTOM);
PyModule_AddIntConstant(m, "FG_BUCKET_FILL",
GIMP_BUCKET_FILL_FG);
PyModule_AddIntConstant(m, "BG_BUCKET_FILL",
GIMP_BUCKET_FILL_BG);
PyModule_AddIntConstant(m, "PATTERN_BUCKET_FILL",
GIMP_BUCKET_FILL_PATTERN);
PyModule_AddIntConstant(m, "BLUR_CONVOLVE",
GIMP_CONVOLVE_BLUR);
PyModule_AddIntConstant(m, "SHARPEN_CONVOLVE",
GIMP_CONVOLVE_SHARPEN);
PyModule_AddIntConstant(m, "IMAGE_CLONE",
GIMP_CLONE_IMAGE);
PyModule_AddIntConstant(m, "PATTERN_CLONE",
GIMP_CLONE_PATTERN);
PyModule_AddIntConstant(m, "FOREGROUND_FILL",
GIMP_FILL_FOREGROUND);
PyModule_AddIntConstant(m, "BACKGROUND_FILL",
GIMP_FILL_BACKGROUND);
PyModule_AddIntConstant(m, "WHITE_FILL",
GIMP_FILL_WHITE);
PyModule_AddIntConstant(m, "TRANSPARENT_FILL",
GIMP_FILL_TRANSPARENT);
PyModule_AddIntConstant(m, "PATTERN_FILL",
GIMP_FILL_PATTERN);
PyModule_AddIntConstant(m, "DODGE",
GIMP_DODGE_BURN_TYPE_DODGE);
PyModule_AddIntConstant(m, "BURN",
GIMP_DODGE_BURN_TYPE_BURN);
PyModule_AddIntConstant(m, "SHADOWS",
GIMP_TRANSFER_SHADOWS);
PyModule_AddIntConstant(m, "MIDTONES",
GIMP_TRANSFER_MIDTONES);
PyModule_AddIntConstant(m, "HIGHLIGHTS",
GIMP_TRANSFER_HIGHLIGHTS);
PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_RGB",
GIMP_EXPORT_CAN_HANDLE_RGB);
PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_GRAY",
GIMP_EXPORT_CAN_HANDLE_GRAY);
PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_INDEXED",
GIMP_EXPORT_CAN_HANDLE_INDEXED);
PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_BITMAP",
GIMP_EXPORT_CAN_HANDLE_BITMAP);
PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_ALPHA",
GIMP_EXPORT_CAN_HANDLE_ALPHA);
PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_LAYERS",
GIMP_EXPORT_CAN_HANDLE_LAYERS);
PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION",
GIMP_EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION);
PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_LAYER_MASKS",
GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS);
PyModule_AddIntConstant(m, "EXPORT_NEEDS_ALPHA",
GIMP_EXPORT_NEEDS_ALPHA);
PyModule_AddIntConstant(m, "EXPORT_CANCEL",
GIMP_EXPORT_CANCEL);
PyModule_AddIntConstant(m, "EXPORT_IGNORE",
GIMP_EXPORT_IGNORE);
PyModule_AddIntConstant(m, "EXPORT_EXPORT",
GIMP_EXPORT_EXPORT);
}
/* module initializer */
PyMODINIT_FUNC PyInit_netconf(void)
{
PyObject *nc;
/* initiate libnetconf - all subsystems */
nc_init(NC_INIT_ALL);
/* set print callback */
nc_callback_print(clb_print);
/* get default caapbilities */
global_cpblts = nc_session_get_cpblts_default();
ncSessionType.tp_new = PyType_GenericNew;
if (PyType_Ready(&ncSessionType) < 0) {
return NULL;
}
/* create netconf as the Python module */
nc = PyModule_Create(&ncModule);
if (nc == NULL) {
return NULL;
}
Py_INCREF(&ncSessionType);
PyModule_AddObject(nc, "Session", (PyObject *)&ncSessionType);
datastores = PyDict_New();
PyModule_AddObject(nc, "Datastores", datastores);
PyModule_AddStringConstant(nc, "NETCONFv1_0", NETCONF_CAP_BASE10);
PyModule_AddStringConstant(nc, "NETCONFv1_1", NETCONF_CAP_BASE11);
PyModule_AddStringConstant(nc, "TRANSPORT_SSH", NETCONF_TRANSPORT_SSH);
PyModule_AddStringConstant(nc, "TRANSPORT_TLS", NETCONF_TRANSPORT_TLS);
PyModule_AddIntConstant(nc, "WD_ALL", NCWD_MODE_ALL);
PyModule_AddIntConstant(nc, "WD_ALL_TAGGED", NCWD_MODE_ALL_TAGGED);
PyModule_AddIntConstant(nc, "WD_TRIM", NCWD_MODE_TRIM);
PyModule_AddIntConstant(nc, "WD_MODE_EXPLICIT", NCWD_MODE_EXPLICIT);
PyModule_AddIntConstant(nc, "RUNNING", NC_DATASTORE_RUNNING);
PyModule_AddIntConstant(nc, "STARTUP", NC_DATASTORE_STARTUP);
PyModule_AddIntConstant(nc, "CANDIDATE", NC_DATASTORE_CANDIDATE);
PyModule_AddIntConstant(nc, "NC_EDIT_DEFOP_NOTSET", NC_EDIT_DEFOP_NOTSET);
PyModule_AddIntConstant(nc, "NC_EDIT_DEFOP_MERGE", NC_EDIT_DEFOP_MERGE);
PyModule_AddIntConstant(nc, "NC_EDIT_DEFOP_REPLACE", NC_EDIT_DEFOP_REPLACE);
PyModule_AddIntConstant(nc, "NC_EDIT_DEFOP_NONE", NC_EDIT_DEFOP_NONE);
PyModule_AddIntConstant(nc, "NC_EDIT_ERROPT_NOTSET", NC_EDIT_ERROPT_NOTSET);
PyModule_AddIntConstant(nc, "NC_EDIT_ERROPT_STOP", NC_EDIT_ERROPT_STOP);
PyModule_AddIntConstant(nc, "NC_EDIT_ERROPT_CONT", NC_EDIT_ERROPT_CONT);
PyModule_AddIntConstant(nc, "NC_EDIT_ERROPT_ROLLBACK", NC_EDIT_ERROPT_ROLLBACK);
PyModule_AddIntConstant(nc, "NC_EDIT_TESTOPT_NOTSET", NC_EDIT_TESTOPT_NOTSET);
PyModule_AddIntConstant(nc, "NC_EDIT_TESTOPT_TESTSET", NC_EDIT_TESTOPT_TESTSET);
PyModule_AddIntConstant(nc, "NC_EDIT_TESTOPT_SET", NC_EDIT_TESTOPT_SET);
PyModule_AddIntConstant(nc, "NC_EDIT_TESTOPT_TEST", NC_EDIT_TESTOPT_TEST);
/* init libnetconf exceptions for use in clb_print() */
libnetconfError = PyErr_NewExceptionWithDoc("netconf.Error", "Error passed from the underlying libnetconf library.", NULL, NULL);
Py_INCREF(libnetconfError);
PyModule_AddObject(nc, "Error", libnetconfError);
libnetconfWarning = PyErr_NewExceptionWithDoc("netconf.Warning", "Warning passed from the underlying libnetconf library.", PyExc_Warning, NULL);
Py_INCREF(libnetconfWarning);
PyModule_AddObject(nc, "Warning", libnetconfWarning);
return nc;
}
/*
* 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:
;
}
static void
PyInit_timezone(PyObject *m) {
/* This code moved from PyInit_time wholesale to allow calling it from
time_tzset. In the future, some parts of it can be moved back
(for platforms that don't HAVE_WORKING_TZSET, when we know what they
are), and the extraneous calls to tzset(3) should be removed.
I haven't done this yet, as I don't want to change this code as
little as possible when introducing the time.tzset and time.tzsetwall
methods. This should simply be a method of doing the following once,
at the top of this function and removing the call to tzset() from
time_tzset():
#ifdef HAVE_TZSET
tzset()
#endif
And I'm lazy and hate C so nyer.
*/
#if defined(HAVE_TZNAME) && !defined(__GLIBC__) && !defined(__CYGWIN__)
PyObject *otz0, *otz1;
tzset();
PyModule_AddIntConstant(m, "timezone", timezone);
#ifdef HAVE_ALTZONE
PyModule_AddIntConstant(m, "altzone", altzone);
#else
PyModule_AddIntConstant(m, "altzone", timezone-3600);
#endif
PyModule_AddIntConstant(m, "daylight", daylight);
otz0 = PyUnicode_DecodeLocale(tzname[0], "surrogateescape");
otz1 = PyUnicode_DecodeLocale(tzname[1], "surrogateescape");
PyModule_AddObject(m, "tzname", Py_BuildValue("(NN)", otz0, otz1));
#else /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
{
#define YEAR ((time_t)((365 * 24 + 6) * 3600))
time_t t;
struct tm p;
long janzone, julyzone;
char janname[10], julyname[10];
t = (time((time_t *)0) / YEAR) * YEAR;
_PyTime_localtime(t, &p);
get_zone(janname, 9, &p);
janzone = -get_gmtoff(t, &p);
janname[9] = '\0';
t += YEAR/2;
_PyTime_localtime(t, &p);
get_zone(julyname, 9, &p);
julyzone = -get_gmtoff(t, &p);
julyname[9] = '\0';
if( janzone < julyzone ) {
/* DST is reversed in the southern hemisphere */
PyModule_AddIntConstant(m, "timezone", julyzone);
PyModule_AddIntConstant(m, "altzone", janzone);
PyModule_AddIntConstant(m, "daylight",
janzone != julyzone);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)",
julyname, janname));
} else {
PyModule_AddIntConstant(m, "timezone", janzone);
PyModule_AddIntConstant(m, "altzone", julyzone);
PyModule_AddIntConstant(m, "daylight",
janzone != julyzone);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)",
janname, julyname));
}
}
#ifdef __CYGWIN__
tzset();
PyModule_AddIntConstant(m, "timezone", _timezone);
PyModule_AddIntConstant(m, "altzone", _timezone-3600);
PyModule_AddIntConstant(m, "daylight", _daylight);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)", _tzname[0], _tzname[1]));
#endif /* __CYGWIN__ */
#endif /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
}
PyMODINIT_FUNC
PyInit__ssl(void)
{
PyObject *m, *d;
PySocketModule_APIObject *socket_api;
if (PyType_Ready(&PySSL_Type) < 0)
return NULL;
m = PyModule_Create(&_sslmodule);
if (m == NULL)
return NULL;
d = PyModule_GetDict(m);
/* Load _socket module and its C API */
socket_api = PySocketModule_ImportModuleAndAPI();
if (!socket_api)
return NULL;
PySocketModule = *socket_api;
/* Init OpenSSL */
SSL_load_error_strings();
#ifdef WITH_THREAD
/* note that this will start threading if not already started */
if (!_setup_ssl_threads()) {
return NULL;
}
#endif
SSLeay_add_ssl_algorithms();
/* Add symbols to module dict */
PySSLErrorObject = PyErr_NewException("ssl.SSLError",
PySocketModule.error,
NULL);
if (PySSLErrorObject == NULL)
return NULL;
if (PyDict_SetItemString(d, "SSLError", PySSLErrorObject) != 0)
return NULL;
if (PyDict_SetItemString(d, "SSLType",
(PyObject *)&PySSL_Type) != 0)
return NULL;
PyModule_AddIntConstant(m, "SSL_ERROR_ZERO_RETURN",
PY_SSL_ERROR_ZERO_RETURN);
PyModule_AddIntConstant(m, "SSL_ERROR_WANT_READ",
PY_SSL_ERROR_WANT_READ);
PyModule_AddIntConstant(m, "SSL_ERROR_WANT_WRITE",
PY_SSL_ERROR_WANT_WRITE);
PyModule_AddIntConstant(m, "SSL_ERROR_WANT_X509_LOOKUP",
PY_SSL_ERROR_WANT_X509_LOOKUP);
PyModule_AddIntConstant(m, "SSL_ERROR_SYSCALL",
PY_SSL_ERROR_SYSCALL);
PyModule_AddIntConstant(m, "SSL_ERROR_SSL",
PY_SSL_ERROR_SSL);
PyModule_AddIntConstant(m, "SSL_ERROR_WANT_CONNECT",
PY_SSL_ERROR_WANT_CONNECT);
/* non ssl.h errorcodes */
PyModule_AddIntConstant(m, "SSL_ERROR_EOF",
PY_SSL_ERROR_EOF);
PyModule_AddIntConstant(m, "SSL_ERROR_INVALID_ERROR_CODE",
PY_SSL_ERROR_INVALID_ERROR_CODE);
/* cert requirements */
PyModule_AddIntConstant(m, "CERT_NONE",
PY_SSL_CERT_NONE);
PyModule_AddIntConstant(m, "CERT_OPTIONAL",
PY_SSL_CERT_OPTIONAL);
PyModule_AddIntConstant(m, "CERT_REQUIRED",
PY_SSL_CERT_REQUIRED);
/* protocol versions */
PyModule_AddIntConstant(m, "PROTOCOL_SSLv2",
PY_SSL_VERSION_SSL2);
PyModule_AddIntConstant(m, "PROTOCOL_SSLv3",
PY_SSL_VERSION_SSL3);
PyModule_AddIntConstant(m, "PROTOCOL_SSLv23",
PY_SSL_VERSION_SSL23);
PyModule_AddIntConstant(m, "PROTOCOL_TLSv1",
PY_SSL_VERSION_TLS1);
return m;
}
PyMODINIT_FUNC
initpyodbc()
{
#ifdef _DEBUG
#ifndef Py_REF_DEBUG
#error Py_REF_DEBUG not set!
#endif
int grfDebugFlags = _CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF;
_CrtSetDbgFlag(grfDebugFlags);
#endif
ErrorInit();
if (PyType_Ready(&ConnectionType) < 0 || PyType_Ready(&CursorType) < 0 || PyType_Ready(&RowType) < 0 || PyType_Ready(&CnxnInfoType) < 0)
return;
pModule = Py_InitModule4("pyodbc", pyodbc_methods, module_doc, NULL, PYTHON_API_VERSION);
if (!import_types())
return;
init_locale_info();
if (!CreateExceptions())
return;
// The 'build' version number is a beta identifier. For example, if it is 7, then we are on beta7 of the
// (major,minor.micro) version. On Windows, we poke these values into the DLL's version resource, so when we make
// an official build (which come *after* the betas), we set the BUILD to 9999 so installers will know that it
// should replace any installed betas. However, we obviously don't want to see these.
PyObject* pVersion;
if (PYODBC_BUILD == 9999)
pVersion = PyString_FromFormat("%d.%d.%d", PYODBC_MAJOR, PYODBC_MINOR, PYODBC_MICRO);
else
pVersion = PyString_FromFormat("%d.%d.%d-beta%d", PYODBC_MAJOR, PYODBC_MINOR, PYODBC_MICRO, PYODBC_BUILD);
PyModule_AddObject(pModule, "version", pVersion);
PyModule_AddIntConstant(pModule, "threadsafety", 1);
PyModule_AddStringConstant(pModule, "apilevel", "2.0");
PyModule_AddStringConstant(pModule, "paramstyle", "qmark");
PyModule_AddObject(pModule, "pooling", Py_True);
Py_INCREF(Py_True);
PyModule_AddObject(pModule, "lowercase", Py_False);
Py_INCREF(Py_False);
PyModule_AddObject(pModule, "Connection", (PyObject*)&ConnectionType);
Py_INCREF((PyObject*)&ConnectionType);
PyModule_AddObject(pModule, "Cursor", (PyObject*)&CursorType);
Py_INCREF((PyObject*)&CursorType);
PyModule_AddObject(pModule, "Row", (PyObject*)&RowType);
Py_INCREF((PyObject*)&RowType);
// Add the SQL_XXX defines from ODBC.
for (unsigned int i = 0; i < _countof(aConstants); i++)
PyModule_AddIntConstant(pModule, (char*)aConstants[i].szName, aConstants[i].value);
PyModule_AddObject(pModule, "Date", (PyObject*)PyDateTimeAPI->DateType);
Py_INCREF((PyObject*)PyDateTimeAPI->DateType);
PyModule_AddObject(pModule, "Time", (PyObject*)PyDateTimeAPI->TimeType);
Py_INCREF((PyObject*)PyDateTimeAPI->TimeType);
PyModule_AddObject(pModule, "Timestamp", (PyObject*)PyDateTimeAPI->DateTimeType);
Py_INCREF((PyObject*)PyDateTimeAPI->DateTimeType);
PyModule_AddObject(pModule, "DATETIME", (PyObject*)PyDateTimeAPI->DateTimeType);
Py_INCREF((PyObject*)PyDateTimeAPI->DateTimeType);
PyModule_AddObject(pModule, "STRING", (PyObject*)&PyString_Type);
Py_INCREF((PyObject*)&PyString_Type);
PyModule_AddObject(pModule, "NUMBER", (PyObject*)&PyFloat_Type);
Py_INCREF((PyObject*)&PyFloat_Type);
PyModule_AddObject(pModule, "ROWID", (PyObject*)&PyInt_Type);
Py_INCREF((PyObject*)&PyInt_Type);
PyModule_AddObject(pModule, "BINARY", (PyObject*)&PyBuffer_Type);
Py_INCREF((PyObject*)&PyBuffer_Type);
PyModule_AddObject(pModule, "Binary", (PyObject*)&PyBuffer_Type);
Py_INCREF((PyObject*)&PyBuffer_Type);
if (PyErr_Occurred())
ErrorCleanup();
}
PyMODINIT_FUNC initpaho_mqtt3c(void)
{
PyObject *m;
PyEval_InitThreads();
callbacks = ListInitialize();
m = Py_InitModule("paho_mqtt3c", MqttV3Methods);
if (m == NULL)
return;
MqttV3Error = PyErr_NewException("paho_mqtt3c.error", NULL, NULL);
Py_INCREF(MqttV3Error);
PyModule_AddObject(m, "error", MqttV3Error);
PyModule_AddIntConstant(m, "SUCCESS", MQTTCLIENT_SUCCESS);
PyModule_AddIntConstant(m, "FAILURE", MQTTCLIENT_FAILURE);
PyModule_AddIntConstant(m, "DISCONNECTED", MQTTCLIENT_DISCONNECTED);
PyModule_AddIntConstant(m, "MAX_MESSAGES_INFLIGHT", MQTTCLIENT_MAX_MESSAGES_INFLIGHT);
PyModule_AddIntConstant(m, "BAD_UTF8_STRING", MQTTCLIENT_BAD_UTF8_STRING);
PyModule_AddIntConstant(m, "BAD_NULL_PARAMETER", MQTTCLIENT_NULL_PARAMETER);
PyModule_AddIntConstant(m, "BAD_TOPICNAME_TRUNCATED", MQTTCLIENT_TOPICNAME_TRUNCATED);
PyModule_AddIntConstant(m, "PERSISTENCE_DEFAULT", MQTTCLIENT_PERSISTENCE_DEFAULT);
PyModule_AddIntConstant(m, "PERSISTENCE_NONE", MQTTCLIENT_PERSISTENCE_NONE);
PyModule_AddIntConstant(m, "PERSISTENCE_USER", MQTTCLIENT_PERSISTENCE_USER);
PyModule_AddIntConstant(m, "PERSISTENCE_ERROR",
MQTTCLIENT_PERSISTENCE_ERROR);
}
PyMODINIT_FUNC
initicu(void)
{
PyObject* m;
UVersionInfo ver, uver;
UErrorCode status = U_ZERO_ERROR;
char version[U_MAX_VERSION_STRING_LENGTH+1] = {0}, uversion[U_MAX_VERSION_STRING_LENGTH+5] = {0};
if (sizeof(Py_UNICODE) != 2 && sizeof(Py_UNICODE) != 4) {
PyErr_SetString(PyExc_RuntimeError, "This module only works on python versions <= 3.2");
return;
}
u_init(&status);
if (U_FAILURE(status)) {
PyErr_SetString(PyExc_RuntimeError, u_errorName(status));
return;
}
u_getVersion(ver);
u_versionToString(ver, version);
u_getUnicodeVersion(uver);
u_versionToString(uver, uversion);
if (PyType_Ready(&icu_CollatorType) < 0)
return;
if (PyType_Ready(&icu_BreakIteratorType) < 0)
return;
m = Py_InitModule3("icu", icu_methods,
"Wrapper for the ICU internationalization library");
Py_INCREF(&icu_CollatorType); Py_INCREF(&icu_BreakIteratorType);
PyModule_AddObject(m, "Collator", (PyObject *)&icu_CollatorType);
PyModule_AddObject(m, "BreakIterator", (PyObject *)&icu_BreakIteratorType);
// uint8_t must be the same size as char
PyModule_AddIntConstant(m, "ok", (U_SUCCESS(status) && sizeof(uint8_t) == sizeof(char)) ? 1 : 0);
PyModule_AddStringConstant(m, "icu_version", version);
PyModule_AddStringConstant(m, "unicode_version", uversion);
ADDUCONST(USET_SPAN_NOT_CONTAINED);
ADDUCONST(USET_SPAN_CONTAINED);
ADDUCONST(USET_SPAN_SIMPLE);
ADDUCONST(UCOL_DEFAULT);
ADDUCONST(UCOL_PRIMARY);
ADDUCONST(UCOL_SECONDARY);
ADDUCONST(UCOL_TERTIARY);
ADDUCONST(UCOL_DEFAULT_STRENGTH);
ADDUCONST(UCOL_QUATERNARY);
ADDUCONST(UCOL_IDENTICAL);
ADDUCONST(UCOL_OFF);
ADDUCONST(UCOL_ON);
ADDUCONST(UCOL_SHIFTED);
ADDUCONST(UCOL_NON_IGNORABLE);
ADDUCONST(UCOL_LOWER_FIRST);
ADDUCONST(UCOL_UPPER_FIRST);
ADDUCONST(UNORM_NONE);
ADDUCONST(UNORM_NFD);
ADDUCONST(UNORM_NFKD);
ADDUCONST(UNORM_NFC);
ADDUCONST(UNORM_DEFAULT);
ADDUCONST(UNORM_NFKC);
ADDUCONST(UNORM_FCD);
ADDUCONST(UPPER_CASE);
ADDUCONST(LOWER_CASE);
ADDUCONST(TITLE_CASE);
ADDUCONST(UBRK_CHARACTER);
ADDUCONST(UBRK_WORD);
ADDUCONST(UBRK_LINE);
ADDUCONST(UBRK_SENTENCE);
}
PyMODINIT_FUNC
PyInit_syslog(void)
{
PyObject *m;
/* Create the module and add the functions */
m = PyModule_Create(&syslogmodule);
if (m == NULL)
return NULL;
/* Add some symbolic constants to the module */
/* Priorities */
PyModule_AddIntConstant(m, "LOG_EMERG", LOG_EMERG);
PyModule_AddIntConstant(m, "LOG_ALERT", LOG_ALERT);
PyModule_AddIntConstant(m, "LOG_CRIT", LOG_CRIT);
PyModule_AddIntConstant(m, "LOG_ERR", LOG_ERR);
PyModule_AddIntConstant(m, "LOG_WARNING", LOG_WARNING);
PyModule_AddIntConstant(m, "LOG_NOTICE", LOG_NOTICE);
PyModule_AddIntConstant(m, "LOG_INFO", LOG_INFO);
PyModule_AddIntConstant(m, "LOG_DEBUG", LOG_DEBUG);
/* openlog() option flags */
PyModule_AddIntConstant(m, "LOG_PID", LOG_PID);
PyModule_AddIntConstant(m, "LOG_CONS", LOG_CONS);
PyModule_AddIntConstant(m, "LOG_NDELAY", LOG_NDELAY);
#ifdef LOG_ODELAY
PyModule_AddIntConstant(m, "LOG_ODELAY", LOG_ODELAY);
#endif
#ifdef LOG_NOWAIT
PyModule_AddIntConstant(m, "LOG_NOWAIT", LOG_NOWAIT);
#endif
#ifdef LOG_PERROR
PyModule_AddIntConstant(m, "LOG_PERROR", LOG_PERROR);
#endif
/* Facilities */
PyModule_AddIntConstant(m, "LOG_KERN", LOG_KERN);
PyModule_AddIntConstant(m, "LOG_USER", LOG_USER);
PyModule_AddIntConstant(m, "LOG_MAIL", LOG_MAIL);
PyModule_AddIntConstant(m, "LOG_DAEMON", LOG_DAEMON);
PyModule_AddIntConstant(m, "LOG_AUTH", LOG_AUTH);
PyModule_AddIntConstant(m, "LOG_LPR", LOG_LPR);
PyModule_AddIntConstant(m, "LOG_LOCAL0", LOG_LOCAL0);
PyModule_AddIntConstant(m, "LOG_LOCAL1", LOG_LOCAL1);
PyModule_AddIntConstant(m, "LOG_LOCAL2", LOG_LOCAL2);
PyModule_AddIntConstant(m, "LOG_LOCAL3", LOG_LOCAL3);
PyModule_AddIntConstant(m, "LOG_LOCAL4", LOG_LOCAL4);
PyModule_AddIntConstant(m, "LOG_LOCAL5", LOG_LOCAL5);
PyModule_AddIntConstant(m, "LOG_LOCAL6", LOG_LOCAL6);
PyModule_AddIntConstant(m, "LOG_LOCAL7", LOG_LOCAL7);
#ifndef LOG_SYSLOG
#define LOG_SYSLOG LOG_DAEMON
#endif
#ifndef LOG_NEWS
#define LOG_NEWS LOG_MAIL
#endif
#ifndef LOG_UUCP
#define LOG_UUCP LOG_MAIL
#endif
#ifndef LOG_CRON
#define LOG_CRON LOG_DAEMON
#endif
PyModule_AddIntConstant(m, "LOG_SYSLOG", LOG_SYSLOG);
PyModule_AddIntConstant(m, "LOG_CRON", LOG_CRON);
PyModule_AddIntConstant(m, "LOG_UUCP", LOG_UUCP);
PyModule_AddIntConstant(m, "LOG_NEWS", LOG_NEWS);
#ifdef LOG_AUTHPRIV
PyModule_AddIntConstant(m, "LOG_AUTHPRIV", LOG_AUTHPRIV);
#endif
return m;
}
int py_init(void)
{
PyObject *PyObj, *PyWmPluginModule;
int i;
Py_InitializeEx(0);
if (!(PyCWiidModule = PyImport_ImportModule("cwiid"))) {
PyErr_Print();
goto ERR_HND;
}
if (!(PySysModule = PyImport_ImportModule("sys"))) {
PyErr_Print();
goto ERR_HND;
}
if (!(PyPath = PyObject_GetAttrString(PySysModule, "path"))) {
PyErr_Print();
goto ERR_HND;
}
if (!(PyObj = PyObject_GetAttrString(PyCWiidModule,
"ConvertMesgArray"))) {
PyErr_Print();
goto ERR_HND;
}
ConvertMesgArray = PyCObject_AsVoidPtr(PyObj);
Py_DECREF(PyObj);
/* note: PyWmPluginModule is a borrowed reference - do not decref */
if (!(PyWmPluginModule = Py_InitModule3("wmplugin", Module_Methods,
"wminput plugin interface"))) {
PyErr_Print();
goto ERR_HND;
}
for (i = 0; wmplugin_constants[i].name; i++) {
if (PyModule_AddIntConstant(PyWmPluginModule,
wmplugin_constants[i].name,
wmplugin_constants[i].value)) {
PyErr_Print();
goto ERR_HND;
}
}
return 0;
ERR_HND:
if (PyCWiidModule) {
Py_DECREF(PyCWiidModule);
PyCWiidModule = NULL;
}
if (PyPath) {
Py_DECREF(PyPath);
PyPath = NULL;
}
if (PySysModule) {
Py_DECREF(PySysModule);
PySysModule = NULL;
}
Py_Finalize();
return -1;
}
PyMODINIT_FUNC
InitPluginModule()
{
// init general xbmc modules
PyObject* pXbmcPluginModule;
pXbmcPluginModule = Py_InitModule((char*)"xbmcplugin", pluginMethods);
if (pXbmcPluginModule == NULL) return;
// constants
PyModule_AddStringConstant(pXbmcPluginModule, (char*)"__author__", (char*)PY_XBMC_AUTHOR);
PyModule_AddStringConstant(pXbmcPluginModule, (char*)"__date__", (char*)"20 August 2007");
PyModule_AddStringConstant(pXbmcPluginModule, (char*)"__version__", (char*)"1.0");
PyModule_AddStringConstant(pXbmcPluginModule, (char*)"__credits__", (char*)PY_XBMC_CREDITS);
PyModule_AddStringConstant(pXbmcPluginModule, (char*)"__platform__", (char*)PY_XBMC_PLATFORM);
// sort method constants
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_NONE", SORT_METHOD_NONE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_LABEL", SORT_METHOD_LABEL);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_LABEL_IGNORE_THE", SORT_METHOD_LABEL_IGNORE_THE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_DATE", SORT_METHOD_DATE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_SIZE", SORT_METHOD_SIZE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_FILE", SORT_METHOD_FILE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_DRIVE_TYPE", SORT_METHOD_DRIVE_TYPE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_TRACKNUM", SORT_METHOD_TRACKNUM);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_DURATION", SORT_METHOD_DURATION);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_TITLE", SORT_METHOD_TITLE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_TITLE_IGNORE_THE", SORT_METHOD_TITLE_IGNORE_THE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_ARTIST", SORT_METHOD_ARTIST);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_ARTIST_IGNORE_THE", SORT_METHOD_ARTIST_IGNORE_THE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_ALBUM", SORT_METHOD_ALBUM);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_ALBUM_IGNORE_THE", SORT_METHOD_ALBUM_IGNORE_THE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_GENRE", SORT_METHOD_GENRE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_VIDEO_YEAR", SORT_METHOD_YEAR);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_VIDEO_RATING", SORT_METHOD_VIDEO_RATING);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_PROGRAM_COUNT", SORT_METHOD_PROGRAM_COUNT);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_PLAYLIST_ORDER", SORT_METHOD_PLAYLIST_ORDER);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_EPISODE", SORT_METHOD_EPISODE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_VIDEO_TITLE", SORT_METHOD_VIDEO_TITLE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_PRODUCTIONCODE", SORT_METHOD_PRODUCTIONCODE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_SONG_RATING", SORT_METHOD_SONG_RATING);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_MPAA_RATING", SORT_METHOD_MPAA_RATING);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_VIDEO_RUNTIME", SORT_METHOD_VIDEO_RUNTIME);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_STUDIO", SORT_METHOD_STUDIO);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_STUDIO_IGNORE_THE", SORT_METHOD_STUDIO_IGNORE_THE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_UNSORTED", SORT_METHOD_UNSORTED);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_BITRATE", SORT_METHOD_BITRATE);
PyModule_AddIntConstant(pXbmcPluginModule, (char*)"SORT_METHOD_LISTENERS", SORT_METHOD_LISTENERS);
}
PyMODINIT_FUNC initaerospike(void)
{
static char version[6] = "1.0.58";
// Makes things "thread-safe"
PyEval_InitThreads();
int i = 0;
// aerospike Module
PyObject * aerospike = Py_InitModule3("aerospike", Aerospike_Methods,
"Aerospike Python Client");
py_global_hosts = PyDict_New();
declare_policy_constants(aerospike);
PyModule_AddStringConstant(aerospike, "__version__", version);
PyObject * exception = AerospikeException_New();
Py_INCREF(exception);
PyModule_AddObject(aerospike, "exception", exception);
PyTypeObject * client = AerospikeClient_Ready();
Py_INCREF(client);
PyModule_AddObject(aerospike, "Client", (PyObject *) client);
PyTypeObject * key = AerospikeKey_Ready();
Py_INCREF(key);
PyModule_AddObject(aerospike, "Key", (PyObject *) key);
PyTypeObject * query = AerospikeQuery_Ready();
Py_INCREF(query);
PyModule_AddObject(aerospike, "Query", (PyObject *) query);
declare_policy_constants(aerospike);
declare_log_constants(aerospike);
PyTypeObject * scan = AerospikeScan_Ready();
Py_INCREF(scan);
PyModule_AddObject(aerospike, "Scan", (PyObject *) scan);
for (i = 0; i <= OPERATOR_CONSTANTS_ARR_SIZE; i++) {
PyModule_AddIntConstant(aerospike,
operator_constants[i].constant_str,
operator_constants[i].constantno);
}
/*
* Add constants to module.
*/
declare_policy_constants(aerospike);
PyObject * predicates = AerospikePredicates_New();
Py_INCREF(predicates);
PyModule_AddObject(aerospike, "predicates", predicates);
PyTypeObject * lstack = AerospikeLStack_Ready();
Py_INCREF(lstack);
PyModule_AddObject(aerospike, "lstack", (PyObject *) lstack);
PyTypeObject * lset = AerospikeLSet_Ready();
Py_INCREF(lset);
PyModule_AddObject(aerospike, "lset", (PyObject *) lset);
PyTypeObject * llist = AerospikeLList_Ready();
Py_INCREF(llist);
PyModule_AddObject(aerospike, "llist", (PyObject *) llist);
PyTypeObject * lmap = AerospikeLMap_Ready();
Py_INCREF(lmap);
PyModule_AddObject(aerospike, "lmap", (PyObject *) lmap);
PyTypeObject * geospatial = AerospikeGeospatial_Ready();
Py_INCREF(geospatial);
PyModule_AddObject(aerospike, "GeoJSON", (PyObject *) geospatial);
PyObject * null_object = AerospikeNullObject_New();
Py_INCREF(null_object);
PyModule_AddObject(aerospike, "null", (PyObject *) null_object);
}
initfract4dc(void)
#endif
{
pymod = Py_InitModule(MODULE_NAME, PfMethods);
#ifdef USE_GMP
mpf_t x;
mpf_init(x);
#endif
/* expose some constants */
PyModule_AddIntConstant(pymod, "CALC_DONE", GF4D_FRACTAL_DONE);
PyModule_AddIntConstant(pymod, "CALC_CALCULATING", GF4D_FRACTAL_CALCULATING);
PyModule_AddIntConstant(pymod, "CALC_DEEPENING", GF4D_FRACTAL_DEEPENING);
PyModule_AddIntConstant(pymod, "CALC_ANTIALIASING", GF4D_FRACTAL_ANTIALIASING);
PyModule_AddIntConstant(pymod, "CALC_PAUSED", GF4D_FRACTAL_PAUSED);
PyModule_AddIntConstant(pymod, "AA_NONE", AA_NONE);
PyModule_AddIntConstant(pymod, "AA_FAST", AA_FAST);
PyModule_AddIntConstant(pymod, "AA_BEST", AA_BEST);
PyModule_AddIntConstant(pymod, "RENDER_TWO_D", RENDER_TWO_D);
PyModule_AddIntConstant(pymod, "RENDER_LANDSCAPE", RENDER_LANDSCAPE);
PyModule_AddIntConstant(pymod, "RENDER_THREE_D", RENDER_THREE_D);
PyModule_AddIntConstant(pymod, "DRAW_GUESSING", DRAW_GUESSING);
PyModule_AddIntConstant(pymod, "DRAW_TO_DISK", DRAW_TO_DISK);
PyModule_AddIntConstant(pymod, "DELTA_X", DELTA_X);
PyModule_AddIntConstant(pymod, "DELTA_Y", DELTA_Y);
PyModule_AddIntConstant(pymod, "TOPLEFT", TOPLEFT);
/* cf image_dims */
PyModule_AddIntConstant(pymod, "IMAGE_WIDTH", 0);
PyModule_AddIntConstant(pymod, "IMAGE_HEIGHT", 1);
PyModule_AddIntConstant(pymod, "IMAGE_TOTAL_WIDTH", 2);
PyModule_AddIntConstant(pymod, "IMAGE_TOTAL_HEIGHT", 3);
PyModule_AddIntConstant(pymod, "IMAGE_XOFFSET", 4);
PyModule_AddIntConstant(pymod, "IMAGE_YOFFSET", 5);
/* image type consts */
PyModule_AddIntConstant(pymod, "FILE_TYPE_TGA", FILE_TYPE_TGA);
PyModule_AddIntConstant(pymod, "FILE_TYPE_PNG", FILE_TYPE_PNG);
PyModule_AddIntConstant(pymod, "FILE_TYPE_JPG", FILE_TYPE_JPG);
}
void initc(void)
{
PyObject *m = Py_InitModule3("c", c_funcs, "C repository types module");
Empty_TUPLE = PyTuple_New(0);
None_PAIR = PyTuple_Pack(2, Py_None, Py_None);
_init_view(m);
_init_repository(m);
_init_container(m);
_init_sequence(m);
_init_db(m);
_init_cursor(m);
_init_env(m);
_init_txn(m);
_init_lock(m);
_init_record(m);
_init_store(m);
PyExc_DBError = PyErr_NewException("chandlerdb.persistence.c.DBError",
NULL, NULL);
PyObject_SetAttrString(m, "DBError", PyExc_DBError);
MAKE_EXC(m, DBLockDeadlockError, DBError);
MAKE_EXC(m, DBLockNotGrantedError, DBError);
MAKE_EXC(m, DBAccessError, DBError);
MAKE_EXC(m, DBBusyError, DBError);
MAKE_EXC(m, DBInvalidArgError, DBError);
MAKE_EXC(m, DBNoSpaceError, DBError);
MAKE_EXC(m, DBNotFoundError, DBError);
MAKE_EXC(m, DBNoSuchFileError, DBError);
MAKE_EXC(m, DBPermissionsError, DBError);
MAKE_EXC(m, DBVersionMismatchError, DBError);
MAKE_EXC(m, DBRunRecoveryError, DBError);
PyModule_AddIntConstant(m, "DB_VERSION_MAJOR", DB_VERSION_MAJOR);
PyModule_AddIntConstant(m, "DB_VERSION_MINOR", DB_VERSION_MINOR);
PyModule_AddIntConstant(m, "DB_VERSION_PATCH", DB_VERSION_PATCH);
if (!(m = PyImport_ImportModule("chandlerdb.util.c")))
return;
LOAD_FN(m, PyUUID_Check);
LOAD_FN(m, PyUUID_Make16);
LOAD_FN(m, _hash_bytes);
LOAD_OBJ(m, Nil);
LOAD_TYPE(m, CtxMgr);
LOAD_TYPE(m, SkipList);
SkipList_Node = (PyTypeObject *)
PyObject_GetAttrString((PyObject *) SkipList, "Node");
Py_DECREF(m);
if (!(m = PyImport_ImportModule("chandlerdb.item.c")))
return;
LOAD_TYPE(m, CItem);
LOAD_TYPE(m, ItemRef);
LOAD_FN(m, CItem_getLocalAttributeValue);
Py_DECREF(m);
if (!(m = PyImport_ImportModule("chandlerdb.schema.c")))
return;
LOAD_FN(m, CAttribute_invokeAfterChange);
Py_DECREF(m);
}
PyMODINIT_FUNC
InitGUIModule(void)
{
// init xbmc gui modules
PyObject* pXbmcGuiModule;
Py_INCREF(&Window_Type);
Py_INCREF(&WindowDialog_Type);
Py_INCREF(&WindowXML_Type);
Py_INCREF(&WindowXMLDialog_Type);
Py_INCREF(&ListItem_Type);
Py_INCREF(&Control_Type);
Py_INCREF(&ControlSpin_Type);
Py_INCREF(&ControlLabel_Type);
Py_INCREF(&ControlFadeLabel_Type);
Py_INCREF(&ControlTextBox_Type);
Py_INCREF(&ControlButton_Type);
Py_INCREF(&ControlCheckMark_Type);
Py_INCREF(&ControlList_Type);
Py_INCREF(&ControlImage_Type);
Py_INCREF(&ControlProgress_Type);
Py_INCREF(&ControlSlider_Type);
Py_INCREF(&ControlGroup_Type);
Py_INCREF(&Dialog_Type);
Py_INCREF(&DialogProgress_Type);
Py_INCREF(&Action_Type);
Py_INCREF(&ControlRadioButton_Type);
pXbmcGuiModule = Py_InitModule3((char*)"xbmcgui", xbmcGuiMethods, xbmcgui_module_documentation);
if (pXbmcGuiModule == NULL) return;
PyModule_AddObject(pXbmcGuiModule, (char*)"Window", (PyObject*)&Window_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"WindowDialog", (PyObject*)&WindowDialog_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"WindowXML", (PyObject*)&WindowXML_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"WindowXMLDialog", (PyObject*)&WindowXMLDialog_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ListItem", (PyObject*)&ListItem_Type);
//PyModule_AddObject(pXbmcGuiModule, (char*)"Control", (PyObject*)&Control_Type);
//PyModule_AddObject(pXbmcGuiModule, (char*)"ControlSpin", (PyObject*)&ControlSpin_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlLabel", (PyObject*)&ControlLabel_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlFadeLabel", (PyObject*)&ControlFadeLabel_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlTextBox", (PyObject*)&ControlTextBox_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlButton", (PyObject*)&ControlButton_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlCheckMark", (PyObject*)&ControlCheckMark_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlList", (PyObject*)&ControlList_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlImage", (PyObject*)& ControlImage_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlProgress", (PyObject*)& ControlProgress_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlSlider", (PyObject*)& ControlSlider_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlGroup", (PyObject*)& ControlGroup_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"Dialog", (PyObject *)&Dialog_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"DialogProgress", (PyObject *)&DialogProgress_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"Action", (PyObject *)&Action_Type);
PyModule_AddObject(pXbmcGuiModule, (char*)"ControlRadioButton", (PyObject*)&ControlRadioButton_Type);
PyModule_AddStringConstant(pXbmcGuiModule, (char*)"__author__", (char*)PY_XBMC_AUTHOR);
PyModule_AddStringConstant(pXbmcGuiModule, (char*)"__date__", (char*)"14 July 2006");
PyModule_AddStringConstant(pXbmcGuiModule, (char*)"__version__", (char*)"1.2");
PyModule_AddStringConstant(pXbmcGuiModule, (char*)"__credits__", (char*)PY_XBMC_CREDITS);
PyModule_AddStringConstant(pXbmcGuiModule, (char*)"__platform__", (char*)PY_XBMC_PLATFORM);
// icon overlay constants
PyModule_AddIntConstant(pXbmcGuiModule, (char*)"ICON_OVERLAY_NONE", CGUIListItem::ICON_OVERLAY_NONE);
PyModule_AddIntConstant(pXbmcGuiModule, (char*)"ICON_OVERLAY_RAR", CGUIListItem::ICON_OVERLAY_RAR);
PyModule_AddIntConstant(pXbmcGuiModule, (char*)"ICON_OVERLAY_ZIP", CGUIListItem::ICON_OVERLAY_ZIP);
PyModule_AddIntConstant(pXbmcGuiModule, (char*)"ICON_OVERLAY_LOCKED", CGUIListItem::ICON_OVERLAY_LOCKED);
PyModule_AddIntConstant(pXbmcGuiModule, (char*)"ICON_OVERLAY_HAS_TRAINER", CGUIListItem::ICON_OVERLAY_HAS_TRAINER);
PyModule_AddIntConstant(pXbmcGuiModule, (char*)"ICON_OVERLAY_TRAINED", CGUIListItem::ICON_OVERLAY_TRAINED);
PyModule_AddIntConstant(pXbmcGuiModule, (char*)"ICON_OVERLAY_UNWATCHED", CGUIListItem::ICON_OVERLAY_UNWATCHED);
PyModule_AddIntConstant(pXbmcGuiModule, (char*)"ICON_OVERLAY_WATCHED", CGUIListItem::ICON_OVERLAY_WATCHED);
PyModule_AddIntConstant(pXbmcGuiModule, (char*)"ICON_OVERLAY_HD", CGUIListItem::ICON_OVERLAY_HD);
}
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);
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 */
}
static void
inittimezone(PyObject *m) {
/* This code moved from inittime wholesale to allow calling it from
time_tzset. In the future, some parts of it can be moved back
(for platforms that don't HAVE_WORKING_TZSET, when we know what they
are), and the extraneous calls to tzset(3) should be removed.
I haven't done this yet, as I don't want to change this code as
little as possible when introducing the time.tzset and time.tzsetwall
methods. This should simply be a method of doing the following once,
at the top of this function and removing the call to tzset() from
time_tzset():
#ifdef HAVE_TZSET
tzset()
#endif
And I'm lazy and hate C so nyer.
*/
#if defined(HAVE_TZNAME) && !defined(__GLIBC__) && !defined(__CYGWIN__)
tzset();
#ifdef PYOS_OS2
PyModule_AddIntConstant(m, "timezone", _timezone);
#else /* !PYOS_OS2 */
PyModule_AddIntConstant(m, "timezone", timezone);
#endif /* PYOS_OS2 */
#ifdef HAVE_ALTZONE
PyModule_AddIntConstant(m, "altzone", altzone);
#else
#ifdef PYOS_OS2
PyModule_AddIntConstant(m, "altzone", _timezone-3600);
#else /* !PYOS_OS2 */
PyModule_AddIntConstant(m, "altzone", timezone-3600);
#endif /* PYOS_OS2 */
#endif
PyModule_AddIntConstant(m, "daylight", daylight);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)", tzname[0], tzname[1]));
#else /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
#ifdef HAVE_STRUCT_TM_TM_ZONE
{
#define YEAR ((time_t)((365 * 24 + 6) * 3600))
time_t t;
struct tm *p;
long janzone, julyzone;
char janname[10], julyname[10];
t = (time((time_t *)0) / YEAR) * YEAR;
p = localtime(&t);
janzone = -p->tm_gmtoff;
strncpy(janname, p->tm_zone ? p->tm_zone : " ", 9);
janname[9] = '\0';
t += YEAR/2;
p = localtime(&t);
julyzone = -p->tm_gmtoff;
strncpy(julyname, p->tm_zone ? p->tm_zone : " ", 9);
julyname[9] = '\0';
if( janzone < julyzone ) {
/* DST is reversed in the southern hemisphere */
PyModule_AddIntConstant(m, "timezone", julyzone);
PyModule_AddIntConstant(m, "altzone", janzone);
PyModule_AddIntConstant(m, "daylight",
janzone != julyzone);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)",
julyname, janname));
} else {
PyModule_AddIntConstant(m, "timezone", janzone);
PyModule_AddIntConstant(m, "altzone", julyzone);
PyModule_AddIntConstant(m, "daylight",
janzone != julyzone);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)",
janname, julyname));
}
}
#else
#endif /* HAVE_STRUCT_TM_TM_ZONE */
#ifdef __CYGWIN__
tzset();
PyModule_AddIntConstant(m, "timezone", _timezone);
PyModule_AddIntConstant(m, "altzone", _timezone-3600);
PyModule_AddIntConstant(m, "daylight", _daylight);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)", _tzname[0], _tzname[1]));
#endif /* __CYGWIN__ */
#endif /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
}
static void
add_misc_enums(PyObject *m)
{
PyModule_AddIntConstant(m, "PARASITE_PERSISTENT",
GIMP_PARASITE_PERSISTENT);
PyModule_AddIntConstant(m, "PARASITE_UNDOABLE",
GIMP_PARASITE_UNDOABLE);
PyModule_AddIntConstant(m, "PARASITE_ATTACH_PARENT",
GIMP_PARASITE_ATTACH_PARENT);
PyModule_AddIntConstant(m, "PARASITE_PARENT_PERSISTENT",
GIMP_PARASITE_PARENT_PERSISTENT);
PyModule_AddIntConstant(m, "PARASITE_PARENT_UNDOABLE",
GIMP_PARASITE_PARENT_UNDOABLE);
PyModule_AddIntConstant(m, "PARASITE_ATTACH_GRANDPARENT",
GIMP_PARASITE_ATTACH_GRANDPARENT);
PyModule_AddIntConstant(m, "PARASITE_GRANDPARENT_PERSISTENT",
GIMP_PARASITE_GRANDPARENT_PERSISTENT);
PyModule_AddIntConstant(m, "PARASITE_GRANDPARENT_UNDOABLE",
GIMP_PARASITE_GRANDPARENT_UNDOABLE);
PyModule_AddIntConstant(m, "UNIT_PIXEL",
GIMP_UNIT_PIXEL);
PyModule_AddIntConstant(m, "UNIT_INCH",
GIMP_UNIT_INCH);
PyModule_AddIntConstant(m, "UNIT_MM",
GIMP_UNIT_MM);
PyModule_AddIntConstant(m, "UNIT_POINT",
GIMP_UNIT_POINT);
PyModule_AddIntConstant(m, "UNIT_PICA",
GIMP_UNIT_PICA);
PyModule_AddIntConstant(m, "MIN_IMAGE_SIZE",
GIMP_MIN_IMAGE_SIZE);
PyModule_AddIntConstant(m, "MAX_IMAGE_SIZE",
GIMP_MAX_IMAGE_SIZE);
PyModule_AddObject(m, "MIN_RESOLUTION",
PyFloat_FromDouble(GIMP_MIN_RESOLUTION));
PyModule_AddObject(m, "MAX_RESOLUTION",
PyFloat_FromDouble(GIMP_MAX_RESOLUTION));
PyModule_AddObject(m, "MAX_MEMSIZE",
PyLong_FromUnsignedLongLong(GIMP_MAX_MEMSIZE));
PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_NONE",
GIMP_PIXEL_FETCHER_EDGE_NONE);
PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_WRAP",
GIMP_PIXEL_FETCHER_EDGE_WRAP);
PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_SMEAR",
GIMP_PIXEL_FETCHER_EDGE_SMEAR);
PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_BLACK",
GIMP_PIXEL_FETCHER_EDGE_BLACK);
PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_BACKGROUND",
GIMP_PIXEL_FETCHER_EDGE_BACKGROUND);
}
//-------------------------------------------------------------------------------------
bool PythonApp::installPyModules()
{
// 安装入口模块
PyObject *entryScriptFileName = NULL;
if(componentType() == BASEAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getBaseApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if(componentType() == CELLAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getCellApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if(componentType() == INTERFACES_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getInterfaces();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if (componentType() == LOGINAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getLoginApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if (componentType() == DBMGR_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getDBMgr();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else
{
ERROR_MSG("PythonApp::installPyModules: entryScriptFileName is NULL!\n");
}
// 注册创建entity的方法到py
// 向脚本注册app发布状态
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), publish, __py_getAppPublish, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), scriptLogType, __py_setScriptLogType, METH_VARARGS, 0);
// 获得资源全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getResFullPath, __py_getResFullPath, METH_VARARGS, 0);
// 是否存在某个资源
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), hasRes, __py_hasRes, METH_VARARGS, 0);
// 打开一个文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), open, __py_kbeOpen, METH_VARARGS, 0);
// 列出目录下所有文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), listPathRes, __py_listPathRes, METH_VARARGS, 0);
// 匹配相对路径获得全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), matchPath, __py_matchPath, METH_VARARGS, 0);
// debug追踪kbe封装的py对象计数
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), debugTracing, script::PyGC::__py_debugTracing, METH_VARARGS, 0);
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "NEXT_ONLY", KBE_NEXT_ONLY))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.NEXT_ONLY.\n");
}
onInstallPyModules();
if (entryScriptFileName != NULL)
{
entryScript_ = PyImport_Import(entryScriptFileName);
SCRIPT_ERROR_CHECK();
S_RELEASE(entryScriptFileName);
if(entryScript_.get() == NULL)
{
return false;
}
}
return true;
}
PyMODINIT_FUNC initumath(void)
#endif
{
PyObject *m, *d, *s, *s2, *c_api;
int UFUNC_FLOATING_POINT_SUPPORT = 1;
#ifdef NO_UFUNC_FLOATING_POINT_SUPPORT
UFUNC_FLOATING_POINT_SUPPORT = 0;
#endif
/* Create the module and add the functions */
#if defined(NPY_PY3K)
m = PyModule_Create(&moduledef);
#else
m = Py_InitModule("umath", methods);
#endif
if (!m) {
goto err;
}
/* Import the array */
if (_import_array() < 0) {
if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_ImportError,
"umath failed: Could not import array core.");
}
goto err;
}
/* Initialize the types */
if (PyType_Ready(&PyUFunc_Type) < 0)
goto err;
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
c_api = NpyCapsule_FromVoidPtr((void *)PyUFunc_API, NULL);
if (PyErr_Occurred()) {
goto err;
}
PyDict_SetItemString(d, "_UFUNC_API", c_api);
Py_DECREF(c_api);
if (PyErr_Occurred()) {
goto err;
}
/* Load the ufunc operators into the array module's namespace */
if (InitOperators(d) < 0) {
goto err;
}
PyDict_SetItemString(d, "pi", s = PyFloat_FromDouble(NPY_PI));
Py_DECREF(s);
PyDict_SetItemString(d, "e", s = PyFloat_FromDouble(NPY_E));
Py_DECREF(s);
PyDict_SetItemString(d, "euler_gamma", s = PyFloat_FromDouble(NPY_EULER));
Py_DECREF(s);
#define ADDCONST(str) PyModule_AddIntConstant(m, #str, UFUNC_##str)
#define ADDSCONST(str) PyModule_AddStringConstant(m, "UFUNC_" #str, UFUNC_##str)
ADDCONST(ERR_IGNORE);
ADDCONST(ERR_WARN);
ADDCONST(ERR_CALL);
ADDCONST(ERR_RAISE);
ADDCONST(ERR_PRINT);
ADDCONST(ERR_LOG);
ADDCONST(ERR_DEFAULT);
ADDCONST(SHIFT_DIVIDEBYZERO);
ADDCONST(SHIFT_OVERFLOW);
ADDCONST(SHIFT_UNDERFLOW);
ADDCONST(SHIFT_INVALID);
ADDCONST(FPE_DIVIDEBYZERO);
ADDCONST(FPE_OVERFLOW);
ADDCONST(FPE_UNDERFLOW);
ADDCONST(FPE_INVALID);
ADDCONST(FLOATING_POINT_SUPPORT);
ADDSCONST(PYVALS_NAME);
#undef ADDCONST
#undef ADDSCONST
PyModule_AddIntConstant(m, "UFUNC_BUFSIZE_DEFAULT", (long)NPY_BUFSIZE);
PyModule_AddObject(m, "PINF", PyFloat_FromDouble(NPY_INFINITY));
PyModule_AddObject(m, "NINF", PyFloat_FromDouble(-NPY_INFINITY));
PyModule_AddObject(m, "PZERO", PyFloat_FromDouble(NPY_PZERO));
PyModule_AddObject(m, "NZERO", PyFloat_FromDouble(NPY_NZERO));
PyModule_AddObject(m, "NAN", PyFloat_FromDouble(NPY_NAN));
#if defined(NPY_PY3K)
s = PyDict_GetItemString(d, "true_divide");
PyDict_SetItemString(d, "divide", s);
#endif
s = PyDict_GetItemString(d, "conjugate");
s2 = PyDict_GetItemString(d, "remainder");
/* Setup the array object's numerical structures with appropriate
ufuncs in d*/
PyArray_SetNumericOps(d);
PyDict_SetItemString(d, "conj", s);
PyDict_SetItemString(d, "mod", s2);
initscalarmath(m);
if (!intern_strings()) {
goto err;
}
return RETVAL(m);
err:
/* Check for errors */
if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_RuntimeError,
"cannot load umath module.");
}
return RETVAL(NULL);
}
PyMODINIT_FUNC
initresource(void)
{
PyObject *m, *v;
/* Create the module and add the functions */
m = Py_InitModule("resource", resource_methods);
if (m == NULL)
return;
/* Add some symbolic constants to the module */
if (ResourceError == NULL) {
ResourceError = PyErr_NewException("resource.error",
NULL, NULL);
}
Py_INCREF(ResourceError);
PyModule_AddObject(m, "error", ResourceError);
PyStructSequence_InitType(&StructRUsageType, &struct_rusage_desc);
PyModule_AddObject(m, "struct_rusage",
(PyObject*) &StructRUsageType);
/* insert constants */
#ifdef RLIMIT_CPU
PyModule_AddIntConstant(m, "RLIMIT_CPU", RLIMIT_CPU);
#endif
#ifdef RLIMIT_FSIZE
PyModule_AddIntConstant(m, "RLIMIT_FSIZE", RLIMIT_FSIZE);
#endif
#ifdef RLIMIT_DATA
PyModule_AddIntConstant(m, "RLIMIT_DATA", RLIMIT_DATA);
#endif
#ifdef RLIMIT_STACK
PyModule_AddIntConstant(m, "RLIMIT_STACK", RLIMIT_STACK);
#endif
#ifdef RLIMIT_CORE
PyModule_AddIntConstant(m, "RLIMIT_CORE", RLIMIT_CORE);
#endif
#ifdef RLIMIT_NOFILE
PyModule_AddIntConstant(m, "RLIMIT_NOFILE", RLIMIT_NOFILE);
#endif
#ifdef RLIMIT_OFILE
PyModule_AddIntConstant(m, "RLIMIT_OFILE", RLIMIT_OFILE);
#endif
#ifdef RLIMIT_VMEM
PyModule_AddIntConstant(m, "RLIMIT_VMEM", RLIMIT_VMEM);
#endif
#ifdef RLIMIT_AS
PyModule_AddIntConstant(m, "RLIMIT_AS", RLIMIT_AS);
#endif
#ifdef RLIMIT_RSS
PyModule_AddIntConstant(m, "RLIMIT_RSS", RLIMIT_RSS);
#endif
#ifdef RLIMIT_NPROC
PyModule_AddIntConstant(m, "RLIMIT_NPROC", RLIMIT_NPROC);
#endif
#ifdef RLIMIT_MEMLOCK
PyModule_AddIntConstant(m, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK);
#endif
#ifdef RUSAGE_SELF
PyModule_AddIntConstant(m, "RUSAGE_SELF", RUSAGE_SELF);
#endif
#ifdef RUSAGE_CHILDREN
PyModule_AddIntConstant(m, "RUSAGE_CHILDREN", RUSAGE_CHILDREN);
#endif
#ifdef RUSAGE_BOTH
PyModule_AddIntConstant(m, "RUSAGE_BOTH", RUSAGE_BOTH);
#endif
#if defined(HAVE_LONG_LONG)
if (sizeof(RLIM_INFINITY) > sizeof(long)) {
v = PyLong_FromLongLong((PY_LONG_LONG) RLIM_INFINITY);
} else
#endif
{
v = PyInt_FromLong((long) RLIM_INFINITY);
}
if (v) {
PyModule_AddObject(m, "RLIM_INFINITY", v);
}
}
PyMODINIT_FUNC
init_locale(void)
{
PyObject *m, *d, *x;
#ifdef HAVE_LANGINFO_H
int i;
#endif
m = Py_InitModule("_locale", PyLocale_Methods);
if (m == NULL)
return;
d = PyModule_GetDict(m);
x = PyInt_FromLong(LC_CTYPE);
PyDict_SetItemString(d, "LC_CTYPE", x);
Py_XDECREF(x);
x = PyInt_FromLong(LC_TIME);
PyDict_SetItemString(d, "LC_TIME", x);
Py_XDECREF(x);
x = PyInt_FromLong(LC_COLLATE);
PyDict_SetItemString(d, "LC_COLLATE", x);
Py_XDECREF(x);
x = PyInt_FromLong(LC_MONETARY);
PyDict_SetItemString(d, "LC_MONETARY", x);
Py_XDECREF(x);
#ifdef LC_MESSAGES
x = PyInt_FromLong(LC_MESSAGES);
PyDict_SetItemString(d, "LC_MESSAGES", x);
Py_XDECREF(x);
#endif /* LC_MESSAGES */
x = PyInt_FromLong(LC_NUMERIC);
PyDict_SetItemString(d, "LC_NUMERIC", x);
Py_XDECREF(x);
x = PyInt_FromLong(LC_ALL);
PyDict_SetItemString(d, "LC_ALL", x);
Py_XDECREF(x);
x = PyInt_FromLong(CHAR_MAX);
PyDict_SetItemString(d, "CHAR_MAX", x);
Py_XDECREF(x);
Error = PyErr_NewException("locale.Error", NULL, NULL);
PyDict_SetItemString(d, "Error", Error);
x = PyString_FromString(locale__doc__);
PyDict_SetItemString(d, "__doc__", x);
Py_XDECREF(x);
#ifdef HAVE_LANGINFO_H
for (i = 0; langinfo_constants[i].name; i++) {
PyModule_AddIntConstant(m, langinfo_constants[i].name,
langinfo_constants[i].value);
}
#endif
}
static void
add_constants (PyObject* m) {
PyModule_AddIntConstant(m, "DO_NOT_STRIP", ctemplate::DO_NOT_STRIP);
PyModule_AddIntConstant(m, "STRIP_BLANK_LINES", ctemplate::STRIP_BLANK_LINES);
PyModule_AddIntConstant(m, "STRIP_WHITESPACE", ctemplate::STRIP_WHITESPACE);
PyModule_AddIntConstant(m, "TS_EMPTY", ctemplate::TS_EMPTY);
PyModule_AddIntConstant(m, "TS_ERROR", ctemplate::TS_ERROR);
PyModule_AddIntConstant(m, "TS_READY", ctemplate::TS_READY);
// PyModule_AddIntConstant(m, "TS_SHOULD_RELOAD", ctemplate::TS_SHOULD_RELOAD);
PyModule_AddIntConstant(m, "TC_HTML", ctemplate::TC_HTML);
PyModule_AddIntConstant(m, "TC_JS", ctemplate::TC_JS);
PyModule_AddIntConstant(m, "TC_CSS", ctemplate::TC_CSS);
PyModule_AddIntConstant(m, "TC_JSON", ctemplate::TC_JSON);
PyModule_AddIntConstant(m, "TC_XML", ctemplate::TC_XML);
PyModule_AddIntConstant(m, "TC_MANUAL", ctemplate::TC_MANUAL);
}
bool EntityApp<E>::installPyModules()
{
Entities<E>::installScript(NULL);
//Entity::installScript(g_script.getModule());
pEntities_ = new Entities<E>();
registerPyObjectToScript("entities", pEntities_);
// 安装入口模块
PyObject *entryScriptFileName = NULL;
if(componentType() == BASEAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getBaseApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if(componentType() == CELLAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getCellApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
// 添加pywatcher支持
if(!initializePyWatcher(&this->getScript()))
return false;
// 添加globalData, globalBases支持
pGlobalData_ = new GlobalDataClient(DBMGR_TYPE, GlobalDataServer::GLOBAL_DATA);
registerPyObjectToScript("globalData", pGlobalData_);
// 注册创建entity的方法到py
// 向脚本注册app发布状态
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), publish, __py_getAppPublish, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), scriptLogType, __py_setScriptLogType, METH_VARARGS, 0);
// 获得资源全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getResFullPath, __py_getResFullPath, METH_VARARGS, 0);
// 是否存在某个资源
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), hasRes, __py_hasRes, METH_VARARGS, 0);
// 打开一个文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), open, __py_kbeOpen, METH_VARARGS, 0);
// 列出目录下所有文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), listPathRes, __py_listPathRes, METH_VARARGS, 0);
// 匹配相对路径获得全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), matchPath, __py_matchPath, METH_VARARGS, 0);
// 获取watcher值
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getWatcher, __py_getWatcher, METH_VARARGS, 0);
// 获取watcher目录
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getWatcherDir, __py_getWatcherDir, METH_VARARGS, 0);
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "NEXT_ONLY", KBE_NEXT_ONLY))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.NEXT_ONLY.\n");
}
if(entryScriptFileName != NULL)
{
entryScript_ = PyImport_Import(entryScriptFileName);
SCRIPT_ERROR_CHECK();
S_RELEASE(entryScriptFileName);
if(entryScript_.get() == NULL)
{
return false;
}
}
onInstallPyModules();
return true;
}
PyMODINIT_FUNC
InitXBMCModule()
{
// init general xbmc modules
PyObject* pXbmcModule;
Py_INCREF(&Keyboard_Type);
Py_INCREF(&Player_Type);
Py_INCREF(&PlayList_Type);
Py_INCREF(&PlayListItem_Type);
Py_INCREF(&InfoTagMusic_Type);
Py_INCREF(&InfoTagVideo_Type);
pXbmcModule = Py_InitModule("xbmc", xbmcMethods);
if (pXbmcModule == NULL) return;
PyModule_AddObject(pXbmcModule, "Keyboard", (PyObject*)&Keyboard_Type);
PyModule_AddObject(pXbmcModule, "Player", (PyObject*)&Player_Type);
PyModule_AddObject(pXbmcModule, "PlayList", (PyObject*)&PlayList_Type);
PyModule_AddObject(pXbmcModule, "PlayListItem", (PyObject*)&PlayListItem_Type);
PyModule_AddObject(pXbmcModule, "InfoTagMusic", (PyObject*)&InfoTagMusic_Type);
PyModule_AddObject(pXbmcModule, "InfoTagVideo", (PyObject*)&InfoTagVideo_Type);
// constants
PyModule_AddStringConstant(pXbmcModule, "__author__", PY_XBMC_AUTHOR);
PyModule_AddStringConstant(pXbmcModule, "__date__", "15 November 2005");
PyModule_AddStringConstant(pXbmcModule, "__version__", "1.3");
PyModule_AddStringConstant(pXbmcModule, "__credits__", PY_XBMC_CREDITS);
PyModule_AddStringConstant(pXbmcModule, "__platform__", PY_XBMC_PLATFORM);
// playlist constants
PyModule_AddIntConstant(pXbmcModule, "PLAYLIST_MUSIC", PLAYLIST_MUSIC);
//PyModule_AddIntConstant(pXbmcModule, "PLAYLIST_MUSIC_TEMP", PLAYLIST_MUSIC_TEMP);
PyModule_AddIntConstant(pXbmcModule, "PLAYLIST_VIDEO", PLAYLIST_VIDEO);
//PyModule_AddIntConstant(pXbmcModule, "PLAYLIST_VIDEO_TEMP", PLAYLIST_VIDEO_TEMP);
// player constants
PyModule_AddIntConstant(pXbmcModule, "PLAYER_CORE_AUTO", EPC_NONE);
PyModule_AddIntConstant(pXbmcModule, "PLAYER_CORE_DVDPLAYER", EPC_DVDPLAYER);
PyModule_AddIntConstant(pXbmcModule, "PLAYER_CORE_MPLAYER", EPC_MPLAYER);
PyModule_AddIntConstant(pXbmcModule, "PLAYER_CORE_PAPLAYER", EPC_PAPLAYER);
PyModule_AddIntConstant(pXbmcModule, "PLAYER_CORE_MODPLAYER", EPC_MODPLAYER);
// dvd state constants
PyModule_AddIntConstant(pXbmcModule, "TRAY_OPEN", TRAY_OPEN);
PyModule_AddIntConstant(pXbmcModule, "DRIVE_NOT_READY", DRIVE_NOT_READY);
PyModule_AddIntConstant(pXbmcModule, "TRAY_CLOSED_NO_MEDIA", TRAY_CLOSED_NO_MEDIA);
PyModule_AddIntConstant(pXbmcModule, "TRAY_CLOSED_MEDIA_PRESENT", TRAY_CLOSED_MEDIA_PRESENT);
}
PyMODINIT_FUNC
init_symtable(void)
{
PyObject *m;
m = Py_InitModule("_symtable", symtable_methods);
if (m == NULL)
return;
PyModule_AddIntConstant(m, "USE", USE);
PyModule_AddIntConstant(m, "DEF_GLOBAL", DEF_GLOBAL);
PyModule_AddIntConstant(m, "DEF_LOCAL", DEF_LOCAL);
PyModule_AddIntConstant(m, "DEF_PARAM", DEF_PARAM);
PyModule_AddIntConstant(m, "DEF_STAR", DEF_STAR);
PyModule_AddIntConstant(m, "DEF_DOUBLESTAR", DEF_DOUBLESTAR);
PyModule_AddIntConstant(m, "DEF_INTUPLE", DEF_INTUPLE);
PyModule_AddIntConstant(m, "DEF_FREE", DEF_FREE);
PyModule_AddIntConstant(m, "DEF_FREE_GLOBAL", DEF_FREE_GLOBAL);
PyModule_AddIntConstant(m, "DEF_FREE_CLASS", DEF_FREE_CLASS);
PyModule_AddIntConstant(m, "DEF_IMPORT", DEF_IMPORT);
PyModule_AddIntConstant(m, "DEF_BOUND", DEF_BOUND);
PyModule_AddIntConstant(m, "TYPE_FUNCTION", FunctionBlock);
PyModule_AddIntConstant(m, "TYPE_CLASS", ClassBlock);
PyModule_AddIntConstant(m, "TYPE_MODULE", ModuleBlock);
PyModule_AddIntConstant(m, "OPT_IMPORT_STAR", OPT_IMPORT_STAR);
PyModule_AddIntConstant(m, "OPT_EXEC", OPT_EXEC);
PyModule_AddIntConstant(m, "OPT_BARE_EXEC", OPT_BARE_EXEC);
PyModule_AddIntConstant(m, "LOCAL", LOCAL);
PyModule_AddIntConstant(m, "GLOBAL_EXPLICIT", GLOBAL_EXPLICIT);
PyModule_AddIntConstant(m, "GLOBAL_IMPLICIT", GLOBAL_IMPLICIT);
PyModule_AddIntConstant(m, "FREE", FREE);
PyModule_AddIntConstant(m, "CELL", CELL);
}
PyMODINIT_FUNC
initwinutil(void) {
PyObject *m;
m = Py_InitModule3("winutil", WinutilMethods,
"Defines utility methods to interface with windows."
);
if (m == NULL) return;
DriveError = PyErr_NewException("winutil.DriveError", NULL, NULL);
PyModule_AddIntConstant(m, "CSIDL_ADMINTOOLS", CSIDL_ADMINTOOLS);
PyModule_AddIntConstant(m, "CSIDL_APPDATA", CSIDL_APPDATA);
PyModule_AddIntConstant(m, "CSIDL_COMMON_ADMINTOOLS", CSIDL_COMMON_ADMINTOOLS);
PyModule_AddIntConstant(m, "CSIDL_COMMON_APPDATA", CSIDL_COMMON_APPDATA);
PyModule_AddIntConstant(m, "CSIDL_COMMON_DOCUMENTS", CSIDL_COMMON_DOCUMENTS);
PyModule_AddIntConstant(m, "CSIDL_COOKIES", CSIDL_COOKIES);
PyModule_AddIntConstant(m, "CSIDL_FLAG_CREATE", CSIDL_FLAG_CREATE);
PyModule_AddIntConstant(m, "CSIDL_FLAG_DONT_VERIFY", CSIDL_FLAG_DONT_VERIFY);
PyModule_AddIntConstant(m, "CSIDL_FONTS", CSIDL_FONTS);
PyModule_AddIntConstant(m, "CSIDL_HISTORY", CSIDL_HISTORY);
PyModule_AddIntConstant(m, "CSIDL_INTERNET_CACHE", CSIDL_INTERNET_CACHE);
PyModule_AddIntConstant(m, "CSIDL_LOCAL_APPDATA", CSIDL_LOCAL_APPDATA);
PyModule_AddIntConstant(m, "CSIDL_MYPICTURES", CSIDL_MYPICTURES);
PyModule_AddIntConstant(m, "CSIDL_PERSONAL", CSIDL_PERSONAL);
PyModule_AddIntConstant(m, "CSIDL_PROGRAM_FILES", CSIDL_PROGRAM_FILES);
PyModule_AddIntConstant(m, "CSIDL_PROGRAM_FILES_COMMON", CSIDL_PROGRAM_FILES_COMMON);
PyModule_AddIntConstant(m, "CSIDL_SYSTEM", CSIDL_SYSTEM);
PyModule_AddIntConstant(m, "CSIDL_WINDOWS", CSIDL_WINDOWS);
}
