pythoncapi
diff --git a/‎Doc/c-api/arg.rst‎
Lines changed: 15 additions & 0 deletions b/‎Doc/c-api/arg.rst‎
Lines changed: 15 additions & 0 deletions
diff --git a/‎Doc/whatsnew/2.6.rst‎
Lines changed: 2 additions & 2 deletions b/‎Doc/whatsnew/2.6.rst‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎Include/abstract.h‎
Lines changed: 5 additions & 19 deletions b/‎Include/abstract.h‎
Lines changed: 5 additions & 19 deletions
diff --git a/‎Include/object.h‎
Lines changed: 2 additions & 1 deletion b/‎Include/object.h‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎Lib/test/test_sys.py‎
Lines changed: 1 addition & 1 deletion b/‎Lib/test/test_sys.py‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎Modules/_bsddb.c‎
Lines changed: 2 additions & 2 deletions b/‎Modules/_bsddb.c‎
Lines changed: 2 additions & 2 deletions
@@ -40,6 +40,12 @@ variable(s) whose address should be passed.
    other read-buffer compatible objects pass back a reference to the raw internal
    data representation.
 
+``s*`` (string, Unicode, or any buffer compatible object) [Py_buffer \*]
+  Similar to ``s#``, this code fills a Py_buffer structure provided by the caller.
+  The buffer gets locked, so that the caller can subsequently use the buffer even
+  inside a ``Py_BEGIN_ALLOW_THREADS`` block; the caller is responsible for calling
+  ``PyBuffer_Release`` with the structure after it has processed the data.
+
 ``y`` (bytes object) [const char \*]
    This variant on ``s`` convert a Python bytes object to a C pointer to a
    character string. The bytes object must not contain embedded NUL bytes; if it
@@ -49,13 +55,19 @@ variable(s) whose address should be passed.
    This variant on ``s#`` stores into two C variables, the first one a pointer to a
    character string, the second one its length.  This only accepts bytes objects.
 
+``y*`` (bytes object) [Py_buffer \*]
+   This is to ``s*`` as ``y`` is to ``s``.
+
 ``z`` (string or ``None``) [const char \*]
    Like ``s``, but the Python object may also be ``None``, in which case the C
    pointer is set to *NULL*.
 
 ``z#`` (string or ``None`` or any read buffer compatible object) [const char \*, int]
    This is to ``s#`` as ``z`` is to ``s``.
 
+``z*`` (string or ``None`` or any buffer compatible object) [Py_buffer*]
+   This is to ``s*`` as ``z`` is to ``s``.
+
 ``u`` (Unicode object) [Py_UNICODE \*]
    Convert a Python Unicode object to a C pointer to a NUL-terminated buffer of
    16-bit Unicode (UTF-16) data.  As with ``s``, there is no need to provide
@@ -244,6 +256,9 @@ variable(s) whose address should be passed.
    single-segment buffer objects are accepted; :exc:`TypeError` is raised for all
    others.
 
+``w*`` (read-write byte-oriented buffer) [Py_buffer \*]
+   This is to ``w`` what ``s*`` is to ``s``.
+
 ``(items)`` (tuple) [*matching-items*]
    The object must be a Python sequence whose length is the number of format units
    in *items*.  The C arguments must correspond to the individual format units in
 
@@ -1064,7 +1064,7 @@ about the object's memory representation.  Objects
 can use this operation to lock memory in place
 while an external caller could be modifying the contents,
 so there's a corresponding
-``PyObject_ReleaseBuffer(PyObject *obj, Py_buffer *view)`` to
+``PyBuffer_Release(Py_buffer *view)`` to
 indicate that the external caller is done.
 
 The **flags** argument to :cfunc:`PyObject_GetBuffer` specifies
@@ -2841,7 +2841,7 @@ Changes to Python's build process and to the C API include:
 
 * The new buffer interface, previously described in
   `the PEP 3118 section <#pep-3118-revised-buffer-protocol>`__,
-  adds :cfunc:`PyObject_GetBuffer` and :cfunc:`PyObject_ReleaseBuffer`,
+  adds :cfunc:`PyObject_GetBuffer` and :cfunc:`PyBuffer_Release`,
   as well as a few other functions.
 
 * Python's use of the C stdio library is now thread-safe, or at least
 
@@ -526,24 +526,6 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
         */
 
 
-     PyAPI_FUNC(void) PyObject_ReleaseBuffer(PyObject *obj, Py_buffer *view);
-
-
-	/* C-API version of the releasebuffer function call.  It
-	   checks to make sure the object has the required function
-	   pointer and issues the call.  The obj must have the buffer
-	   interface or this function will cause a segfault (i.e. it
-	   is assumed to be called only after a corresponding
-	   getbuffer which already verified the existence of the
-	   tp_as_buffer pointer).
-           
-           Returns 0 on success and -1 (with an error raised) on
-           failure.  This function always succeeds (as a NO-OP) if
-           there is no releasebuffer function for the object so that
-           it can always be called when the consumer is done with the
-           buffer
-        */
-
      PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);
 
         /* Get the memory area pointed to by the indices for the buffer given. 
@@ -600,7 +582,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
             per element.
         */
 
-     PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, void *buf,
+     PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf,
 		             	       Py_ssize_t len, int readonly,
 				       int flags);
 
@@ -610,6 +592,10 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
            and -1 (with raising an error) on error.
          */
 
+     PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view);
+
+       /* Releases a Py_buffer obtained from getbuffer ParseTuple's s*.
+        */
 
      PyAPI_FUNC(PyObject *) PyObject_Format(PyObject* obj,
 					    PyObject *format_spec);
 
@@ -142,7 +142,8 @@ typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
 
 /* buffer interface */
 typedef struct bufferinfo {
-	void *buf;         
+	void *buf;   
+	PyObject *obj;        /* borrowed reference */
         Py_ssize_t len;
         Py_ssize_t itemsize;  /* This is Py_ssize_t so it can be 
                                  pointed to by strides in simple case.*/
 
@@ -550,7 +550,7 @@ def get_gen(): yield 1
         check(32768*32768-1, size(vh) + 2*self.H)
         check(32768*32768, size(vh) + 3*self.H)
         # memory
-        check(memoryview(b''), size(h + 'P P2P2i5P'))
+        check(memoryview(b''), size(h + 'P PP2P2i5P'))
         # module
         check(unittest, size(h + '3P'))
         # None
 
@@ -288,7 +288,7 @@ static void free_dbt(DBT *dbt)
 static void free_buf_view(PyObject *obj, Py_buffer *view)
 {
     if (view) {
-        PyObject_ReleaseBuffer(obj, view);
+        PyBuffer_Release(view);
         PyMem_Free(view);
     }
 }
@@ -319,7 +319,7 @@ static Py_buffer * _malloc_view(PyObject *obj)
     if (view->ndim > 1) {
         PyErr_SetString(PyExc_BufferError,
                         "buffers must be single dimension");
-        PyObject_ReleaseBuffer(obj, view);
+        PyBuffer_Release(view);
         PyMem_Free(view);
         return NULL;
     }
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ static void free_dbt(DBT *dbt)`
`288`	`288`	`static void free_buf_view(PyObject obj, Py_buffer view)`
`289`	`289`	`{`
`290`	`290`	`if (view) {`
`291`		`- PyObject_ReleaseBuffer(obj, view);`
	`291`	`+ PyBuffer_Release(view);`
`292`	`292`	`PyMem_Free(view);`
`293`	`293`	`}`
`294`	`294`	`}`
`@@ -319,7 +319,7 @@ static Py_buffer * _malloc_view(PyObject *obj)`
`319`	`319`	`if (view->ndim > 1) {`
`320`	`320`	`PyErr_SetString(PyExc_BufferError,`
`321`	`321`	`"buffers must be single dimension");`
`322`		`- PyObject_ReleaseBuffer(obj, view);`
	`322`	`+ PyBuffer_Release(view);`
`323`	`323`	`PyMem_Free(view);`
`324`	`324`	`return NULL;`
`325`	`325`	`}`