/** * Helper function to convert Python objects into a representation that the * rrdtool functions can work with. * * @param command RRDtool command name * @param args Command arguments * @return Zero if the function succeeds, otherwise -1 */ static int convert_args(char *command, PyObject *args) { PyObject *o, *lo; int i, j, args_count, argv_count, element_count; argv_count = element_count = 0; args_count = PyTuple_Size(args); for (i = 0; i < args_count; i++) { o = PyTuple_GET_ITEM(args, i); if (PyRRD_String_Check(o)) element_count++; else if (PyList_CheckExact(o)) element_count += PyList_Size(o); else { PyErr_Format(PyExc_TypeError, "Argument %d must be str or a list of str", i); return -1; } } rrdtool_argv = PyMem_New(char *, element_count + 1); if (rrdtool_argv == NULL) return -1; for (i = 0; i < args_count; i++) { o = PyTuple_GET_ITEM(args, i); if (PyRRD_String_Check(o)) rrdtool_argv[++argv_count] = PyRRD_String_AS_STRING(o); else if (PyList_CheckExact(o)) { for (j = 0; j < PyList_Size(o); j++) { lo = PyList_GetItem(o, j); if (PyRRD_String_Check(lo)) rrdtool_argv[++argv_count] = PyRRD_String_AS_STRING(lo); else { PyMem_Del(rrdtool_argv); PyErr_Format(PyExc_TypeError, "Element %d in argument %d must be str", j, i); return -1; } } } else { PyMem_Del(rrdtool_argv); PyErr_Format(rrdtool_ProgrammingError, "Argument %d must be str or list of str", i); return -1; } } rrdtool_argv[0] = command; rrdtool_argc = element_count + 1; return 0; }
static int rw_close_th(SDL_RWops* context) { RWHelper* helper = (RWHelper*)context->hidden.unknown.data1; PyObject* result; int retval = 0; PyThreadState* oldstate; PyEval_AcquireLock(); oldstate = PyThreadState_Swap(helper->thread); if(helper->close) { result = PyObject_CallFunction(helper->close, NULL); if(result) retval = -1; Py_XDECREF(result); } PyThreadState_Swap(oldstate); PyThreadState_Clear(helper->thread); PyThreadState_Delete(helper->thread); Py_XDECREF(helper->seek); Py_XDECREF(helper->tell); Py_XDECREF(helper->write); Py_XDECREF(helper->read); Py_XDECREF(helper->close); PyMem_Del(helper); PyEval_ReleaseLock(); SDL_FreeRW(context); return retval; }
static int create_args(char *command, PyObject *args, int *argc, char ***argv) { PyObject *o; int size, i; size = PyTuple_Size(args); *argv = PyMem_New(char *, size + 1); if (*argv == NULL) return -1; for (i = 0; i < size; i++) { o = PyTuple_GET_ITEM(args, i); if (PyString_Check(o)) (*argv)[i + 1] = PyString_AS_STRING(o); else { PyMem_Del(*argv); PyErr_Format(PyExc_TypeError, "argument %d must be string", i); return -1; } } (*argv)[0] = command; *argc = size + 1; /* reset getopt state */ opterr = optind = 0; return 0; }
static PyObject * scss_Scanner_setup_patterns(PyObject *self, PyObject *patterns) { PyObject *item, *item0, *item1; int i, is_tuple, _is_tuple; long size; Pattern *_patterns = NULL; int patterns_sz = 0; if (!Scanner_initialized()) { is_tuple = PyTuple_Check(patterns); if (is_tuple || PyList_Check(patterns)) { size = is_tuple ? PyTuple_Size(patterns) : PyList_Size(patterns); _patterns = PyMem_New(Pattern, size); for (i = 0; i < size; ++i) { item = is_tuple ? PyTuple_GetItem(patterns, i) : PyList_GetItem(patterns, i); _is_tuple = PyTuple_Check(item); if (_is_tuple || PyList_Check(item)) { item0 = _is_tuple ? PyTuple_GetItem(item, 0) : PyList_GetItem(item, 0); item1 = _is_tuple ? PyTuple_GetItem(item, 1) : PyList_GetItem(item, 1); if (PyString_Check(item0) && PyString_Check(item1)) { _patterns[patterns_sz].tok = PyString_AsString(item0); _patterns[patterns_sz].expr = PyString_AsString(item1); patterns_sz++; } } } } Scanner_initialize(_patterns, patterns_sz); if (_patterns != NULL) PyMem_Del(_patterns); } Py_INCREF(Py_None); return (PyObject *)Py_None; }
/* ArrayListType.tp_dealloc */ static void ArrayList_dealloc(ArrayList *self) { Py_XDECREF(self->data); PyMem_Del(self->data); Py_TYPE(self)->tp_free((PyObject*)self); }
static void Pattern_finalize(void) { int j; #ifdef DEBUG fprintf(stderr, "%s\n", __PRETTY_FUNCTION__); #endif if (Pattern_patterns_initialized) { for (j = 0; j < Pattern_patterns_sz; j++) { PyMem_Del(Pattern_patterns[j].tok); PyMem_Del(Pattern_patterns[j].expr); if (Pattern_patterns[j].pattern != NULL) { pcre_free(Pattern_patterns[j].pattern); } } PyMem_Del(Pattern_patterns); Pattern_patterns = NULL; Pattern_patterns_sz = 0; Pattern_patterns_bsz = 0; Pattern_patterns_initialized = 0; } }
static int _pyobj_close_threaded (SDL_RWops *ops) { _RWWrapper *wrapper = (_RWWrapper *) ops->hidden.unknown.data1; PyObject *result; int retval = 0; PyThreadState* oldstate; PyThreadState* wrap; PyEval_AcquireThread (wrapper->thread); oldstate = PyThreadState_Swap (wrapper->thread); if (wrapper->close) { result = PyObject_CallFunction (wrapper->close, NULL); if (!result) { PyErr_Print (); retval = -1; } Py_XDECREF (result); } Py_XDECREF (wrapper->seek); Py_XDECREF (wrapper->tell); Py_XDECREF (wrapper->write); Py_XDECREF (wrapper->read); Py_XDECREF (wrapper->close); PyThreadState_Swap (oldstate); wrap = wrapper->thread; PyMem_Del (wrapper); PyThreadState_Clear (wrap); PyEval_ReleaseThread (wrap); PyThreadState_Delete (wrap); SDL_FreeRW (ops); return retval; }
static int rw_close(SDL_RWops* context) { RWHelper* helper = (RWHelper*)context->hidden.unknown.data1; PyObject* result; int retval = 0; if(helper->close) { result = PyObject_CallFunction(helper->close, NULL); if(result) retval = -1; Py_XDECREF(result); } Py_XDECREF(helper->seek); Py_XDECREF(helper->tell); Py_XDECREF(helper->write); Py_XDECREF(helper->read); Py_XDECREF(helper->close); PyMem_Del(helper); SDL_FreeRW(context); return retval; }
static int _pyobj_close (SDL_RWops *ops) { _RWWrapper *wrapper = (_RWWrapper *) ops->hidden.unknown.data1; PyObject *result; int retval = 0; if (wrapper->close) { result = PyObject_CallFunction (wrapper->close, NULL); if (!result) retval = -1; Py_XDECREF (result); } Py_XDECREF (wrapper->seek); Py_XDECREF (wrapper->tell); Py_XDECREF (wrapper->write); Py_XDECREF (wrapper->read); Py_XDECREF (wrapper->close); PyMem_Del (wrapper); SDL_FreeRW (ops); return retval; }
static PyObject * scss_Scanner_token(scss_Scanner *self, PyObject *args) { PyObject *iter; PyObject *item; long size; Token *p_token; int token_num; PyObject *restrictions = NULL; Pattern *_restrictions = NULL; int restrictions_sz = 0; if (self->scanner != NULL) { if (PyArg_ParseTuple(args, "i|O", &token_num, &restrictions)) { if (restrictions != NULL) { size = PySequence_Size(restrictions); if (size != -1) { _restrictions = PyMem_New(Pattern, size); iter = PyObject_GetIter(restrictions); while ((item = PyIter_Next(iter))) { if (PyString_Check(item)) { _restrictions[restrictions_sz].tok = PyString_AsString(item); _restrictions[restrictions_sz].expr = NULL; restrictions_sz++; } Py_DECREF(item); } Py_DECREF(iter); } } p_token = Scanner_token(self->scanner, token_num, _restrictions, restrictions_sz); if (_restrictions != NULL) PyMem_Del(_restrictions); if (p_token == (Token *)SCANNER_EXC_BAD_TOKEN) { PyErr_SetString(PyExc_SyntaxError, self->scanner->exc); return NULL; } if (p_token == (Token *)SCANNER_EXC_RESTRICTED) { PyErr_SetString(PyExc_SyntaxError, self->scanner->exc); return NULL; } if (p_token == (Token *)SCANNER_EXC_UNIMPLEMENTED) { PyErr_SetString(PyExc_NotImplementedError, self->scanner->exc); return NULL; } if (p_token == (Token *)SCANNER_EXC_NO_MORE_TOKENS) { PyErr_SetNone(PyExc_scss_NoMoreTokens); return NULL; } if (p_token < 0) { PyErr_SetNone(PyExc_Exception); return NULL; } return Py_BuildValue( "iiss#", p_token->string - self->scanner->input, p_token->string - self->scanner->input + p_token->string_sz, p_token->regex->tok, p_token->string, p_token->string_sz ); } } Py_INCREF(Py_None); return (PyObject *)Py_None; }
static void fortran_dealloc(PyFortranObject *fp) { Py_XDECREF(fp->dict); PyMem_Del(fp); }
static void Polygon_dealloc(Polygon *self) { gpc_free_polygon(self->p); free(self->p); Py_XDECREF(self->attr); PyMem_Del(self); }
static void destroy_args( char ***argv) { PyMem_Del(*argv); *argv = NULL; }
static PyObject * SimplePinyin_convert(SimplePinyin* self, PyObject *args, PyObject *kwds) { const char *pinyin = ""; const char *prefix = ""; static char *kwlist[] = {"pinyin", "prefix", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|s", kwlist, &pinyin, &prefix)) return NULL; // printf("DEBUG: pinyin=%s, prefix=%s.\n", pinyin, prefix); pinyin_parse_more_full_pinyins(self->instance, pinyin); pinyin_guess_sentence_with_prefix(self->instance, prefix); pinyin_guess_full_pinyin_candidates(self->instance, 0); guint num = 0; guint16 *arr = NULL; //FIXME: Use a name better than `arr` pinyin_get_n_pinyin(self->instance, &num); arr = PyMem_New(guint16, num); // printf("DEBUG: num=%i, arr=%p.\n", num, arr); for (size_t i = 0; i < num; ++i) { ChewingKeyRest *key_rest = NULL; pinyin_get_pinyin_key_rest(self->instance, i, &key_rest); pinyin_get_pinyin_key_rest_length(self->instance, key_rest, &arr[i]); if (i > 0) { arr[i] += arr[i-1]; } // printf("DEBUG: %i\n", arr[i]); } guint len = 0; pinyin_get_n_candidate(self->instance, &len); // printf("DEBUG: len=%i\n", len); PyObject *candidate_list = PyList_New(len); PyObject *match_len_list = PyList_New(len); for (size_t i = 0; i < len; ++i) { lookup_candidate_t * candidate = NULL; pinyin_get_candidate(self->instance, i, &candidate); const char * word = NULL; pinyin_get_candidate_string(self->instance, candidate, &word); PyObject *ob_word = NULL; ob_word = Py_BuildValue("s", word); PyList_SetItem(candidate_list, i, ob_word); lookup_candidate_type_t type; pinyin_get_candidate_type(self->instance, candidate, &type); // printf("DEBUG: type=%i\n", type); int cursor = pinyin_choose_candidate(self->instance, 0, candidate); int match_len = 0; int index = 0; switch (type) { case BEST_MATCH_CANDIDATE: match_len = strlen(pinyin); break; case DIVIDED_CANDIDATE: //FIXME: we assume that only one key get divided index = cursor-2; //FIXME: remove the below hack if possible if (index >= num) { index = num-1; } match_len = arr[index]; break; case RESPLIT_CANDIDATE: case NORMAL_CANDIDATE: index = cursor-1; match_len = arr[index]; default: break; } // printf("DEBUG: match_len=%i\n", match_len); PyObject *ob_match_len = NULL; ob_match_len = Py_BuildValue("i", match_len); PyList_SetItem(match_len_list, i, ob_match_len); pinyin_clear_constraint(self->instance, 0); // printf("DEBUG: %s %d\n", word, arr[cursor-1]); } PyMem_Del(arr); pinyin_reset(self->instance); PyObject *ob_pair = NULL; ob_pair = Py_BuildValue("(O,O)", candidate_list, match_len_list); return ob_pair; }
/** * Destroy argument vector. */ static void destroy_args(void) { PyMem_Del(rrdtool_argv); rrdtool_argv = NULL; }
static int scss_Scanner_init(scss_Scanner *self, PyObject *args, PyObject *kwds) { PyObject *item, *item0, *item1; int i, is_tuple, _is_tuple; long size; PyObject *patterns, *ignore; Pattern *_patterns = NULL; int patterns_sz = 0; Pattern *_ignore = NULL; int ignore_sz = 0; char *input = NULL; int input_sz = 0; self->scanner = NULL; if (!PyArg_ParseTuple(args, "OO|z#", &patterns, &ignore, &input, &input_sz)) { return -1; } if (!Scanner_initialized()) { is_tuple = PyTuple_Check(patterns); if (is_tuple || PyList_Check(patterns)) { size = is_tuple ? PyTuple_Size(patterns) : PyList_Size(patterns); _patterns = PyMem_New(Pattern, size); for (i = 0; i < size; ++i) { item = is_tuple ? PyTuple_GetItem(patterns, i) : PyList_GetItem(patterns, i); _is_tuple = PyTuple_Check(item); if (_is_tuple || PyList_Check(item)) { item0 = _is_tuple ? PyTuple_GetItem(item, 0) : PyList_GetItem(item, 0); item1 = _is_tuple ? PyTuple_GetItem(item, 1) : PyList_GetItem(item, 1); if (PyString_Check(item0) && PyString_Check(item1)) { _patterns[patterns_sz].tok = PyString_AsString(item0); _patterns[patterns_sz].expr = PyString_AsString(item1); patterns_sz++; } } } } Scanner_initialize(_patterns, patterns_sz); } is_tuple = PyTuple_Check(ignore); if (is_tuple || PyList_Check(ignore)) { size = is_tuple ? PyTuple_Size(ignore) : PyList_Size(ignore); _ignore = PyMem_New(Pattern, size); for (i = 0; i < size; ++i) { item = is_tuple ? PyTuple_GetItem(ignore, i) : PyList_GetItem(ignore, i); if (PyString_Check(item)) { _ignore[ignore_sz].tok = PyString_AsString(item); _ignore[ignore_sz].expr = NULL; ignore_sz++; } } } self->scanner = Scanner_new(_patterns, patterns_sz, _ignore, ignore_sz, input, input_sz); if (_patterns != NULL) PyMem_Del(_patterns); if (_ignore != NULL) PyMem_Del(_ignore); #ifdef DEBUG PySys_WriteStderr("Scss Scanner object initialized! (%lu bytes)\n", sizeof(scss_Scanner)); #endif return 0; }
PyObject* JPy_create_jvm(PyObject* self, PyObject* args, PyObject* kwds) { static char* keywords[] = {"options", NULL}; PyObject* options; Py_ssize_t optionCount; PyObject* option; JavaVMOption* jvmOptions; JavaVMInitArgs jvmInitArgs; jint jvmErrorCode; JNIEnv* jenv; Py_ssize_t i; //printf("JPy_create_jvm: JPy_JVM=%p\n", JPy_JVM); options = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:create_jvm", keywords, &options)) { return NULL; } if (JPy_JVM != NULL) { JPy_DIAG_PRINT(JPy_DIAG_F_JVM + JPy_DIAG_F_ERR, "JPy_create_jvm: WARNING: Java VM is already running.\n"); Py_DECREF(options); return Py_BuildValue(""); } if (!PySequence_Check(options)) { PyErr_SetString(PyExc_ValueError, "create_jvm: argument 1 (options) must be a sequence of Java VM option strings"); return NULL; } optionCount = PySequence_Length(options); if (optionCount == -1) { PyErr_SetString(PyExc_ValueError, "create_jvm: failed to determine sequence length of argument 1 (options)"); return NULL; } jvmOptions = PyMem_New(JavaVMOption, optionCount); if (jvmOptions == NULL) { return PyErr_NoMemory(); } for (i = 0; i < optionCount; i++) { option = PySequence_GetItem(options, i); if (option == NULL) { PyMem_Del(jvmOptions); return NULL; } jvmOptions[i].optionString = (char*) JPy_AS_UTF8(option); jvmOptions[i].extraInfo = NULL; JPy_DIAG_PRINT(JPy_DIAG_F_JVM, "JPy_create_jvm: jvmOptions[%d].optionString = '%s'\n", i, jvmOptions[i].optionString); if (jvmOptions[i].optionString == NULL) { PyMem_Del(jvmOptions); return NULL; } Py_DECREF(option); } jvmInitArgs.version = JPY_JNI_VERSION; jvmInitArgs.options = jvmOptions; jvmInitArgs.nOptions = (size_t) optionCount; jvmInitArgs.ignoreUnrecognized = 0; jvmErrorCode = JNI_CreateJavaVM(&JPy_JVM, (void**) &jenv, &jvmInitArgs); JPy_MustDestroyJVM = JNI_TRUE; JPy_DIAG_PRINT(JPy_DIAG_F_JVM, "JPy_create_jvm: res=%d, JPy_JVM=%p, jenv=%p, JPy_MustDestroyJVM=%d\n", jvmErrorCode, JPy_JVM, jenv, JPy_MustDestroyJVM); PyMem_Del(jvmOptions); if (jvmErrorCode != JNI_OK) { JPy_DIAG_PRINT(JPy_DIAG_F_JVM + JPy_DIAG_F_ERR, "JPy_create_jvm: INTERNAL ERROR: Failed to create Java VM (JNI error code %d). Possible reasons are:\n" "* The Java heap space setting is too high (option -Xmx). Try '256M' first, then increment.\n" "* The JVM shared library (Unix: libjvm.so, Windows: jvm.dll) cannot be found or cannot be loaded.\n" " Make sure the shared library can be found via the 'PATH' environment variable.\n" " Also make sure that the JVM is compiled for the same architecture as Python.\n", jvmErrorCode); PyErr_SetString(PyExc_RuntimeError, "jpy: failed to create Java VM"); return NULL; } if (JPy_InitGlobalVars(jenv) < 0) { return NULL; } return Py_BuildValue(""); }
static int create_args( char *command, PyObject * args, int *argc, char ***argv) { PyObject *o, *lo; int args_count, argv_count, element_count, i, j; args_count = PyTuple_Size(args); element_count = 0; for (i = 0; i < args_count; i++) { o = PyTuple_GET_ITEM(args, i); if (PyString_Check(o)) element_count++; else if (PyList_CheckExact(o)) element_count += PyList_Size(o); else { PyErr_Format(PyExc_TypeError, "argument %d must be string or list of strings", i); return -1; } } *argv = PyMem_New(char *, element_count + 1); if (*argv == NULL) return -1; argv_count = 0; for (i = 0; i < args_count; i++) { o = PyTuple_GET_ITEM(args, i); if (PyString_Check(o)) { argv_count++; (*argv)[argv_count] = PyString_AS_STRING(o); } else if (PyList_CheckExact(o)) for (j = 0; j < PyList_Size(o); j++) { lo = PyList_GetItem(o, j); if (PyString_Check(lo)) { argv_count++; (*argv)[argv_count] = PyString_AS_STRING(lo); } else { PyMem_Del(*argv); PyErr_Format(PyExc_TypeError, "element %d in argument %d must be string", j, i); return -1; } } else { PyMem_Del(*argv); PyErr_Format(PyExc_TypeError, "argument %d must be string or list of strings", i); return -1; } } (*argv)[0] = command; *argc = element_count + 1; /* reset getopt state */ opterr = optind = 0; return 0; }
static void Cache_dealloc(Cache* self) { Py_XDECREF(self->parent); // Causes a segfault, but why? PyMem_Del(self->placement); Py_TYPE(self)->tp_free((PyObject*)self); }