diff --git a/Doc/c-api/buffer.rst b/Doc/c-api/buffer.rst
index d3081894eadaf5..fae5b6240f2000 100644
--- a/Doc/c-api/buffer.rst
+++ b/Doc/c-api/buffer.rst
@@ -501,10 +501,14 @@ Buffer-related functions
    *indices* must point to an array of ``view->ndim`` indices.
 
 
-.. c:function:: int PyBuffer_FromContiguous(const Py_buffer *view, const void *buf, Py_ssize_t len, char fort)
+.. c:function:: int PyBuffer_FromContiguous(const Py_buffer *view, const void *buf, Py_ssize_t len, char order)
 
    Copy contiguous *len* bytes from *buf* to *view*.
-   *fort* can be ``'C'`` or ``'F'`` (for C-style or Fortran-style ordering).
+
+   If *order* is ``'C'``, the data is copied in C-style order.
+   If *order* is ``'F'``, the data is copied in Fortran-style order.
+   If *order* is ``'A'``, either style may be used, whichever is more efficient.
+
    ``0`` is returned on success, ``-1`` on error.
 
 
diff --git a/Include/pybuffer.h b/Include/pybuffer.h
index ca1c6058d9052c..6371b9b483777b 100644
--- a/Include/pybuffer.h
+++ b/Include/pybuffer.h
@@ -67,27 +67,27 @@ PyAPI_FUNC(int) PyBuffer_FromContiguous(const Py_buffer *view, const void *buf,
    error (i.e. the object does not have a buffer interface or
    it is not working).
 
-   If fort is 'F', then if the object is multi-dimensional,
+   If order is 'F', then if the object is multi-dimensional,
    then the data will be copied into the array in
    Fortran-style (first dimension varies the fastest).  If
-   fort is 'C', then the data will be copied into the array
-   in C-style (last dimension varies the fastest).  If fort
+   order is 'C', then the data will be copied into the array
+   in C-style (last dimension varies the fastest).  If order
    is 'A', then it does not matter and the copy will be made
    in whatever way is more efficient. */
 PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src);
 
 /* Copy the data from the src buffer to the buffer of destination. */
-PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort);
+PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char order);
 
 /*Fill the strides array with byte-strides of a contiguous
-  (Fortran-style if fort is 'F' or C-style otherwise)
+  (Fortran-style if order is 'F' or C-style otherwise)
   array of the given shape with the given number of bytes
   per element. */
 PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims,
                                                Py_ssize_t *shape,
                                                Py_ssize_t *strides,
                                                int itemsize,
-                                               char fort);
+                                               char order);
 
 /* Fills in a buffer-info structure correctly for an exporter
    that can only share a contiguous chunk of memory of
diff --git a/Objects/abstract.c b/Objects/abstract.c
index 8adad8407d04d4..9afa42cdd4eb2d 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -616,7 +616,7 @@ PyBuffer_SizeFromFormat(const char *format)
 }
 
 int
-PyBuffer_FromContiguous(const Py_buffer *view, const void *buf, Py_ssize_t len, char fort)
+PyBuffer_FromContiguous(const Py_buffer *view, const void *buf, Py_ssize_t len, char order)
 {
     int k;
     void (*addone)(int, Py_ssize_t *, const Py_ssize_t *);
@@ -628,7 +628,7 @@ PyBuffer_FromContiguous(const Py_buffer *view, const void *buf, Py_ssize_t len,
         len = view->len;
     }
 
-    if (PyBuffer_IsContiguous(view, fort)) {
+    if (PyBuffer_IsContiguous(view, order)) {
         /* simplest copy is all that is needed */
         memcpy(view->buf, buf, len);
         return 0;
@@ -646,7 +646,7 @@ PyBuffer_FromContiguous(const Py_buffer *view, const void *buf, Py_ssize_t len,
         indices[k] = 0;
     }
 
-    if (fort == 'F') {
+    if (order == 'F') {
         addone = _Py_add_one_to_index_F;
     }
     else {
@@ -741,13 +741,13 @@ int PyObject_CopyData(PyObject *dest, PyObject *src)
 void
 PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,
                                Py_ssize_t *strides, int itemsize,
-                               char fort)
+                               char order)
 {
     int k;
     Py_ssize_t sd;
 
     sd = itemsize;
-    if (fort == 'F') {
+    if (order == 'F') {
         for (k=0; k<nd; k++) {
             strides[k] = sd;
             sd *= shape[k];