Пример #1
0
PyMODINIT_FUNC init_journal(void) {
        PyObject *m;

        m = Py_InitModule("_journal", methods);
        if (m == NULL)
                return;

        PyModule_AddStringConstant(m, "__version__", PACKAGE_VERSION);
}
Пример #2
0
/* PYTHON MODULE EXPORTS */
_DLLEXPORT_ void initdistorm()
{
	PyObject* distormModule = Py_InitModule3("distorm", distormModulebMethods, ":[diStorm64}:");
	PyModule_AddIntConstant(distormModule, "Decode16Bits", Decode16Bits);
	PyModule_AddIntConstant(distormModule, "Decode32Bits", Decode32Bits);
	PyModule_AddIntConstant(distormModule, "Decode64Bits", Decode64Bits);
	PyModule_AddIntConstant(distormModule, "OffsetTypeSize", sizeof(_OffsetType) * 8);
	PyModule_AddStringConstant(distormModule, "info", ":[diStorm64 1.7.30}:\r\nCopyright RageStorm (C) 2008, Gil Dabah \r\n\r\ndiStorm is licensed under the BSD license.\r\nhttp://ragestorm.net/distorm/\r\n");
}
Пример #3
0
PyMODINIT_FUNC
PyInit__csv(void)
{
    PyObject *module;
    const StyleDesc *style;

    if (PyType_Ready(&Dialect_Type) < 0)
        return NULL;

    if (PyType_Ready(&Reader_Type) < 0)
        return NULL;

    if (PyType_Ready(&Writer_Type) < 0)
        return NULL;

    /* Create the module and add the functions */
    module = PyModule_Create(&_csvmodule);
    if (module == NULL)
        return NULL;

    /* Add version to the module. */
    if (PyModule_AddStringConstant(module, "__version__",
                                   MODULE_VERSION) == -1)
        return NULL;

    /* Set the field limit */
    _csvstate(module)->field_limit = 128 * 1024;
    /* Do I still need to add this var to the Module Dict? */

    /* Add _dialects dictionary */
    _csvstate(module)->dialects = PyDict_New();
    if (_csvstate(module)->dialects == NULL)
        return NULL;
    Py_INCREF(_csvstate(module)->dialects);
    if (PyModule_AddObject(module, "_dialects", _csvstate(module)->dialects))
        return NULL;

    /* Add quote styles into dictionary */
    for (style = quote_styles; style->name; style++) {
        if (PyModule_AddIntConstant(module, style->name,
                                    style->style) == -1)
            return NULL;
    }

    /* Add the Dialect type */
    Py_INCREF(&Dialect_Type);
    if (PyModule_AddObject(module, "Dialect", (PyObject *)&Dialect_Type))
        return NULL;

    /* Add the CSV exception object to the module. */
    _csvstate(module)->error_obj = PyErr_NewException("_csv.Error", NULL, NULL);
    if (_csvstate(module)->error_obj == NULL)
        return NULL;
    Py_INCREF(_csvstate(module)->error_obj);
    PyModule_AddObject(module, "Error", _csvstate(module)->error_obj);
    return module;
}
Пример #4
0
PyMODINIT_FUNC
init_nk20(void) 
{
	PyObject* m;
	import_array();	
	import_pyk_k20();
	m = Py_InitModule3("_nk20", funcs, doc);	
	PyModule_AddStringConstant(m, "__version__", __version__);
}
Пример #5
0
// Initialization
void initpydeep(void)
{
    PyObject *pydeep;
    pydeep = Py_InitModule3("pydeep", pydeepMethods, "C/Python bindings for ssdeep [ssdeep.sourceforge.net]");
    pydeepError = PyErr_NewException("pydeep.Error", NULL, NULL);
    Py_INCREF(pydeepError);
    PyModule_AddObject(pydeep, "error", pydeepError);
    PyModule_AddStringConstant(pydeep, "__version__", PYDEEP_VERSION);
}
Пример #6
0
PyObject *
_PyImport_LoadDynamicModule(char *name, char *pathname, FILE *fp)
{
	PyObject *m;
	char *lastdot, *shortname, *packagecontext, *oldcontext;
	dl_funcptr p;

	if ((m = _PyImport_FindExtension(name, pathname)) != NULL) {
		Py_INCREF(m);
		return m;
	}
	lastdot = strrchr(name, '.');
	if (lastdot == NULL) {
		packagecontext = NULL;
		shortname = name;
	}
	else {
		packagecontext = name;
		shortname = lastdot+1;
	}

	p = _PyImport_GetDynLoadFunc(name, shortname, pathname, fp);
	if (PyErr_Occurred())
		return NULL;
	if (p == NULL) {
		PyErr_Format(PyExc_ImportError,
		   "dynamic module does not define init function (init%.200s)",
			     shortname);
		return NULL;
	}
        oldcontext = _Py_PackageContext;
	_Py_PackageContext = packagecontext;
	(*p)();
	_Py_PackageContext = oldcontext;
	if (PyErr_Occurred())
		return NULL;

	m = PyDict_GetItemString(PyImport_GetModuleDict(), name);
	if (m == NULL) {
		PyErr_SetString(PyExc_SystemError,
				"dynamic module not initialized properly");
		return NULL;
	}
	/* Remember the filename as the __file__ attribute */
	if (PyModule_AddStringConstant(m, "__file__", pathname) < 0)
		PyErr_Clear(); /* Not important enough to report */

	if (_PyImport_FixupExtension(name, pathname) == NULL)
		return NULL;
	if (Py_VerboseFlag)
		PySys_WriteStderr(
			"import %s # dynamically loaded from %s\n",
			name, pathname);
	Py_INCREF(m);
	return m;
}
Пример #7
0
Файл: cqsl.c Проект: fabioz/coev
PyMODINIT_FUNC
initcqsl(void) {
    PyObject *m;
    
    m = Py_InitModule3("cqsl", cqsl_methods, cqsl_doc);
    if (m == NULL)
	return;
    
    PyModule_AddStringConstant(m, "__version__", "1.0");
}
Пример #8
0
PyMODINIT_FUNC init_daemon(void) {
        PyObject *m;

        m = Py_InitModule3("_daemon", methods, module__doc__);
        if (m == NULL)
                return;

        PyModule_AddIntConstant(m, "LISTEN_FDS_START", SD_LISTEN_FDS_START);
        PyModule_AddStringConstant(m, "__version__", PACKAGE_VERSION);
}
Пример #9
0
  PyMODINIT_FUNC
  InitAddonModule(void)
  {
    Py_INCREF(&Addon_Type);

    // init general xbmcaddon modules
    PyObject* pXbmcAddonModule;
    pXbmcAddonModule = Py_InitModule((char*)"xbmcaddon", xbmcAddonMethods);
    if (pXbmcAddonModule == NULL) return;

    PyModule_AddObject(pXbmcAddonModule, (char*)"Addon", (PyObject*)&Addon_Type);

    // constants
    PyModule_AddStringConstant(pXbmcAddonModule, (char*)"__author__", (char*)PY_XBMC_AUTHOR);
    PyModule_AddStringConstant(pXbmcAddonModule, (char*)"__date__", (char*)"1 May 2010");
    PyModule_AddStringConstant(pXbmcAddonModule, (char*)"__version__", (char*)"1.0");
    PyModule_AddStringConstant(pXbmcAddonModule, (char*)"__credits__", (char*)PY_XBMC_CREDITS);
    PyModule_AddStringConstant(pXbmcAddonModule, (char*)"__platform__", (char*)PY_XBMC_PLATFORM);
  }
Пример #10
0
PyMODINIT_FUNC
init_csv(void)
{
    PyObject *module;
    StyleDesc *style;

    if (PyType_Ready(&Dialect_Type) < 0)
        return;

    if (PyType_Ready(&Reader_Type) < 0)
        return;

    if (PyType_Ready(&Writer_Type) < 0)
        return;

    /* Create the module and add the functions */
    module = Py_InitModule3("_csv", csv_methods, csv_module_doc);
    if (module == NULL)
        return;

    /* Add version to the module. */
    if (PyModule_AddStringConstant(module, "__version__",
                                   MODULE_VERSION) == -1)
        return;

    /* Add _dialects dictionary */
    dialects = PyDict_New();
    if (dialects == NULL)
        return;
    if (PyModule_AddObject(module, "_dialects", dialects))
        return;

    /* Add quote styles into dictionary */
    for (style = quote_styles; style->name; style++) {
        if (PyModule_AddIntConstant(module, style->name,
                                    style->style) == -1)
            return;
    }

    /* Add the Dialect type */
    Py_INCREF(&Dialect_Type);
    if (PyModule_AddObject(module, "Dialect", (PyObject *)&Dialect_Type))
        return;

    /* Add the CSV exception object to the module. */
    error_obj = PyErr_NewException("_csv.Error", NULL, NULL);
    if (error_obj == NULL)
        return;

    // Pyston change: I *think* an incref is needed here, but it doesn't matter in CPython since they don't
    // try to tear down builtin classes:
    Py_INCREF(error_obj);

    PyModule_AddObject(module, "Error", error_obj);
}
Пример #11
0
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);
}
Пример #12
0
extern PyMODINIT_FUNC
initscamurmur3(void)
{
    PyObject *m;

    m = Py_InitModule3("scamurmur3", scamurmur3_methods, module_doc);

    if (m == NULL)
        return;
    PyModule_AddStringConstant(m, "__version__", MODULE_VERSION);
}
Пример #13
0
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);
}
Пример #14
0
PyObject *init_guava(void) {
  PyObject *guava_module = NULL;
  PyObject *request_module = NULL;
  PyObject *server_module = NULL;
  PyObject *handler_module = NULL;
  PyObject *controller_module = NULL;
  PyObject *router_module = NULL;
  PyObject *session_module = NULL;
  PyObject *cookie_module = NULL;

  PyEval_InitThreads();

  guava_module = Py_InitModule("guava", NULL);

  request_module = init_request();
  if (!register_module(guava_module, "request", request_module)) {
    return NULL;
  }

  server_module = init_server();
  if (!register_module(guava_module, "server", server_module)) {
    return NULL;
  }

  handler_module = init_handler();
  if (!register_module(guava_module, "handler", handler_module)) {
    return NULL;
  }

  router_module = init_router();
  if (!register_module(guava_module, "router", router_module)) {
    return NULL;
  }

  controller_module = init_controller();
  if (!register_module(guava_module, "controller", controller_module)) {
    return NULL;
  }

  session_module = init_session();
  if (!register_module(guava_module, "session", session_module)) {
    return NULL;
  }

  cookie_module = init_cookie();
  if (!register_module(guava_module, "cookie", cookie_module)) {
    return NULL;
  }

  PyModule_AddStringConstant(guava_module, "version", GUAVA_VERSION);

  return guava_module;
}
Пример #15
0
void
init_aes(PyObject*const module) {
    if (PyType_Ready(&AES_type) < 0)
        return;
    Py_INCREF(&AES_type);
    PyModule_AddObject(module, "aes_AES", (PyObject *)&AES_type);

    aes_error = PyErr_NewException(const_cast<char*>("_aes.Error"), NULL, NULL);
    PyModule_AddObject(module, "aes_Error", aes_error);

    PyModule_AddStringConstant(module, "aes___doc__", const_cast<char*>(aes___doc__));
}
Пример #16
0
PyMODINIT_FUNC MODINIT2(void)
{
	PyObject *m;

	m = Py_InitModule(SPONGE_MODULE, NULL);
	if (m == NULL)
		return;

	PyModule_AddStringConstant(m, "__doc__", mod_doc);

	mod_init(m);
}
Пример #17
0
PyMODINIT_FUNC initid128(void) {
        PyObject *m;

        m = Py_InitModule3("id128", methods, module__doc__);
        if (m == NULL)
                return;

        /* a series of lines like 'add_id() ;' follow */
#define JOINER ;
#include "id128-constants.h"
#undef JOINER
        PyModule_AddStringConstant(m, "__version__", PACKAGE_VERSION);
}
Пример #18
0
extern PyMODINIT_FUNC
PyInit_smhasher(void)
{
    PyObject *m;

    m = PyModule_Create(&smhasher_module);
    if (m == NULL)
        goto finally;
    PyModule_AddStringConstant(m, "__version__", MODULE_VERSION);

finally:
    return m;
}
Пример #19
0
void
gimpthumb_add_constants(PyObject *module, const gchar *strip_prefix)
{
#ifdef VERSION
    PyModule_AddStringConstant(module, "__version__", VERSION);
#endif
  pyg_enum_add(module, "ThumbFileType", strip_prefix, GIMP_TYPE_THUMB_FILE_TYPE);
  pyg_enum_add(module, "ThumbSize", strip_prefix, GIMP_TYPE_THUMB_SIZE);
  pyg_enum_add(module, "ThumbState", strip_prefix, GIMP_TYPE_THUMB_STATE);

  if (PyErr_Occurred())
    PyErr_Print();
}
Пример #20
0
int
get_and_load_rules(struct rules_motor_env_s** me, const gchar *ns_name){
	int rc;
	GByteArray *mod_in_string = NULL;
	PyObject *py_main = NULL;
	GError *err = NULL;

	/* Free previous module and function in 'me' */
	if ((*me)->py_function != NULL) {
		Py_XDECREF((*me)->py_function);
		(*me)->py_function = NULL;
	}
	if ((*me)->py_module != NULL) {
		Py_XDECREF((*me)->py_module);
		(*me)->py_module = NULL;
	}

	/* Get rule script from conscience */
	mod_in_string = namespace_get_rules(ns_name, CHUNK_CRAWLER, &err);
	if(mod_in_string == NULL){
		ERROR("Failed to fetch rules : %s", err->message);
		g_clear_error (&err);
		return -1;
	}
	PyRun_SimpleString("import imp");
	PyRun_SimpleString("rules_mod = imp.new_module('rules_mod')");
	py_main = PyImport_AddModule("__main__");

	rc = PyModule_AddStringConstant(py_main, "mod_in_string", (char *)mod_in_string->data);
	g_byte_array_free(mod_in_string, TRUE);
	if(rc == -1){
		ERROR("Failed to import rules(GByteArray) into python environment");
		return -1;
	}

	PyRun_SimpleString("exec mod_in_string in rules_mod.__dict__");

	(*me)->py_module = PyObject_GetAttrString(py_main, "rules_mod");
	if((*me)->py_module == NULL){
		ERROR("Failed to load python module");
		return -1;
	}

	(*me)->py_function = PyObject_GetAttrString((*me)->py_module, "main");
	if((*me)->py_function == NULL){
		ERROR("Failed to get python function hook");
		return -1;
	}

	return 1;
}
Пример #21
0
    PyMODINIT_FUNC
    initmisaka(void)
#endif
{
    #if PY_MAJOR_VERSION >= 3
        PyObject *module = PyModule_Create(&moduledef);
    #else
        PyObject *module = Py_InitModule3("misaka", misaka_methods,
            misaka_module__doc__);
    #endif

    if (module == NULL) {
        INITERROR;
    }
    struct module_state *st = GETSTATE(module);

    st->error = PyErr_NewException("misaka.Error", NULL, NULL);
    if (st->error == NULL) {
        Py_DECREF(module);
        INITERROR;
    }

    /* Version */
    PyModule_AddStringConstant(module, "__version__", "0.3.2");

    /* Markdown extensions */
    PyModule_AddIntConstant(module, "EXT_NO_INTRA_EMPHASIS", MKDEXT_NO_INTRA_EMPHASIS);
    PyModule_AddIntConstant(module, "EXT_TABLES", MKDEXT_TABLES);
    PyModule_AddIntConstant(module, "EXT_FENCED_CODE", MKDEXT_FENCED_CODE);
    PyModule_AddIntConstant(module, "EXT_AUTOLINK", MKDEXT_AUTOLINK);
    PyModule_AddIntConstant(module, "EXT_STRIKETHROUGH", MKDEXT_STRIKETHROUGH);
    PyModule_AddIntConstant(module, "EXT_LAX_HTML_BLOCKS", MKDEXT_LAX_HTML_BLOCKS);
    PyModule_AddIntConstant(module, "EXT_SPACE_HEADERS", MKDEXT_SPACE_HEADERS);

    /* XHTML Render flags */
    PyModule_AddIntConstant(module, "HTML_SKIP_HTML", HTML_SKIP_HTML);
    PyModule_AddIntConstant(module, "HTML_SKIP_STYLE", HTML_SKIP_STYLE);
    PyModule_AddIntConstant(module, "HTML_SKIP_IMAGES", HTML_SKIP_IMAGES);
    PyModule_AddIntConstant(module, "HTML_SKIP_LINKS", HTML_SKIP_LINKS);
    PyModule_AddIntConstant(module, "HTML_EXPAND_TABS", HTML_EXPAND_TABS);
    PyModule_AddIntConstant(module, "HTML_SAFELINK", HTML_SAFELINK);
    PyModule_AddIntConstant(module, "HTML_TOC", HTML_TOC);
    PyModule_AddIntConstant(module, "HTML_HARD_WRAP", HTML_HARD_WRAP);
    PyModule_AddIntConstant(module, "HTML_GITHUB_BLOCKCODE", HTML_GITHUB_BLOCKCODE);
    PyModule_AddIntConstant(module, "HTML_USE_XHTML", HTML_USE_XHTML);
    PyModule_AddIntConstant(module, "HTML_SMARTYPANTS", HTML_SMARTYPANTS);

    #if PY_MAJOR_VERSION >= 3
        return module;
    #endif
}
initflowd(void)
{
    PyObject *m;

    if (PyType_Ready(&Flow_Type) < 0)
        return;
    if (PyType_Ready(&FlowLog_Type) < 0)
        return;
    m = Py_InitModule3("flowd", flowd_methods, module_doc);

#define STORE_CONST(c) \
	PyModule_AddObject(m, #c, PyLong_FromUnsignedLong(STORE_##c))
    STORE_CONST(FIELD_TAG);
    STORE_CONST(FIELD_RECV_TIME);
    STORE_CONST(FIELD_PROTO_FLAGS_TOS);
    STORE_CONST(FIELD_AGENT_ADDR4);
    STORE_CONST(FIELD_AGENT_ADDR6);
    STORE_CONST(FIELD_SRC_ADDR4);
    STORE_CONST(FIELD_SRC_ADDR6);
    STORE_CONST(FIELD_DST_ADDR4);
    STORE_CONST(FIELD_DST_ADDR6);
    STORE_CONST(FIELD_GATEWAY_ADDR4);
    STORE_CONST(FIELD_GATEWAY_ADDR6);
    STORE_CONST(FIELD_SRCDST_PORT);
    STORE_CONST(FIELD_PACKETS);
    STORE_CONST(FIELD_OCTETS);
    STORE_CONST(FIELD_IF_INDICES);
    STORE_CONST(FIELD_AGENT_INFO);
    STORE_CONST(FIELD_FLOW_TIMES);
    STORE_CONST(FIELD_AS_INFO);
    STORE_CONST(FIELD_FLOW_ENGINE_INFO);
    STORE_CONST(FIELD_CRC32);
    STORE_CONST(FIELD_RESERVED);
    STORE_CONST(FIELD_ALL);
    STORE_CONST(FIELD_AGENT_ADDR);
    STORE_CONST(FIELD_SRC_ADDR);
    STORE_CONST(FIELD_DST_ADDR);
    STORE_CONST(FIELD_SRCDST_ADDR);
    STORE_CONST(FIELD_GATEWAY_ADDR);
    STORE_CONST(DISPLAY_ALL);
    STORE_CONST(DISPLAY_BRIEF);
#undef STORE_CONST
#define STORE_CONST2(c) \
	PyModule_AddObject(m, "STORE_"#c, PyLong_FromUnsignedLong(STORE_##c))
    STORE_CONST2(VER_MAJOR);
    STORE_CONST2(VER_MINOR);
    STORE_CONST2(VERSION);
#undef STORE_CONST2

    PyModule_AddStringConstant(m, "__version__", PROGVER);
}
Пример #23
0
int python_initialize()
{
	PyObject *ekg, *ekg_config;

	/* PyImport_ImportModule spodziewa siê nazwy modu³u, który znajduje
	 * siê w $PYTHONPATH, wiêc dodajemy tam katalog ~/.gg/scripts. mo¿na
	 * to zrobiæ w bardziej elegancki sposób, ale po co komplikowaæ sobie
	 * ¿ycie?
	 *
	 * Argument putenv() nie jest zwalniany xfree(), bo powoduje to
	 * problemy na systemach, w których putenv() jest zgodne z SUSv2 (np
	 * niektóre SunOS).
	 */

	if (getenv("PYTHONPATH")) {
		char *tmp = saprintf("%s:%s", getenv("PYTHONPATH"), prepare_path("scripts", 0));
#ifdef HAVE_SETENV
		setenv("PYTHONPATH", tmp, 1);
#else
		{
			char *s = saprintf("PYTHONPATH=%s", tmp);
			putenv(s);
		}
#endif
		xfree(tmp);
	} else {
#ifdef HAVE_SETENV
		setenv("PYTHONPATH", prepare_path("scripts", 0), 1);
#else
		{
			char *s = saprintf("PYTHONPATH=%s", prepare_path("scripts", 0));
			putenv(s);
		}
#endif
	}

	Py_Initialize();

	PyImport_AddModule("ekg");

	if (!(ekg = Py_InitModule("ekg", ekg_methods)))
		return -1;

	PyModule_AddStringConstant(ekg, "version", VERSION);

	ekg_config = PyObject_NEW(PyObject, &ekg_config_type);
	PyModule_AddObject(ekg, "config", ekg_config);

	return 0;
}
Пример #24
0
PyMODINIT_FUNC initsnudown(void)
{
	PyObject *module;

	module = Py_InitModule3("snudown", snudown_methods, snudown_module__doc__);
	if (module == NULL)
		return;

	init_default_renderer(module);
	init_wiki_renderer(module);

	/* Version */
	PyModule_AddStringConstant(module, "__version__", SNUDOWN_VERSION);
}
Пример #25
0
PyMODINIT_FUNC
init_csv(void)
{
    PyObject *module;
    StyleDesc *style;

    if (PyType_Ready(&Dialect_Type) < 0)
        return;

    if (PyType_Ready(&Reader_Type) < 0)
        return;

    if (PyType_Ready(&Writer_Type) < 0)
        return;

    /* Create the module and add the functions */
    module = Py_InitModule3("_csv", csv_methods, csv_module_doc);
    if (module == NULL)
        return;

    /* Add version to the module. */
    if (PyModule_AddStringConstant(module, "__version__",
                                   MODULE_VERSION) == -1)
        return;

    /* Add _dialects dictionary */
    dialects = PyGC_AddRoot(PyDict_New());
    if (dialects == NULL)
        return;
    if (PyModule_AddObject(module, "_dialects", dialects))
        return;

    /* Add quote styles into dictionary */
    for (style = quote_styles; style->name; style++) {
        if (PyModule_AddIntConstant(module, style->name,
                                    style->style) == -1)
            return;
    }

    /* Add the Dialect type */
    Py_INCREF(&Dialect_Type);
    if (PyModule_AddObject(module, "Dialect", (PyObject *)&Dialect_Type))
        return;

    /* Add the CSV exception object to the module. */
    error_obj = PyGC_AddRoot(PyErr_NewException("_csv.Error", NULL, NULL));
    if (error_obj == NULL)
        return;
    PyModule_AddObject(module, "Error", error_obj);
}
Пример #26
0
PyMODINIT_FUNC PyInit__journal(void) {
        PyObject *m;

        m = PyModule_Create(&module);
        if (m == NULL)
                return NULL;

        if (PyModule_AddStringConstant(m, "__version__", PACKAGE_VERSION)) {
                Py_DECREF(m);
                return NULL;
        }

        return m;
}
Пример #27
0
PyMODINIT_FUNC inittypes ( void )
{
    PyObject * module = 0;

    if ( ! ( module = Py_InitModule3 ( "fudgepyc.types",
                                       module_methods,
                                       DOC_fudgepyc_typesmodule ) ) )
        return;

    PyModule_AddStringConstant ( module, "__version__", fudgepyc_version );

    if ( fudgepyc_typesAddModuleAttrs ( module, "TYPE_NAMES",      module_typeattrs ) ||
         fudgepyc_typesAddModuleAttrs ( module, "PRECISION_NAMES", module_precisionattrs ) )
        return;
}
Пример #28
0
PyMODINIT_FUNC
initbarcode (void)
{
  PyObject *m;

  BarcodeType.tp_new = PyType_GenericNew;
  if (PyType_Ready (&BarcodeType) < 0)
    return;

  m = Py_InitModule3 ("spam", spam_methods, "Testing");

  Py_INCREF (&BarcodeType);
  PyModule_AddObject (m, "Spam", (PyObject *) &SpamType);
  PyModule_AddStringConstant (m, "MODULE_VERSION", "0.0.0.1");
}
Пример #29
0
PyMODINIT_FUNC
initfinalCleanup(void)
{
    PyObject *m;

    m = Py_InitModule3("finalCleanup", finalCleanup_methods, module_doc);

    if (m == NULL) {
        printf("Null value in init\n");
        exit(2);
    //return NULL;
    }

    PyModule_AddStringConstant(m, "__version__", FINALCLEANUP_VERSION);
}
Пример #30
0
PyMODINIT_FUNC init_wrtctl_const( void ){
    PyObject *module = NULL;
    const_map_t emi;

    if ( !(module = Py_InitModule("_wrtctl_const", NULL)) )
        return;

    for ( emi = constants_map; emi->name; emi++ ){
        if ( emi->val != -1 )
            PyModule_AddIntConstant(module, emi->name, emi->val);
        else
            PyModule_AddStringConstant(module, emi->name, emi->str);
    }
    return;
}