/**
* 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);
}
