Refactor ext/gd (all tests passes)

diff --git a/ext/gd/gd.c b/ext/gd/gd.c
index 33416a23d9d3109e81db9e6ddacfa48469c690a2..f4245b93fdfaf096947e688e79897d04f70772a7 100644 (file)
--- a/ext/gd/gd.c
+++ b/ext/gd/gd.c
@@ -64,8 +64,8 @@ static int le_gd, le_gd_font;
 #if HAVE_LIBT1
 #include <t1lib.h>
 static int le_ps_font, le_ps_enc;
-static void php_free_ps_font(zend_rsrc_list_entry *rsrc TSRMLS_DC);
-static void php_free_ps_enc(zend_rsrc_list_entry *rsrc TSRMLS_DC);
+static void php_free_ps_font(zend_resource *rsrc TSRMLS_DC);
+static void php_free_ps_enc(zend_resource *rsrc TSRMLS_DC);
 #endif
 
 #include <gd.h>
@@ -135,7 +135,7 @@ static void php_image_filter_smooth(INTERNAL_FUNCTION_PARAMETERS);
 static void php_image_filter_pixelate(INTERNAL_FUNCTION_PARAMETERS);
 
 /* End Section filters declarations */
-static gdImagePtr _php_image_create_from_string (zval **Data, char *tn, gdImagePtr (*ioctx_func_p)() TSRMLS_DC);
+static gdImagePtr _php_image_create_from_string (zval *Data, char *tn, gdImagePtr (*ioctx_func_p)() TSRMLS_DC);
 static void _php_image_create_from(INTERNAL_FUNCTION_PARAMETERS, int image_type, char *tn, gdImagePtr (*func_p)(), gdImagePtr (*ioctx_func_p)());
 static void _php_image_output(INTERNAL_FUNCTION_PARAMETERS, int image_type, char *tn, void (*func_p)());
 static int _php_image_type(char data[8]);
@@ -1072,7 +1072,7 @@ PHP_INI_END()
 
 /* {{{ php_free_gd_image
  */
-static void php_free_gd_image(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void php_free_gd_image(zend_resource *rsrc TSRMLS_DC)
 {
        gdImageDestroy((gdImagePtr) rsrc->ptr);
 }
@@ -1080,7 +1080,7 @@ static void php_free_gd_image(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 
 /* {{{ php_free_gd_font
  */
-static void php_free_gd_font(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void php_free_gd_font(zend_resource *rsrc TSRMLS_DC)
 {
        gdFontPtr fp = (gdFontPtr) rsrc->ptr;
 
@@ -1419,9 +1419,10 @@ PHP_GD_API int phpi_get_le_gd(void)
    Load a new font */
 PHP_FUNCTION(imageloadfont)
 {
+       zval *ind;
        char *file;
        int file_name, hdr_size = sizeof(gdFont) - sizeof(char *);
-       int ind, body_size, n = 0, b, i, body_size_check;
+       int body_size, n = 0, b, i, body_size_check;
        gdFontPtr font;
        php_stream *stream;
 
@@ -1508,13 +1509,13 @@ PHP_FUNCTION(imageloadfont)
        }
        php_stream_close(stream);
 
+       ind = zend_list_insert(font, le_gd_font TSRMLS_CC);
+
        /* Adding 5 to the font index so we will never have font indices
         * that overlap with the old fonts (with indices 1-5).  The first
         * list index given out is always 1.
         */
-       ind = 5 + zend_list_insert(font, le_gd_font TSRMLS_CC);
-
-       RETURN_LONG(ind);
+       RETURN_LONG(Z_RES_HANDLE_P(ind) + 5);
 }
 /* }}} */
 
@@ -1522,40 +1523,30 @@ PHP_FUNCTION(imageloadfont)
    Set the line drawing styles for use with imageline and IMG_COLOR_STYLED. */
 PHP_FUNCTION(imagesetstyle)
 {
-       zval *IM, *styles;
+       zval *IM, *styles, *item;
        gdImagePtr im;
-       int * stylearr;
-       int index;
-       HashPosition pos;
+       int *stylearr;
+       int index = 0;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &IM, &styles) == FAILURE)  {
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        /* copy the style values in the stylearr */
        stylearr = safe_emalloc(sizeof(int), zend_hash_num_elements(HASH_OF(styles)), 0);
 
-       zend_hash_internal_pointer_reset_ex(HASH_OF(styles), &pos);
-
-       for (index = 0;; zend_hash_move_forward_ex(HASH_OF(styles), &pos))      {
-               zval ** item;
-
-               if (zend_hash_get_current_data_ex(HASH_OF(styles), (void **) &item, &pos) == FAILURE) {
-                       break;
-               }
-
-               if (Z_TYPE_PP(item) != IS_LONG) {
+       ZEND_HASH_FOREACH_VAL(HASH_OF(styles), item) {
+               if (Z_TYPE_P(item) != IS_LONG) {
                        zval lval;
-                       lval = **item;
-                       zval_copy_ctor(&lval);
+                       ZVAL_COPY(&lval, item);
                        convert_to_long(&lval);
                        stylearr[index++] = Z_LVAL(lval);
                } else {
-                       stylearr[index++] = Z_LVAL_PP(item);
+                       stylearr[index++] = Z_LVAL_P(item);
                }
-       }
+       } ZEND_HASH_FOREACH_END();
 
        gdImageSetStyle(im, stylearr, index);
 
@@ -1602,7 +1593,7 @@ PHP_FUNCTION(imageistruecolor)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_BOOL(im->trueColor);
 }
@@ -1621,7 +1612,7 @@ PHP_FUNCTION(imagetruecolortopalette)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        if (ncolors <= 0) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of colors has to be greater than zero");
@@ -1633,8 +1624,6 @@ PHP_FUNCTION(imagetruecolortopalette)
 }
 /* }}} */
 
-
-
 /* {{{ proto void imagetruecolortopalette(resource im, bool ditherFlag, int colorsWanted)
    Convert a true colour image to a palette based image with a number of colours, optionally using dithering. */
 PHP_FUNCTION(imagepalettetotruecolor)
@@ -1646,7 +1635,7 @@ PHP_FUNCTION(imagepalettetotruecolor)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        if (gdImagePaletteToTrueColor(im) == 0) {
                RETURN_FALSE;
@@ -1668,8 +1657,8 @@ PHP_FUNCTION(imagecolormatch)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im1, gdImagePtr, &IM1, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(im2, gdImagePtr, &IM2, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im1, gdImagePtr, IM1, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im2, gdImagePtr, IM2, -1, "Image", le_gd);
 
        result = gdImageColorMatch(im1, im2);
        switch (result) {
@@ -1707,7 +1696,7 @@ PHP_FUNCTION(imagesetthickness)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        gdImageSetThickness(im, thick);
 
@@ -1727,7 +1716,7 @@ PHP_FUNCTION(imagefilledellipse)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        gdImageFilledEllipse(im, cx, cy, w, h, color);
 
@@ -1748,7 +1737,7 @@ PHP_FUNCTION(imagefilledarc)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        e = E;
        if (e < 0) {
@@ -1778,7 +1767,7 @@ PHP_FUNCTION(imagealphablending)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageAlphaBlending(im, blend);
 
        RETURN_TRUE;
@@ -1797,7 +1786,7 @@ PHP_FUNCTION(imagesavealpha)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageSaveAlpha(im, save);
 
        RETURN_TRUE;
@@ -1816,7 +1805,7 @@ PHP_FUNCTION(imagelayereffect)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageAlphaBlending(im, effect);
 
        RETURN_TRUE;
@@ -1836,7 +1825,7 @@ PHP_FUNCTION(imagecolorallocatealpha)
                RETURN_FALSE;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        ct = gdImageColorAllocateAlpha(im, red, green, blue, alpha);
        if (ct < 0) {
                RETURN_FALSE;
@@ -1857,7 +1846,7 @@ PHP_FUNCTION(imagecolorresolvealpha)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageColorResolveAlpha(im, red, green, blue, alpha));
 }
@@ -1875,7 +1864,7 @@ PHP_FUNCTION(imagecolorclosestalpha)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageColorClosestAlpha(im, red, green, blue, alpha));
 }
@@ -1893,7 +1882,7 @@ PHP_FUNCTION(imagecolorexactalpha)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageColorExactAlpha(im, red, green, blue, alpha));
 }
@@ -1912,8 +1901,8 @@ PHP_FUNCTION(imagecopyresampled)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, DIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
 
        srcX = SX;
        srcY = SY;
@@ -2094,7 +2083,7 @@ PHP_FUNCTION(imagerotate)
                RETURN_FALSE;
        }
 
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
 
        im_dst = gdImageRotateInterpolated(im_src, (const float)degrees, color);
 
@@ -2117,8 +2106,8 @@ PHP_FUNCTION(imagesettile)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(tile, gdImagePtr, &TILE, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(tile, gdImagePtr, TILE, -1, "Image", le_gd);
 
        gdImageSetTile(im, tile);
 
@@ -2137,8 +2126,8 @@ PHP_FUNCTION(imagesetbrush)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(tile, gdImagePtr, &TILE, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(tile, gdImagePtr, TILE, -1, "Image", le_gd);
 
        gdImageSetBrush(im, tile);
 
@@ -2257,12 +2246,12 @@ static int _php_image_type (char data[8])
 
 /* {{{ _php_image_create_from_string
  */
-gdImagePtr _php_image_create_from_string(zval **data, char *tn, gdImagePtr (*ioctx_func_p)() TSRMLS_DC)
+gdImagePtr _php_image_create_from_string(zval *data, char *tn, gdImagePtr (*ioctx_func_p)() TSRMLS_DC)
 {
        gdImagePtr im;
        gdIOCtx *io_ctx;
 
-       io_ctx = gdNewDynamicCtxEx(Z_STRLEN_PP(data), Z_STRVAL_PP(data), 0);
+       io_ctx = gdNewDynamicCtxEx(Z_STRLEN_P(data), Z_STRVAL_P(data), 0);
 
        if (!io_ctx) {
                return NULL;
@@ -2285,22 +2274,22 @@ gdImagePtr _php_image_create_from_string(zval **data, char *tn, gdImagePtr (*ioc
    Create a new image from the image stream in the string */
 PHP_FUNCTION(imagecreatefromstring)
 {
-       zval **data;
+       zval *data;
        gdImagePtr im;
        int imtype;
        char sig[8];
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &data) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) {
                return;
        }
 
        convert_to_string_ex(data);
-       if (Z_STRLEN_PP(data) < 8) {
+       if (Z_STRLEN_P(data) < 8) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string or invalid image");
                RETURN_FALSE;
        }
 
-       memcpy(sig, Z_STRVAL_PP(data), 8);
+       memcpy(sig, Z_STRVAL_P(data), 8);
 
        imtype = _php_image_type(sig);
 
@@ -2359,7 +2348,9 @@ static void _php_image_create_from(INTERNAL_FUNCTION_PARAMETERS, int image_type,
        gdImagePtr im = NULL;
        php_stream *stream;
        FILE * fp = NULL;
+#ifdef HAVE_GD_JPG
        long ignore_warning;
+#endif
 
        if (image_type == PHP_GDIMG_TYPE_GD2PART) {
                if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sllll", &file, &file_len, &srcx, &srcy, &width, &height) == FAILURE) {
@@ -2389,20 +2380,22 @@ static void _php_image_create_from(INTERNAL_FUNCTION_PARAMETERS, int image_type,
        } else if (ioctx_func_p) {
                /* we can create an io context */
                gdIOCtx* io_ctx;
-               size_t buff_size;
-               char *buff;
+               zend_string *buff;
+               char *pstr;
 
-               /* needs to be malloc (persistent) - GD will free() it later */
-               buff_size = php_stream_copy_to_mem(stream, &buff, PHP_STREAM_COPY_ALL, 1);
+               buff = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0);
 
-               if (!buff_size) {
+               if (!buff) {
                        php_error_docref(NULL TSRMLS_CC, E_WARNING,"Cannot read image data");
                        goto out_err;
                }
 
-               io_ctx = gdNewDynamicCtxEx(buff_size, buff, 0);
+               /* needs to be malloc (persistent) - GD will free() it later */
+               pstr = pestrndup(buff->val, buff->len, 1);
+               io_ctx = gdNewDynamicCtxEx(buff->len, pstr, 0);
                if (!io_ctx) {
-                       pefree(buff, 1);
+                       pefree(pstr, 1);
+                       STR_RELEASE(buff);
                        php_error_docref(NULL TSRMLS_CC, E_WARNING,"Cannot allocate GD IO context");
                        goto out_err;
                }
@@ -2413,7 +2406,8 @@ static void _php_image_create_from(INTERNAL_FUNCTION_PARAMETERS, int image_type,
                        im = (*ioctx_func_p)(io_ctx);
                }
                io_ctx->gd_free(io_ctx);
-               pefree(buff, 1);
+               pefree(pstr, 1);
+               STR_RELEASE(buff);
        }
        else if (php_stream_can_cast(stream, PHP_STREAM_AS_STDIO)) {
                /* try and force the stream to be FILE* */
@@ -2572,7 +2566,7 @@ static void _php_image_output(INTERNAL_FUNCTION_PARAMETERS, int image_type, char
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &imgind, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, imgind, -1, "Image", le_gd);
 
        if (argc > 1) {
                fn = file;
@@ -2786,9 +2780,9 @@ PHP_FUNCTION(imagedestroy)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
-       zend_list_delete(Z_LVAL_P(IM));
+       zend_list_close(Z_RES_P(IM));
 
        RETURN_TRUE;
 }
@@ -2808,7 +2802,7 @@ PHP_FUNCTION(imagecolorallocate)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        ct = gdImageColorAllocate(im, red, green, blue);
        if (ct < 0) {
@@ -2829,8 +2823,8 @@ PHP_FUNCTION(imagepalettecopy)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(dst, gdImagePtr, &dstim, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(src, gdImagePtr, &srcim, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(dst, gdImagePtr, dstim, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(src, gdImagePtr, srcim, -1, "Image", le_gd);
 
        gdImagePaletteCopy(dst, src);
 }
@@ -2848,7 +2842,7 @@ PHP_FUNCTION(imagecolorat)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        if (gdImageTrueColor(im)) {
                if (im->tpixels && gdImageBoundsSafe(im, x, y)) {
@@ -2880,7 +2874,7 @@ PHP_FUNCTION(imagecolorclosest)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageColorClosest(im, red, green, blue));
 }
@@ -2898,7 +2892,7 @@ PHP_FUNCTION(imagecolorclosesthwb)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageColorClosestHWB(im, red, green, blue));
 }
@@ -2917,7 +2911,7 @@ PHP_FUNCTION(imagecolordeallocate)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        /* We can return right away for a truecolor image as deallocating colours is meaningless here */
        if (gdImageTrueColor(im)) {
@@ -2948,7 +2942,7 @@ PHP_FUNCTION(imagecolorresolve)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageColorResolve(im, red, green, blue));
 }
@@ -2966,7 +2960,7 @@ PHP_FUNCTION(imagecolorexact)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageColorExact(im, red, green, blue));
 }
@@ -2985,7 +2979,7 @@ PHP_FUNCTION(imagecolorset)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        col = color;
 
@@ -3013,7 +3007,7 @@ PHP_FUNCTION(imagecolorsforindex)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        col = index;
 
@@ -3044,7 +3038,7 @@ PHP_FUNCTION(imagegammacorrect)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        if (gdImageTrueColor(im))       {
                int x, y, c;
@@ -3086,7 +3080,7 @@ PHP_FUNCTION(imagesetpixel)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageSetPixel(im, x, y, col);
        RETURN_TRUE;
 }
@@ -3104,7 +3098,7 @@ PHP_FUNCTION(imageline)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
 #ifdef HAVE_GD_BUNDLED
        if (im->antialias) {
@@ -3130,7 +3124,7 @@ PHP_FUNCTION(imagedashedline)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageDashedLine(im, x1, y1, x2, y2, col);
        RETURN_TRUE;
 }
@@ -3148,7 +3142,7 @@ PHP_FUNCTION(imagerectangle)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageRectangle(im, x1, y1, x2, y2, col);
        RETURN_TRUE;
 }
@@ -3166,7 +3160,7 @@ PHP_FUNCTION(imagefilledrectangle)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageFilledRectangle(im, x1, y1, x2, y2, col);
        RETURN_TRUE;
 }
@@ -3185,7 +3179,7 @@ PHP_FUNCTION(imagearc)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        e = E;
        if (e < 0) {
@@ -3214,7 +3208,7 @@ PHP_FUNCTION(imageellipse)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        gdImageEllipse(im, cx, cy, w, h, color);
        RETURN_TRUE;
@@ -3233,7 +3227,7 @@ PHP_FUNCTION(imagefilltoborder)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageFillToBorder(im, x, y, border, col);
        RETURN_TRUE;
 }
@@ -3251,7 +3245,7 @@ PHP_FUNCTION(imagefill)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageFill(im, x, y, col);
        RETURN_TRUE;
 }
@@ -3268,7 +3262,7 @@ PHP_FUNCTION(imagecolorstotal)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageColorsTotal(im));
 }
@@ -3287,7 +3281,7 @@ PHP_FUNCTION(imagecolortransparent)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        if (argc > 1) {
                gdImageColorTransparent(im, COL);
@@ -3310,7 +3304,7 @@ PHP_FUNCTION(imageinterlace)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        if (argc > 1) {
                gdImageInterlace(im, INT);
@@ -3328,7 +3322,7 @@ static void php_imagepolygon(INTERNAL_FUNCTION_PARAMETERS, int filled)
 {
        zval *IM, *POINTS;
        long NPOINTS, COL;
-       zval **var = NULL;
+       zval *var = NULL;
        gdImagePtr im;
        gdPointPtr points;
        int npoints, col, nelem, i;
@@ -3337,7 +3331,7 @@ static void php_imagepolygon(INTERNAL_FUNCTION_PARAMETERS, int filled)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        npoints = NPOINTS;
        col = COL;
@@ -3359,26 +3353,24 @@ static void php_imagepolygon(INTERNAL_FUNCTION_PARAMETERS, int filled)
        points = (gdPointPtr) safe_emalloc(npoints, sizeof(gdPoint), 0);
 
        for (i = 0; i < npoints; i++) {
-               if (zend_hash_index_find(Z_ARRVAL_P(POINTS), (i * 2), (void **) &var) == SUCCESS) {
-                       if (Z_TYPE_PP(var) != IS_LONG) {
+               if ((var = zend_hash_index_find(Z_ARRVAL_P(POINTS), (i * 2))) != NULL) {
+                       if (Z_TYPE_P(var) != IS_LONG) {
                                zval lval;
-                               lval = **var;
-                               zval_copy_ctor(&lval);
+                               ZVAL_COPY(&lval, var);
                                convert_to_long(&lval);
                                points[i].x = Z_LVAL(lval);
                        } else {
-                               points[i].x = Z_LVAL_PP(var);
+                               points[i].x = Z_LVAL_P(var);
                        }
                }
-               if (zend_hash_index_find(Z_ARRVAL_P(POINTS), (i * 2) + 1, (void **) &var) == SUCCESS) {
-                       if (Z_TYPE_PP(var) != IS_LONG) {
+               if ((var = zend_hash_index_find(Z_ARRVAL_P(POINTS), (i * 2) + 1)) != NULL) {
+                       if (Z_TYPE_P(var) != IS_LONG) {
                                zval lval;
-                               lval = **var;
-                               zval_copy_ctor(&lval);
+                               ZVAL_COPY(&lval, var);
                                convert_to_long(&lval);
                                points[i].y = Z_LVAL(lval);
                        } else {
-                               points[i].y = Z_LVAL_PP(var);
+                               points[i].y = Z_LVAL_P(var);
                        }
                }
        }
@@ -3415,34 +3407,36 @@ PHP_FUNCTION(imagefilledpolygon)
 static gdFontPtr php_find_gd_font(int size TSRMLS_DC)
 {
        gdFontPtr font;
-       int ind_type;
 
        switch (size) {
                case 1:
-                        font = gdFontTiny;
-                        break;
+                       font = gdFontTiny;
+                       break;
                case 2:
-                        font = gdFontSmall;
-                        break;
+                       font = gdFontSmall;
+                       break;
                case 3:
-                        font = gdFontMediumBold;
-                        break;
+                       font = gdFontMediumBold;
+                       break;
                case 4:
-                        font = gdFontLarge;
-                        break;
+                       font = gdFontLarge;
+                       break;
                case 5:
-                        font = gdFontGiant;
-                        break;
-               default:
-                       font = zend_list_find(size - 5, &ind_type);
-                        if (!font || ind_type != le_gd_font) {
-                                 if (size < 1) {
-                                          font = gdFontTiny;
-                                 } else {
-                                          font = gdFontGiant;
-                                 }
+                       font = gdFontGiant;
+                       break;
+               default: {
+                        zval *zv = zend_hash_index_find(&EG(regular_list), size - 5);
+                        if (!zv || (Z_RES_P(zv))->type != le_gd_font) {
+                                if (size < 1) {
+                                        font = gdFontTiny;
+                                } else {
+                                        font = gdFontGiant;
+                                }
+                        } else {
+                                font = (gdFontPtr)Z_RES_P(zv)->ptr;
                         }
-                        break;
+                }
+                break;
        }
 
        return font;
@@ -3530,7 +3524,7 @@ static void php_imagechar(INTERNAL_FUNCTION_PARAMETERS, int mode)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        col = COL;
 
@@ -3621,8 +3615,8 @@ PHP_FUNCTION(imagecopy)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, DIM, -1, "Image", le_gd);
 
        srcX = SX;
        srcY = SY;
@@ -3649,8 +3643,8 @@ PHP_FUNCTION(imagecopymerge)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, DIM, -1, "Image", le_gd);
 
        srcX = SX;
        srcY = SY;
@@ -3678,8 +3672,8 @@ PHP_FUNCTION(imagecopymergegray)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, DIM, -1, "Image", le_gd);
 
        srcX = SX;
        srcY = SY;
@@ -3707,8 +3701,8 @@ PHP_FUNCTION(imagecopyresized)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, DIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
 
        srcX = SX;
        srcY = SY;
@@ -3740,7 +3734,7 @@ PHP_FUNCTION(imagesx)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageSX(im));
 }
@@ -3757,7 +3751,7 @@ PHP_FUNCTION(imagesy)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        RETURN_LONG(gdImageSY(im));
 }
@@ -3830,37 +3824,28 @@ static void php_imagettftext_common(INTERNAL_FUNCTION_PARAMETERS, int mode, int
                } else if (zend_parse_parameters(argc TSRMLS_CC, "rddlllss|a", &IM, &ptsize, &angle, &x, &y, &col, &fontname, &fontname_len, &str, &str_len, &EXT) == FAILURE) {
                        RETURN_FALSE;
                }
-               ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+               ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        }
 
        /* convert angle to radians */
        angle = angle * (M_PI/180);
 
        if (extended && EXT) {  /* parse extended info */
-               HashPosition pos;
+               zval *item;
+               zend_string *key;
+               ulong num_key;
 
                /* walk the assoc array */
-               zend_hash_internal_pointer_reset_ex(HASH_OF(EXT), &pos);
-               do {
-                       zval ** item;
-                       char * key;
-                       ulong num_key;
-
-                       if (zend_hash_get_current_key_ex(HASH_OF(EXT), &key, NULL, &num_key, 0, &pos) != HASH_KEY_IS_STRING) {
+               ZEND_HASH_FOREACH_KEY_VAL(HASH_OF(EXT), num_key, key, item) {
+                       if (key == NULL) {
                                continue;
                        }
-
-                       if (zend_hash_get_current_data_ex(HASH_OF(EXT), (void **) &item, &pos) == FAILURE) {
-                               continue;
-                       }
-               
-                       if (strcmp("linespacing", key) == 0) {
+                       if (strcmp("linespacing", key->val) == 0) {
                                convert_to_double_ex(item);
                                strex.flags |= gdFTEX_LINESPACE;
-                               strex.linespacing = Z_DVAL_PP(item);
+                               strex.linespacing = Z_DVAL_P(item);
                        }
-
-               } while (zend_hash_move_forward_ex(HASH_OF(EXT), &pos) == SUCCESS);
+               } ZEND_HASH_FOREACH_END();
        }
 
 #ifdef VIRTUAL_DIR
@@ -3903,9 +3888,9 @@ static void php_imagettftext_common(INTERNAL_FUNCTION_PARAMETERS, int mode, int
 
 /* {{{ php_free_ps_font
  */
-static void php_free_ps_font(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void php_free_ps_font(zend_resource *rsrc TSRMLS_DC)
 {
-       int *font = (int *) rsrc->ptr;
+       int *font = (int *)rsrc->ptr;
 
        T1_DeleteFont(*font);
        efree(font);
@@ -3914,9 +3899,9 @@ static void php_free_ps_font(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 
 /* {{{ php_free_ps_enc
  */
-static void php_free_ps_enc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void php_free_ps_enc(zend_resource *rsrc TSRMLS_DC)
 {
-       char **enc = (char **) rsrc->ptr;
+       char **enc = (char **)rsrc->ptr;
 
        T1_DeleteEncoding(enc);
 }
@@ -4025,7 +4010,7 @@ PHP_FUNCTION(imagepsfreefont)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
+       ZEND_FETCH_RESOURCE(f_ind, int *, fnt, -1, "Type 1 font", le_ps_font);
        zend_list_delete(Z_LVAL_P(fnt));
        RETURN_TRUE;
 }
@@ -4043,7 +4028,7 @@ PHP_FUNCTION(imagepsencodefont)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
+       ZEND_FETCH_RESOURCE(f_ind, int *, fnt, -1, "Type 1 font", le_ps_font);
 
        if ((enc_vector = T1_LoadEncoding(enc)) == NULL) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't load encoding vector from %s", enc);
@@ -4075,7 +4060,7 @@ PHP_FUNCTION(imagepsextendfont)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
+       ZEND_FETCH_RESOURCE(f_ind, int *, fnt, -1, "Type 1 font", le_ps_font);
 
        T1_DeleteAllSizes(*f_ind);
 
@@ -4104,7 +4089,7 @@ PHP_FUNCTION(imagepsslantfont)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
+       ZEND_FETCH_RESOURCE(f_ind, int *, fnt, -1, "Type 1 font", le_ps_font);
 
        if (T1_SlantFont(*f_ind, slt) != 0) {
                RETURN_FALSE;
@@ -4145,8 +4130,8 @@ PHP_FUNCTION(imagepstext)
                RETURN_FALSE;
        }
 
-       ZEND_FETCH_RESOURCE(bg_img, gdImagePtr, &img, -1, "Image", le_gd);
-       ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
+       ZEND_FETCH_RESOURCE(bg_img, gdImagePtr, img, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(f_ind, int *, fnt, -1, "Type 1 font", le_ps_font);
 
        /* Ensure that the provided colors are valid */
        if (_fg < 0 || (!gdImageTrueColor(bg_img) && _fg > gdImageColorsTotal(bg_img))) {
@@ -4286,7 +4271,7 @@ PHP_FUNCTION(imagepsbbox)
                per_char =  add_width || angle ? 1 : 0;
        }
 
-       ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
+       ZEND_FETCH_RESOURCE(f_ind, int *, fnt, -1, "Type 1 font", le_ps_font);
 
 #define max(a, b) (a > b ? a : b)
 #define min(a, b) (a < b ? a : b)
@@ -4451,7 +4436,9 @@ static void _php_image_convert(INTERNAL_FUNCTION_PARAMETERS, int image_type )
        int int_threshold;
        int x, y;
        float x_ratio, y_ratio;
+#ifdef HAVE_GD_JPG
     long ignore_warning;
+#endif
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pplll", &f_org, &f_org_len, &f_dest, &f_dest_len, &height, &width, &threshold) == FAILURE) {
                return;
@@ -4617,7 +4604,7 @@ static void _php_image_convert(INTERNAL_FUNCTION_PARAMETERS, int image_type )
        if (zend_parse_parameters(1 TSRMLS_CC, "r", &SIM) == FAILURE) { \
                RETURN_FALSE;   \
        }       \
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);      \
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);       \
        if (im_src == NULL) {   \
                RETURN_FALSE;   \
        }
@@ -4654,7 +4641,7 @@ static void php_image_filter_brightness(INTERNAL_FUNCTION_PARAMETERS)
                RETURN_FALSE;
        }
 
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
 
        if (im_src == NULL) {
                RETURN_FALSE;
@@ -4677,7 +4664,7 @@ static void php_image_filter_contrast(INTERNAL_FUNCTION_PARAMETERS)
                RETURN_FALSE;
        }
 
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
 
        if (im_src == NULL) {
                RETURN_FALSE;
@@ -4701,7 +4688,7 @@ static void php_image_filter_colorize(INTERNAL_FUNCTION_PARAMETERS)
                RETURN_FALSE;
        }
 
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
 
        if (im_src == NULL) {
                RETURN_FALSE;
@@ -4780,7 +4767,7 @@ static void php_image_filter_smooth(INTERNAL_FUNCTION_PARAMETERS)
                RETURN_FALSE;
        }
 
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
 
        if (im_src == NULL) {
                RETURN_FALSE;
@@ -4804,7 +4791,7 @@ static void php_image_filter_pixelate(INTERNAL_FUNCTION_PARAMETERS)
                RETURN_FALSE;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        if (im == NULL) {
                RETURN_FALSE;
@@ -4858,7 +4845,7 @@ PHP_FUNCTION(imagefilter)
 PHP_FUNCTION(imageconvolution)
 {
        zval *SIM, *hash_matrix;
-       zval **var = NULL, **var2 = NULL;
+       zval *var = NULL, *var2 = NULL;
        gdImagePtr im_src = NULL;
        double div, offset;
        int nelem, i, j, res;
@@ -4868,7 +4855,7 @@ PHP_FUNCTION(imageconvolution)
                RETURN_FALSE;
        }
 
-       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im_src, gdImagePtr, SIM, -1, "Image", le_gd);
 
        nelem = zend_hash_num_elements(Z_ARRVAL_P(hash_matrix));
        if (nelem != 3) {
@@ -4877,22 +4864,21 @@ PHP_FUNCTION(imageconvolution)
        }
 
        for (i=0; i<3; i++) {
-               if (zend_hash_index_find(Z_ARRVAL_P(hash_matrix), (i), (void **) &var) == SUCCESS && Z_TYPE_PP(var) == IS_ARRAY) {
-                       if (Z_TYPE_PP(var) != IS_ARRAY || zend_hash_num_elements(Z_ARRVAL_PP(var)) != 3 ) {
+               if ((var = zend_hash_index_find(Z_ARRVAL_P(hash_matrix), (i))) != NULL && Z_TYPE_P(var) == IS_ARRAY) {
+                       if (zend_hash_num_elements(Z_ARRVAL_P(var)) != 3 ) {
                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must have 3x3 array");
                                RETURN_FALSE;
                        }
 
                        for (j=0; j<3; j++) {
-                               if (zend_hash_index_find(Z_ARRVAL_PP(var), (j), (void **) &var2) == SUCCESS) {
-                                       if (Z_TYPE_PP(var2) != IS_DOUBLE) {
+                               if ((var2 = zend_hash_index_find(Z_ARRVAL_P(var), (j))) != NULL) {
+                                       if (Z_TYPE_P(var2) != IS_DOUBLE) {
                                                zval dval;
-                                               dval = **var2;
-                                               zval_copy_ctor(&dval);
+                                               ZVAL_COPY(&dval, var2);
                                                convert_to_double(&dval);
                                                matrix[i][j] = (float)Z_DVAL(dval);
                                        } else {
-                                               matrix[i][j] = (float)Z_DVAL_PP(var2);
+                                               matrix[i][j] = (float)Z_DVAL_P(var2);
                                        }
                                } else {
                                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must have a 3x3 matrix");
@@ -4924,7 +4910,7 @@ PHP_FUNCTION(imageflip)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        switch (mode) {
                case GD_FLIP_VERTICAL:
@@ -4961,7 +4947,7 @@ PHP_FUNCTION(imageantialias)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
        gdImageAntialias(im, alias);
        RETURN_TRUE;
 }
@@ -4977,68 +4963,64 @@ PHP_FUNCTION(imagecrop)
        gdImagePtr im_crop;
        gdRect rect;
        zval *z_rect;
-       zval **tmp;
+       zval *tmp;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &IM, &z_rect) == FAILURE)  {
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
-       if (zend_hash_find(HASH_OF(z_rect), "x", sizeof("x"), (void **)&tmp) != FAILURE) {
-               if (Z_TYPE_PP(tmp) != IS_LONG) {
+       if ((tmp = zend_hash_str_find(HASH_OF(z_rect), "x", sizeof("x") -1)) != NULL) {
+               if (Z_TYPE_P(tmp) != IS_LONG) {
                        zval lval;
-                       lval = **tmp;
-                       zval_copy_ctor(&lval);
+                       ZVAL_COPY(&lval, tmp);
                        convert_to_long(&lval);
                        rect.x = Z_LVAL(lval);
                } else {
-                       rect.x = Z_LVAL_PP(tmp);
+                       rect.x = Z_LVAL_P(tmp);
                }
        } else {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing x position");
                RETURN_FALSE;
        }
 
-       if (zend_hash_find(HASH_OF(z_rect), "y", sizeof("x"), (void **)&tmp) != FAILURE) {
-               if (Z_TYPE_PP(tmp) != IS_LONG) {
+       if ((tmp = zend_hash_str_find(HASH_OF(z_rect), "y", sizeof("y") - 1)) != NULL) {
+               if (Z_TYPE_P(tmp) != IS_LONG) {
                        zval lval;
-                       lval = **tmp;
-                       zval_copy_ctor(&lval);
+                       ZVAL_COPY(&lval, tmp);
                        convert_to_long(&lval);
                        rect.y = Z_LVAL(lval);
                } else {
-                       rect.y = Z_LVAL_PP(tmp);
+                       rect.y = Z_LVAL_P(tmp);
                }
        } else {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing y position");
                RETURN_FALSE;
        }
 
-       if (zend_hash_find(HASH_OF(z_rect), "width", sizeof("width"), (void **)&tmp) != FAILURE) {
-               if (Z_TYPE_PP(tmp) != IS_LONG) {
+       if ((tmp = zend_hash_str_find(HASH_OF(z_rect), "width", sizeof("width") - 1)) != NULL) {
+               if (Z_TYPE_P(tmp) != IS_LONG) {
                        zval lval;
-                       lval = **tmp;
-                       zval_copy_ctor(&lval);
+                       ZVAL_COPY(&lval, tmp);
                        convert_to_long(&lval);
                        rect.width = Z_LVAL(lval);
                } else {
-                       rect.width = Z_LVAL_PP(tmp);
+                       rect.width = Z_LVAL_P(tmp);
                }
        } else {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing width");
                RETURN_FALSE;
        }
 
-       if (zend_hash_find(HASH_OF(z_rect), "height", sizeof("height"), (void **)&tmp) != FAILURE) {
-               if (Z_TYPE_PP(tmp) != IS_LONG) {
+       if ((tmp = zend_hash_str_find(HASH_OF(z_rect), "height", sizeof("height") - 1)) != NULL) {
+               if (Z_TYPE_P(tmp) != IS_LONG) {
                        zval lval;
-                       lval = **tmp;
-                       zval_copy_ctor(&lval);
+                       ZVAL_COPY(&lval, tmp);
                        convert_to_long(&lval);
                        rect.height = Z_LVAL(lval);
                } else {
-                       rect.height = Z_LVAL_PP(tmp);
+                       rect.height = Z_LVAL_P(tmp);
                }
        } else {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing height");
@@ -5070,7 +5052,7 @@ PHP_FUNCTION(imagecropauto)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        switch (mode) {
                case -1:
@@ -5121,7 +5103,7 @@ PHP_FUNCTION(imagescale)
        new_width = tmp_w;
        new_height = tmp_h;
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        if (gdImageSetInterpolationMethod(im, method)) {
                im_scaled = gdImageScale(im, new_width, new_height);
@@ -5146,16 +5128,16 @@ PHP_FUNCTION(imageaffine)
        gdRectPtr pRect = NULL;
        zval *z_rect = NULL;
        zval *z_affine;
-       zval **tmp;
+       zval *tmp;
        double affine[6];
        int i, nelems;
-       zval **zval_affine_elem = NULL;
+       zval *zval_affine_elem = NULL;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra|a", &IM, &z_affine, &z_rect) == FAILURE)  {
                return;
        }
 
-       ZEND_FETCH_RESOURCE(src, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(src, gdImagePtr, IM, -1, "Image", le_gd);
 
        if ((nelems = zend_hash_num_elements(Z_ARRVAL_P(z_affine))) != 6) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Affine array must have six elements");
@@ -5163,19 +5145,18 @@ PHP_FUNCTION(imageaffine)
        }
 
        for (i = 0; i < nelems; i++) {
-               if (zend_hash_index_find(Z_ARRVAL_P(z_affine), i, (void **) &zval_affine_elem) == SUCCESS) {
-                       switch (Z_TYPE_PP(zval_affine_elem)) {
+               if ((zval_affine_elem = zend_hash_index_find(Z_ARRVAL_P(z_affine), i)) != NULL) {
+                       switch (Z_TYPE_P(zval_affine_elem)) {
                                case IS_LONG:
-                                       affine[i]  = Z_LVAL_PP(zval_affine_elem);
+                                       affine[i]  = Z_LVAL_P(zval_affine_elem);
                                        break;
                                case IS_DOUBLE:
-                                       affine[i] = Z_DVAL_PP(zval_affine_elem);
+                                       affine[i] = Z_DVAL_P(zval_affine_elem);
                                        break;
                                case IS_STRING:
                                        {
                                                zval dval;
-                                               dval = **zval_affine_elem;
-                                               zval_copy_ctor(&dval);
+                                               ZVAL_COPY(&dval, zval_affine_elem);
                                                convert_to_double(&dval);
                                                affine[i] = Z_DVAL(dval);
                                        }
@@ -5188,60 +5169,56 @@ PHP_FUNCTION(imageaffine)
        }
 
        if (z_rect != NULL) {
-               if (zend_hash_find(HASH_OF(z_rect), "x", sizeof("x"), (void **)&tmp) != FAILURE) {
-                       if (Z_TYPE_PP(tmp) != IS_LONG) {
+               if ((tmp = zend_hash_str_find(HASH_OF(z_rect), "x", sizeof("x") - 1)) != NULL) {
+                       if (Z_TYPE_P(tmp) != IS_LONG) {
                                zval lval;
-                               lval = **tmp;
-                               zval_copy_ctor(&lval);
+                               ZVAL_COPY(&lval, tmp);
                                convert_to_long(&lval);
                                rect.x = Z_LVAL(lval);
                        } else {
-                               rect.x = Z_LVAL_PP(tmp);
+                               rect.x = Z_LVAL_P(tmp);
                        }
                } else {
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing x position");
                        RETURN_FALSE;
                }
 
-               if (zend_hash_find(HASH_OF(z_rect), "y", sizeof("x"), (void **)&tmp) != FAILURE) {
-                       if (Z_TYPE_PP(tmp) != IS_LONG) {
+               if ((tmp = zend_hash_str_find(HASH_OF(z_rect), "y", sizeof("y") - 1)) != NULL) {
+                       if (Z_TYPE_P(tmp) != IS_LONG) {
                                zval lval;
-                               lval = **tmp;
-                               zval_copy_ctor(&lval);
+                               ZVAL_COPY(&lval, tmp);
                                convert_to_long(&lval);
                                rect.y = Z_LVAL(lval);
                        } else {
-                               rect.y = Z_LVAL_PP(tmp);
+                               rect.y = Z_LVAL_P(tmp);
                        }
                } else {
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing y position");
                        RETURN_FALSE;
                }
 
-               if (zend_hash_find(HASH_OF(z_rect), "width", sizeof("width"), (void **)&tmp) != FAILURE) {
-                       if (Z_TYPE_PP(tmp) != IS_LONG) {
+               if ((tmp = zend_hash_str_find(HASH_OF(z_rect), "width", sizeof("width") - 1)) != NULL) {
+                       if (Z_TYPE_P(tmp) != IS_LONG) {
                                zval lval;
-                               lval = **tmp;
-                               zval_copy_ctor(&lval);
+                               ZVAL_COPY(&lval, tmp);
                                convert_to_long(&lval);
                                rect.width = Z_LVAL(lval);
                        } else {
-                               rect.width = Z_LVAL_PP(tmp);
+                               rect.width = Z_LVAL_P(tmp);
                        }
                } else {
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing width");
                        RETURN_FALSE;
                }
 
-               if (zend_hash_find(HASH_OF(z_rect), "height", sizeof("height"), (void **)&tmp) != FAILURE) {
-                       if (Z_TYPE_PP(tmp) != IS_LONG) {
+               if ((tmp = zend_hash_str_find(HASH_OF(z_rect), "height", sizeof("height") - 1)) != NULL) {
+                       if (Z_TYPE_P(tmp) != IS_LONG) {
                                zval lval;
-                               lval = **tmp;
-                               zval_copy_ctor(&lval);
+                               ZVAL_COPY(&lval, tmp);
                                convert_to_long(&lval);
                                rect.height = Z_LVAL(lval);
                        } else {
-                               rect.height = Z_LVAL_PP(tmp);
+                               rect.height = Z_LVAL_P(tmp);
                        }
                } else {
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing height");
@@ -5275,7 +5252,7 @@ PHP_FUNCTION(imageaffinematrixget)
        double affine[6];
        long type;
        zval *options;
-       zval **tmp;
+       zval *tmp;
        int res = GD_FALSE, i;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|z", &type, &options) == FAILURE)  {
@@ -5290,30 +5267,28 @@ PHP_FUNCTION(imageaffinematrixget)
                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array expected as options");
                                RETURN_FALSE;
                        }
-                       if (zend_hash_find(HASH_OF(options), "x", sizeof("x"), (void **)&tmp) != FAILURE) {
-                               if (Z_TYPE_PP(tmp) != IS_DOUBLE) {
+                       if ((tmp = zend_hash_str_find(HASH_OF(options), "x", sizeof("x") - 1)) != NULL) {
+                               if (Z_TYPE_P(tmp) != IS_DOUBLE) {
                                        zval dval;
-                                       dval = **tmp;
-                                       zval_copy_ctor(&dval);
+                                       ZVAL_COPY(&dval, tmp);
                                        convert_to_double(&dval);
                                        x = Z_DVAL(dval);
                                } else {
-                                       x = Z_DVAL_PP(tmp);
+                                       x = Z_DVAL_P(tmp);
                                }
                        } else {
                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing x position");
                                RETURN_FALSE;
                        }
 
-                       if (zend_hash_find(HASH_OF(options), "y", sizeof("y"), (void **)&tmp) != FAILURE) {
-                               if (Z_TYPE_PP(tmp) != IS_DOUBLE) {
+                       if ((tmp = zend_hash_str_find(HASH_OF(options), "y", sizeof("y") - 1)) != NULL) {
+                               if (Z_TYPE_P(tmp) != IS_DOUBLE) {
                                        zval dval;
-                                       dval = **tmp;
-                                       zval_copy_ctor(&dval);
+                                       ZVAL_COPY(&dval, tmp);
                                        convert_to_double(&dval);
                                        y = Z_DVAL(dval);
                                } else {
-                                       y = Z_DVAL_PP(tmp);
+                                       y = Z_DVAL_P(tmp);
                                }
                        } else {
                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing y position");
@@ -5333,7 +5308,7 @@ PHP_FUNCTION(imageaffinematrixget)
                case GD_AFFINE_SHEAR_VERTICAL: {
                        double angle;
 
-                       convert_to_double_ex(&options);
+                       convert_to_double_ex(options);
                        angle = Z_DVAL_P(options);
 
                        if (type == GD_AFFINE_SHEAR_HORIZONTAL) {
@@ -5359,8 +5334,7 @@ PHP_FUNCTION(imageaffinematrixget)
                        add_index_double(return_value, i, affine[i]);
                }
        }
-}
-
+} /* }}} */
 
 /* {{{ proto array imageaffineconcat(array m1, array m2)
    Concat two matrices (as in doing many ops in one go) */
@@ -5370,7 +5344,7 @@ PHP_FUNCTION(imageaffinematrixconcat)
        double m2[6];
        double mr[6];
 
-       zval **tmp;
+       zval *tmp;
        zval *z_m1;
        zval *z_m2;
        int i, nelems;
@@ -5385,19 +5359,18 @@ PHP_FUNCTION(imageaffinematrixconcat)
        }
 
        for (i = 0; i < 6; i++) {
-               if (zend_hash_index_find(Z_ARRVAL_P(z_m1), i, (void **) &tmp) == SUCCESS) {
-                       switch (Z_TYPE_PP(tmp)) {
+               if ((tmp = zend_hash_index_find(Z_ARRVAL_P(z_m1), i)) != NULL) {
+                       switch (Z_TYPE_P(tmp)) {
                                case IS_LONG:
-                                       m1[i]  = Z_LVAL_PP(tmp);
+                                       m1[i]  = Z_LVAL_P(tmp);
                                        break;
                                case IS_DOUBLE:
-                                       m1[i] = Z_DVAL_PP(tmp);
+                                       m1[i] = Z_DVAL_P(tmp);
                                        break;
                                case IS_STRING:
                                        {
                                                zval dval;
-                                               dval = **tmp;
-                                               zval_copy_ctor(&dval);
+                                               ZVAL_COPY(&dval, tmp);
                                                convert_to_double(&dval);
                                                m1[i] = Z_DVAL(dval);
                                        }
@@ -5407,19 +5380,18 @@ PHP_FUNCTION(imageaffinematrixconcat)
                                        RETURN_FALSE;
                        }
                }
-               if (zend_hash_index_find(Z_ARRVAL_P(z_m2), i, (void **) &tmp) == SUCCESS) {
-                       switch (Z_TYPE_PP(tmp)) {
+               if ((tmp = zend_hash_index_find(Z_ARRVAL_P(z_m2), i)) != NULL) {
+                       switch (Z_TYPE_P(tmp)) {
                                case IS_LONG:
-                                       m2[i]  = Z_LVAL_PP(tmp);
+                                       m2[i]  = Z_LVAL_P(tmp);
                                        break;
                                case IS_DOUBLE:
-                                       m2[i] = Z_DVAL_PP(tmp);
+                                       m2[i] = Z_DVAL_P(tmp);
                                        break;
                                case IS_STRING:
                                        {
                                                zval dval;
-                                               dval = **tmp;
-                                               zval_copy_ctor(&dval);
+                                               ZVAL_COPY(&dval, tmp);
                                                convert_to_double(&dval);
                                                m2[i] = Z_DVAL(dval);
                                        }
@@ -5439,7 +5411,7 @@ PHP_FUNCTION(imageaffinematrixconcat)
        for (i = 0; i < 6; i++) {
                add_index_double(return_value, i, mr[i]);
        }
-}
+} /* }}} */
 
 /* {{{ proto resource imagesetinterpolation(resource im, [, method]])
    Set the default interpolation method, passing -1 or 0 sets it to the libgd default (bilinear). */
@@ -5453,7 +5425,7 @@ PHP_FUNCTION(imagesetinterpolation)
                return;
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, IM, -1, "Image", le_gd);
 
        if (method == -1) {
                 method = GD_BILINEAR_FIXED;

diff --git a/ext/gd/gd_ctx.c b/ext/gd/gd_ctx.c
index 59eff80443685ffc99516423f47beb1ace4910eb..4f97af846a7bfe1c1d433fb92df63062a00a9cb1 100644 (file)
--- a/ext/gd/gd_ctx.c
+++ b/ext/gd/gd_ctx.c
@@ -22,7 +22,7 @@
 
 #define CTX_PUTC(c,ctx) ctx->putC(ctx, c)
 
-static void _php_image_output_putc(struct gdIOCtx *ctx, int c)
+static void _php_image_output_putc(struct gdIOCtx *ctx, int c) /* {{{ */
 {
        /* without the following downcast, the write will fail
         * (i.e., will write a zero byte) for all
@@ -31,36 +31,36 @@ static void _php_image_output_putc(struct gdIOCtx *ctx, int c)
        unsigned char ch = (unsigned char) c;
        TSRMLS_FETCH();
        php_write(&ch, 1 TSRMLS_CC);
-}
+} /* }}} */
 
-static int _php_image_output_putbuf(struct gdIOCtx *ctx, const void* buf, int l)
+static int _php_image_output_putbuf(struct gdIOCtx *ctx, const void* buf, int l) /* {{{ */
 {
        TSRMLS_FETCH();
        return php_write((void *)buf, l TSRMLS_CC);
-}
+} /* }}} */
 
-static void _php_image_output_ctxfree(struct gdIOCtx *ctx)
+static void _php_image_output_ctxfree(struct gdIOCtx *ctx) /* {{{ */
 {
        if(ctx) {
                efree(ctx);
        }
-}
+} /* }}} */
 
-static void _php_image_stream_putc(struct gdIOCtx *ctx, int c)  {
+static void _php_image_stream_putc(struct gdIOCtx *ctx, int c) /* {{{ */ {
        char ch = (char) c;
        php_stream * stream = (php_stream *)ctx->data;
        TSRMLS_FETCH();
        php_stream_write(stream, &ch, 1);
-}
+} /* }}} */
 
-static int _php_image_stream_putbuf(struct gdIOCtx *ctx, const void* buf, int l)
+static int _php_image_stream_putbuf(struct gdIOCtx *ctx, const void* buf, int l) /* {{{ */
 {
        php_stream * stream = (php_stream *)ctx->data;
        TSRMLS_FETCH();
        return php_stream_write(stream, (void *)buf, l);
-}
+} /* }}} */
 
-static void _php_image_stream_ctxfree(struct gdIOCtx *ctx)
+static void _php_image_stream_ctxfree(struct gdIOCtx *ctx) /* {{{ */
 {
        TSRMLS_FETCH();
 
@@ -71,7 +71,7 @@ static void _php_image_stream_ctxfree(struct gdIOCtx *ctx)
        if(ctx) {
                efree(ctx);
        }
-}
+} /* }}} */
 
 /* {{{ _php_image_output_ctx */
 static void _php_image_output_ctx(INTERNAL_FUNCTION_PARAMETERS, int image_type, char *tn, void (*func_p)())
@@ -108,7 +108,7 @@ static void _php_image_output_ctx(INTERNAL_FUNCTION_PARAMETERS, int image_type,
                }
        }
 
-       ZEND_FETCH_RESOURCE(im, gdImagePtr, &imgind, -1, "Image", phpi_get_le_gd());
+       ZEND_FETCH_RESOURCE(im, gdImagePtr, imgind, -1, "Image", phpi_get_le_gd());
 
        if (argc >= 3) {
                q = quality; /* or colorindex for foreground of BW images (defaults to black) */
@@ -119,7 +119,7 @@ static void _php_image_output_ctx(INTERNAL_FUNCTION_PARAMETERS, int image_type,
 
        if (argc > 1 && to_zval != NULL) {
                if (Z_TYPE_P(to_zval) == IS_RESOURCE) {
-                       php_stream_from_zval_no_verify(stream, &to_zval);
+                       php_stream_from_zval_no_verify(stream, to_zval);
                        if (stream == NULL) {
                                RETURN_FALSE;
                        }