/** Gets the dimensions of a Blender Image in pixels (WxH) */ static imagesize_t get_image_size(PyObject* image) { korlib::pyref size = PyObject_GetAttrString(image, "size"); size_t width = PyLong_AsSize_t(PySequence_GetItem(size, 0)); size_t height = PyLong_AsSize_t(PySequence_GetItem(size, 1)); return std::make_tuple(width, height); }
static PyObject* pyGLTexture__enter__(pyGLTexture* self) { // Is the image already loaded? PyObjectRef bindcode = PyObject_GetAttrString(self->m_blenderImage, "bindcode"); // bindcode changed to a sequence in 2.77. We want the first element for a 2D texture. // Why did we make this change, exactly? if (PySequence_Check(bindcode)) { bindcode = PySequence_GetItem(bindcode, TEXTARGET_TEXTURE_2D); } // Now we should have a GLuint... if (!PyLong_Check(bindcode)) { PyErr_SetString(PyExc_TypeError, "Image bindcode isn't a long?"); return NULL; } glGetIntegerv(GL_TEXTURE_BINDING_2D, &self->m_prevImage); GLuint image_bindcode = PyLong_AsUnsignedLong(bindcode); self->m_ownIt = image_bindcode == 0; // Load image into GL if (self->m_ownIt) { PyObjectRef new_bind = PyObject_CallMethod(self->m_blenderImage, "gl_load", NULL); if (!PyLong_Check(new_bind)) { PyErr_SetString(PyExc_TypeError, "gl_load() did not return a long"); return NULL; } ssize_t result = PyLong_AsSize_t(new_bind); if (result != GL_NO_ERROR) { PyErr_Format(PyExc_RuntimeError, "gl_load() error: %d", result); return NULL; } bindcode = PyObject_GetAttrString(self->m_blenderImage, "bindcode"); if (PySequence_Check(bindcode)) { bindcode = PySequence_GetItem(bindcode, TEXTARGET_TEXTURE_2D); } // Now we should have a GLuint... if (!PyLong_Check(bindcode)) { PyErr_SetString(PyExc_TypeError, "Image bindcode isn't a long?"); return NULL; } image_bindcode = PyLong_AsUnsignedLong(bindcode); } // Set image as current in GL if (self->m_prevImage != image_bindcode) { self->m_changedState = true; glBindTexture(GL_TEXTURE_2D, image_bindcode); } // Misc GL state glGetTexParameteriv(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &self->m_mipmapState); Py_INCREF(self); return (PyObject*)self; }
static PyObject *pair_repr(PyObject *self) { PyObject *tmp = NULL; PyObject *col = PyList_New(0); PyObject *found = PyDict_New(); size_t index = 0; PyObject *rest = self; PyObject *rest_id; PyList_Append(col, _str_cons_paren); while (rest->ob_type == &SibPairType) { rest_id = PyLong_FromVoidPtr(rest); if (PyDict_Contains(found, rest_id)) { /* recursive pair detected */ PyList_Append(col, _str_recursive_true); if (rest != self) { tmp = PyDict_GetItem(found, rest_id); PyList_Insert(col, PyLong_AsSize_t(tmp) - 1, _str_cons_paren); PyList_Append(col, _str_close_paren); } Py_DECREF(rest_id); rest = NULL; break; } else { index += 2; tmp = PyLong_FromSize_t(index); PyDict_SetItem(found, rest_id, tmp); Py_DECREF(tmp); tmp = PyObject_Repr(SibPair_CAR(rest)); PyList_Append(col, tmp); PyList_Append(col, _str_comma_space); Py_DECREF(tmp); rest = SibPair_CDR(rest); Py_DECREF(rest_id); } } if (rest) { PyList_Append(col, PyObject_Repr(rest)); } PyList_Append(col, _str_close_paren); tmp = PyUnicode_Join(_str_empty, col); Py_DECREF(col); Py_DECREF(found); return tmp; }
PyObject * Remote_get_refspec(Remote *self, PyObject *value) { size_t n; const git_refspec *refspec; n = PyLong_AsSize_t(value); if (PyErr_Occurred()) return NULL; refspec = git_remote_get_refspec(self->remote, n); if (refspec == NULL) { PyErr_SetObject(PyExc_IndexError, value); return NULL; } return (PyObject*) wrap_refspec(self, refspec); }
static int get_size_t(PyObject *v, size_t *p) { size_t x; v = get_pylong(v); if (v == NULL) return -1; assert(PyLong_Check(v)); x = PyLong_AsSize_t(v); Py_DECREF(v); if (x == (size_t)-1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_SetString(StructError, "argument out of range"); return -1; } *p = x; return 0; }
static int _generate_detail_map(pyGLTexture* self, uint8_t* buf, size_t bufsz, GLint level) { float alpha; if (_generate_detail_alpha(self, level, &alpha) != 0) return -1; PyObjectRef pydetail_blend = PyObject_GetAttrString(self->m_textureKey, "detail_blend"); if (!pydetail_blend) return -1; size_t detail_blend = PyLong_AsSize_t(pydetail_blend); switch (detail_blend) { case TEX_DETAIL_ALPHA: { for (size_t i = 0; i < bufsz; i += 4) { buf[i+3] = (uint8_t)(((float)buf[i+3]) * alpha); } } break; case TEX_DETAIL_ADD: { for (size_t i = 0; i < bufsz; i += 4) { buf[i+0] = (uint8_t)(((float)buf[i+0]) * alpha); buf[i+1] = (uint8_t)(((float)buf[i+1]) * alpha); buf[i+2] = (uint8_t)(((float)buf[i+2]) * alpha); } } break; case TEX_DETAIL_MULTIPLY: { float invert_alpha = (1.f - alpha) * 255.f; for (size_t i = 0; i < bufsz; i += 4) { buf[i+3] = (uint8_t)((invert_alpha + (float)buf[i+3]) * alpha); } } break; default: return -1; } return 0; }
PyObject * option(PyObject *self, PyObject *args) { long option; int error; PyObject *py_option; py_option = PyTuple_GetItem(args, 0); if (!py_option) return NULL; if (!PyLong_Check(py_option)) goto on_non_integer; option = PyLong_AsLong(py_option); switch (option) { case GIT_OPT_GET_SEARCH_PATH: { PyObject *py_level; py_level = PyTuple_GetItem(args, 1); if (!py_level) return NULL; if (!PyLong_Check(py_level)) goto on_non_integer; return get_search_path(PyLong_AsLong(py_level)); break; } case GIT_OPT_SET_SEARCH_PATH: { PyObject *py_level, *py_path, *tpath; const char *path; int err; py_level = PyTuple_GetItem(args, 1); if (!py_level) return NULL; py_path = PyTuple_GetItem(args, 2); if (!py_path) return NULL; if (!PyLong_Check(py_level)) goto on_non_integer; path = py_str_borrow_c_str(&tpath, py_path, NULL); if (!path) return NULL; err = git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, PyLong_AsLong(py_level), path); Py_DECREF(tpath); if (err < 0) { Error_set(err); return NULL; } Py_RETURN_NONE; break; } case GIT_OPT_GET_MWINDOW_SIZE: { size_t size; error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &size); if (error < 0) { Error_set(error); return NULL; } return PyLong_FromSize_t(size); break; } case GIT_OPT_SET_MWINDOW_SIZE: { size_t size; PyObject *py_size; py_size = PyTuple_GetItem(args, 1); if (!py_size) return NULL; if (!PyLong_Check(py_size)) goto on_non_integer; size = PyLong_AsSize_t(py_size); error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, size); if (error < 0) { Error_set(error); return NULL; } Py_RETURN_NONE; break; } case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT: { size_t limit; error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_MAPPED_LIMIT, &limit); if (error < 0) { Error_set(error); return NULL; } return PyLong_FromSize_t(limit); break; } case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT: { size_t limit; PyObject *py_limit; py_limit = PyTuple_GetItem(args, 1); if (!py_limit) return NULL; if (!PyLong_Check(py_limit)) goto on_non_integer; limit = PyLong_AsSize_t(py_limit); error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_MAPPED_LIMIT, limit); if (error < 0) { Error_set(error); return NULL; } Py_RETURN_NONE; break; } case GIT_OPT_SET_CACHE_OBJECT_LIMIT: { size_t limit; int object_type; PyObject *py_object_type, *py_limit; py_object_type = PyTuple_GetItem(args, 1); if (!py_object_type) return NULL; py_limit = PyTuple_GetItem(args, 2); if (!py_limit) return NULL; if (!PyLong_Check(py_limit)) goto on_non_integer; object_type = PyLong_AsLong(py_object_type); limit = PyLong_AsSize_t(py_limit); error = git_libgit2_opts(GIT_OPT_SET_CACHE_OBJECT_LIMIT, object_type, limit); if (error < 0) { Error_set(error); return NULL; } Py_RETURN_NONE; break; } case GIT_OPT_SET_CACHE_MAX_SIZE: { size_t max_size; PyObject *py_max_size; py_max_size = PyTuple_GetItem(args, 1); if (!py_max_size) return NULL; if (!PyLong_Check(py_max_size)) goto on_non_integer; max_size = PyLong_AsSize_t(py_max_size); error = git_libgit2_opts(GIT_OPT_SET_CACHE_MAX_SIZE, max_size); if (error < 0) { Error_set(error); return NULL; } Py_RETURN_NONE; break; } case GIT_OPT_ENABLE_CACHING: { int flag; PyObject *py_flag; py_flag = PyTuple_GetItem(args, 1); if (!PyLong_Check(py_flag)) goto on_non_integer; flag = PyLong_AsSize_t(py_flag); error = git_libgit2_opts(GIT_OPT_ENABLE_CACHING, flag); if (error < 0) { Error_set(error); return NULL; } Py_RETURN_NONE; break; } case GIT_OPT_GET_CACHED_MEMORY: { size_t current; size_t allowed; PyObject* tup = PyTuple_New(2); error = git_libgit2_opts(GIT_OPT_GET_CACHED_MEMORY, ¤t, &allowed); if (error < 0) { Error_set(error); return NULL; } PyTuple_SetItem(tup, 0, PyLong_FromLong(current)); PyTuple_SetItem(tup, 1, PyLong_FromLong(allowed)); return tup; break; } } PyErr_SetString(PyExc_ValueError, "unknown/unsupported option value"); return NULL; on_non_integer: PyErr_SetString(PyExc_TypeError, "option is not an integer"); return NULL; }
PyObject * option(PyObject *self, PyObject *args) { long option; int error; PyObject *py_option; py_option = PyTuple_GetItem(args, 0); if (!py_option) return NULL; if (!PyLong_Check(py_option)) goto on_non_integer; option = PyLong_AsLong(py_option); switch (option) { case GIT_OPT_GET_SEARCH_PATH: { PyObject *py_level; py_level = PyTuple_GetItem(args, 1); if (!py_level) return NULL; if (!PyLong_Check(py_level)) goto on_non_integer; return get_search_path(PyLong_AsLong(py_level)); break; } case GIT_OPT_SET_SEARCH_PATH: { PyObject *py_level, *py_path, *tpath; const char *path; int err; py_level = PyTuple_GetItem(args, 1); if (!py_level) return NULL; py_path = PyTuple_GetItem(args, 2); if (!py_path) return NULL; if (!PyLong_Check(py_level)) goto on_non_integer; path = py_str_borrow_c_str(&tpath, py_path, NULL); if (!path) return NULL; err = git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, PyLong_AsLong(py_level), path); Py_DECREF(tpath); if (err < 0) { Error_set(err); return NULL; } Py_RETURN_NONE; break; } case GIT_OPT_GET_MWINDOW_SIZE: { size_t size; error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &size); if (error < 0) { Error_set(error); return NULL; } return PyLong_FromSize_t(size); break; } case GIT_OPT_SET_MWINDOW_SIZE: { size_t size; PyObject *py_size; py_size = PyTuple_GetItem(args, 1); if (!py_size) return NULL; if (!PyLong_Check(py_size)) goto on_non_integer; size = PyLong_AsSize_t(py_size); error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, size); if (error < 0) { Error_set(error); return NULL; } Py_RETURN_NONE; break; } } PyErr_SetString(PyExc_ValueError, "unknown/unsupported option value"); return NULL; on_non_integer: PyErr_SetString(PyExc_TypeError, "option is not an integer"); return NULL; }
PyObject * option(PyObject *self, PyObject *args) { long option; int error; PyObject *py_option; py_option = PyTuple_GetItem(args, 0); if (!py_option) return NULL; if (!PyInt_Check(py_option)) return Error_type_error( "option should be an integer, got %.200s", py_option); option = PyInt_AsLong(py_option); switch (option) { case GIT_OPT_GET_MWINDOW_SIZE: { size_t size; error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &size); if (error < 0) return Error_set(error); return PyInt_FromSize_t(size); } case GIT_OPT_SET_MWINDOW_SIZE: { size_t size; PyObject *py_size; py_size = PyTuple_GetItem(args, 1); if (!py_size) return NULL; if (!PyInt_Check(py_size)) return Error_type_error( "size should be an integer, got %.200s", py_size); size = PyInt_AsSize_t(py_size); error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, size); if (error < 0) return Error_set(error); Py_RETURN_NONE; } case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT: { size_t limit; error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_MAPPED_LIMIT, &limit); if (error < 0) return Error_set(error); return PyInt_FromSize_t(limit); } case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT: { size_t limit; PyObject *py_limit; py_limit = PyTuple_GetItem(args, 1); if (!py_limit) return NULL; if (PyInt_Check(py_limit)) { limit = PyInt_AsSize_t(py_limit); } else if (PyLong_Check(py_limit)) { limit = PyLong_AsSize_t(py_limit); } else { return Error_type_error( "limit should be an integer, got %.200s", py_limit); } error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_MAPPED_LIMIT, limit); if (error < 0) return Error_set(error); Py_RETURN_NONE; } case GIT_OPT_GET_SEARCH_PATH: { PyObject *py_level; py_level = PyTuple_GetItem(args, 1); if (!py_level) return NULL; if (!PyInt_Check(py_level)) return Error_type_error( "level should be an integer, got %.200s", py_level); return get_search_path(PyInt_AsLong(py_level)); } case GIT_OPT_SET_SEARCH_PATH: { PyObject *py_level, *py_path, *tpath; const char *path; int err; py_level = PyTuple_GetItem(args, 1); if (!py_level) return NULL; py_path = PyTuple_GetItem(args, 2); if (!py_path) return NULL; if (!PyInt_Check(py_level)) return Error_type_error( "level should be an integer, got %.200s", py_level); path = py_str_borrow_c_str(&tpath, py_path, NULL); if (!path) return NULL; err = git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, PyInt_AsLong(py_level), path); Py_DECREF(tpath); if (err < 0) return Error_set(err); Py_RETURN_NONE; } case GIT_OPT_SET_CACHE_OBJECT_LIMIT: { size_t limit; int object_type; PyObject *py_object_type, *py_limit; py_object_type = PyTuple_GetItem(args, 1); if (!py_object_type) return NULL; py_limit = PyTuple_GetItem(args, 2); if (!py_limit) return NULL; if (!PyInt_Check(py_limit)) return Error_type_error( "limit should be an integer, got %.200s", py_limit); object_type = PyInt_AsLong(py_object_type); limit = PyInt_AsSize_t(py_limit); error = git_libgit2_opts( GIT_OPT_SET_CACHE_OBJECT_LIMIT, object_type, limit); if (error < 0) return Error_set(error); Py_RETURN_NONE; } case GIT_OPT_SET_CACHE_MAX_SIZE: { size_t max_size; PyObject *py_max_size; py_max_size = PyTuple_GetItem(args, 1); if (!py_max_size) return NULL; if (!PyInt_Check(py_max_size)) return Error_type_error( "max_size should be an integer, got %.200s", py_max_size); max_size = PyInt_AsSize_t(py_max_size); error = git_libgit2_opts(GIT_OPT_SET_CACHE_MAX_SIZE, max_size); if (error < 0) return Error_set(error); Py_RETURN_NONE; } case GIT_OPT_GET_CACHED_MEMORY: { size_t current; size_t allowed; PyObject* tup = PyTuple_New(2); error = git_libgit2_opts(GIT_OPT_GET_CACHED_MEMORY, ¤t, &allowed); if (error < 0) return Error_set(error); PyTuple_SetItem(tup, 0, PyInt_FromLong(current)); PyTuple_SetItem(tup, 1, PyInt_FromLong(allowed)); return tup; } case GIT_OPT_SET_SSL_CERT_LOCATIONS: { PyObject *py_file, *py_dir; const char *file_path, *dir_path; int err; py_file = PyTuple_GetItem(args, 1); py_dir = PyTuple_GetItem(args, 2); /* py_file and py_dir are only valid if they are strings */ if (PyUnicode_Check(py_file) || PyBytes_Check(py_file)) { file_path = py_str_to_c_str(py_file, Py_FileSystemDefaultEncoding); } else { file_path = NULL; } if (PyUnicode_Check(py_dir) || PyBytes_Check(py_dir)) { dir_path = py_str_to_c_str(py_dir, Py_FileSystemDefaultEncoding); } else { dir_path = NULL; } err = git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, file_path, dir_path); if (err < 0) return Error_set(err); Py_RETURN_NONE; } // int enabled case GIT_OPT_ENABLE_CACHING: case GIT_OPT_ENABLE_STRICT_OBJECT_CREATION: case GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION: case GIT_OPT_ENABLE_OFS_DELTA: case GIT_OPT_ENABLE_FSYNC_GITDIR: case GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION: case GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY: { PyObject *py_enabled; int enabled; py_enabled = PyTuple_GetItem(args, 1); if (!py_enabled) return NULL; if (!PyInt_Check(py_enabled)) return Error_type_error("expected integer, got %.200s", py_enabled); enabled = PyInt_AsSize_t(py_enabled); error = git_libgit2_opts(option, enabled); if (error < 0) return Error_set(error); Py_RETURN_NONE; } // Not implemented case GIT_OPT_GET_TEMPLATE_PATH: case GIT_OPT_SET_TEMPLATE_PATH: case GIT_OPT_SET_USER_AGENT: case GIT_OPT_SET_SSL_CIPHERS: case GIT_OPT_GET_USER_AGENT: case GIT_OPT_GET_WINDOWS_SHAREMODE: case GIT_OPT_SET_WINDOWS_SHAREMODE: case GIT_OPT_SET_ALLOCATOR: case GIT_OPT_GET_PACK_MAX_OBJECTS: case GIT_OPT_SET_PACK_MAX_OBJECTS: { Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } } PyErr_SetString(PyExc_ValueError, "unknown/unsupported option value"); return NULL; }
static PyObject *pair_str(PyObject *self) { PyObject *tmp = NULL; PyObject *col = PyList_New(0); PyObject *found = PyDict_New(); size_t index = 0; PyObject *rest = self; PyObject *rest_id; PyList_Append(col, _str_open_paren); for (rest = self; SibPair_CheckExact(rest); rest = SibPair_CDR(rest)) { rest_id = PyLong_FromVoidPtr(rest); if (PyDict_Contains(found, rest_id)) { /* recursive pair detected */ PyList_Append(col, _str_elipsis); PyList_Append(col, _str_close_paren); if (rest != self) { tmp = PyDict_GetItem(found, rest_id); PyList_Insert(col, PyLong_AsSize_t(tmp) - 1, _str_open_paren); PyList_Insert(col, PyLong_AsSize_t(tmp) - 1, _str_dot_space); PyList_Append(col, _str_close_paren); } Py_DECREF(rest_id); /* set rest to NULL so we don't try to close it like we would a normal proper or improper list */ rest = NULL; break; } else { index += 2; tmp = PyLong_FromSize_t(index); PyDict_SetItem(found, rest_id, tmp); Py_DECREF(tmp); Py_DECREF(rest_id); tmp = SibPair_CAR(rest); if (PyUnicode_CheckExact(tmp)) { tmp = sib_quoted(tmp); } else { tmp = PyObject_Str(tmp); } PyList_Append(col, tmp); Py_DECREF(tmp); PyList_Append(col, _str_space); } } if(SibNil_Check(rest)) { /* end of a proper list */ Py_INCREF(_str_close_paren); PyList_SetItem(col, index, _str_close_paren); } else if (rest) { /* end of an improper list */ tmp = rest; if (PyUnicode_CheckExact(tmp)) { tmp = sib_quoted(tmp); } else { tmp = PyObject_Str(tmp); } PyList_Append(col, _str_dot_space); PyList_Append(col, tmp); PyList_Append(col, _str_close_paren); Py_DECREF(tmp); } tmp = PyUnicode_Join(_str_empty, col); Py_DECREF(col); Py_DECREF(found); return tmp; }