From 54cf12b625397ff52e30efd9b14f0b61edfdfd9d Mon Sep 17 00:00:00 2001 From: Sean Reifscheider Date: Mon, 17 Sep 2007 17:55:36 +0000 Subject: [PATCH] Fixing the spelling of "writeable" to "writable", particularly PyBUF_WRITEABLE. --- Doc/c-api/abstract.rst | 2 +- Doc/c-api/concrete.rst | 2 +- Include/abstract.h | 4 ++-- Include/memoryobject.h | 6 +++--- Include/object.h | 12 +++++++----- .../CodeWarrior/Metrowerks_Shell_Suite.py | 2 +- Lib/plat-mac/macresource.py | 2 +- Misc/HISTORY | 2 +- Misc/setuid-prog.c | 2 +- Modules/mmapmodule.c | 14 +++++++------- Modules/socketmodule.c | 2 +- Objects/abstract.c | 8 ++++---- Objects/memoryobject.c | 6 +++--- 13 files changed, 33 insertions(+), 31 deletions(-) diff --git a/Doc/c-api/abstract.rst b/Doc/c-api/abstract.rst index 44bd579df05..515150d4594 100644 --- a/Doc/c-api/abstract.rst +++ b/Doc/c-api/abstract.rst @@ -944,7 +944,7 @@ Buffer Protocol .. cfunction:: int PyObject_AsWriteBuffer(PyObject *obj, void **buffer, Py_ssize_t *buffer_len) - Returns a pointer to a writeable memory location. The *obj* argument must + Returns a pointer to a writable memory location. The *obj* argument must support the single-segment, character buffer interface. On success, returns ``0``, sets *buffer* to the memory location and *buffer_len* to the buffer length. Returns ``-1`` and sets a :exc:`TypeError` on error. diff --git a/Doc/c-api/concrete.rst b/Doc/c-api/concrete.rst index 8d913caa916..ba41fc5c4f6 100644 --- a/Doc/c-api/concrete.rst +++ b/Doc/c-api/concrete.rst @@ -1882,7 +1882,7 @@ could be used to pass around structured data in its native, in-memory format. Return a new writable buffer object. Parameters and exceptions are similar to those for :cfunc:`PyBuffer_FromObject`. If the *base* object does not export - the writeable buffer protocol, then :exc:`TypeError` is raised. + the writable buffer protocol, then :exc:`TypeError` is raised. .. cfunction:: PyObject* PyBuffer_FromMemory(void *ptr, Py_ssize_t size) diff --git a/Include/abstract.h b/Include/abstract.h index b8cc59c421f..c3c8fd1d89c 100644 --- a/Include/abstract.h +++ b/Include/abstract.h @@ -524,9 +524,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ Py_ssize_t *buffer_len); /* - Takes an arbitrary object which must support the (writeable, + Takes an arbitrary object which must support the (writable, single segment) buffer interface and returns a pointer to a - writeable memory location in buffer of size buffer_len. + writable memory location in buffer of size buffer_len. 0 is returned on success. buffer and buffer_len are only set in case no error occurrs. Otherwise, -1 is returned and diff --git a/Include/memoryobject.h b/Include/memoryobject.h index eb49c2e83ef..1713e8f81cb 100644 --- a/Include/memoryobject.h +++ b/Include/memoryobject.h @@ -33,15 +33,15 @@ PyAPI_FUNC(PyObject *) PyMemoryView_GetContiguous(PyObject *base, int buffertype The buffertype argument can be PyBUF_READ, PyBUF_WRITE, PyBUF_UPDATEIFCOPY to determine whether the returned buffer - should be READONLY, WRITEABLE, or set to update the + should be READONLY, WRITABLE, or set to update the original buffer if a copy must be made. If buffertype is PyBUF_WRITE and the buffer is not contiguous an error will be raised. In this circumstance, the user can use - PyBUF_UPDATEIFCOPY to ensure that a a writeable temporary + PyBUF_UPDATEIFCOPY to ensure that a a writable temporary contiguous buffer is returned. The contents of this contiguous buffer will be copied back into the original object after the memoryview object is deleted as long as - the original object is writeable and allows setting its + the original object is writable and allows setting its memory to "readonly". If this is not allowed by the original object, then a BufferError is raised. diff --git a/Include/object.h b/Include/object.h index 03f4796be39..c4a5cba6dd5 100644 --- a/Include/object.h +++ b/Include/object.h @@ -162,7 +162,9 @@ typedef void (*releasebufferproc)(PyObject *, PyBuffer *); /* Flags for getting buffers */ #define PyBUF_SIMPLE 0 #define PyBUF_CHARACTER 1 -#define PyBUF_WRITEABLE 0x0002 +#define PyBUF_WRITABLE 0x0002 +/* we used to include an E, backwards compatible alias */ +#define PyBUF_WRITEABLE PyBUF_WRITABLE #define PyBUF_LOCKDATA 0x0004 #define PyBUF_FORMAT 0x0008 #define PyBUF_ND 0x0010 @@ -172,19 +174,19 @@ typedef void (*releasebufferproc)(PyObject *, PyBuffer *); #define PyBUF_ANY_CONTIGUOUS (0x0100 | PyBUF_STRIDES) #define PyBUF_INDIRECT (0x0200 | PyBUF_STRIDES) -#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITEABLE) +#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE) #define PyBUF_CONTIG_RO (PyBUF_ND) #define PyBUF_CONTIG_LCK (PyBUF_ND | PyBUF_LOCKDATA) -#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITEABLE) +#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE) #define PyBUF_STRIDED_RO (PyBUF_STRIDES) #define PyBUF_STRIDED_LCK (PyBUF_STRIDES | PyBUF_LOCKDATA) -#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITEABLE | PyBUF_FORMAT) +#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT) #define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT) #define PyBUF_RECORDS_LCK (PyBUF_STRIDES | PyBUF_LOCKDATA | PyBUF_FORMAT) -#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITEABLE | PyBUF_FORMAT) +#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT) #define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT) #define PyBUF_FULL_LCK (PyBUF_INDIRECT | PyBUF_LOCKDATA | PyBUF_FORMAT) diff --git a/Lib/plat-mac/lib-scriptpackages/CodeWarrior/Metrowerks_Shell_Suite.py b/Lib/plat-mac/lib-scriptpackages/CodeWarrior/Metrowerks_Shell_Suite.py index 2a32e93ce0a..4a9cc5e7a5b 100644 --- a/Lib/plat-mac/lib-scriptpackages/CodeWarrior/Metrowerks_Shell_Suite.py +++ b/Lib/plat-mac/lib-scriptpackages/CodeWarrior/Metrowerks_Shell_Suite.py @@ -1346,7 +1346,7 @@ class _Prop_format(aetools.NProperty): which = 'Frmt' want = 'PthF' class _Prop_framework(aetools.NProperty): - """framework - Is the path a Mac OS X framework style path? (This flag is readable but not writeable from AppleScript.) """ + """framework - Is the path a Mac OS X framework style path? (This flag is readable but not writable from AppleScript.) """ which = 'Frmw' want = 'bool' class _Prop_host_flags(aetools.NProperty): diff --git a/Lib/plat-mac/macresource.py b/Lib/plat-mac/macresource.py index 4592ff57d01..f670ad7d52c 100644 --- a/Lib/plat-mac/macresource.py +++ b/Lib/plat-mac/macresource.py @@ -135,7 +135,7 @@ def _decode(pathname, verbose=0): return newpathname if hasattr(os, 'access') and not \ os.access(os.path.dirname(pathname), os.W_OK|os.X_OK): - # The destination directory isn't writeable. Create the file in + # The destination directory isn't writable. Create the file in # a temporary directory import tempfile fd, newpathname = tempfile.mkstemp(".rsrc") diff --git a/Misc/HISTORY b/Misc/HISTORY index 7ab7e370760..5ae7dd423ca 100644 --- a/Misc/HISTORY +++ b/Misc/HISTORY @@ -403,7 +403,7 @@ Extension modules - os.urandom has been added for systems that support sources of random data. -- Patch 1012740: truncate() on a writeable cStringIO now resets the +- Patch 1012740: truncate() on a writable cStringIO now resets the position to the end of the stream. This is consistent with the original StringIO module and avoids inadvertently resurrecting data that was supposed to have been truncated away. diff --git a/Misc/setuid-prog.c b/Misc/setuid-prog.c index d850b47bcb0..2841acd28f0 100644 --- a/Misc/setuid-prog.c +++ b/Misc/setuid-prog.c @@ -155,7 +155,7 @@ main(int argc, char **argv) fprintf(stderr, "%s: %s has the wrong owner\n", argv[0], FULL_PATH); fprintf(stderr, "The script should be owned by root,\n"); - fprintf(stderr, "and shouldn't be writeable by anyone.\n"); + fprintf(stderr, "and shouldn't be writable by anyone.\n"); exit(1); } diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c index 77f64bc3727..cbea1c46bdc 100644 --- a/Modules/mmapmodule.c +++ b/Modules/mmapmodule.c @@ -272,7 +272,7 @@ mmap_find_method(mmap_object *self, } static int -is_writeable(mmap_object *self) +is_writable(mmap_object *self) { if (self->access != ACCESS_READ) return 1; @@ -307,7 +307,7 @@ mmap_write_method(mmap_object *self, if (!PyArg_ParseTuple(args, "s#:write", &data, &length)) return(NULL); - if (!is_writeable(self)) + if (!is_writable(self)) return NULL; if ((self->pos + length) > self->size) { @@ -330,7 +330,7 @@ mmap_write_byte_method(mmap_object *self, if (!PyArg_ParseTuple(args, "c:write_byte", &value)) return(NULL); - if (!is_writeable(self)) + if (!is_writable(self)) return NULL; *(self->data+self->pos) = value; self->pos += 1; @@ -562,7 +562,7 @@ mmap_move_method(mmap_object *self, PyObject *args) unsigned long dest, src, count; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "kkk:move", &dest, &src, &count) || - !is_writeable(self)) { + !is_writable(self)) { return NULL; } else { /* bounds check the values */ @@ -733,7 +733,7 @@ mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v) "mmap assignment must be length-1 bytes()"); return -1; } - if (!is_writeable(self)) + if (!is_writable(self)) return -1; buf = PyBytes_AsString(v); self->data[i] = buf[0]; @@ -768,7 +768,7 @@ mmap_ass_subscript(mmap_object *self, PyObject *item, PyObject *value) "mmap assignment must be length-1 bytes()"); return -1; } - if (!is_writeable(self)) + if (!is_writable(self)) return -1; buf = PyBytes_AsString(value); self->data[i] = buf[0]; @@ -797,7 +797,7 @@ mmap_ass_subscript(mmap_object *self, PyObject *item, PyObject *value) "mmap slice assignment is wrong size"); return -1; } - if (!is_writeable(self)) + if (!is_writable(self)) return -1; if (slicelen == 0) diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c index 90a2f964000..7fe562e71a1 100644 --- a/Modules/socketmodule.c +++ b/Modules/socketmodule.c @@ -1831,7 +1831,7 @@ internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen, timeout = 1; } else if (res > 0) { if (FD_ISSET(s->sock_fd, &fds)) - /* The socket is in the writeable set - this + /* The socket is in the writable set - this means connected */ res = 0; else { diff --git a/Objects/abstract.c b/Objects/abstract.c index cdd3706200e..284eb3308cb 100644 --- a/Objects/abstract.c +++ b/Objects/abstract.c @@ -304,9 +304,9 @@ int PyObject_AsWriteBuffer(PyObject *obj, pb = obj->ob_type->tp_as_buffer; if (pb == NULL || pb->bf_getbuffer == NULL || - ((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITEABLE) != 0)) { + ((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITABLE) != 0)) { PyErr_SetString(PyExc_TypeError, - "expected an object with a writeable buffer interface"); + "expected an object with a writable buffer interface"); return -1; } @@ -659,10 +659,10 @@ PyBuffer_FillInfo(PyBuffer *view, void *buf, Py_ssize_t len, "Cannot make this object read-only."); return -1; } - if (((flags & PyBUF_WRITEABLE) == PyBUF_WRITEABLE) && + if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) && readonly == 1) { PyErr_SetString(PyExc_BufferError, - "Object is not writeable."); + "Object is not writable."); return -1; } diff --git a/Objects/memoryobject.c b/Objects/memoryobject.c index 51dd1e01953..f0a70532973 100644 --- a/Objects/memoryobject.c +++ b/Objects/memoryobject.c @@ -183,8 +183,8 @@ _indirect_copy_nd(char *dest, PyBuffer *view, char fort) buffertype PyBUF_READ buffer only needs to be read-only - PyBUF_WRITE buffer needs to be writeable (give error if not contiguous) - PyBUF_SHADOW buffer needs to be writeable so shadow it with + PyBUF_WRITE buffer needs to be writable (give error if not contiguous) + PyBUF_SHADOW buffer needs to be writable so shadow it with a contiguous buffer if it is not. The view will point to the shadow buffer which can be written to and then will be copied back into the other buffer when the memory @@ -235,7 +235,7 @@ PyMemoryView_GetContiguous(PyObject *obj, int buffertype, char fort) if (buffertype == PyBUF_WRITE) { PyObject_DEL(mem); PyErr_SetString(PyExc_BufferError, - "writeable contiguous buffer requested for a non-contiguous" \ + "writable contiguous buffer requested for a non-contiguous" \ "object."); return NULL; }