Patch #976880: add mmap .rfind() method, and 'end' paramter to .find().

Contributed by John Lenton.

diff --git a/Doc/library/mmap.rst b/Doc/library/mmap.rst
index 070ce4feb696dbbe9c97ca4b2886b01126c8d7e6..cdc761c9af4a07725ee066d11d37148cb18821d0 100644 (file)
--- a/Doc/library/mmap.rst
+++ b/Doc/library/mmap.rst
@@ -139,11 +139,12 @@ Memory-mapped file objects support the following methods:
    an exception being raised.
 
 
-.. method:: mmap.find(string[, start])
+.. method:: mmap.find(string[, start[, end]])
 
-   Returns the lowest index in the object where the substring *string* is found.
-   Returns ``-1`` on failure.  *start* is the index at which the search begins, and
-   defaults to zero.
+   Returns the lowest index in the object where the substring *string* is found,
+   such that *string* is contained in the range [*start*, *end*]. Optional
+   arguments *start* and *end* are interpreted as in slice notation.
+   Returns ``-1`` on failure.
 
 
 .. method:: mmap.flush([offset, size])
@@ -188,6 +189,14 @@ Memory-mapped file objects support the following methods:
    :exc:`TypeError` exception.
 
 
+.. method:: mmap.rfind(string[, start[, end]])
+
+   Returns the highest index in the object where the substring *string* is
+   found, such that *string* is contained in the range [*start*,
+   *end*]. Optional arguments *start* and *end* are interpreted as in slice
+   notation.  Returns ``-1`` on failure.
+
+
 .. method:: mmap.seek(pos[, whence])
 
    Set the file's current position.  *whence* argument is optional and defaults to

diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
index b4f85fceef5378592cbb1bc9ce1ee5c6071e7340..8cc8dedb73d565973776399cb67dcddf96a4e6a5 100644 (file)
--- a/Lib/test/test_mmap.py
+++ b/Lib/test/test_mmap.py
@@ -255,6 +255,42 @@ class MmapTests(unittest.TestCase):
                 self.assertEqual(m.find(slice + 'x'), -1)
         m.close()
 
+    def test_find_end(self):
+        # test the new 'end' parameter works as expected
+        f = open(TESTFN, 'w+')
+        data = 'one two ones'
+        n = len(data)
+        f.write(data)
+        f.flush()
+        m = mmap.mmap(f.fileno(), n)
+        f.close()
+
+        self.assertEqual(m.find('one'), 0)
+        self.assertEqual(m.find('ones'), 8)
+        self.assertEqual(m.find('one', 0, -1), 0)
+        self.assertEqual(m.find('one', 1), 8)
+        self.assertEqual(m.find('one', 1, -1), 8)
+        self.assertEqual(m.find('one', 1, -2), -1)
+
+
+    def test_rfind(self):
+        # test the new 'end' parameter works as expected
+        f = open(TESTFN, 'w+')
+        data = 'one two ones'
+        n = len(data)
+        f.write(data)
+        f.flush()
+        m = mmap.mmap(f.fileno(), n)
+        f.close()
+
+        self.assertEqual(m.rfind('one'), 8)
+        self.assertEqual(m.rfind('one '), 0)
+        self.assertEqual(m.rfind('one', 0, -1), 8)
+        self.assertEqual(m.rfind('one', 0, -2), 0)
+        self.assertEqual(m.rfind('one', 1, -1), 8)
+        self.assertEqual(m.rfind('one', 1, -2), -1)
+
+
     def test_double_close(self):
         # make sure a double close doesn't crash on Solaris (Bug# 665913)
         f = open(TESTFN, 'w+')

diff --git a/Misc/ACKS b/Misc/ACKS
index 499b1d01e6daf2ff2e2c1180411a19c05c6ca657..35ceceef728f707ccee05882b2fa717af5a3283e 100644 (file)
--- a/Misc/ACKS
+++ b/Misc/ACKS
@@ -395,6 +395,7 @@ Kip Lehman
 Joerg Lehmann
 Luke Kenneth Casson Leighton
 Marc-Andre Lemburg
+John Lenton
 Mark Levinson
 William Lewis
 Robert van Liere

diff --git a/Misc/NEWS b/Misc/NEWS
index 9e25b9669625c82ceb99079fbfbcaae40dcb25c4..ce643ce8dd2dc4fd19582827bd1f6b5862eb3620 100644 (file)
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -1011,6 +1011,10 @@ Library
 Extension Modules
 -----------------
 
+- Patch 976880: ``mmap`` objects now have an ``rfind`` method that
+  works as expected.  ``mmap.find`` also takes an optional ``end``
+  parameter.
+
 - _winreg's HKEY object has gained __enter__ and __exit__ methods to support
   the context manager protocol.  The _winreg module also gained a new function
   ``ExpandEnvironmentStrings`` to expand REG_EXPAND_SZ keys.

diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index 9a39b2424e8e1c694962af6fa5b509fd2ea686b3..dd35c10728b8a5e2482b434da6beb9ea43b0c04d 100644 (file)
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -248,19 +248,22 @@ mmap_read_method(mmap_object *self,
 }
 
 static PyObject *
-mmap_find_method(mmap_object *self,
-                PyObject *args)
+mmap_gfind(mmap_object *self,
+          PyObject *args,
+          int reverse)
 {
        Py_ssize_t start = self->pos;
+        Py_ssize_t end = self->size;
        char *needle;
        Py_ssize_t len;
 
        CHECK_VALID(NULL);
-       if (!PyArg_ParseTuple(args, "s#|n:find", &needle, &len, &start)) {
+       if (!PyArg_ParseTuple(args, reverse ? "s#|nn:rfind" : "s#|nn:find",
+                             &needle, &len, &start, &end)) {
                return NULL;
        } else {
                char *p;
-               char *e = self->data + self->size;
+               char sign = reverse ? -1 : 1;
 
                 if (start < 0)
                        start += self->size;
@@ -269,7 +272,18 @@ mmap_find_method(mmap_object *self,
                 else if ((size_t)start > self->size)
                        start = self->size;
 
-               for (p = self->data + start; p + len <= e; ++p) {
+                if (end < 0)
+                       end += self->size;
+               if (end < 0)
+                       end = 0;
+               else if ((size_t)end > self->size)
+                       end = self->size;
+
+               start += (Py_ssize_t)self->data;
+               end += (Py_ssize_t)self->data;
+
+               for (p = (char *)(reverse ? end - len : start);
+                    p >= (char *)start && p + len <= (char *)end; p+=sign) {
                        Py_ssize_t i;
                        for (i = 0; i < len && needle[i] == p[i]; ++i)
                                /* nothing */;
@@ -281,6 +295,20 @@ mmap_find_method(mmap_object *self,
        }
 }
 
+static PyObject *
+mmap_find_method(mmap_object *self,
+                PyObject *args)
+{
+       return mmap_gfind(self, args, 0);
+}
+
+static PyObject *
+mmap_rfind_method(mmap_object *self,
+                PyObject *args)
+{
+       return mmap_gfind(self, args, 1);
+}
+
 static int
 is_writeable(mmap_object *self)
 {
@@ -593,6 +621,7 @@ mmap_move_method(mmap_object *self, PyObject *args)
 static struct PyMethodDef mmap_object_methods[] = {
        {"close",       (PyCFunction) mmap_close_method,        METH_NOARGS},
        {"find",        (PyCFunction) mmap_find_method,         METH_VARARGS},
+       {"rfind",       (PyCFunction) mmap_rfind_method,        METH_VARARGS},
        {"flush",       (PyCFunction) mmap_flush_method,        METH_VARARGS},
        {"move",        (PyCFunction) mmap_move_method,         METH_VARARGS},
        {"read",        (PyCFunction) mmap_read_method,         METH_VARARGS},