static PyObject * mmap_resize_method(mmap_object *self, PyObject *args) { Py_ssize_t new_size; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "n:resize", &new_size) || !is_resizeable(self)) { return NULL; #ifdef MS_WINDOWS } else { DWORD dwErrCode = 0; DWORD newSizeLow, newSizeHigh; /* First, unmap the file view */ UnmapViewOfFile(self->data); /* Close the mapping object */ CloseHandle(self->map_handle); /* Move to the desired EOF position */ #if SIZEOF_SIZE_T > 4 newSizeHigh = (DWORD)(new_size >> 32); newSizeLow = (DWORD)(new_size & 0xFFFFFFFF); #else newSizeHigh = 0; newSizeLow = (DWORD)new_size; #endif SetFilePointer(self->file_handle, newSizeLow, &newSizeHigh, FILE_BEGIN); /* Change the size of the file */ SetEndOfFile(self->file_handle); /* Create another mapping object and remap the file view */ self->map_handle = CreateFileMapping( self->file_handle, NULL, PAGE_READWRITE, newSizeHigh, newSizeLow, self->tagname); if (self->map_handle != NULL) { self->data = (char *) MapViewOfFile(self->map_handle, FILE_MAP_WRITE, 0, 0, 0); if (self->data != NULL) { self->size = new_size; Py_INCREF(Py_None); return Py_None; } else { dwErrCode = GetLastError(); } } else { dwErrCode = GetLastError(); } PyErr_SetFromWindowsErr(dwErrCode); return NULL; #endif /* MS_WINDOWS */ #ifdef UNIX #ifndef HAVE_MREMAP } else {
static int mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v) { const char *buf; CHECK_VALID(-1); if (i < 0 || i >= self->size) { PyErr_SetString(PyExc_IndexError, "mmap index out of range"); return -1; } if (v == NULL) { PyErr_SetString(PyExc_TypeError, "mmap object doesn't support item deletion"); return -1; } if (! (PyBytes_Check(v) && PyBytes_Size(v)==1) ) { PyErr_SetString(PyExc_IndexError, "mmap assignment must be length-1 bytes()"); return -1; } if (!is_writable(self)) return -1; buf = PyBytes_AsString(v); self->data[i] = buf[0]; return 0; }
static PyObject * mmap_write_method(mmap_object *self, PyObject *args) { Py_buffer data; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "y*:write", &data)) return(NULL); if (!is_writable(self)) { PyBuffer_Release(&data); return NULL; } if ((self->pos + data.len) > self->size) { PyErr_SetString(PyExc_ValueError, "data out of range"); PyBuffer_Release(&data); return NULL; } memcpy(self->data + self->pos, data.buf, data.len); self->pos = self->pos + data.len; PyBuffer_Release(&data); Py_INCREF(Py_None); return Py_None; }
static PyObject * mmap_read_method(mmap_object *self, PyObject *args) { Py_ssize_t num_bytes = -1, n; PyObject *result; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "|O&:read", mmap_convert_ssize_t, &num_bytes)) return(NULL); /* silently 'adjust' out-of-range requests */ assert(self->size >= self->pos); n = self->size - self->pos; /* The difference can overflow, only if self->size is greater than * PY_SSIZE_T_MAX. But then the operation cannot possibly succeed, * because the mapped area and the returned string each need more * than half of the addressable memory. So we clip the size, and let * the code below raise MemoryError. */ if (n < 0) n = PY_SSIZE_T_MAX; if (num_bytes < 0 || num_bytes > n) { num_bytes = n; } result = PyBytes_FromStringAndSize(self->data+self->pos, num_bytes); self->pos += num_bytes; return result; }
static PyObject * mmap_flush_method(mmap_object *self, PyObject *args) { Py_ssize_t offset = 0; Py_ssize_t size = self->size; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "|nn:flush", &offset, &size)) return NULL; if (size < 0 || offset < 0 || self->size - offset < size) { PyErr_SetString(PyExc_ValueError, "flush values out of range"); return NULL; } if (self->access == ACCESS_READ || self->access == ACCESS_COPY) return PyLong_FromLong(0); #ifdef MS_WINDOWS return PyLong_FromLong((long) FlushViewOfFile(self->data+offset, size)); #elif defined(UNIX) /* XXX semantics of return value? */ /* XXX flags for msync? */ if (-1 == msync(self->data + offset, size, MS_SYNC)) { PyErr_SetFromErrno(PyExc_OSError); return NULL; } return PyLong_FromLong(0); #else PyErr_SetString(PyExc_ValueError, "flush not supported on this system"); return NULL; #endif }
static PyObject * mmap_find_method(mmap_object *self, PyObject *args) { Py_ssize_t start = self->pos; char *needle; Py_ssize_t len; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "s#|n:find", &needle, &len, &start)) { return NULL; } else { char *p; char *e = self->data + self->size; if (start < 0) start += self->size; if (start < 0) start = 0; else if ((size_t)start > self->size) start = self->size; for (p = self->data + start; p + len <= e; ++p) { Py_ssize_t i; for (i = 0; i < len && needle[i] == p[i]; ++i) /* nothing */; if (i == len) { return PyInt_FromSsize_t(p - self->data); } } return PyInt_FromLong(-1); } }
static PyObject * mmap_write_method(mmap_object *self, PyObject *args) { Py_buffer data; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "y*:write", &data)) return(NULL); if (!is_writable(self)) { PyBuffer_Release(&data); return NULL; } if (self->pos > self->size || self->size - self->pos < data.len) { PyBuffer_Release(&data); PyErr_SetString(PyExc_ValueError, "data out of range"); return NULL; } memcpy(&self->data[self->pos], data.buf, data.len); self->pos += data.len; PyBuffer_Release(&data); return PyLong_FromSsize_t(data.len); }
static PyObject * mmap_size_method(mmap_object *self, PyObject *args) { CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, ":size")) return NULL; #ifdef MS_WINDOWS if (self->file_handle != INVALID_HANDLE_VALUE) { return (Py_BuildValue ( "l", (long) GetFileSize (self->file_handle, NULL))); } else { return (Py_BuildValue ("l", (long) self->size) ); } #endif /* MS_WINDOWS */ #ifdef UNIX { struct stat buf; if (-1 == fstat(self->fd, &buf)) { PyErr_SetFromErrno(mmap_module_error); return NULL; } return (Py_BuildValue ("l", (long) buf.st_size) ); } #endif /* UNIX */ }
static PyObject * mmap_find_method(mmap_object *self, PyObject *args) { long start = self->pos; char *needle; int len; CHECK_VALID(NULL); if (!PyArg_ParseTuple (args, "s#|l:find", &needle, &len, &start)) { return NULL; } else { char *p; char *e = self->data + self->size; if (start < 0) start += self->size; if (start < 0) start = 0; else if ((size_t)start > self->size) start = self->size; for (p = self->data + start; p + len <= e; ++p) { int i; for (i = 0; i < len && needle[i] == p[i]; ++i) /* nothing */; if (i == len) { return Py_BuildValue ( "l", (long) (p - self->data)); } } return Py_BuildValue ("l", (long) -1); } }
static PyObject * mmap_move_method(mmap_object *self, PyObject *args) { Py_ssize_t dest, src, cnt; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "nnn:move", &dest, &src, &cnt) || !is_writable(self)) { return NULL; } else { /* bounds check the values */ if (dest < 0 || src < 0 || cnt < 0) goto bounds; if (self->size - dest < cnt || self->size - src < cnt) goto bounds; memmove(&self->data[dest], &self->data[src], cnt); Py_RETURN_NONE; bounds: PyErr_SetString(PyExc_ValueError, "source, destination, or count out of range"); return NULL; } }
static PyObject * mmap__enter__method(mmap_object *self, PyObject *args) { CHECK_VALID(NULL); Py_INCREF(self); return (PyObject *)self; }
static PyObject * mmap_concat(mmap_object *self, PyObject *bb) { CHECK_VALID(NULL); PyErr_SetString(PyExc_SystemError, "mmaps don't support concatenation"); return NULL; }
static PyObject * mmap_repeat(mmap_object *self, Py_ssize_t n) { CHECK_VALID(NULL); PyErr_SetString(PyExc_SystemError, "mmaps don't support repeat operation"); return NULL; }
static int mmap_buffer_getbuf(mmap_object *self, Py_buffer *view, int flags) { CHECK_VALID(-1); if (PyBuffer_FillInfo(view, (PyObject*)self, self->data, self->size, (self->access == ACCESS_READ), flags) < 0) return -1; self->exports++; return 0; }
static PyObject * mmap_item(mmap_object *self, Py_ssize_t i) { CHECK_VALID(NULL); if (i < 0 || i >= self->size) { PyErr_SetString(PyExc_IndexError, "mmap index out of range"); return NULL; } return PyBytes_FromStringAndSize(self->data + i, 1); }
static PyObject * mmap_read_byte_method(mmap_object *self, PyObject *unused) { CHECK_VALID(NULL); if (self->pos >= self->size) { PyErr_SetString(PyExc_ValueError, "read byte out of range"); return NULL; } return PyLong_FromLong((unsigned char)self->data[self->pos++]); }
static PyObject * mmap_subscript(mmap_object *self, PyObject *item) { CHECK_VALID(NULL); if (PyIndex_Check(item)) { Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); if (i == -1 && PyErr_Occurred()) return NULL; if (i < 0) i += self->size; if (i < 0 || i >= self->size) { PyErr_SetString(PyExc_IndexError, "mmap index out of range"); return NULL; } return PyLong_FromLong(Py_CHARMASK(self->data[i])); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelen; if (PySlice_Unpack(item, &start, &stop, &step) < 0) { return NULL; } slicelen = PySlice_AdjustIndices(self->size, &start, &stop, step); if (slicelen <= 0) return PyBytes_FromStringAndSize("", 0); else if (step == 1) return PyBytes_FromStringAndSize(self->data + start, slicelen); else { char *result_buf = (char *)PyMem_Malloc(slicelen); Py_ssize_t cur, i; PyObject *result; if (result_buf == NULL) return PyErr_NoMemory(); for (cur = start, i = 0; i < slicelen; cur += step, i++) { result_buf[i] = self->data[cur]; } result = PyBytes_FromStringAndSize(result_buf, slicelen); PyMem_Free(result_buf); return result; } } else { PyErr_SetString(PyExc_TypeError, "mmap indices must be integers"); return NULL; } }
static int QAngle___div (lua_State *L) { QAngle a = *(QAngle *)luaL_checkangle(L, 1); float b = luaL_checknumber(L, 2); QAngle c; CHECK_VALID(a); Assert( b != 0.0f ); vec_t oob = 1.0f / b; c.x = a.x * oob; c.y = a.y * oob; c.z = a.z * oob; lua_pushangle(L, &c); return 1; }
static PyObject * mmap_read_byte_method(mmap_object *self, PyObject *unused) { CHECK_VALID(NULL); if (self->pos < self->size) { char value = self->data[self->pos]; self->pos += 1; return Py_BuildValue("B", (unsigned char)value); } else { PyErr_SetString(PyExc_ValueError, "read byte out of range"); return NULL; } }
static PyObject * mmap_gfind(mmap_object *self, PyObject *args, int reverse) { Py_ssize_t start = self->pos; Py_ssize_t end = self->size; Py_buffer view; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, reverse ? "y*|nn:rfind" : "y*|nn:find", &view, &start, &end)) { return NULL; } else { const char *p, *start_p, *end_p; int sign = reverse ? -1 : 1; const char *needle = view.buf; Py_ssize_t len = view.len; if (start < 0) start += self->size; if (start < 0) start = 0; else if (start > self->size) start = self->size; if (end < 0) end += self->size; if (end < 0) end = 0; else if (end > self->size) end = self->size; start_p = self->data + start; end_p = self->data + end; for (p = (reverse ? end_p - len : start_p); (p >= start_p) && (p + len <= end_p); p += sign) { Py_ssize_t i; for (i = 0; i < len && needle[i] == p[i]; ++i) /* nothing */; if (i == len) { PyBuffer_Release(&view); return PyLong_FromSsize_t(p - self->data); } } PyBuffer_Release(&view); return PyLong_FromLong(-1); } }
int pthread_kill(pthread_t thread, int signal) { if ((unsigned) signal <= RTL_MAX_SIGNAL) { CHECK_VALID(thread); if (signal == 0) { return 0; } set_bit(signal, &thread->pending); return 0; } return 0; }
static PyObject * mmap_read_byte_method(mmap_object *self, PyObject *args) { CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, ":read_byte")) return NULL; if (self->pos < self->size) { char value = self->data[self->pos]; self->pos += 1; return Py_BuildValue("c", value); } else { PyErr_SetString (PyExc_ValueError, "read byte out of range"); return NULL; } }
static PyObject * mmap_write_byte_method(mmap_object *self, PyObject *args) { char value; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "c:write_byte", &value)) return(NULL); if (!is_writeable(self)) return NULL; *(self->data+self->pos) = value; self->pos += 1; Py_INCREF(Py_None); return Py_None; }
static PyObject * mmap_read_method(mmap_object *self, PyObject *args) { Py_ssize_t num_bytes; PyObject *result; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "n:read", &num_bytes)) return(NULL); /* silently 'adjust' out-of-range requests */ if (num_bytes > self->size - self->pos) { num_bytes -= (self->pos+num_bytes) - self->size; } result = Py_BuildValue("s#", self->data+self->pos, num_bytes); self->pos += num_bytes; return result; }
static PyObject * mmap_read_method(mmap_object *self, PyObject *args) { Py_ssize_t num_bytes = PY_SSIZE_T_MAX, remaining; PyObject *result; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "|O&:read", _Py_convert_optional_to_ssize_t, &num_bytes)) return(NULL); /* silently 'adjust' out-of-range requests */ remaining = (self->pos < self->size) ? self->size - self->pos : 0; if (num_bytes < 0 || num_bytes > remaining) num_bytes = remaining; result = PyBytes_FromStringAndSize(&self->data[self->pos], num_bytes); self->pos += num_bytes; return result; }
static PyObject * mmap_size_method(mmap_object *self, PyObject *unused) { CHECK_VALID(NULL); #ifdef MS_WINDOWS if (self->file_handle != INVALID_HANDLE_VALUE) { DWORD low,high; PY_LONG_LONG size; low = GetFileSize(self->file_handle, &high); if (low == INVALID_FILE_SIZE) { /* It might be that the function appears to have failed, when indeed its size equals INVALID_FILE_SIZE */ DWORD error = GetLastError(); if (error != NO_ERROR) return PyErr_SetFromWindowsErr(error); } if (!high && low < LONG_MAX) return PyLong_FromLong((long)low); size = (((PY_LONG_LONG)high)<<32) + low; return PyLong_FromLongLong(size); } else { return PyLong_FromSsize_t(self->size); } #endif /* MS_WINDOWS */ #ifdef UNIX { struct stat buf; if (-1 == fstat(self->fd, &buf)) { PyErr_SetFromErrno(PyExc_OSError); return NULL; } #ifdef HAVE_LARGEFILE_SUPPORT return PyLong_FromLongLong(buf.st_size); #else return PyLong_FromLong(buf.st_size); #endif } #endif /* UNIX */ }
__inline Vector Clamp() { CHECK_VALID(*this); if (this->x < -89.0f) this->x = -89.0f; if (this->x > 89.0f) this->x = 89.0f; while (this->y < -180.0f) this->y += 360.0f; while (this->y > 180.0f) this->y -= 360.0f; this->z = 0.0f; return *this; }
static PyObject * mmap_read_line_method(mmap_object *self, PyObject *unused) { char *start = self->data+self->pos; char *eof = self->data+self->size; char *eol; PyObject *result; CHECK_VALID(NULL); eol = memchr(start, '\n', self->size - self->pos); if (!eol) eol = eof; else ++eol; /* we're interested in the position after the newline. */ result = PyBytes_FromStringAndSize(start, (eol - start)); self->pos += (eol - start); return result; }
static PyObject * mmap_seek_method(mmap_object *self, PyObject *args) { Py_ssize_t dist; int how=0; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "n|i:seek", &dist, &how)) return NULL; else { Py_ssize_t where; switch (how) { case 0: /* relative to start */ where = dist; break; case 1: /* relative to current position */ if (PY_SSIZE_T_MAX - self->pos < dist) goto onoutofrange; where = self->pos + dist; break; case 2: /* relative to end */ if (PY_SSIZE_T_MAX - self->size < dist) goto onoutofrange; where = self->size + dist; break; default: PyErr_SetString(PyExc_ValueError, "unknown seek type"); return NULL; } if (where > self->size || where < 0) goto onoutofrange; self->pos = where; Py_INCREF(Py_None); return Py_None; } onoutofrange: PyErr_SetString(PyExc_ValueError, "seek out of range"); return NULL; }
static PyObject * mmap_write_byte_method(mmap_object *self, PyObject *args) { char value; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "b:write_byte", &value)) return(NULL); if (!is_writable(self)) return NULL; if (self->pos < self->size) { self->data[self->pos++] = value; Py_RETURN_NONE; } else { PyErr_SetString(PyExc_ValueError, "write byte out of range"); return NULL; } }