]> granicus.if.org Git - python/commitdiff
Primarily formatting changes, but I also plugged a couple of potential
authorBarry Warsaw <barry@python.org>
Thu, 9 Jan 1997 22:29:12 +0000 (22:29 +0000)
committerBarry Warsaw <barry@python.org>
Thu, 9 Jan 1997 22:29:12 +0000 (22:29 +0000)
return value problems, memory leaks, and descriptor leaks.

Modules/rgbimgmodule.c

index 4ece3cc3a088e0bf58d5c4059174620cf9d5b16a..02005bb7dd664f83352504b6a35ecaeb023227b1 100644 (file)
@@ -106,11 +106,12 @@ static int reverse_order;
  *             this is used to extract image data from core dumps.
  *
  */
-addlongimgtag(dptr,xsize,ysize)
+static void 
+addlongimgtag(dptr, xsize, ysize)
        unsigned long *dptr;
-int xsize, ysize;
+       int xsize, ysize;
 {
-       dptr = dptr+(xsize*ysize);
+       dptr = dptr + (xsize * ysize);
        dptr[0] = 0x12345678;
        dptr[1] = 0x59493333;
        dptr[2] = 0x69434222;
@@ -123,100 +124,108 @@ int xsize, ysize;
  *     byte order independent read/write of shorts and longs.
  *
  */
-static unsigned short getshort(inf)
+static unsigned short
+getshort(inf)
        FILE *inf;
 {
        unsigned char buf[2];
 
-       fread(buf,2,1,inf);
-       return (buf[0]<<8)+(buf[1]<<0);
+       fread(buf, 2, 1, inf);
+       return (buf[0] << 8) + (buf[1] << 0);
 }
 
-static unsigned long getlong(inf)
+static unsigned long
+getlong(inf)
        FILE *inf;
 {
        unsigned char buf[4];
 
-       fread(buf,4,1,inf);
-       return (buf[0]<<24)+(buf[1]<<16)+(buf[2]<<8)+(buf[3]<<0);
+       fread(buf, 4, 1, inf);
+       return (buf[0] << 24) + (buf[1] << 16) + (buf[2] << 8) + (buf[3] << 0);
 }
 
-static void putshort(outf,val)
+static void
+putshort(outf, val)
        FILE *outf;
-unsigned short val;
+       unsigned short val;
 {
        unsigned char buf[2];
 
-       buf[0] = (val>>8);
-       buf[1] = (val>>0);
-       fwrite(buf,2,1,outf);
+       buf[0] = (val >> 8);
+       buf[1] = (val >> 0);
+       fwrite(buf, 2, 1, outf);
 }
 
-static int putlong(outf,val)
+static int
+putlong(outf, val)
        FILE *outf;
-unsigned long val;
+       unsigned long val;
 {
        unsigned char buf[4];
 
-       buf[0] = (val>>24);
-       buf[1] = (val>>16);
-       buf[2] = (val>>8);
-       buf[3] = (val>>0);
-       return fwrite(buf,4,1,outf);
+       buf[0] = (val >> 24);
+       buf[1] = (val >> 16);
+       buf[2] = (val >> 8);
+       buf[3] = (val >> 0);
+       return fwrite(buf, 4, 1, outf);
 }
 
-static void readheader(inf,image)
+static void
+readheader(inf, image)
        FILE *inf;
-IMAGE *image;
+       IMAGE *image;
 {
-       memset(image,0,sizeof(IMAGE));
+       memset(image ,0, sizeof(IMAGE));
        image->imagic = getshort(inf);
-       image->type = getshort(inf);
-       image->dim = getshort(inf);
-       image->xsize = getshort(inf);
-       image->ysize = getshort(inf);
-       image->zsize = getshort(inf);
+       image->type   = getshort(inf);
+       image->dim    = getshort(inf);
+       image->xsize  = getshort(inf);
+       image->ysize  = getshort(inf);
+       image->zsize  = getshort(inf);
 }
 
-static int writeheader(outf,image)
+static int
+writeheader(outf, image)
        FILE *outf;
-IMAGE *image;
+       IMAGE *image;
 {
        IMAGE t;
 
-       memset(&t,0,sizeof(IMAGE));
-       fwrite(&t,sizeof(IMAGE),1,outf);
-       fseek(outf,0,SEEK_SET);
-       putshort(outf,image->imagic);
-       putshort(outf,image->type);
-       putshort(outf,image->dim);
-       putshort(outf,image->xsize);
-       putshort(outf,image->ysize);
-       putshort(outf,image->zsize);
-       putlong(outf,image->min);
-       putlong(outf,image->max);
-       putlong(outf,0);
-       return fwrite("no name",8,1,outf);
+       memset(&t, 0, sizeof(IMAGE));
+       fwrite(&t, sizeof(IMAGE), 1, outf);
+       fseek(outf, 0, SEEK_SET);
+       putshort(outf, image->imagic);
+       putshort(outf, image->type);
+       putshort(outf, image->dim);
+       putshort(outf, image->xsize);
+       putshort(outf, image->ysize);
+       putshort(outf, image->zsize);
+       putlong(outf, image->min);
+       putlong(outf, image->max);
+       putlong(outf, 0);
+       return fwrite("no name", 8, 1, outf);
 }
 
-static int writetab(outf,tab,len)
+static int
+writetab(outf, tab, len)
        FILE *outf;
-/*unsigned*/ long *tab;
-int len;
+       /*unsigned*/ long *tab;
+       int len;
 {
        int r = 0;
 
        while(len) {
-               r = putlong(outf,*tab++);
+               r = putlong(outf, *tab++);
                len -= 4;
        }
        return r;
 }
 
-static void readtab(inf,tab,len)
+static void
+readtab(inf, tab, len)
        FILE *inf;
-/*unsigned*/ long *tab;
-int len;
+       /*unsigned*/ long *tab;
+       int len;
 {
        while(len) {
                *tab++ = getlong(inf);
@@ -240,14 +249,14 @@ sizeofimage(self, args)
        if (!PyArg_Parse(args, "s", &name))
                return NULL;
 
-       inf = fopen(name,"r");
-       if(!inf) {
+       inf = fopen(name, "r");
+       if (!inf) {
                PyErr_SetString(ImgfileError, "can't open image file");
                return NULL;
        }
-       readheader(inf,&image);
+       readheader(inf, &image);
        fclose(inf);
-       if(image.imagic != IMAGIC) {
+       if (image.imagic != IMAGIC) {
                PyErr_SetString(ImgfileError,
                                "bad magic number in image file");
                return NULL;
@@ -267,107 +276,104 @@ longimagedata(self, args)
 {
        char *name;
        unsigned char *base, *lptr;
-       unsigned char *rledat, *verdat;
-       long *starttab, *lengthtab;
-       FILE *inf;
+       unsigned char *rledat = NULL, *verdat = NULL;
+       long *starttab = NULL, *lengthtab = NULL;
+       FILE *inf = NULL;
        IMAGE image;
        int y, z, tablen;
        int xsize, ysize, zsize;
        int bpp, rle, cur, badorder;
        int rlebuflen;
-       PyObject *rv;
+       PyObject *rv = NULL;
 
        if (!PyArg_Parse(args, "s", &name))
                return NULL;
 
        inf = fopen(name,"r");
-       if(!inf) {
-               PyErr_SetString(ImgfileError,"can't open image file");
+       if (!inf) {
+               PyErr_SetString(ImgfileError, "can't open image file");
                return NULL;
        }
        readheader(inf,&image);
-       if(image.imagic != IMAGIC) {
-               PyErr_SetString(ImgfileError,"bad magic number in image file");
-               fclose(inf);
-               return NULL;
+       if (image.imagic != IMAGIC) {
+               PyErr_SetString(ImgfileError,
+                               "bad magic number in image file");
+               goto finally;
        }
        rle = ISRLE(image.type);
        bpp = BPP(image.type);
-       if(bpp != 1 ) {
+       if (bpp != 1) {
                PyErr_SetString(ImgfileError,
                                "image must have 1 byte per pix chan");
-               fclose(inf);
-               return NULL;
+               goto finally;
        }
        xsize = image.xsize;
        ysize = image.ysize;
        zsize = image.zsize;
-       if(rle) {
-               tablen = ysize*zsize*sizeof(long);
+       if (rle) {
+               tablen = ysize * zsize * sizeof(long);
                starttab = (long *)malloc(tablen);
                lengthtab = (long *)malloc(tablen);
-               rlebuflen = 1.05*xsize+10;
+               rlebuflen = 1.05 * xsize +10;
                rledat = (unsigned char *)malloc(rlebuflen);
-               fseek(inf,512,SEEK_SET);
-               readtab(inf,starttab,tablen);
-               readtab(inf,lengthtab,tablen);
+               if (!starttab || !lengthtab || !rledat) {
+                       PyErr_NoMemory();
+                       goto finally;
+               }
+               
+               fseek(inf, 512, SEEK_SET);
+               readtab(inf, starttab, tablen);
+               readtab(inf, lengthtab, tablen);
 
-/* check data order */
+               /* check data order */
                cur = 0;
                badorder = 0;
-               for(y=0; y<ysize; y++) {
-                       for(z=0; z<zsize; z++) {
-                               if(starttab[y+z*ysize]<cur) {
+               for(y = 0; y < ysize; y++) {
+                       for(z = 0; z < zsize; z++) {
+                               if (starttab[y + z * ysize] < cur) {
                                        badorder = 1;
                                        break;
                                }
-                               cur = starttab[y+z*ysize];
+                               cur = starttab[y +z * ysize];
                        }
-                       if(badorder) 
+                       if (badorder)
                                break;
                }
 
-               fseek(inf,512+2*tablen,SEEK_SET);
-               cur = 512+2*tablen;
-               rv = PyString_FromStringAndSize((char *) 0,
-                                        (xsize*ysize+TAGLEN)*sizeof(long));
-               if (rv == NULL) {
-                       fclose(inf);
-                       free(lengthtab);
-                       free(starttab);
-                       free(rledat);
-                       return NULL;
-               }
+               fseek(inf, 512 + 2 * tablen, SEEK_SET);
+               cur = 512 + 2 * tablen;
+               rv = PyString_FromStringAndSize((char *)NULL,
+                                     (xsize * ysize + TAGLEN) * sizeof(long));
+               if (rv == NULL)
+                       goto finally;
+
                base = (unsigned char *) PyString_AsString(rv);
 #ifdef ADD_TAGS
                addlongimgtag(base,xsize,ysize);
 #endif
-               if(badorder) {
-                       for(z=0; z<zsize; z++) {
+               if (badorder) {
+                       for (z = 0; z < zsize; z++) {
                                lptr = base;
                                if (reverse_order)
                                        lptr += (ysize - 1) * xsize
                                                * sizeof(unsigned long);
-                               for(y=0; y<ysize; y++) {
-                                       if(cur != starttab[y+z*ysize]) {
-                                               fseek(inf,starttab[y+z*ysize],
+                               for (y = 0; y < ysize; y++) {
+                                       int idx = y + z * ysize;
+                                       if (cur != starttab[idx]) {
+                                               fseek(inf,starttab[idx],
                                                      SEEK_SET);
-                                               cur = starttab[y+z*ysize];
+                                               cur = starttab[idx];
                                        }
-                                       if(lengthtab[y+z*ysize]>rlebuflen) {
+                                       if (lengthtab[idx] > rlebuflen) {
                                                PyErr_SetString(ImgfileError,
-                                            "rlebuf is too small - bad poop");
-                                               fclose(inf);
+                                                       "rlebuf is too small");
                                                Py_DECREF(rv);
-                                               free(rledat);
-                                               free(starttab);
-                                               free(lengthtab);
-                                               return NULL;
+                                               rv = NULL;
+                                               goto finally;
                                        }
-                                       fread(rledat,lengthtab[y+z*ysize],
-                                             1,inf);
-                                       cur += lengthtab[y+z*ysize];
-                                       expandrow(lptr,rledat,3-z);
+                                       fread(rledat, lengthtab[idx], 1, inf);
+                                       cur += lengthtab[idx];
+                                       expandrow(lptr, rledat, 3-z);
                                        if (reverse_order)
                                                lptr -= xsize
                                                      * sizeof(unsigned long);
@@ -381,17 +387,17 @@ longimagedata(self, args)
                        if (reverse_order)
                                lptr += (ysize - 1) * xsize
                                        * sizeof(unsigned long);
-                       for(y=0; y<ysize; y++) {
-                               for(z=0; z<zsize; z++) {
-                                       if(cur != starttab[y+z*ysize]) {
-                                               fseek(inf,starttab[y+z*ysize],
+                       for (y = 0; y < ysize; y++) {
+                               for(z = 0; z < zsize; z++) {
+                                       int idx = y + z * ysize;
+                                       if (cur != starttab[idx]) {
+                                               fseek(inf, starttab[idx],
                                                      SEEK_SET);
-                                               cur = starttab[y+z*ysize];
+                                               cur = starttab[idx];
                                        }
-                                       fread(rledat,lengthtab[y+z*ysize],
-                                             1,inf);
-                                       cur += lengthtab[y+z*ysize];
-                                       expandrow(lptr,rledat,3-z);
+                                       fread(rledat, lengthtab[idx], 1, inf);
+                                       cur += lengthtab[idx];
+                                       expandrow(lptr, rledat, 3-z);
                                }
                                if (reverse_order)
                                        lptr -= xsize * sizeof(unsigned long);
@@ -399,154 +405,158 @@ longimagedata(self, args)
                                        lptr += xsize * sizeof(unsigned long);
                        }
                }
-               if(zsize == 3) 
-                       setalpha(base,xsize*ysize);
-               else if(zsize<3) 
-                       copybw((long *) base,xsize*ysize);
-               fclose(inf);
-               free(starttab);
-               free(lengthtab);
-               free(rledat);
-               return rv;
-       } else {
+               if (zsize == 3) 
+                       setalpha(base, xsize * ysize);
+               else if (zsize < 3) 
+                       copybw((long *) base, xsize * ysize);
+       }
+       else {
                rv = PyString_FromStringAndSize((char *) 0,
                                           (xsize*ysize+TAGLEN)*sizeof(long));
-               if (rv == NULL) {
-                       fclose(inf);
-                       return NULL;
-               }
+               if (rv == NULL)
+                       goto finally;
+
                base = (unsigned char *) PyString_AsString(rv);
 #ifdef ADD_TAGS
-               addlongimgtag(base,xsize,ysize);
+               addlongimgtag(base, xsize, ysize);
 #endif
                verdat = (unsigned char *)malloc(xsize);
-               fseek(inf,512,SEEK_SET);
-               for(z=0; z<zsize; z++) {
+               fseek(inf, 512, SEEK_SET);
+               for (z = 0; z < zsize; z++) {
                        lptr = base;
                        if (reverse_order)
                                lptr += (ysize - 1) * xsize
                                        * sizeof(unsigned long);
-                       for(y=0; y<ysize; y++) {
-                               fread(verdat,xsize,1,inf);
-                               interleaverow(lptr,verdat,3-z,xsize);
+                       for (y = 0; y < ysize; y++) {
+                               fread(verdat, xsize, 1, inf);
+                               interleaverow(lptr, verdat, 3-z, xsize);
                                if (reverse_order)
                                        lptr -= xsize * sizeof(unsigned long);
                                else
                                        lptr += xsize * sizeof(unsigned long);
                        }
                }
-               if(zsize == 3) 
-                       setalpha(base,xsize*ysize);
-               else if(zsize<3) 
-                       copybw((long *) base,xsize*ysize);
-               fclose(inf);
-               free(verdat);
-               return rv;
+               if (zsize == 3)
+                       setalpha(base, xsize * ysize);
+               else if (zsize < 3) 
+                       copybw((long *) base, xsize * ysize);
        }
+  finally:
+       free(starttab);
+       free(lengthtab);
+       free(rledat);
+       free(verdat);
+       fclose(inf);
+       return rv;
 }
 
 /* static utility functions for longimagedata */
 
-static void interleaverow(lptr,cptr,z,n)
+static void
+interleaverow(lptr, cptr, z, n)
        unsigned char *lptr, *cptr;
-int z, n;
+       int z, n;
 {
        lptr += z;
-       while(n--) {
+       while (n--) {
                *lptr = *cptr++;
                lptr += 4;
        }
 }
 
-static void copybw(lptr,n)
+static void
+copybw(lptr, n)
        long *lptr;
-int n;
+       int n;
 {
-       while(n>=8) {
-               lptr[0] = 0xff000000+(0x010101*(lptr[0]&0xff));
-               lptr[1] = 0xff000000+(0x010101*(lptr[1]&0xff));
-               lptr[2] = 0xff000000+(0x010101*(lptr[2]&0xff));
-               lptr[3] = 0xff000000+(0x010101*(lptr[3]&0xff));
-               lptr[4] = 0xff000000+(0x010101*(lptr[4]&0xff));
-               lptr[5] = 0xff000000+(0x010101*(lptr[5]&0xff));
-               lptr[6] = 0xff000000+(0x010101*(lptr[6]&0xff));
-               lptr[7] = 0xff000000+(0x010101*(lptr[7]&0xff));
+       while (n >= 8) {
+               lptr[0] = 0xff000000 + (0x010101 * (lptr[0] & 0xff));
+               lptr[1] = 0xff000000 + (0x010101 * (lptr[1] & 0xff));
+               lptr[2] = 0xff000000 + (0x010101 * (lptr[2] & 0xff));
+               lptr[3] = 0xff000000 + (0x010101 * (lptr[3] & 0xff));
+               lptr[4] = 0xff000000 + (0x010101 * (lptr[4] & 0xff));
+               lptr[5] = 0xff000000 + (0x010101 * (lptr[5] & 0xff));
+               lptr[6] = 0xff000000 + (0x010101 * (lptr[6] & 0xff));
+               lptr[7] = 0xff000000 + (0x010101 * (lptr[7] & 0xff));
                lptr += 8;
-               n-=8;
+               n -= 8;
        }
-       while(n--) {
-               *lptr = 0xff000000+(0x010101*(*lptr&0xff));
+       while (n--) {
+               *lptr = 0xff000000 + (0x010101 * (*lptr&0xff));
                lptr++;
        }
 }
 
-static void setalpha(lptr,n)
+static void
+setalpha(lptr, n)
        unsigned char *lptr;
 {
-       while(n>=8) {
-               lptr[0*4] = 0xff;
-               lptr[1*4] = 0xff;
-               lptr[2*4] = 0xff;
-               lptr[3*4] = 0xff;
-               lptr[4*4] = 0xff;
-               lptr[5*4] = 0xff;
-               lptr[6*4] = 0xff;
-               lptr[7*4] = 0xff;
-               lptr += 4*8;
+       while (n >= 8) {
+               lptr[0 * 4] = 0xff;
+               lptr[1 * 4] = 0xff;
+               lptr[2 * 4] = 0xff;
+               lptr[3 * 4] = 0xff;
+               lptr[4 * 4] = 0xff;
+               lptr[5 * 4] = 0xff;
+               lptr[6 * 4] = 0xff;
+               lptr[7 * 4] = 0xff;
+               lptr += 4 * 8;
                n -= 8;
        }
-       while(n--) {
+       while (n--) {
                *lptr = 0xff;
                lptr += 4;
        }
 }
 
-static void expandrow(optr,iptr,z)
+static void
+expandrow(optr, iptr, z)
        unsigned char *optr, *iptr;
-int z;
+       int z;
 {
        unsigned char pixel, count;
 
        optr += z;
-       while(1) {
+       while (1) {
                pixel = *iptr++;
-               if ( !(count = (pixel & 0x7f)) )
+               if (!(count = (pixel & 0x7f)))
                        return;
-               if(pixel & 0x80) {
-                       while(count>=8) {
-                               optr[0*4] = iptr[0];
-                               optr[1*4] = iptr[1];
-                               optr[2*4] = iptr[2];
-                               optr[3*4] = iptr[3];
-                               optr[4*4] = iptr[4];
-                               optr[5*4] = iptr[5];
-                               optr[6*4] = iptr[6];
-                               optr[7*4] = iptr[7];
-                               optr += 8*4;
+               if (pixel & 0x80) {
+                       while (count >= 8) {
+                               optr[0 * 4] = iptr[0];
+                               optr[1 * 4] = iptr[1];
+                               optr[2 * 4] = iptr[2];
+                               optr[3 * 4] = iptr[3];
+                               optr[4 * 4] = iptr[4];
+                               optr[5 * 4] = iptr[5];
+                               optr[6 * 4] = iptr[6];
+                               optr[7 * 4] = iptr[7];
+                               optr += 8 * 4;
                                iptr += 8;
                                count -= 8;
                        }
-                       while(count--) {
+                       while (count--) {
                                *optr = *iptr++;
-                               optr+=4;
+                               optr += 4;
                        }
-               } else {
+               }
+               else {
                        pixel = *iptr++;
-                       while(count>=8) {
-                               optr[0*4] = pixel;
-                               optr[1*4] = pixel;
-                               optr[2*4] = pixel;
-                               optr[3*4] = pixel;
-                               optr[4*4] = pixel;
-                               optr[5*4] = pixel;
-                               optr[6*4] = pixel;
-                               optr[7*4] = pixel;
-                               optr += 8*4;
+                       while (count >= 8) {
+                               optr[0 * 4] = pixel;
+                               optr[1 * 4] = pixel;
+                               optr[2 * 4] = pixel;
+                               optr[3 * 4] = pixel;
+                               optr[4 * 4] = pixel;
+                               optr[5 * 4] = pixel;
+                               optr[6 * 4] = pixel;
+                               optr[7 * 4] = pixel;
+                               optr += 8 * 4;
                                count -= 8;
                        }
-                       while(count--) {
+                       while (count--) {
                                *optr = pixel;
-                               optr+=4;
+                               optr += 4;
                        }
                }
        }
@@ -570,36 +580,41 @@ longstoimage(self, args)
        unsigned char *lptr;
        char *name;
        int xsize, ysize, zsize;
-       FILE *outf;
+       FILE *outf = NULL;
        IMAGE image;
        int tablen, y, z, pos, len;
-       long *starttab, *lengthtab;
-       unsigned char *rlebuf;
-       unsigned char *lumbuf;
+       long *starttab = NULL, *lengthtab = NULL;
+       unsigned char *rlebuf = NULL;
+       unsigned char *lumbuf = NULL;
        int rlebuflen, goodwrite;
+       PyObject *retval = NULL;
 
        if (!PyArg_Parse(args, "(s#iiis)", &lptr, &len, &xsize, &ysize, &zsize,
                         &name))
                return NULL;
 
        goodwrite = 1;
-       outf = fopen(name,"w");
-       if(!outf) {
-               PyErr_SetString(ImgfileError,"can't open output file");
+       outf = fopen(name, "w");
+       if (!outf) {
+               PyErr_SetString(ImgfileError, "can't open output file");
                return NULL;
        }
-       tablen = ysize*zsize*sizeof(long);
+       tablen = ysize * zsize * sizeof(long);
 
        starttab = (long *)malloc(tablen);
        lengthtab = (long *)malloc(tablen);
-       rlebuflen = 1.05*xsize+10;
+       rlebuflen = 1.05 * xsize + 10;
        rlebuf = (unsigned char *)malloc(rlebuflen);
-       lumbuf = (unsigned char *)malloc(xsize*sizeof(long));
-
-       memset(&image,0,sizeof(IMAGE));
+       lumbuf = (unsigned char *)malloc(xsize * sizeof(long));
+       if (!starttab || !lengthtab || !rlebuf || !lumbuf) {
+               PyErr_NoMemory();
+               goto finally;
+       }
+       
+       memset(&image, 0, sizeof(IMAGE));
        image.imagic = IMAGIC; 
        image.type = RLE(1);
-       if(zsize>1)
+       if (zsize>1)
                image.dim = 3;
        else
                image.dim = 2;
@@ -608,34 +623,29 @@ longstoimage(self, args)
        image.zsize = zsize;
        image.min = 0;
        image.max = 255;
-       goodwrite *= writeheader(outf,&image);
-       fseek(outf,512+2*tablen,SEEK_SET);
-       pos = 512+2*tablen;
+       goodwrite *= writeheader(outf, &image);
+       pos = 512 + 2 * tablen;
+       fseek(outf, pos, SEEK_SET);
        if (reverse_order)
                lptr += (ysize - 1) * xsize * sizeof(unsigned long);
-       for(y=0; y<ysize; y++) {
-               for(z=0; z<zsize; z++) {
-                       if(zsize == 1) {
-                               lumrow(lptr,lumbuf,xsize);
-                               len = compressrow(lumbuf,rlebuf,CHANOFFSET(z),
-                                                 xsize);
+       for (y = 0; y < ysize; y++) {
+               for (z = 0; z < zsize; z++) {
+                       if (zsize == 1) {
+                               lumrow(lptr, lumbuf, xsize);
+                               len = compressrow(lumbuf, rlebuf,
+                                                 CHANOFFSET(z), xsize);
                        } else {
-                               len = compressrow(lptr,rlebuf,CHANOFFSET(z),
-                                                 xsize);
+                               len = compressrow(lptr, rlebuf,
+                                                 CHANOFFSET(z), xsize);
                        }
-                       if(len>rlebuflen) {
+                       if(len > rlebuflen) {
                                PyErr_SetString(ImgfileError,
-                                          "rlebuf is too small - bad poop");
-                               free(starttab);
-                               free(lengthtab);
-                               free(rlebuf);
-                               free(lumbuf);
-                               fclose(outf);
-                               return NULL;
+                                               "rlebuf is too small");
+                               goto finally;
                        }
-                       goodwrite *= fwrite(rlebuf,len,1,outf);
-                       starttab[y+z*ysize] = pos;
-                       lengthtab[y+z*ysize] = len;
+                       goodwrite *= fwrite(rlebuf, len, 1, outf);
+                       starttab[y + z * ysize] = pos;
+                       lengthtab[y + z * ysize] = len;
                        pos += len;
                }
                if (reverse_order)
@@ -644,41 +654,45 @@ longstoimage(self, args)
                        lptr += xsize * sizeof(unsigned long);
        }
 
-       fseek(outf,512,SEEK_SET);
-       goodwrite *= writetab(outf,starttab,tablen);
-       goodwrite *= writetab(outf,lengthtab,tablen);
+       fseek(outf, 512, SEEK_SET);
+       goodwrite *= writetab(outf, starttab, tablen);
+       goodwrite *= writetab(outf, lengthtab, tablen);
+       if (goodwrite) {
+               Py_INCREF(Py_None);
+               retval = Py_None;
+       } else
+               PyErr_SetString(ImgfileError, "not enough space for image");
+
+  finally:
+       fclose(outf);
        free(starttab);
        free(lengthtab);
        free(rlebuf);
        free(lumbuf);
-       fclose(outf);
-       if(goodwrite) {
-               Py_INCREF(Py_None);
-               return Py_None;
-       } else {
-               PyErr_SetString(ImgfileError,"not enough space for image!!");
-               return NULL;
-       }
+       return retval;
 }
 
 /* static utility functions for longstoimage */
 
-static void lumrow(rgbptr,lumptr,n) 
+static void
+lumrow(rgbptr, lumptr, n)
        unsigned char *rgbptr, *lumptr;
-int n;
+       int n;
 {
        lumptr += CHANOFFSET(0);
-       while(n--) {
-               *lumptr = ILUM(rgbptr[OFFSET_R],rgbptr[OFFSET_G],
+       while (n--) {
+               *lumptr = ILUM(rgbptr[OFFSET_R],
+                              rgbptr[OFFSET_G],
                               rgbptr[OFFSET_B]);
                lumptr += 4;
                rgbptr += 4;
        }
 }
 
-static int compressrow(lbuf,rlebuf,z,cnt)
+static int
+compressrow(lbuf, rlebuf, z, cnt)
        unsigned char *lbuf, *rlebuf;
-int z, cnt;
+       int z, cnt;
 {
        unsigned char *iptr, *ibufend, *sptr, *optr;
        short todo, cc;                                                 
@@ -686,35 +700,37 @@ int z, cnt;
 
        lbuf += z;
        iptr = lbuf;
-       ibufend = iptr+cnt*4;
+       ibufend = iptr + cnt * 4;
        optr = rlebuf;
 
-       while(iptr<ibufend) {
+       while(iptr < ibufend) {
                sptr = iptr;
                iptr += 8;
-               while((iptr<ibufend)&& ((iptr[-8]!=iptr[-4])
-                                       ||(iptr[-4]!=iptr[0])))
-                       iptr+=4;
+               while ((iptr<ibufend) &&
+                      ((iptr[-8]!=iptr[-4]) ||(iptr[-4]!=iptr[0])))
+               {
+                       iptr += 4;
+               }
                iptr -= 8;
-               count = (iptr-sptr)/4;
-               while(count) {
-                       todo = count>126 ? 126:count;
+               count = (iptr - sptr) / 4;
+               while (count) {
+                       todo = count > 126 ? 126 : count;
                        count -= todo;
-                       *optr++ = 0x80|todo;
-                       while(todo>8) {
-                               optr[0] = sptr[0*4];
-                               optr[1] = sptr[1*4];
-                               optr[2] = sptr[2*4];
-                               optr[3] = sptr[3*4];
-                               optr[4] = sptr[4*4];
-                               optr[5] = sptr[5*4];
-                               optr[6] = sptr[6*4];
-                               optr[7] = sptr[7*4];
+                       *optr++ = 0x80 | todo;
+                       while (todo > 8) {
+                               optr[0] = sptr[0 * 4];
+                               optr[1] = sptr[1 * 4];
+                               optr[2] = sptr[2 * 4];
+                               optr[3] = sptr[3 * 4];
+                               optr[4] = sptr[4 * 4];
+                               optr[5] = sptr[5 * 4];
+                               optr[6] = sptr[6 * 4];
+                               optr[7] = sptr[7 * 4];
                                optr += 8;
-                               sptr += 8*4;
+                               sptr += 8 * 4;
                                todo -= 8;
                        }
-                       while(todo--) {
+                       while (todo--) {
                                *optr++ = *sptr;
                                sptr += 4;
                        }
@@ -722,11 +738,11 @@ int z, cnt;
                sptr = iptr;
                cc = *iptr;
                iptr += 4;
-               while( (iptr<ibufend) && (*iptr == cc) )
+               while ((iptr < ibufend) && (*iptr == cc))
                        iptr += 4;
-               count = (iptr-sptr)/4;
-               while(count) {
-                       todo = count>126 ? 126:count;
+               count = (iptr - sptr) / 4;
+               while (count) {
+                       todo = count > 126 ? 126 : count;
                        count -= todo;
                        *optr++ = todo;
                        *optr++ = cc;
@@ -739,7 +755,7 @@ int z, cnt;
 static PyObject *
 ttob(self, args)
        PyObject *self;
-PyObject *args;
+       PyObject *args;
 {
        int order, oldorder;
 
@@ -750,14 +766,16 @@ PyObject *args;
        return PyInt_FromLong(oldorder);
 }
 
-static PyMethodDef rgbimg_methods[] = {
-       {"sizeofimage", sizeofimage},
-       {"longimagedata",       longimagedata},
-       {"longstoimage",        longstoimage},
-       {"ttob",                ttob},
-       {NULL, NULL}            /* sentinel */
+static PyMethodDef
+rgbimg_methods[] = {
+       {"sizeofimage",    sizeofimage},
+       {"longimagedata",  longimagedata},
+       {"longstoimage",   longstoimage},
+       {"ttob",           ttob},
+       {NULL,             NULL}             /* sentinel */
 };
 
+
 void
 initrgbimg()
 {
@@ -765,20 +783,8 @@ initrgbimg()
        m = Py_InitModule("rgbimg", rgbimg_methods);
        d = PyModule_GetDict(m);
        ImgfileError = PyString_FromString("rgbimg.error");
-       if (ImgfileError == NULL
-           || PyDict_SetItemString(d, "error", ImgfileError))
-               Py_FatalError("can't define rgbimg.error");
+       if (ImgfileError)
+               PyDict_SetItemString(d, "error", ImgfileError);
+       if (PyErr_Occurred())
+               Py_FatalError("can't initialize rgbimg module");
 }
-
-
-
-
-
-
-
-
-
-
-
-
-