/**
* @brief Initialize the CPU, the board and the peripherals
*
* This function is called by ESP8266 SDK when all system initializations
* has been finished.
*/
void system_init(void)
{
LOG_INFO("\nStarting ESP8266 CPU with ID: %08x", system_get_chip_id());
LOG_INFO("\nSDK Version %s\n\n", system_get_sdk_version());
/* avoid reconnection all the time */
wifi_station_disconnect();
/* set exception handlers */
init_exceptions ();
/* init random number generator */
srand(hwrand());
/* init flash drive */
extern void flash_drive_init (void);
flash_drive_init();
/* trigger static peripheral initialization */
periph_init();
/* trigger board initialization */
board_init();
/* print the board config */
board_print_config();
}
/* Returns the psi.mount module */
PyMODINIT_FUNC
MODFUNC(void)
{
PyObject *mod = NULL;
if (prepare_types() < 0)
RETURN(NULL);
if (init_exceptions() < 0)
goto error;
#ifdef PY3K
mod = PyModule_Create(&moduledef);
#else
mod = Py_InitModule3(MODULE_NAME, mount_methods, MODULE_DOC);
#endif
if (mod == NULL)
goto error;
if (add_module_objects(mod) < 0)
goto error;
PyErr_WarnEx(PyExc_FutureWarning, "Experimental API", 1);
RETURN(mod);
error:
Py_XDECREF(mod);
Py_XDECREF(PsiExc_AttrNotAvailableError);
Py_XDECREF(PsiExc_AttrInsufficientPrivsError);
Py_XDECREF(PsiExc_AttrNotImplementedError);
Py_XDECREF(&MountBase_Type);
Py_XDECREF(&LocalMount_Type);
Py_XDECREF(&RemoteMount_Type);
RETURN(NULL);
}
int __low_level_init(void)
#endif
{
init_exceptions();
init_hmatrix();
init_heap();
// EWAVR32: Request initialization of data segments.
// GCC: Don't-care value.
return 1;
}
int _pSLerr_init (void)
{
if (Default_Error_Queue == NULL)
{
Suspend_Error_Messages = 0;
if (NULL == (Default_Error_Queue = _pSLerr_new_error_queue (1)))
return -1;
}
if (-1 == init_exceptions ())
return -1;
return 0;
}
/*
* start_kernel() - unser C-Eintrittspunkt
*
* Wird direkt nach Initialisierung des Supervisor-Stacks gestartet.
*/
void start_kernel(void)
{
/*
* System initialisieren.
*/
init_other_stacks();
init_exceptions();
dbgu_init();
st_init();
st_set_interval(500);
put_char('c');
scheduler_init();
}
void kernel_main(void)
{
output_clear_screen();
kprint("Starting main kernel init\n");
init_syscalls();
init_exceptions();
init_irqs();
enable_nmi();
sti();
kprintf("printf() call test\n%d %s %X %p", 42, "Hello", 0xFF, IDT);
for(;;); // <-- runs up to here without problems
/* This is an old KupOS functionality ;) */
/*clear_buf();
clear_screen();
puts("Kupec Operation System (KupOS)\nBeta-version 0.1\n");
void* buffer = alloc_page();
while (1)
{
puts("-> ");
read_string((char**)(&buffer));
putenter();
perform();
}*/
}
static void init_spi(void)
{
#if defined(WL_SPI)
int i;
#endif
#if defined(AT45DBX_SPI)
static const gpio_map_t AT45DBX_SPI_GPIO_MAP = {
{ AT45DBX_SPI_SCK_PIN, AT45DBX_SPI_SCK_FUNCTION },
{ AT45DBX_SPI_MISO_PIN, AT45DBX_SPI_MISO_FUNCTION },
{ AT45DBX_SPI_MOSI_PIN, AT45DBX_SPI_MOSI_FUNCTION },
{ AT45DBX_SPI_NPCS2_PIN, AT45DBX_SPI_NPCS2_FUNCTION },
};
#endif
#if defined(WL_SPI)
const gpio_map_t WL_SPI_GPIO_MAP = {
#if defined(WL_SPI_NPCS0)
WL_SPI_NPCS0,
#endif
WL_SPI_NPCS, WL_SPI_MISO, WL_SPI_MOSI, WL_SPI_SCK
};
#endif
#if defined(WL_SPI) || defined(AT45DBX_SPI)
spi_options_t spiOptions = {
.modfdis = 1 /* only param used by spi_initMaster() */
};
#endif
#if defined(AT45DBX_SPI)
gpio_enable_module(AT45DBX_SPI_GPIO_MAP,
sizeof(AT45DBX_SPI_GPIO_MAP) /
sizeof(AT45DBX_SPI_GPIO_MAP[0]));
spi_initMaster(AT45DBX_SPI, &spiOptions);
spi_selectionMode(AT45DBX_SPI, 0, 0, 0);
#endif
#if defined(WL_SPI)
/* same pins might be initialized twice here */
gpio_enable_module(WL_SPI_GPIO_MAP,
sizeof(WL_SPI_GPIO_MAP) /
sizeof(WL_SPI_GPIO_MAP[0]));
for (i = 0; i < sizeof(WL_SPI_GPIO_MAP)/sizeof(WL_SPI_GPIO_MAP[0]); i++)
gpio_enable_pin_pull_up(WL_SPI_GPIO_MAP[i].pin);
/* same SPI controller might be initialized again */
spi_initMaster(&WL_SPI, &spiOptions);
spi_selectionMode(&WL_SPI, 0, 0, 0);
#endif
#if defined(AT45DBX_SPI)
spi_enable(AT45DBX_SPI);
/* put up flash reset pin */
gpio_set_gpio_pin(AT45DBX_CHIP_RESET);
#endif
#if defined(WL_SPI)
spi_enable(&WL_SPI);
#endif
}
static void init_rs232(void)
{
#ifndef NO_SERIAL
#if defined(BOARD_RS232_0)
const gpio_map_t BOARD_RS232_0_GPIO_MAP = {
BOARD_RS232_0_TX,
BOARD_RS232_0_RX,
#if defined(BOARD_RS232_0_RTS) && defined (BOARD_RS232_0_CTS)
BOARD_RS232_0_RTS,
BOARD_RS232_0_CTS
#endif
};
#endif
#if defined(BOARD_RS232_1)
const gpio_map_t BOARD_RS232_1_GPIO_MAP = {
BOARD_RS232_1_TX,
BOARD_RS232_1_RX
#if defined(BOARD_RS232_1_RTS) && defined (BOARD_RS232_1_CTS)
BOARD_RS232_1_RTS,
BOARD_RS232_1_CTS
#endif
};
#endif
#if defined(BOARD_RS232_0)
gpio_enable_module(BOARD_RS232_0_GPIO_MAP,
sizeof(BOARD_RS232_0_GPIO_MAP) /
sizeof(BOARD_RS232_0_GPIO_MAP[0]));
#endif
#if defined(BOARD_RS232_1)
gpio_enable_module(BOARD_RS232_1_GPIO_MAP,
sizeof(BOARD_RS232_1_GPIO_MAP) /
sizeof(BOARD_RS232_1_GPIO_MAP[0]));
#endif
#endif /* NO_SERIAL */
}
static void init_printk(void)
{
#ifndef NO_SERIAL
#if defined(CONFIG_CONSOLE_PORT)
const usart_options_t usart_options = {
.baudrate = 57600,
.charlength = 8,
.paritytype = USART_NO_PARITY,
.stopbits = USART_1_STOPBIT,
.channelmode = USART_NORMAL_CHMODE
};
usart_init_rs232(&CONFIG_CONSOLE_PORT, &usart_options, FPBA_HZ);
#endif
#endif /* NO_SERIAL */
}
void board_init(void)
{
init_exceptions();
init_hmatrix();
init_sys_clocks();
init_interrupts();
init_rs232();
init_printk();
#ifdef WITH_SDRAM
sdramc_init(FHSB_HZ);
#endif
init_spi();
}
void
Py_Initialize(void)
{
PyInterpreterState *interp;
PyThreadState *tstate;
PyObject *bimod, *sysmod;
char *p;
if (initialized)
return;
initialized = 1;
if ((p = getenv("PYTHONDEBUG")) && *p != '\0')
Py_DebugFlag = Py_DebugFlag ? Py_DebugFlag : 1;
if ((p = getenv("PYTHONVERBOSE")) && *p != '\0')
Py_VerboseFlag = Py_VerboseFlag ? Py_VerboseFlag : 1;
if ((p = getenv("PYTHONOPTIMIZE")) && *p != '\0')
Py_OptimizeFlag = Py_OptimizeFlag ? Py_OptimizeFlag : 1;
interp = PyInterpreterState_New();
if (interp == NULL)
Py_FatalError("Py_Initialize: can't make first interpreter");
tstate = PyThreadState_New(interp);
if (tstate == NULL)
Py_FatalError("Py_Initialize: can't make first thread");
(void) PyThreadState_Swap(tstate);
interp->modules = PyDict_New();
if (interp->modules == NULL)
Py_FatalError("Py_Initialize: can't make modules dictionary");
/* Init codec registry */
_PyCodecRegistry_Init();
/* Init Unicode implementation; relies on the codec registry */
_PyUnicode_Init();
_PyCompareState_Key = PyString_InternFromString("cmp_state");
bimod = _PyBuiltin_Init();
if (bimod == NULL)
Py_FatalError("Py_Initialize: can't initialize __builtin__");
interp->builtins = PyModule_GetDict(bimod);
Py_INCREF(interp->builtins);
sysmod = _PySys_Init();
if (sysmod == NULL)
Py_FatalError("Py_Initialize: can't initialize sys");
interp->sysdict = PyModule_GetDict(sysmod);
Py_INCREF(interp->sysdict);
_PyImport_FixupExtension("sys", "sys");
PySys_SetPath(Py_GetPath());
PyDict_SetItemString(interp->sysdict, "modules",
interp->modules);
_PyImport_Init();
/* initialize builtin exceptions */
init_exceptions();
/* phase 2 of builtins */
_PyImport_FixupExtension("__builtin__", "__builtin__");
initsigs(); /* Signal handling stuff, including initintr() */
initmain(); /* Module __main__ */
if (!Py_NoSiteFlag)
initsite(); /* Module site */
}
void Init_wii4r() {
wii_mod = rb_define_module("Wii");
rb_define_const(wii_mod, "MAX_WIIMOTES", INT2NUM(4));
rb_define_const(wii_mod, "TIMEOUT", INT2NUM(5));
//Wiimote led consts
rb_define_const(wii_mod, "LED_NONE", INT2NUM(WIIMOTE_LED_NONE));
rb_define_const(wii_mod, "LED_1", INT2NUM(WIIMOTE_LED_1));
rb_define_const(wii_mod, "LED_2", INT2NUM(WIIMOTE_LED_2));
rb_define_const(wii_mod, "LED_3", INT2NUM(WIIMOTE_LED_3));
rb_define_const(wii_mod, "LED_4", INT2NUM(WIIMOTE_LED_4));
//Wiimote button consts
rb_define_const(wii_mod, "BUTTON_A", INT2NUM(WIIMOTE_BUTTON_A));
rb_define_const(wii_mod, "BUTTON_B", INT2NUM(WIIMOTE_BUTTON_B));
rb_define_const(wii_mod, "BUTTON_ONE", INT2NUM(WIIMOTE_BUTTON_ONE));
rb_define_const(wii_mod, "BUTTON_TWO", INT2NUM(WIIMOTE_BUTTON_TWO));
rb_define_const(wii_mod, "BUTTON_PLUS", INT2NUM(WIIMOTE_BUTTON_PLUS));
rb_define_const(wii_mod, "BUTTON_MINUS", INT2NUM(WIIMOTE_BUTTON_MINUS));
rb_define_const(wii_mod, "BUTTON_HOME", INT2NUM(WIIMOTE_BUTTON_HOME));
rb_define_const(wii_mod, "BUTTON_LEFT", INT2NUM(WIIMOTE_BUTTON_LEFT));
rb_define_const(wii_mod, "BUTTON_RIGHT", INT2NUM(WIIMOTE_BUTTON_RIGHT));
rb_define_const(wii_mod, "BUTTON_DOWN", INT2NUM(WIIMOTE_BUTTON_DOWN));
rb_define_const(wii_mod, "BUTTON_UP", INT2NUM(WIIMOTE_BUTTON_UP));
rb_define_const(wii_mod, "BUTTON_ALL", INT2NUM(WIIMOTE_BUTTON_ALL));
//Wiimote nunchuk button consts
rb_define_const(wii_mod, "N_BUTTON_Z", INT2NUM(NUNCHUK_BUTTON_Z));
rb_define_const(wii_mod, "N_BUTTON_C", INT2NUM(NUNCHUK_BUTTON_C));
rb_define_const(wii_mod, "N_BUTTON_ALL", INT2NUM(NUNCHUK_BUTTON_ALL));
//Wiimote classic controller button codes
rb_define_const(wii_mod, "C_BUTTON_UP", INT2NUM(CLASSIC_CTRL_BUTTON_UP));
rb_define_const(wii_mod, "C_BUTTON_LEFT", INT2NUM(CLASSIC_CTRL_BUTTON_LEFT));
rb_define_const(wii_mod, "C_BUTTON_ZR", INT2NUM(CLASSIC_CTRL_BUTTON_ZR));
rb_define_const(wii_mod, "C_BUTTON_X", INT2NUM(CLASSIC_CTRL_BUTTON_X));
rb_define_const(wii_mod, "C_BUTTON_A", INT2NUM(CLASSIC_CTRL_BUTTON_A));
rb_define_const(wii_mod, "C_BUTTON_Y", INT2NUM(CLASSIC_CTRL_BUTTON_Y));
rb_define_const(wii_mod, "C_BUTTON_B", INT2NUM(CLASSIC_CTRL_BUTTON_B));
rb_define_const(wii_mod, "C_BUTTON_ZL", INT2NUM(CLASSIC_CTRL_BUTTON_ZL));
rb_define_const(wii_mod, "C_BUTTON_FULL_R", INT2NUM(CLASSIC_CTRL_BUTTON_FULL_R));
rb_define_const(wii_mod, "C_BUTTON_PLUS", INT2NUM(CLASSIC_CTRL_BUTTON_PLUS));
rb_define_const(wii_mod, "C_BUTTON_HOME", INT2NUM(CLASSIC_CTRL_BUTTON_HOME));
rb_define_const(wii_mod, "C_BUTTON_MINUS", INT2NUM(CLASSIC_CTRL_BUTTON_MINUS));
rb_define_const(wii_mod, "C_BUTTON_FULL_L", INT2NUM(CLASSIC_CTRL_BUTTON_FULL_L));
rb_define_const(wii_mod, "C_BUTTON_DOWN", INT2NUM(CLASSIC_CTRL_BUTTON_DOWN));
rb_define_const(wii_mod, "C_BUTTON_RIGHT", INT2NUM(CLASSIC_CTRL_BUTTON_RIGHT));
rb_define_const(wii_mod, "C_BUTTON_ALL", INT2NUM(CLASSIC_CTRL_BUTTON_ALL));
//Wiimote hero button codes
rb_define_const(wii_mod, "GUITAR_BUTTON_UP", INT2NUM(GUITAR_HERO_3_BUTTON_STRUM_UP));
rb_define_const(wii_mod, "GUITAR_BUTTON_YELLOW", INT2NUM(GUITAR_HERO_3_BUTTON_YELLOW));
rb_define_const(wii_mod, "GUITAR_BUTTON_GREEN", INT2NUM(GUITAR_HERO_3_BUTTON_GREEN));
rb_define_const(wii_mod, "GUITAR_BUTTON_BLUE", INT2NUM(GUITAR_HERO_3_BUTTON_BLUE));
rb_define_const(wii_mod, "GUITAR_BUTTON_RED", INT2NUM(GUITAR_HERO_3_BUTTON_RED));
rb_define_const(wii_mod, "GUITAR_BUTTON_ORANGE", INT2NUM(GUITAR_HERO_3_BUTTON_ORANGE));
rb_define_const(wii_mod, "GUITAR_BUTTON_PLUS", INT2NUM(GUITAR_HERO_3_BUTTON_PLUS));
rb_define_const(wii_mod, "GUITAR_BUTTON_MINUS", INT2NUM(GUITAR_HERO_3_BUTTON_MINUS));
rb_define_const(wii_mod, "GUITAR_BUTTON_DOWN", INT2NUM(GUITAR_HERO_3_BUTTON_STRUM_DOWN));
rb_define_const(wii_mod, "GUITAR_BUTTON_ALL", INT2NUM(GUITAR_HERO_3_BUTTON_ALL));
//Wiimote expansion codes
rb_define_const(wii_mod, "EXP_NONE", INT2NUM(EXP_NONE));
rb_define_const(wii_mod, "EXP_NUNCHUK", INT2NUM(EXP_NUNCHUK));
rb_define_const(wii_mod, "EXP_CLASSIC", INT2NUM(EXP_CLASSIC));
rb_define_const(wii_mod, "EXP_GUITAR", INT2NUM(EXP_GUITAR_HERO_3));
//Aspect ratio and sensor bar position constants
rb_define_const(wii_mod, "ASPECT_4_3", INT2NUM(WIIUSE_ASPECT_4_3));
rb_define_const(wii_mod, "ASPECT_16_9", INT2NUM(WIIUSE_ASPECT_16_9));
rb_define_const(wii_mod, "ABOVE", INT2NUM(WIIUSE_IR_ABOVE));
rb_define_const(wii_mod, "BELOW", INT2NUM(WIIUSE_IR_BELOW));
init_wiimotemanager();
init_wiimote();
init_nunchuk();
init_gh3();
init_cc();
init_exceptions();
}
void run(void)
{
#if DEBUG_RUNS
int count = 0;
#endif
init_poller();
// Initialize binary image state
initialize_binary();
// Initialize memory
{
TWOBYTES size;
memory_init ();
#if SEGMENTED_HEAP
size = EXTRA_MEMORY_SIZE;
region = (byte *) malloc (size * sizeof (TWOBYTES));
memory_add_region (region, region + size * sizeof (TWOBYTES));
#endif
size = MEMORY_SIZE;
region = (byte *) malloc (size * sizeof (TWOBYTES));
memory_add_region (region, region + size * sizeof (TWOBYTES));
}
// Initialize exceptions
init_exceptions();
// Create the boot thread (bootThread is a special global)
bootThread = (Thread *) new_object_for_class (JAVA_LANG_THREAD);
#if DEBUG_THREADS
printf ("Created bootThread: %d. Initializing...\n", (int) bootThread);
#endif
#if DEBUG_RUNS
for (count = 0; count < 100; count++)
{
#endif // DEBUG_RUNS
#if DEBUG_RCX_MEMORY
{
TWOBYTES numNodes, biggest, freeMem;
scan_memory (&numNodes, &biggest, &freeMem);
printf ("nodes = %d\n", (int) numNodes);
printf ("biggest = %d\n", (int) biggest);
printf ("freeMem = %d\n", (int) freeMem);
}
#endif
init_threads();
if (!init_thread (bootThread))
{
printf ("Unable to initialize threading module.\n");
exit (1);
}
// Execute the bytecode interpreter
set_program_number (0);
#if DEBUG_STARTUP
printf ("Engine starting.\n");
#endif
engine();
// Engine returns when all non-daemon threads are dead
#if DEBUG_STARTUP
printf ("Engine finished.\n");
#endif
#if DEBUG_RUNS
}
#endif // DEBUG_RUNS
}
PyMODINIT_FUNC
init_createrepo_c(void)
#endif
{
#if PY_MAJOR_VERSION >= 3
PyObject *m = PyModule_Create(&createrepo_c_module_def);
#else
PyObject *m = Py_InitModule("_createrepo_c", createrepo_c_methods);
#endif
if (!m)
return FAILURE;
/* Exceptions */
if (!init_exceptions())
return FAILURE;
PyModule_AddObject(m, "CreaterepoCError", CrErr_Exception);
/* Objects */
/* _createrepo_c.ContentStat */
if (PyType_Ready(&ContentStat_Type) < 0)
return FAILURE;
Py_INCREF(&ContentStat_Type);
PyModule_AddObject(m, "ContentStat", (PyObject *)&ContentStat_Type);
/* _createrepo_c.CrFile */
if (PyType_Ready(&CrFile_Type) < 0)
return FAILURE;
Py_INCREF(&CrFile_Type);
PyModule_AddObject(m, "CrFile", (PyObject *)&CrFile_Type);
/* _createrepo_c.Package */
if (PyType_Ready(&Package_Type) < 0)
return FAILURE;
Py_INCREF(&Package_Type);
PyModule_AddObject(m, "Package", (PyObject *)&Package_Type);
/* _createrepo_c.Metadata */
if (PyType_Ready(&Metadata_Type) < 0)
return FAILURE;
Py_INCREF(&Metadata_Type);
PyModule_AddObject(m, "Metadata", (PyObject *)&Metadata_Type);
/* _createrepo_c.MetadataLocation */
if (PyType_Ready(&MetadataLocation_Type) < 0)
return FAILURE;
Py_INCREF(&MetadataLocation_Type);
PyModule_AddObject(m, "MetadataLocation", (PyObject *)&MetadataLocation_Type);
/* _createrepo_c.Repomd */
if (PyType_Ready(&Repomd_Type) < 0)
return FAILURE;
Py_INCREF(&Repomd_Type);
PyModule_AddObject(m, "Repomd", (PyObject *)&Repomd_Type);
/* _createrepo_c.RepomdRecord */
if (PyType_Ready(&RepomdRecord_Type) < 0)
return FAILURE;
Py_INCREF(&RepomdRecord_Type);
PyModule_AddObject(m, "RepomdRecord", (PyObject *)&RepomdRecord_Type);
/* _createrepo_c.Sqlite */
if (PyType_Ready(&Sqlite_Type) < 0)
return FAILURE;
Py_INCREF(&Sqlite_Type);
PyModule_AddObject(m, "Sqlite", (PyObject *)&Sqlite_Type);
/* _createrepo_c.UpdateCollection */
if (PyType_Ready(&UpdateCollection_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateCollection_Type);
PyModule_AddObject(m, "UpdateCollection",
(PyObject *)&UpdateCollection_Type);
/* _createrepo_c.UpdateCollectionPackage */
if (PyType_Ready(&UpdateCollectionPackage_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateCollectionPackage_Type);
PyModule_AddObject(m, "UpdateCollectionPackage",
(PyObject *)&UpdateCollectionPackage_Type);
/* _createrepo_c.UpdateInfo */
if (PyType_Ready(&UpdateInfo_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateInfo_Type);
PyModule_AddObject(m, "UpdateInfo", (PyObject *)&UpdateInfo_Type);
/* _createrepo_c.UpdateRecord */
if (PyType_Ready(&UpdateRecord_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateRecord_Type);
PyModule_AddObject(m, "UpdateRecord", (PyObject *)&UpdateRecord_Type);
/* _createrepo_c.UpdateReference */
if (PyType_Ready(&UpdateReference_Type) < 0)
return FAILURE;
Py_INCREF(&UpdateReference_Type);
PyModule_AddObject(m, "UpdateReference", (PyObject *)&UpdateReference_Type);
/* _createrepo_c.XmlFile */
if (PyType_Ready(&XmlFile_Type) < 0)
return FAILURE;
Py_INCREF(&XmlFile_Type);
PyModule_AddObject(m, "XmlFile", (PyObject *)&XmlFile_Type);
/* Createrepo init */
cr_xml_dump_init();
cr_package_parser_init();
Py_AtExit(cr_xml_dump_cleanup);
Py_AtExit(cr_package_parser_cleanup);
/* Python macro to use datetime objects */
PyDateTime_IMPORT;
/* Module constants */
/* Version */
PyModule_AddIntConstant(m, "VERSION_MAJOR", CR_VERSION_MAJOR);
PyModule_AddIntConstant(m, "VERSION_MINOR", CR_VERSION_MINOR);
PyModule_AddIntConstant(m, "VERSION_PATCH", CR_VERSION_PATCH);
/* Checksum types */
PyModule_AddIntConstant(m, "CHECKSUM_UNKNOWN", CR_CHECKSUM_UNKNOWN);
PyModule_AddIntConstant(m, "MD5", CR_CHECKSUM_MD5);
PyModule_AddIntConstant(m, "SHA", CR_CHECKSUM_SHA);
PyModule_AddIntConstant(m, "SHA1", CR_CHECKSUM_SHA1);
PyModule_AddIntConstant(m, "SHA224", CR_CHECKSUM_SHA224);
PyModule_AddIntConstant(m, "SHA256", CR_CHECKSUM_SHA256);
PyModule_AddIntConstant(m, "SHA384", CR_CHECKSUM_SHA384);
PyModule_AddIntConstant(m, "SHA512", CR_CHECKSUM_SHA512);
/* File open modes */
PyModule_AddIntConstant(m, "MODE_READ", CR_CW_MODE_READ);
PyModule_AddIntConstant(m, "MODE_WRITE", CR_CW_MODE_WRITE);
/* Compression types */
PyModule_AddIntConstant(m, "AUTO_DETECT_COMPRESSION", CR_CW_AUTO_DETECT_COMPRESSION);
PyModule_AddIntConstant(m, "UNKNOWN_COMPRESSION", CR_CW_UNKNOWN_COMPRESSION);
PyModule_AddIntConstant(m, "NO_COMPRESSION", CR_CW_NO_COMPRESSION);
PyModule_AddIntConstant(m, "GZ_COMPRESSION", CR_CW_GZ_COMPRESSION);
PyModule_AddIntConstant(m, "BZ2_COMPRESSION", CR_CW_BZ2_COMPRESSION);
PyModule_AddIntConstant(m, "XZ_COMPRESSION", CR_CW_XZ_COMPRESSION);
/* Load Metadata key values */
PyModule_AddIntConstant(m, "HT_KEY_DEFAULT", CR_HT_KEY_DEFAULT);
PyModule_AddIntConstant(m, "HT_KEY_HASH", CR_HT_KEY_HASH);
PyModule_AddIntConstant(m, "HT_KEY_NAME", CR_HT_KEY_NAME);
PyModule_AddIntConstant(m, "HT_KEY_FILENAME", CR_HT_KEY_FILENAME);
/* Load Metadata key dup action */
PyModule_AddIntConstant(m, "HT_DUPACT_KEEPFIRST", CR_HT_DUPACT_KEEPFIRST);
PyModule_AddIntConstant(m, "HT_DUPACT_REMOVEALL", CR_HT_DUPACT_REMOVEALL);
/* Sqlite DB types */
PyModule_AddIntConstant(m, "DB_PRIMARY", CR_DB_PRIMARY);
PyModule_AddIntConstant(m, "DB_FILELISTS", CR_DB_FILELISTS);
PyModule_AddIntConstant(m, "DB_OTHER", CR_DB_OTHER);
/* XmlFile types */
PyModule_AddIntConstant(m, "XMLFILE_PRIMARY", CR_XMLFILE_PRIMARY);
PyModule_AddIntConstant(m, "XMLFILE_FILELISTS", CR_XMLFILE_FILELISTS);
PyModule_AddIntConstant(m, "XMLFILE_OTHER", CR_XMLFILE_OTHER);
PyModule_AddIntConstant(m, "XMLFILE_PRESTODELTA", CR_XMLFILE_PRESTODELTA);
PyModule_AddIntConstant(m, "XMLFILE_UPDATEINFO", CR_XMLFILE_UPDATEINFO);
/* XmlParser types */
PyModule_AddIntConstant(m, "XML_WARNING_UNKNOWNTAG", CR_XML_WARNING_UNKNOWNTAG);
PyModule_AddIntConstant(m, "XML_WARNING_MISSINGATTR", CR_XML_WARNING_MISSINGATTR);
PyModule_AddIntConstant(m, "XML_WARNING_UNKNOWNVAL", CR_XML_WARNING_UNKNOWNVAL);
PyModule_AddIntConstant(m, "XML_WARNING_BADATTRVAL", CR_XML_WARNING_BADATTRVAL);
#if PY_MAJOR_VERSION >= 3
return m;
#else
return;
#endif
}
void
init_librepo(void)
#endif
{
#if PY_MAJOR_VERSION >= 3
PyObject *m = PyModule_Create(&moduledef);
#else
PyObject *m = Py_InitModule("_librepo", librepo_methods);
#endif
if (!m)
INITERROR;
struct module_state *st = GETSTATE(m);
// Exceptions
if (!init_exceptions()) {
Py_DECREF(m);
INITERROR;
}
st->error = LrErr_Exception;
PyModule_AddObject(m, "LibrepoException", LrErr_Exception);
// Objects
// _librepo.Handle
if (PyType_Ready(&Handle_Type) < 0)
INITERROR;
Py_INCREF(&Handle_Type);
PyModule_AddObject(m, "Handle", (PyObject *)&Handle_Type);
// _librepo.Result
if (PyType_Ready(&Result_Type) < 0)
INITERROR;
Py_INCREF(&Result_Type);
PyModule_AddObject(m, "Result", (PyObject *)&Result_Type);
// _librepo.PackageTarget
if (PyType_Ready(&PackageTarget_Type) < 0)
INITERROR;
Py_INCREF(&PackageTarget_Type);
PyModule_AddObject(m, "PackageTarget", (PyObject *)&PackageTarget_Type);
// Init module
Py_AtExit(exit_librepo);
// Module constants
#define PYMODULE_ADDINTCONSTANT(name) PyModule_AddIntConstant(m, #name, (name))
#define PYMODULE_ADDSTRCONSTANT(name) PyModule_AddStringConstant(m, #name, (name))
// Version
PYMODULE_ADDINTCONSTANT(LR_VERSION_MAJOR);
PYMODULE_ADDINTCONSTANT(LR_VERSION_MINOR);
PYMODULE_ADDINTCONSTANT(LR_VERSION_PATCH);
PYMODULE_ADDSTRCONSTANT(LR_VERSION);
// Handle options
PYMODULE_ADDINTCONSTANT(LRO_UPDATE);
PYMODULE_ADDINTCONSTANT(LRO_URLS);
PYMODULE_ADDINTCONSTANT(LRO_MIRRORLIST);
PYMODULE_ADDINTCONSTANT(LRO_MIRRORLISTURL);
PYMODULE_ADDINTCONSTANT(LRO_METALINKURL);
PYMODULE_ADDINTCONSTANT(LRO_LOCAL);
PYMODULE_ADDINTCONSTANT(LRO_HTTPAUTH);
PYMODULE_ADDINTCONSTANT(LRO_USERPWD);
PYMODULE_ADDINTCONSTANT(LRO_PROXY);
PYMODULE_ADDINTCONSTANT(LRO_PROXYPORT);
PYMODULE_ADDINTCONSTANT(LRO_PROXYTYPE);
PYMODULE_ADDINTCONSTANT(LRO_PROXYAUTH);
PYMODULE_ADDINTCONSTANT(LRO_PROXYUSERPWD);
PYMODULE_ADDINTCONSTANT(LRO_PROGRESSCB);
PYMODULE_ADDINTCONSTANT(LRO_PROGRESSDATA);
PYMODULE_ADDINTCONSTANT(LRO_MAXSPEED);
PYMODULE_ADDINTCONSTANT(LRO_DESTDIR);
PYMODULE_ADDINTCONSTANT(LRO_REPOTYPE);
PYMODULE_ADDINTCONSTANT(LRO_CONNECTTIMEOUT);
PYMODULE_ADDINTCONSTANT(LRO_IGNOREMISSING);
PYMODULE_ADDINTCONSTANT(LRO_INTERRUPTIBLE);
PYMODULE_ADDINTCONSTANT(LRO_USERAGENT);
PYMODULE_ADDINTCONSTANT(LRO_FETCHMIRRORS);
PYMODULE_ADDINTCONSTANT(LRO_MAXMIRRORTRIES);
PYMODULE_ADDINTCONSTANT(LRO_MAXPARALLELDOWNLOADS);
PYMODULE_ADDINTCONSTANT(LRO_MAXDOWNLOADSPERMIRROR);
PYMODULE_ADDINTCONSTANT(LRO_VARSUB);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRROR);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORCACHE);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORMAXAGE);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORCB);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORDATA);
PYMODULE_ADDINTCONSTANT(LRO_LOWSPEEDTIME);
PYMODULE_ADDINTCONSTANT(LRO_LOWSPEEDLIMIT);
PYMODULE_ADDINTCONSTANT(LRO_GPGCHECK);
PYMODULE_ADDINTCONSTANT(LRO_CHECKSUM);
PYMODULE_ADDINTCONSTANT(LRO_YUMDLIST);
PYMODULE_ADDINTCONSTANT(LRO_RPMMDDLIST);
PYMODULE_ADDINTCONSTANT(LRO_YUMBLIST);
PYMODULE_ADDINTCONSTANT(LRO_RPMMDBLIST);
PYMODULE_ADDINTCONSTANT(LRO_HMFCB);
PYMODULE_ADDINTCONSTANT(LRO_SSLVERIFYPEER);
PYMODULE_ADDINTCONSTANT(LRO_SSLVERIFYHOST);
PYMODULE_ADDINTCONSTANT(LRO_SSLCLIENTCERT);
PYMODULE_ADDINTCONSTANT(LRO_SSLCLIENTKEY);
PYMODULE_ADDINTCONSTANT(LRO_SSLCACERT);
PYMODULE_ADDINTCONSTANT(LRO_IPRESOLVE);
PYMODULE_ADDINTCONSTANT(LRO_ALLOWEDMIRRORFAILURES);
PYMODULE_ADDINTCONSTANT(LRO_ADAPTIVEMIRRORSORTING);
PYMODULE_ADDINTCONSTANT(LRO_GNUPGHOMEDIR);
PYMODULE_ADDINTCONSTANT(LRO_FASTESTMIRRORTIMEOUT);
PYMODULE_ADDINTCONSTANT(LRO_HTTPHEADER);
PYMODULE_ADDINTCONSTANT(LRO_OFFLINE);
PYMODULE_ADDINTCONSTANT(LRO_SENTINEL);
// Handle info options
PYMODULE_ADDINTCONSTANT(LRI_UPDATE);
PYMODULE_ADDINTCONSTANT(LRI_URLS);
PYMODULE_ADDINTCONSTANT(LRI_MIRRORLIST);
PYMODULE_ADDINTCONSTANT(LRI_MIRRORLISTURL);
PYMODULE_ADDINTCONSTANT(LRI_METALINKURL);
PYMODULE_ADDINTCONSTANT(LRI_LOCAL);
PYMODULE_ADDINTCONSTANT(LRI_PROGRESSCB);
PYMODULE_ADDINTCONSTANT(LRI_PROGRESSDATA);
PYMODULE_ADDINTCONSTANT(LRI_DESTDIR);
PYMODULE_ADDINTCONSTANT(LRI_REPOTYPE);
PYMODULE_ADDINTCONSTANT(LRI_USERAGENT);
PYMODULE_ADDINTCONSTANT(LRI_YUMDLIST);
PYMODULE_ADDINTCONSTANT(LRI_RPMMDDLIST);
PYMODULE_ADDINTCONSTANT(LRI_YUMBLIST);
PYMODULE_ADDINTCONSTANT(LRI_RPMMDBLIST);
PYMODULE_ADDINTCONSTANT(LRI_FETCHMIRRORS);
PYMODULE_ADDINTCONSTANT(LRI_MAXMIRRORTRIES);
PYMODULE_ADDINTCONSTANT(LRI_VARSUB);
PYMODULE_ADDINTCONSTANT(LRI_MIRRORS);
PYMODULE_ADDINTCONSTANT(LRI_METALINK);
PYMODULE_ADDINTCONSTANT(LRI_FASTESTMIRROR);
PYMODULE_ADDINTCONSTANT(LRI_FASTESTMIRRORCACHE);
PYMODULE_ADDINTCONSTANT(LRI_FASTESTMIRRORMAXAGE);
PYMODULE_ADDINTCONSTANT(LRI_HMFCB);
PYMODULE_ADDINTCONSTANT(LRI_SSLVERIFYPEER);
PYMODULE_ADDINTCONSTANT(LRI_SSLVERIFYHOST);
PYMODULE_ADDINTCONSTANT(LRI_SSLCLIENTCERT);
PYMODULE_ADDINTCONSTANT(LRI_SSLCLIENTKEY);
PYMODULE_ADDINTCONSTANT(LRI_SSLCACERT);
PYMODULE_ADDINTCONSTANT(LRI_IPRESOLVE);
PYMODULE_ADDINTCONSTANT(LRI_ALLOWEDMIRRORFAILURES);
PYMODULE_ADDINTCONSTANT(LRI_ADAPTIVEMIRRORSORTING);
PYMODULE_ADDINTCONSTANT(LRI_GNUPGHOMEDIR);
PYMODULE_ADDINTCONSTANT(LRI_FASTESTMIRRORTIMEOUT);
PYMODULE_ADDINTCONSTANT(LRI_HTTPHEADER);
PYMODULE_ADDINTCONSTANT(LRI_OFFLINE);
PYMODULE_ADDINTCONSTANT(LRI_LOWSPEEDTIME);
PYMODULE_ADDINTCONSTANT(LRI_LOWSPEEDLIMIT);
PYMODULE_ADDINTCONSTANT(LRI_SENTINEL);
// Check options
PYMODULE_ADDINTCONSTANT(LR_CHECK_GPG);
PYMODULE_ADDINTCONSTANT(LR_CHECK_CHECKSUM);
// Repo type
PYMODULE_ADDINTCONSTANT(LR_YUMREPO);
PYMODULE_ADDINTCONSTANT(LR_RPMMDREPO);
PYMODULE_ADDINTCONSTANT(LR_SUSEREPO);
PYMODULE_ADDINTCONSTANT(LR_DEBREPO);
// Proxy type
PYMODULE_ADDINTCONSTANT(LR_PROXY_HTTP);
PYMODULE_ADDINTCONSTANT(LR_PROXY_HTTP_1_0);
PYMODULE_ADDINTCONSTANT(LR_PROXY_SOCKS4);
PYMODULE_ADDINTCONSTANT(LR_PROXY_SOCKS5);
PYMODULE_ADDINTCONSTANT(LR_PROXY_SOCKS4A);
PYMODULE_ADDINTCONSTANT(LR_PROXY_SOCKS5_HOSTNAME);
// IpResolve type
PYMODULE_ADDINTCONSTANT(LR_IPRESOLVE_WHATEVER);
PYMODULE_ADDINTCONSTANT(LR_IPRESOLVE_V4);
PYMODULE_ADDINTCONSTANT(LR_IPRESOLVE_V6);
// Return codes
PYMODULE_ADDINTCONSTANT(LRE_OK);
PYMODULE_ADDINTCONSTANT(LRE_BADFUNCARG);
PYMODULE_ADDINTCONSTANT(LRE_BADOPTARG);
PYMODULE_ADDINTCONSTANT(LRE_UNKNOWNOPT);
PYMODULE_ADDINTCONSTANT(LRE_CURLSETOPT);
PYMODULE_ADDINTCONSTANT(LRE_ALREADYUSEDRESULT);
PYMODULE_ADDINTCONSTANT(LRE_INCOMPLETERESULT);
PYMODULE_ADDINTCONSTANT(LRE_CURLDUP);
PYMODULE_ADDINTCONSTANT(LRE_CURL);
PYMODULE_ADDINTCONSTANT(LRE_CURLM);
PYMODULE_ADDINTCONSTANT(LRE_BADSTATUS);
PYMODULE_ADDINTCONSTANT(LRE_TEMPORARYERR);
PYMODULE_ADDINTCONSTANT(LRE_NOTLOCAL);
PYMODULE_ADDINTCONSTANT(LRE_CANNOTCREATEDIR);
PYMODULE_ADDINTCONSTANT(LRE_IO);
PYMODULE_ADDINTCONSTANT(LRE_MLBAD);
PYMODULE_ADDINTCONSTANT(LRE_MLXML);
PYMODULE_ADDINTCONSTANT(LRE_BADCHECKSUM);
PYMODULE_ADDINTCONSTANT(LRE_REPOMDXML);
PYMODULE_ADDINTCONSTANT(LRE_NOURL);
PYMODULE_ADDINTCONSTANT(LRE_CANNOTCREATETMP);
PYMODULE_ADDINTCONSTANT(LRE_UNKNOWNCHECKSUM);
PYMODULE_ADDINTCONSTANT(LRE_BADURL);
PYMODULE_ADDINTCONSTANT(LRE_GPGNOTSUPPORTED);
PYMODULE_ADDINTCONSTANT(LRE_GPGERROR);
PYMODULE_ADDINTCONSTANT(LRE_BADGPG);
PYMODULE_ADDINTCONSTANT(LRE_INCOMPLETEREPO);
PYMODULE_ADDINTCONSTANT(LRE_INTERRUPTED);
PYMODULE_ADDINTCONSTANT(LRE_SIGACTION);
PYMODULE_ADDINTCONSTANT(LRE_ALREADYDOWNLOADED);
PYMODULE_ADDINTCONSTANT(LRE_UNFINISHED);
PYMODULE_ADDINTCONSTANT(LRE_SELECT);
PYMODULE_ADDINTCONSTANT(LRE_OPENSSL);
PYMODULE_ADDINTCONSTANT(LRE_MEMORY);
PYMODULE_ADDINTCONSTANT(LRE_XMLPARSER);
PYMODULE_ADDINTCONSTANT(LRE_CBINTERRUPTED);
PYMODULE_ADDINTCONSTANT(LRE_REPOMD);
PYMODULE_ADDINTCONSTANT(LRE_VALUE);
PYMODULE_ADDINTCONSTANT(LRE_NOTSET);
PYMODULE_ADDINTCONSTANT(LRE_FILE);
PYMODULE_ADDINTCONSTANT(LRE_KEYFILE);
PYMODULE_ADDINTCONSTANT(LRE_UNKNOWNERROR);
// Result option
PYMODULE_ADDINTCONSTANT(LRR_YUM_REPO);
PYMODULE_ADDINTCONSTANT(LRR_RPMMD_REPOMD);
PYMODULE_ADDINTCONSTANT(LRR_YUM_TIMESTAMP);
PYMODULE_ADDINTCONSTANT(LRR_RPMMD_REPO);
PYMODULE_ADDINTCONSTANT(LRR_YUM_REPOMD);
PYMODULE_ADDINTCONSTANT(LRR_RPMMD_TIMESTAMP);
PYMODULE_ADDINTCONSTANT(LRR_SENTINEL);
// Checksums
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_UNKNOWN);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_MD5);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA1);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA224);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA256);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA384);
PYMODULE_ADDINTCONSTANT(LR_CHECKSUM_SHA512);
// Transfer statuses
PYMODULE_ADDINTCONSTANT(LR_TRANSFER_SUCCESSFUL);
PYMODULE_ADDINTCONSTANT(LR_TRANSFER_ALREADYEXISTS);
PYMODULE_ADDINTCONSTANT(LR_TRANSFER_ERROR);
// Fastest mirror stages
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_INIT);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_CACHELOADING);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_CACHELOADINGSTATUS);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_DETECTION);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_FINISHING);
PYMODULE_ADDINTCONSTANT(LR_FMSTAGE_STATUS);
// Callbacks return values
PYMODULE_ADDINTCONSTANT(LR_CB_OK);
PYMODULE_ADDINTCONSTANT(LR_CB_ABORT);
PYMODULE_ADDINTCONSTANT(LR_CB_ERROR);
// Init librepo library
lr_global_init();
#if PY_MAJOR_VERSION >= 3
return m;
#endif
}
PyMODINIT_FUNC
init_librepo(void)
{
PyObject *m = Py_InitModule("_librepo", librepo_methods);
if (!m)
return;
/* Exceptions */
if (!init_exceptions())
return;
PyModule_AddObject(m, "LibrepoException", LrErr_Exception);
/* Objects */
/* _librepo.Handle */
if (PyType_Ready(&Handle_Type) < 0)
return;
Py_INCREF(&Handle_Type);
PyModule_AddObject(m, "Handle", (PyObject *)&Handle_Type);
/* _librepo.Result */
if (PyType_Ready(&Result_Type) < 0)
return;
Py_INCREF(&Result_Type);
PyModule_AddObject(m, "Result", (PyObject *)&Result_Type);
/* Module constants */
/* Version */
PyModule_AddIntConstant(m, "VERSION_MAJOR", LR_VERSION_MAJOR);
PyModule_AddIntConstant(m, "VERSION_MINOR", LR_VERSION_MINOR);
PyModule_AddIntConstant(m, "VERSION_PATCH", LR_VERSION_PATCH);
/* Handle options */
PyModule_AddIntConstant(m, "LRO_UPDATE", LRO_UPDATE);
PyModule_AddIntConstant(m, "LRO_URL", LRO_URL);
PyModule_AddIntConstant(m, "LRO_MIRRORLIST", LRO_MIRRORLIST);
PyModule_AddIntConstant(m, "LRO_LOCAL", LRO_LOCAL);
PyModule_AddIntConstant(m, "LRO_HTTPAUTH", LRO_HTTPAUTH);
PyModule_AddIntConstant(m, "LRO_USERPWD", LRO_USERPWD);
PyModule_AddIntConstant(m, "LRO_PROXY", LRO_PROXY);
PyModule_AddIntConstant(m, "LRO_PROXYPORT", LRO_PROXYPORT);
PyModule_AddIntConstant(m, "LRO_PROXYTYPE", LRO_PROXYTYPE);
PyModule_AddIntConstant(m, "LRO_PROXYAUTH", LRO_PROXYAUTH);
PyModule_AddIntConstant(m, "LRO_PROXYUSERPWD", LRO_PROXYUSERPWD);
PyModule_AddIntConstant(m, "LRO_PROGRESSCB", LRO_PROGRESSCB);
PyModule_AddIntConstant(m, "LRO_PROGRESSDATA", LRO_PROGRESSDATA);
PyModule_AddIntConstant(m, "LRO_RETRIES", LRO_RETRIES);
PyModule_AddIntConstant(m, "LRO_MAXSPEED", LRO_MAXSPEED);
PyModule_AddIntConstant(m, "LRO_DESTDIR", LRO_DESTDIR);
PyModule_AddIntConstant(m, "LRO_REPOTYPE", LRO_REPOTYPE);
PyModule_AddIntConstant(m, "LRO_CONNECTTIMEOUT", LRO_CONNECTTIMEOUT);
PyModule_AddIntConstant(m, "LRO_IGNOREMISSING", LRO_IGNOREMISSING);
PyModule_AddIntConstant(m, "LRO_GPGCHECK", LRO_GPGCHECK);
PyModule_AddIntConstant(m, "LRO_CHECKSUM", LRO_CHECKSUM);
PyModule_AddIntConstant(m, "LRO_YUMDLIST", LRO_YUMDLIST);
PyModule_AddIntConstant(m, "LRO_YUMBLIST", LRO_YUMBLIST);
PyModule_AddIntConstant(m, "LRO_SENTINEL", LRO_SENTINEL);
/* Handle info options */
PyModule_AddIntConstant(m, "LRI_UPDATE", LRI_UPDATE);
PyModule_AddIntConstant(m, "LRI_URL", LRI_URL);
PyModule_AddIntConstant(m, "LRI_MIRRORLIST", LRI_MIRRORLIST);
PyModule_AddIntConstant(m, "LRI_LOCAL", LRI_LOCAL);
PyModule_AddIntConstant(m, "LRI_PROGRESSCB", LRI_PROGRESSCB);
PyModule_AddIntConstant(m, "LRI_PROGRESSDATA", LRI_PROGRESSDATA);
PyModule_AddIntConstant(m, "LRI_DESTDIR", LRI_DESTDIR);
PyModule_AddIntConstant(m, "LRI_REPOTYPE", LRI_REPOTYPE);
PyModule_AddIntConstant(m, "LRI_YUMDLIST", LRI_YUMDLIST);
PyModule_AddIntConstant(m, "LRI_YUMBLIST", LRI_YUMBLIST);
PyModule_AddIntConstant(m, "LRI_LASTCURLERR", LRI_LASTCURLERR);
PyModule_AddIntConstant(m, "LRI_LASTCURLMERR", LRI_LASTCURLMERR);
PyModule_AddIntConstant(m, "LRI_LASTCURLSTRERR", LRI_LASTCURLSTRERR);
PyModule_AddIntConstant(m, "LRI_LASTCURLMSTRERR", LRI_LASTCURLMSTRERR);
PyModule_AddIntConstant(m, "LRI_LASTBADSTATUSCODE", LRI_LASTBADSTATUSCODE);
/* Check options */
PyModule_AddIntConstant(m, "LR_CHECK_GPG", LR_CHECK_GPG);
PyModule_AddIntConstant(m, "LR_CHECK_CHECKSUM", LR_CHECK_CHECKSUM);
/* Repo type */
PyModule_AddIntConstant(m, "LR_YUMREPO", LR_YUMREPO);
PyModule_AddIntConstant(m, "LR_SUSEREPO", LR_SUSEREPO);
PyModule_AddIntConstant(m, "LR_DEBREPO", LR_DEBREPO);
/* Proxy type */
PyModule_AddIntConstant(m, "LR_PROXY_HTTP", LR_PROXY_HTTP);
PyModule_AddIntConstant(m, "LR_PROXY_HTTP_1_0", LR_PROXY_HTTP_1_0);
PyModule_AddIntConstant(m, "LR_PROXY_SOCKS4", LR_PROXY_SOCKS4);
PyModule_AddIntConstant(m, "LR_PROXY_SOCKS5", LR_PROXY_SOCKS5);
PyModule_AddIntConstant(m, "LR_PROXY_SOCKS4A", LR_PROXY_SOCKS4A);
PyModule_AddIntConstant(m, "LR_PROXY_SOCKS5_HOSTNAME", LR_PROXY_SOCKS5_HOSTNAME);
/* Return codes */
PyModule_AddIntConstant(m, "LRE_OK", LRE_OK);
PyModule_AddIntConstant(m, "LRE_BADFUNCARG", LRE_BADFUNCARG);
PyModule_AddIntConstant(m, "LRE_BADOPTARG", LRE_BADOPTARG);
PyModule_AddIntConstant(m, "LRE_UNKNOWNOPT", LRE_UNKNOWNOPT);
PyModule_AddIntConstant(m, "LRE_CURLSETOPT", LRE_CURLSETOPT);
PyModule_AddIntConstant(m, "LRE_ALREADYUSEDRESULT", LRE_ALREADYUSEDRESULT);
PyModule_AddIntConstant(m, "LRE_INCOMPLETERESULT", LRE_INCOMPLETERESULT);
PyModule_AddIntConstant(m, "LRE_CURLDUP", LRE_CURLDUP);
PyModule_AddIntConstant(m, "LRE_CURL", LRE_CURL);
PyModule_AddIntConstant(m, "LRE_CURLM", LRE_CURLM);
PyModule_AddIntConstant(m, "LRE_BADSTATUS", LRE_BADSTATUS);
PyModule_AddIntConstant(m, "LRE_TEMPORARYERR", LRE_TEMPORARYERR);
PyModule_AddIntConstant(m, "LRE_NOTLOCAL", LRE_NOTLOCAL);
PyModule_AddIntConstant(m, "LRE_CANNOTCREATEDIR", LRE_CANNOTCREATEDIR);
PyModule_AddIntConstant(m, "LRE_IO", LRE_IO);
PyModule_AddIntConstant(m, "LRE_MLBAD", LRE_MLBAD);
PyModule_AddIntConstant(m, "LRE_MLXML", LRE_MLXML);
PyModule_AddIntConstant(m, "LRE_BADCHECKSUM", LRE_BADCHECKSUM);
PyModule_AddIntConstant(m, "LRE_REPOMDXML", LRE_REPOMDXML);
PyModule_AddIntConstant(m, "LRE_NOURL", LRE_NOURL);
PyModule_AddIntConstant(m, "LRE_CANNOTCREATETMP", LRE_CANNOTCREATETMP);
PyModule_AddIntConstant(m, "LRE_UNKNOWNCHECKSUM", LRE_UNKNOWNCHECKSUM);
PyModule_AddIntConstant(m, "LRE_BADURL", LRE_BADURL);
PyModule_AddIntConstant(m, "LRE_GPGNOTSUPPORTED", LRE_GPGNOTSUPPORTED);
PyModule_AddIntConstant(m, "LRE_GPGERROR", LRE_GPGERROR);
PyModule_AddIntConstant(m, "LRE_BADGPG", LRE_BADGPG);
PyModule_AddIntConstant(m, "LRE_INCOMPLETEREPO", LRE_INCOMPLETEREPO);
PyModule_AddIntConstant(m, "LRE_UNKNOWNERROR", LRE_UNKNOWNERROR);
/* Result option */
PyModule_AddIntConstant(m, "LRR_YUM_REPO", LRR_YUM_REPO);
PyModule_AddIntConstant(m, "LRR_YUM_REPOMD", LRR_YUM_REPOMD);
PyModule_AddIntConstant(m, "LRR_SENTINEL", LRR_SENTINEL);
/* Checksums */
PyModule_AddIntConstant(m, "CHECKSUM_UNKNOWN", LR_CHECKSUM_UNKNOWN);
PyModule_AddIntConstant(m, "CHECKSUM_MD2", LR_CHECKSUM_MD2);
PyModule_AddIntConstant(m, "CHECKSUM_MD5", LR_CHECKSUM_MD5);
PyModule_AddIntConstant(m, "CHECKSUM_SHA", LR_CHECKSUM_SHA);
PyModule_AddIntConstant(m, "CHECKSUM_SHA1", LR_CHECKSUM_SHA1);
PyModule_AddIntConstant(m, "CHECKSUM_SHA224", LR_CHECKSUM_SHA224);
PyModule_AddIntConstant(m, "CHECKSUM_SHA256", LR_CHECKSUM_SHA256);
PyModule_AddIntConstant(m, "CHECKSUM_SHA384", LR_CHECKSUM_SHA384);
PyModule_AddIntConstant(m, "CHECKSUM_SHA512", LR_CHECKSUM_SHA512);
}
