自学教程：C++ CHECK_VALID函数代码示例

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 intmmap_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_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_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 intmmap_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_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_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;}

	__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_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;    }}