![]() ![]() |
![]() |
File: [OMI] / omi / scriptext / py / PythonBinding.c
(download)
Revision: 1.1, Mon Apr 20 17:20:13 2015 UTC (9 years, 2 months ago) by krisbash Branch: MAIN CVS Tags: OMI_1_0_8_2, OMI_1_0_8_1, HEAD OMI 1.0.8-1 |
#include "/usr/include/python2.6/Python.h" #include "MI.h" #include <string.h> #include "structmember.h" #include "PMI_Session.c" /*Define a static MI Exception type*/ static PyObject *MIError; PyObject* CleanupApplication(MI_DestinationOptions miDestinationOptions, MI_Application miApplication, MI_Result miResult) { if (miDestinationOptions.ft) { MI_DestinationOptions_Delete(&miDestinationOptions); } MI_Application_Close(&miApplication); char str[80]; strcpy(str,"MI_Application_NewSession failed, error = "); strcat(str,MI_Result_To_String(miResult)); PyErr_SetString(MIError,str); return NULL; } PyObject* CleanupSession(MI_DestinationOptions miDestinationOptions, MI_Application miApplication, MI_Result miResult, MI_Session miSession) { MI_Session_Close(&miSession, NULL, NULL); return CleanupApplication(miDestinationOptions, miApplication, miResult); } static PyObject* Connect(PyObject* self, PyObject* args){ //initiazlie the python module first Py_Initialize(); initPMI_Session(); initPMI_Instance(); initPMI_Class(); PMI_Session* session = (PMI_Session*) InitSession(); MI_Application miApplication = MI_APPLICATION_NULL; MI_Session miSession = MI_SESSION_NULL; MI_Result miResult; MI_DestinationOptions miDestinationOptions = MI_DESTINATIONOPTIONS_NULL; MI_UserCredentials miUserCreds = {0}; char* domain, *username, *password; if(!PyArg_ParseTuple(args,"sss",&domain,&username,&password)) { PyErr_SetString(MIError,"Connection failed: please input the correct domian, username and password"); return NULL; } miUserCreds.authenticationType = MI_AUTH_TYPE_BASIC; miUserCreds.credentials.usernamePassword.domain = MI_T(domain); miUserCreds.credentials.usernamePassword.username = username; miUserCreds.credentials.usernamePassword.password = password; miResult = MI_Application_Initialize(0, NULL, NULL, &miApplication); if (miResult != MI_RESULT_OK) { PyErr_SetString(MIError,"MI_Application_Initialize failed"); return NULL; } miResult = MI_Application_NewDestinationOptions(&miApplication, &miDestinationOptions); if (miResult != MI_RESULT_OK) { return CleanupApplication(miDestinationOptions, miApplication, miResult); } miResult = MI_DestinationOptions_AddDestinationCredentials(&miDestinationOptions, &miUserCreds); if (miResult != MI_RESULT_OK) { return CleanupApplication(miDestinationOptions, miApplication, miResult); } miResult = MI_Application_NewSession(&miApplication, NULL, NULL, &miDestinationOptions, NULL, NULL, &miSession); if (miResult != MI_RESULT_OK) { return CleanupApplication(miDestinationOptions, miApplication, miResult); } /*Make sure the connection is successful */ miResult = TestConnection(&miSession); if(miResult != MI_RESULT_OK) { PyErr_SetString(MIError,"Connection failed.Check the server status and credentials"); return NULL; } session->miSession = miSession; Py_INCREF(session); return (PyObject *)session; } static PyObject *CreateLocalInstance(PyObject *self, PyObject *args, PyObject *kwds) { char *className; PyObject *propertyDict; PyObject *propertyTypes = NULL; PyObject *propertyFlags = NULL; static char *kwlist[] = {"className","propertyValues","propertyTypes","propertyFlags",NULL}; if(!PyArg_ParseTupleAndKeywords(args,kwds,"sO!|OO",kwlist,&className,&PyDict_Type, &propertyDict,&propertyTypes,&propertyFlags)) { PyErr_SetString(MIError,"Please input correct classname and property dictionaries"); return NULL; } MI_Result miResult; MI_Application miApplication = MI_APPLICATION_NULL; MI_Instance *miInstance = NULL; miResult = MI_Application_Initialize(0, NULL, NULL, &miApplication); if (miResult != MI_RESULT_OK) { PyErr_SetString(MIError,"MI_Application Initialize failed"); return NULL; } miResult = MI_Application_NewInstance(&miApplication,className,NULL,&miInstance); if(miResult != MI_RESULT_OK) { char error[200]; strcpy(error,"Failed to create an instance of class "); strcat(error,className); strcat(error,", error = "); strcat(error,MI_Result_To_String(miResult)); PyErr_SetString(MIError,error); return NULL; } //Iterate the dictionary and add property values to the instance PyObject *key, *value; Py_ssize_t pos = 0; while (PyDict_Next(propertyDict, &pos, &key, &value)) { MI_Value miValue; MI_Type miType; MI_Uint32 miFlag; char *propertyName; PyObject *propertyValue; if(!PyArg_Parse(key,"s",&propertyName)) { PyErr_SetString(MIError,"Property name is not correct"); return NULL; } if(!PyArg_Parse(value,"O",&propertyValue)) { PyErr_SetString(MIError,"Property value is not correct"); return NULL; } /*If the user doesn't specify property type, set the default type to be string */ if(propertyTypes != NULL) { PyObject *typeValue = PyDict_GetItemString(propertyTypes,propertyName); if(typeValue != NULL) { miType = PyInt_AsLong(typeValue); SetPropertyValues(miType,propertyValue,&miValue); } else { /*Need to check if it's datetime object otherwise server always expects interval for datetime object*/ if (PyDateTime_Check(propertyValue) || PyDelta_Check(propertyValue)) { miType = MI_DATETIME; SetPropertyValues(miType,propertyValue,&miValue); } else { miValue.string = PyString_AsString(propertyValue); miType = MI_STRING; } } } if(propertyFlags != NULL) { PyObject *flagValue = PyDict_GetItemString(propertyFlags,propertyName); if(flagValue != NULL) { long value = PyInt_AsLong(flagValue); miFlag = (MI_Uint32)value; } } miResult = MI_Instance_AddElement(miInstance,propertyName,&miValue,miType,miFlag); if(miResult != MI_RESULT_OK) { char error[200]; strcpy(error,"MI_Instance_AddElement failed, error ="); strcat(error,MI_Result_To_String(miResult)); PyErr_SetString(MIError,error); return NULL; } } PMI_Instance* pmiInstance = (PMI_Instance*) initPMI(); pmiInstance->miInstance = miInstance; pmiInstance->propertyValues = propertyDict; pmiInstance->propertyTypes = propertyTypes; pmiInstance->propertyFlags = propertyFlags; return (PyObject *)pmiInstance; } void DatetimeToStr(const MI_Datetime* x, _Out_writes_z_(26) MI_Char buf[26]) { if (x->isTimestamp) { const MI_Char FMT[] = "%04d%02d%02d%02d%02d%02d.%06d%c%03d"; MI_Sint32 utc = x->u.timestamp.utc; sprintf(buf,FMT, x->u.timestamp.year, x->u.timestamp.month, x->u.timestamp.day, x->u.timestamp.hour, x->u.timestamp.minute, x->u.timestamp.second, x->u.timestamp.microseconds, utc < 0 ? '-' : '+', utc < 0 ? -utc : utc); } else { const MI_Char FMT[] = "%08u%02u%02u%02u.%06u:000"; sprintf(buf,FMT, x->u.interval.days, x->u.interval.hours, x->u.interval.minutes, x->u.interval.seconds, x->u.interval.microseconds); } } static char* MI_Type_To_String(MI_Type miType) { switch (miType) { case MI_BOOLEAN: { return "MI_BOOLEAN"; } case MI_UINT8: { return "MI_UINT8"; } case MI_SINT8: { return "MI_SINT8"; } case MI_UINT16: { return "MI_UINT16"; } case MI_SINT16: { return "MI_SINT16"; } case MI_UINT32: { return "MI_UINT32"; } case MI_SINT32: { return "MI_SINT32"; } case MI_UINT64: { return "MI_UINT64"; } case MI_SINT64: { return "MI_SINT64"; } case MI_REAL32: { return "MI_REAL32"; } case MI_REAL64: { return "MI_REAL64"; } case MI_CHAR16: { return "MI_CHAR16"; } case MI_DATETIME: { return "MI_DATETIME"; } case MI_STRING: { return "MI_STRING"; } case MI_REFERENCE: { return "MI_REFERENCE"; } case MI_INSTANCE: { return "MI_INSTANCE"; } case MI_BOOLEANA: { return "MI_BOOLEANA"; } case MI_UINT8A: { return "MI_UINT8A"; } case MI_SINT8A: { return "MI_SINT8A"; } case MI_UINT16A: { return "MI_UINT16A"; } case MI_SINT16A: { return "MI_SINT16A"; } case MI_UINT32A: { return "MI_UINT32A"; } case MI_SINT32A: { return "MI_SINT32A"; } case MI_UINT64A: { return "MI_UINT64A"; } case MI_SINT64A: { return "MI_SINT64A"; } case MI_REAL32A: { return "MI_REAL32A"; } case MI_REAL64A: { return "MI_REAL64A"; } case MI_CHAR16A: { return "MI_CHAR16A"; } case MI_DATETIMEA: { return "MI_DATETIMEA"; } case MI_STRINGA: { return "MI_STRINGA"; } case MI_REFERENCEA: { return "MI_REFERENCEA"; } case MI_INSTANCEA: { return "MI_INSTANCEA"; } } return ""; } //forward declaration void Print_Element_Value( const MI_Value *elementValue, MI_Type elementType, size_t level); void Indent(size_t level) { size_t n = level *4; while(n--) PySys_WriteStdout(" "); } /* Print an element */ void Print_Element( const MI_Char *elementName, const MI_Value *elementValue, MI_Type elementType, MI_Uint32 elementFlags, size_t level) { Indent(level); PySys_WriteStdout("%s [%s", elementName, MI_Type_To_String(elementType)); if (elementFlags & MI_FLAG_KEY) { PySys_WriteStdout(", MI_FLAG_KEY"); } if ((elementFlags & MI_FLAG_NULL) || (elementValue == NULL)) { PySys_WriteStdout(", NULL]"); return; } else { PySys_WriteStdout("] "); Print_Element_Value(elementValue, elementType, level); } } void Dump_MI_Instance(MI_Instance *miInstance, MI_Boolean keysOnly, size_t level) { if(miInstance == NULL) { PyErr_SetString(MIError,"MI_Instance is null"); return; } MI_Uint32 elementCount; MI_Result miResult; MI_Uint32 elementIndex; miResult = MI_Instance_GetElementCount(miInstance, &elementCount); if (miResult != MI_RESULT_OK) { PyErr_SetString(MIError,"MI_Instance_GetElementCount failed"); } Indent(level); PySys_WriteStdout("Class %s\n", miInstance->classDecl->name); Indent(level); PySys_WriteStdout("{\n"); Indent(level); for (elementIndex = 0; elementIndex != elementCount; elementIndex++) { const MI_Char *elementName; MI_Value elementValue; MI_Type elementType; MI_Uint32 elementFlags; miResult = MI_Instance_GetElementAt(miInstance, elementIndex, &elementName, &elementValue, &elementType, &elementFlags); if (miResult != MI_RESULT_OK) { PyErr_SetString(MIError,"MI_Instance_GetElementCount failed"); } if ((keysOnly && (elementFlags & MI_FLAG_KEY)) || !keysOnly) { Print_Element(elementName, &elementValue, elementType, elementFlags, level+1); PySys_WriteStdout("\n"); } } Indent(level); PySys_WriteStdout("}\n"); } void Print_Element_Value( const MI_Value *elementValue, MI_Type elementType, size_t level) { switch (elementType) { case MI_BOOLEAN: { PySys_WriteStdout("%s", elementValue->boolean ? "True" : "False"); break; } case MI_SINT8: { PySys_WriteStdout("%hd", elementValue->sint8); break; } case MI_UINT8: { PySys_WriteStdout("%hu", elementValue->uint8); break; } case MI_SINT16: { PySys_WriteStdout("%d", elementValue->sint16); break; } case MI_UINT16: { PySys_WriteStdout("%u", elementValue->uint16); break; } case MI_SINT32: { PySys_WriteStdout("%i", elementValue->sint32); break; } case MI_UINT32: { PySys_WriteStdout("%u", elementValue->uint32); break; } case MI_SINT64: { PySys_WriteStdout("%lld", elementValue->sint64); break; } case MI_UINT64: { PySys_WriteStdout("%llu", elementValue->uint64); break; } case MI_REAL32: { PySys_WriteStdout("%g", elementValue->real32); break; } case MI_REAL64: { PySys_WriteStdout("%lg", elementValue->real64); break; } case MI_CHAR16: { PySys_WriteStdout("%u", elementValue->char16); break; } case MI_DATETIME: { MI_Char buf[26]; DatetimeToStr(&elementValue->datetime, buf); PySys_WriteStdout("%s", buf); break; } case MI_STRING: { PySys_WriteStdout("%s", elementValue->string); break; } case MI_BOOLEANA: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->booleana.size; i++) { MI_Value value; value.boolean = elementValue->booleana.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_SINT8A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->sint8a.size; i++) { MI_Value value; value.sint8 = elementValue->sint8a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_UINT8A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->uint8a.size; i++) { MI_Value value; value.uint8 = elementValue->uint8a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_SINT16A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->sint16a.size; i++) { MI_Value value; value.sint16 = elementValue->sint16a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_UINT16A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->uint16a.size; i++) { MI_Value value; value.uint16 = elementValue->uint16a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_SINT32A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->sint32a.size; i++) { MI_Value value; value.sint32 = elementValue->sint32a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_UINT32A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->uint32a.size; i++) { MI_Value value; value.uint32 = elementValue->uint32a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_SINT64A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->sint64a.size; i++) { MI_Value value; value.sint64 = elementValue->sint64a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_UINT64A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->uint64a.size; i++) { MI_Value value; value.uint64 = elementValue->uint64a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_REAL32A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->real32a.size; i++) { MI_Value value; value.real32 = elementValue->real32a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_REAL64A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->real64a.size; i++) { MI_Value value; value.real64 = elementValue->real64a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_CHAR16A: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->char16a.size; i++) { MI_Value value; value.char16 = elementValue->char16a.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_DATETIMEA: { MI_Uint32 i; MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY)); PySys_WriteStdout("{"); for (i = 0; i < elementValue->datetimea.size; i++) { MI_Value value; value.datetime = elementValue->datetimea.data[i]; Print_Element_Value(&value, nonArrayType, level); if (i + 1 != elementValue->datetimea.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_STRINGA: { MI_Uint32 i; PySys_WriteStdout("{"); for (i = 0; i < elementValue->stringa.size; i++) { MI_Char *value; value = elementValue->stringa.data[i]; PySys_WriteStdout(value); if (i + 1 != elementValue->stringa.size) PySys_WriteStdout(", "); } PySys_WriteStdout("}"); break; } case MI_INSTANCE: { MI_Instance* inst = elementValue->instance; Dump_MI_Instance(inst, MI_FALSE, level); break; } case MI_REFERENCE: { MI_Instance* inst = elementValue->reference; PySys_WriteStdout(" REF "); Dump_MI_Instance(inst, MI_TRUE, level); break; } case MI_INSTANCEA: { const MI_InstanceA* inst = &elementValue->instancea; MI_Uint32 i; PySys_WriteStdout("\n"); Indent(level); PySys_WriteStdout("{\n"); for (i = 0; i < inst->size; i++) { Dump_MI_Instance(inst->data[i], MI_TRUE, level + 1); } Indent(level); PySys_WriteStdout("}"); break; } case MI_REFERENCEA: { const MI_InstanceA* inst = &elementValue->instancea; MI_Uint32 i; PySys_WriteStdout(" REF "); PySys_WriteStdout("\n"); Indent(level); PySys_WriteStdout("{\n"); for (i = 0; i < inst->size; i++) { Dump_MI_Instance(inst->data[i], MI_FALSE, level + 1); } Indent(level); PySys_WriteStdout("}"); break; } default: break; } } static PyObject *Print(PyObject *self,PyObject *args) { PyObject *instance; if(!PyArg_ParseTuple(args,"O",&instance)) { PyErr_SetString(MIError,"Please input correct MI_Instance"); return NULL; } PMI_Instance *pmiInstance = (PMI_Instance *)instance; MI_Instance *miInstance; if(pmiInstance != NULL && (PyObject_Compare((PyObject *)pmiInstance,Py_None))) { miInstance = pmiInstance->miInstance; } else { PyErr_SetString(MIError,"MI_Instance cannot be null!"); return NULL; } Dump_MI_Instance(miInstance,MI_FALSE,0); Py_INCREF(Py_None); return Py_None; } static PyMethodDef mi_funcs[] = { {"connect",(PyCFunction)Connect,METH_VARARGS,NULL}, {"create_local_instance",(PyCFunction)CreateLocalInstance,METH_VARARGS|METH_KEYWORDS,NULL}, {"print_instance",(PyCFunction)Print,METH_VARARGS,NULL}, {NULL} }; void initmi(void) { PyObject *m; m = Py_InitModule3("mi", mi_funcs, "MI module that wraps up the MI operation from client API"); /*Add the exception type to the module */ MIError = PyErr_NewException("mi.error",NULL,NULL); Py_INCREF(MIError); PyModule_AddObject(m,"MIError",MIError); /*enum types */ PyModule_AddIntConstant(m, "BOOLEAN",0); PyModule_AddIntConstant(m,"UINT8",1); PyModule_AddIntConstant(m, "SINT8",2); PyModule_AddIntConstant(m,"UINT16",3); PyModule_AddIntConstant(m,"SINT16",4); PyModule_AddIntConstant(m, "UINT32",5); PyModule_AddIntConstant(m,"SINT32",6); PyModule_AddIntConstant(m, "UINT64",7); PyModule_AddIntConstant(m,"SINT64",8); PyModule_AddIntConstant(m,"REAL32",9); PyModule_AddIntConstant(m, "REAL64",10); PyModule_AddIntConstant(m,"CHAR16",11); PyModule_AddIntConstant(m, "DATETIME",12); PyModule_AddIntConstant(m,"STRING",13); PyModule_AddIntConstant(m,"REFERENCE",14); PyModule_AddIntConstant(m, "INSTANCE",15); PyModule_AddIntConstant(m,"BOOLEANA",16); PyModule_AddIntConstant(m, "UINT8A",17); PyModule_AddIntConstant(m,"SINT8A",18); PyModule_AddIntConstant(m,"UINT16A",19); PyModule_AddIntConstant(m, "SINT16A",20); PyModule_AddIntConstant(m,"UINT32A",21); PyModule_AddIntConstant(m, "SINT32A",22); PyModule_AddIntConstant(m,"UINT64A",23); PyModule_AddIntConstant(m,"SINT64A",24); PyModule_AddIntConstant(m, "REAL32A",25); PyModule_AddIntConstant(m,"REAL64A",26); PyModule_AddIntConstant(m, "CHAR16A",27); PyModule_AddIntConstant(m,"DATETIMEA",28); PyModule_AddIntConstant(m,"STRINGA",29); PyModule_AddIntConstant(m,"REFERENCEA",30); PyModule_AddIntConstant(m,"INSTANCEA",31); /*CIM meta types */ PyModule_AddIntConstant(m,"FLAG_CLASS",1 << 0); PyModule_AddIntConstant(m,"FLAG_METHOD",1 << 1); PyModule_AddIntConstant(m,"FLAG_PROPERTY",1 << 2); PyModule_AddIntConstant(m,"FLAG_PARAMETER", 1 << 3); PyModule_AddIntConstant(m,"FLAG_ASSOCIATION",1 << 4); PyModule_AddIntConstant(m,"FLAG_INDICATION", 1 << 5); PyModule_AddIntConstant(m,"FLAG_REFERENCE", 1 << 6); PyModule_AddIntConstant(m,"FLAG_ANY",1|2|4|8|16|32|64); /*Qualifier flavors */ PyModule_AddIntConstant(m,"FLAG_ENABLEOVERRIDE",1 << 7); PyModule_AddIntConstant(m,"FLAG_DISABLEOVERRIDE",1 << 8); PyModule_AddIntConstant(m,"FLAG_RESTRICTED",1 << 9); PyModule_AddIntConstant(m,"FLAG_TOSUBCLASS",1 << 10); PyModule_AddIntConstant(m,"FLAG_PARAMETER", 1 << 11); /*Select boolean qualifiers */ PyModule_AddIntConstant(m,"FLAG_KEY",1 << 12); PyModule_AddIntConstant(m,"FLAG_IN",1 << 13); PyModule_AddIntConstant(m,"FLAG_OUT",1 << 14); PyModule_AddIntConstant(m,"FLAG_REQUIRED",1 << 15); PyModule_AddIntConstant(m,"FLAG_STATIC", 1 << 16); PyModule_AddIntConstant(m,"FLAG_ABSTRACT",1 << 17); PyModule_AddIntConstant(m,"FLAG_TERMINAL",1 << 18); PyModule_AddIntConstant(m,"FLAG_EXPENSIVE",1 << 19); PyModule_AddIntConstant(m,"FLAG_STREAM",1 << 20); PyModule_AddIntConstant(m,"FLAG_READONLY", 1 << 21); /* Special flags */ PyModule_AddIntConstant(m,"FLAG_NOT_MODIFIED",1 << 25); PyModule_AddIntConstant(m,"FLAG_VERSION",1<<26|1<<27|1<<28); PyModule_AddIntConstant(m,"FLAG_NULL",1 << 29); PyModule_AddIntConstant(m,"FLAG_BORROW",1 << 30); PyModule_AddIntConstant(m,"FLAG_ADOPT", 1 << 31); }
ViewCVS 0.9.2 |