Net result of Tim's checkins 2.28 through 2.31:

- SF but #417587: compiler warnings compiling 2.1.
  Repaired *some* of the SGI compiler warnings Sjoerd Mullender
  reported.

- Minor fiddling related to
  SF patch 416251 2.1c1 mmapmodule: unused vrbl cleanup

- Fix the .find() method for memory maps.

  1) it didn't obey the "start" parameter (and when it does, we must
     validate the value)
  2) the return value needs to be an absolute index, rather than
     relative to some arbitrary point in the file

  (checking CVS, it appears this method never worked; these changes
   bring it into line with typical .find() behavior)

- Fix new compiler warnings.  Also boost "start" from (C) int to long and
  return a (C) long:  PyArg_ParseTuple and Py_BuildValue may not let
  us get at the size_t we really want, but C int is clearly too small
  for a 64-bit box, and both the start parameter and the return value
  should work for large mapped files even on 32-bit boxes.  The code
  really needs to be rethought from scratch (not by me, though ...).

diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index c1cc013ed29f14ff329e2d55d17c8b951b8f49c3..63ef72a7f36d8c83d418eb60db1a93b144e00108 100644 (file)
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -163,16 +163,13 @@ static PyObject *
 mmap_read_byte_method(mmap_object *self,
                      PyObject *args)
 {
-       char value;
-       char *where;
        CHECK_VALID(NULL);
         if (!PyArg_ParseTuple(args, ":read_byte"))
                return NULL;
        if (self->pos < self->size) {
-               where = self->data + self->pos;
-               value = (char) *(where);
+               char value = self->data[self->pos];
                self->pos += 1;
-               return Py_BuildValue("c", (char) *(where));
+               return Py_BuildValue("c", value);
        } else {
                PyErr_SetString (PyExc_ValueError, "read byte out of range");
                return NULL;
@@ -227,16 +224,25 @@ static PyObject *
 mmap_find_method(mmap_object *self,
                 PyObject *args)
 {
-       int start = self->pos;
+       long start = self->pos;
        char *needle;
        int len;
 
        CHECK_VALID(NULL);
-       if (!PyArg_ParseTuple (args, "s#|i:find", &needle, &len, &start)) {
+       if (!PyArg_ParseTuple (args, "s#|l:find", &needle, &len, &start)) {
                return NULL;
        } else {
-               char *p = self->data+self->pos;
-               char *e = self->data+self->size;
+               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;
+                p = self->data + start;
+
                while (p < e) {
                        char *s = p;
                        char *n = needle;
@@ -245,8 +251,8 @@ mmap_find_method(mmap_object *self,
                        }
                        if (!*n) {
                                return Py_BuildValue (
-                                       "i",
-                                       (int) (p - (self->data + start)));
+                                       "l",
+                                       (long) (p - self->data));
                        }
                        p++;
                }
@@ -818,7 +824,7 @@ new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
        m_obj->data = mmap(NULL, map_size, 
                           prot, flags,
                           fd, 0);
-       if (m_obj->data == (void *)-1)
+       if (m_obj->data == (char *)-1)
        {
                Py_DECREF(m_obj);
                PyErr_SetFromErrno(mmap_module_error);