Imported Upstream version 5.2.0upstream/5.2.0

12 files changed, 471 insertions, 443 deletions

diff --git a/ext/gd/libgd/gd.c b/ext/gd/libgd/gd.c
index bb12cefc0..3edec2edf 100644
--- a/ext/gd/libgd/gd.c
+++ b/ext/gd/libgd/gd.c
@@ -1885,6 +1885,10 @@ void gdImageFill(gdImagePtr im, int x, int y, int nc)
 	struct seg *stack;
 	struct seg *sp;
 
+	if (!im->trueColor && nc > (im->colorsTotal -1)) {
+		return;
+	}
+
 	alphablending_bak = im->alphaBlendingFlag;	
 	im->alphaBlendingFlag = 0;
 
diff --git a/ext/gd/libgd/gd_gd2.c b/ext/gd/libgd/gd_gd2.c
index 3f24e4a47..efc6ef47a 100644
--- a/ext/gd/libgd/gd_gd2.c
+++ b/ext/gd/libgd/gd_gd2.c
@@ -544,7 +544,7 @@ gdImagePtr gdImageCreateFromGd2PartCtx (gdIOCtx * in, int srcx, int srcy, int w,
 				chunkNum = cx + cy * ncx;
 
 				chunkLen = chunkMax;
-				if (!_gd2ReadChunk (chunkIdx[chunkNum].offset, compBuf, chunkIdx[chunkNum].size, chunkBuf, &chunkLen, in)) {
+				if (!_gd2ReadChunk (chunkIdx[chunkNum].offset, compBuf, chunkIdx[chunkNum].size, (char *)chunkBuf, &chunkLen, in)) {
 					php_gd_error("Error reading comproessed chunk");
 					goto fail2;
 				}
@@ -558,7 +558,7 @@ gdImagePtr gdImageCreateFromGd2PartCtx (gdIOCtx * in, int srcx, int srcy, int w,
 				for (x = xlo; x < xhi; x++) {
 					if (!gd2_compressed(fmt)) {
 						if (im->trueColor) {
-							if (!gdGetInt(&ch, in)) {
+							if (!gdGetInt((int *)&ch, in)) {
 								ch = 0;
 							}
 						} else {
diff --git a/ext/gd/libgd/gd_gif_in.c b/ext/gd/libgd/gd_gif_in.c
index ffe4168c8..e3d635b31 100644
--- a/ext/gd/libgd/gd_gif_in.c
+++ b/ext/gd/libgd/gd_gif_in.c
@@ -17,9 +17,9 @@ static int verbose;
 
 static int set_verbose(void)
 {
- verbose = !!getenv("GIF_VERBOSE");
- verbose_set = 1;
- return(verbose);
+	verbose = !!getenv("GIF_VERBOSE");
+	verbose_set = 1;
+	return(verbose);
 }
 
 #else
@@ -51,21 +51,21 @@ static int set_verbose(void)
 /* We may eventually want to use this information, but def it out for now */
 #if 0
 static struct {
-       unsigned int    Width;
-       unsigned int    Height;
-       unsigned char   ColorMap[3][MAXCOLORMAPSIZE];
-       unsigned int    BitPixel;
-       unsigned int    ColorResolution;
-       unsigned int    Background;
-       unsigned int    AspectRatio;
+	unsigned int    Width;
+	unsigned int    Height;
+	unsigned char   ColorMap[3][MAXCOLORMAPSIZE];
+	unsigned int    BitPixel;
+	unsigned int    ColorResolution;
+	unsigned int    Background;
+	unsigned int    AspectRatio;
 } GifScreen;
 #endif
 
 static struct {
-       int     transparent;
-       int     delayTime;
-       int     inputFlag;
-       int     disposal;
+	int     transparent;
+	int     delayTime;
+	int     inputFlag;
+	int     disposal;
 } Gif89 = { -1, -1, -1, 0 };
 
 static int ReadColorMap (gdIOCtx *fd, int number, unsigned char (*buffer)[256]);
@@ -78,225 +78,231 @@ static void ReadImage (gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned
 
 int ZeroDataBlock;
 
-gdImagePtr gdImageCreateFromGifSource(gdSourcePtr inSource)
+gdImagePtr gdImageCreateFromGifSource(gdSourcePtr inSource) /* {{{ */
 {
-        gdIOCtx         *in = gdNewSSCtx(inSource, NULL);
-        gdImagePtr      im;
+	gdIOCtx         *in = gdNewSSCtx(inSource, NULL);
+	gdImagePtr      im;
 
-        im = gdImageCreateFromGifCtx(in);
+	im = gdImageCreateFromGifCtx(in);
 
-        in->gd_free(in);
+	in->gd_free(in);
 
-        return im;
+	return im;
 }
+/* }}} */
 
-gdImagePtr
-gdImageCreateFromGif(FILE *fdFile)
+gdImagePtr gdImageCreateFromGif(FILE *fdFile) /* {{{ */
 {
-        gdIOCtx		*fd = gdNewFileCtx(fdFile);
-        gdImagePtr    	im = 0;
+	gdIOCtx		*fd = gdNewFileCtx(fdFile);
+	gdImagePtr    	im = 0;
 
-        im = gdImageCreateFromGifCtx(fd);
+	im = gdImageCreateFromGifCtx(fd);
 
-        fd->gd_free(fd);
+	fd->gd_free(fd);
 
-        return im;
+	return im;
 }
+/* }}} */
 
-gdImagePtr
-gdImageCreateFromGifCtx(gdIOCtxPtr fd)
+gdImagePtr gdImageCreateFromGifCtx(gdIOCtxPtr fd) /* {{{ */
 {
-/* 1.4       int imageNumber; */
-       int BitPixel;
-       int ColorResolution;
-       int Background;
-       int AspectRatio;
-       int Transparent = (-1);
-       unsigned char   buf[16];
-       unsigned char   c;
-       unsigned char   ColorMap[3][MAXCOLORMAPSIZE];
-       unsigned char   localColorMap[3][MAXCOLORMAPSIZE];
-       int             imw, imh;
-       int             useGlobalColormap;
-       int             bitPixel;
-       int	       i;
-       /*1.4//int             imageCount = 0; */
-       char            version[4];
-
-       gdImagePtr im = 0;
-       ZeroDataBlock = FALSE;
-
-       /*1.4//imageNumber = 1; */
-       if (! ReadOK(fd,buf,6)) {
+	/* 1.4       int imageNumber; */
+	int BitPixel;
+	int ColorResolution;
+	int Background;
+	int AspectRatio;
+	int Transparent = (-1);
+	unsigned char   buf[16];
+	unsigned char   c;
+	unsigned char   ColorMap[3][MAXCOLORMAPSIZE];
+	unsigned char   localColorMap[3][MAXCOLORMAPSIZE];
+	int             imw, imh;
+	int             useGlobalColormap;
+	int             bitPixel;
+	int	       i;
+	/*1.4//int             imageCount = 0; */
+	char            version[4];
+
+	gdImagePtr im = 0;
+	ZeroDataBlock = FALSE;
+
+	/*1.4//imageNumber = 1; */
+	if (! ReadOK(fd,buf,6)) {
 		return 0;
 	}
-       if (strncmp((char *)buf,"GIF",3) != 0) {
+	if (strncmp((char *)buf,"GIF",3) != 0) {
 		return 0;
 	}
-       strncpy(version, (char *)buf + 3, 3);
-       version[3] = '\0';
+	strncpy(version, (char *)buf + 3, 3);
+	version[3] = '\0';
 
-       if ((strcmp(version, "87a") != 0) && (strcmp(version, "89a") != 0)) {
+	if ((strcmp(version, "87a") != 0) && (strcmp(version, "89a") != 0)) {
 		return 0;
 	}
-       if (! ReadOK(fd,buf,7)) {
+	if (! ReadOK(fd,buf,7)) {
 		return 0;
 	}
-       BitPixel        = 2<<(buf[4]&0x07);
-       ColorResolution = (int) (((buf[4]&0x70)>>3)+1);
-       Background      = buf[5];
-       AspectRatio     = buf[6];
+	BitPixel        = 2<<(buf[4]&0x07);
+	ColorResolution = (int) (((buf[4]&0x70)>>3)+1);
+	Background      = buf[5];
+	AspectRatio     = buf[6];
 
-		imw = LM_to_uint(buf[0],buf[1]);
-		imh = LM_to_uint(buf[2],buf[3]);
+	imw = LM_to_uint(buf[0],buf[1]);
+	imh = LM_to_uint(buf[2],buf[3]);
 
-       if (BitSet(buf[4], LOCALCOLORMAP)) {    /* Global Colormap */
-               if (ReadColorMap(fd, BitPixel, ColorMap)) {
+	if (BitSet(buf[4], LOCALCOLORMAP)) {    /* Global Colormap */
+		if (ReadColorMap(fd, BitPixel, ColorMap)) {
 			return 0;
 		}
-       }
-       for (;;) {
-               if (! ReadOK(fd,&c,1)) {
-                       return 0;
-               }
-               if (c == ';') {         /* GIF terminator */
+	}
+	for (;;) {
+		if (! ReadOK(fd,&c,1)) {
+			return 0;
+		}
+		if (c == ';') {         /* GIF terminator */
 			goto terminated;
-	       }
+		}
 
-               if (c == '!') {         /* Extension */
-                       if (! ReadOK(fd,&c,1)) {
-                               return 0;
-                       }
-                       DoExtension(fd, c, &Transparent);
-                       continue;
-               }
+		if (c == '!') {         /* Extension */
+			if (! ReadOK(fd,&c,1)) {
+				return 0;
+			}
+			DoExtension(fd, c, &Transparent);
+			continue;
+		}
 
-               if (c != ',') {         /* Not a valid start character */
-                       continue;
-               }
+		if (c != ',') {         /* Not a valid start character */
+			continue;
+		}
 
-               /*1.4//++imageCount; */
+		/*1.4//++imageCount; */
 
-               if (! ReadOK(fd,buf,9)) {
-	               return 0;
-               }
+		if (! ReadOK(fd,buf,9)) {
+			return 0;
+		}
 
-               useGlobalColormap = ! BitSet(buf[8], LOCALCOLORMAP);
+		useGlobalColormap = ! BitSet(buf[8], LOCALCOLORMAP);
 
-               bitPixel = 1<<((buf[8]&0x07)+1);
+		bitPixel = 1<<((buf[8]&0x07)+1);
+
+		if (!useGlobalColormap) {
+			if (ReadColorMap(fd, bitPixel, localColorMap)) {
+				return 0;
+			}
+		}
 
 		if (!(im = gdImageCreate(imw, imh))) {
 			return 0;
 		}
 
-               im->interlace = BitSet(buf[8], INTERLACE);
-               if (! useGlobalColormap) {
-		       if (ReadColorMap(fd, bitPixel, localColorMap)) {
-                                 return 0;
-                       }
-                       ReadImage(im, fd, imw, imh, localColorMap,
-                                 BitSet(buf[8], INTERLACE));
-                                 /*1.4//imageCount != imageNumber); */
-               } else {
-                       ReadImage(im, fd, imw, imh,
-                                 ColorMap,
-                                 BitSet(buf[8], INTERLACE));
-                                 /*1.4//imageCount != imageNumber); */
-               }
-               if (Transparent != (-1)) {
-                       gdImageColorTransparent(im, Transparent);
-               }
-	       goto terminated;
-       }
+		im->interlace = BitSet(buf[8], INTERLACE);
+		if (! useGlobalColormap) {
+			ReadImage(im, fd, imw, imh, localColorMap,
+					BitSet(buf[8], INTERLACE));
+			/*1.4//imageCount != imageNumber); */
+		} else {
+			ReadImage(im, fd, imw, imh,
+					ColorMap,
+					BitSet(buf[8], INTERLACE));
+			/*1.4//imageCount != imageNumber); */
+		}
+
+		if (Transparent != (-1)) {
+			gdImageColorTransparent(im, Transparent);
+		}
+		goto terminated;
+	}
 
 terminated:
-       /* Terminator before any image was declared! */
-       if (!im) {
+	/* Terminator before any image was declared! */
+	if (!im) {
 		return 0;
-       }
+	}
+
 	if (!im->colorsTotal) {
 		gdImageDestroy(im);
 		return 0;
 	}
-       /* Check for open colors at the end, so
-          we can reduce colorsTotal and ultimately
-          BitsPerPixel */
-       for (i=((im->colorsTotal-1)); (i>=0); i--) {
+
+	/* Check for open colors at the end, so
+	   we can reduce colorsTotal and ultimately
+	   BitsPerPixel */
+	for (i=((im->colorsTotal-1)); (i>=0); i--) {
 		if (im->open[i]) {
-                	im->colorsTotal--;
-                } else {
-                	break;
-                }
-       }
-       return im;
+			im->colorsTotal--;
+		} else {
+			break;
+		}
+	}
+	return im;
 }
+/* }}} */
 
-static int
-ReadColorMap(gdIOCtx *fd, int number, unsigned char (*buffer)[256])
+static int ReadColorMap(gdIOCtx *fd, int number, unsigned char (*buffer)[256]) /* {{{ */
 {
-       int             i;
-       unsigned char   rgb[3];
+	int             i;
+	unsigned char   rgb[3];
 
 
-       for (i = 0; i < number; ++i) {
-               if (! ReadOK(fd, rgb, sizeof(rgb))) {
-                       return TRUE;
-               }
-               buffer[CM_RED][i] = rgb[0] ;
-               buffer[CM_GREEN][i] = rgb[1] ;
-               buffer[CM_BLUE][i] = rgb[2] ;
-       }
+	for (i = 0; i < number; ++i) {
+		if (! ReadOK(fd, rgb, sizeof(rgb))) {
+			return TRUE;
+		}
+		buffer[CM_RED][i] = rgb[0] ;
+		buffer[CM_GREEN][i] = rgb[1] ;
+		buffer[CM_BLUE][i] = rgb[2] ;
+	}
 
 
-       return FALSE;
+	return FALSE;
 }
+/* }}} */
 
-static int
-DoExtension(gdIOCtx *fd, int label, int *Transparent)
+static int DoExtension(gdIOCtx *fd, int label, int *Transparent) /* {{{ */
 {
-       static unsigned char     buf[256];
-
-       switch (label) {
-       case 0xf9:              /* Graphic Control Extension */
-               (void) GetDataBlock(fd, (unsigned char*) buf);
-               Gif89.disposal    = (buf[0] >> 2) & 0x7;
-               Gif89.inputFlag   = (buf[0] >> 1) & 0x1;
-               Gif89.delayTime   = LM_to_uint(buf[1],buf[2]);
-               if ((buf[0] & 0x1) != 0)
-                       *Transparent = buf[3];
-
-               while (GetDataBlock(fd, (unsigned char*) buf) > 0)
-                       ;
-               return FALSE;
-       default:
-               break;
-       }
-       while (GetDataBlock(fd, (unsigned char*) buf) > 0)
-               ;
-
-       return FALSE;
+	static unsigned char     buf[256];
+
+	switch (label) {
+		case 0xf9:              /* Graphic Control Extension */
+			(void) GetDataBlock(fd, (unsigned char*) buf);
+			Gif89.disposal    = (buf[0] >> 2) & 0x7;
+			Gif89.inputFlag   = (buf[0] >> 1) & 0x1;
+			Gif89.delayTime   = LM_to_uint(buf[1],buf[2]);
+			if ((buf[0] & 0x1) != 0)
+				*Transparent = buf[3];
+
+			while (GetDataBlock(fd, (unsigned char*) buf) > 0)
+				;
+			return FALSE;
+		default:
+			break;
+	}
+	while (GetDataBlock(fd, (unsigned char*) buf) > 0)
+		;
+
+	return FALSE;
 }
+/* }}} */
 
-static int
-GetDataBlock_(gdIOCtx *fd, unsigned char *buf)
+static int GetDataBlock_(gdIOCtx *fd, unsigned char *buf) /* {{{ */
 {
-       unsigned char   count;
+	unsigned char   count;
 
-       if (! ReadOK(fd,&count,1)) {
-               return -1;
-       }
+	if (! ReadOK(fd,&count,1)) {
+		return -1;
+	}
 
-       ZeroDataBlock = count == 0;
+	ZeroDataBlock = count == 0;
 
-       if ((count != 0) && (! ReadOK(fd, buf, count))) {
-               return -1;
-       }
+	if ((count != 0) && (! ReadOK(fd, buf, count))) {
+		return -1;
+	}
 
-       return count;
+	return count;
 }
+/* }}} */
 
-static int
-GetDataBlock(gdIOCtx *fd, unsigned char *buf)
+static int GetDataBlock(gdIOCtx *fd, unsigned char *buf) /* {{{ */
 {
 	int rv;
 	int i;
@@ -317,277 +323,276 @@ GetDataBlock(gdIOCtx *fd, unsigned char *buf)
 	}
 	return(rv);
 }
+/* }}} */
 
-static int
-GetCode_(gdIOCtx *fd, int code_size, int flag)
+static int GetCode_(gdIOCtx *fd, int code_size, int flag) /* {{{ */
 {
-       static unsigned char    buf[280];
-       static int              curbit, lastbit, done, last_byte;
-       int                     i, j, ret;
-       unsigned char           count;
-
-       if (flag) {
-               curbit = 0;
-               lastbit = 0;
-               done = FALSE;
-               return 0;
-       }
-
-       if ( (curbit+code_size) >= lastbit) {
-               if (done) {
-                       if (curbit >= lastbit) {
-                                /* Oh well */
-                       }
-                       return -1;
-               }
-               buf[0] = buf[last_byte-2];
-               buf[1] = buf[last_byte-1];
-
-               if ((count = GetDataBlock(fd, &buf[2])) <= 0)
-                       done = TRUE;
-
-               last_byte = 2 + count;
-               curbit = (curbit - lastbit) + 16;
-               lastbit = (2+count)*8 ;
-       }
-
-       ret = 0;
-       for (i = curbit, j = 0; j < code_size; ++i, ++j)
-               ret |= ((buf[ i / 8 ] & (1 << (i % 8))) != 0) << j;
-
-       curbit += code_size;
-       return ret;
+	static unsigned char    buf[280];
+	static int              curbit, lastbit, done, last_byte;
+	int                     i, j, ret;
+	unsigned char           count;
+
+	if (flag) {
+		curbit = 0;
+		lastbit = 0;
+		done = FALSE;
+		return 0;
+	}
+
+	if ( (curbit+code_size) >= lastbit) {
+		if (done) {
+			if (curbit >= lastbit) {
+				/* Oh well */
+			}
+			return -1;
+		}
+		buf[0] = buf[last_byte-2];
+		buf[1] = buf[last_byte-1];
+
+		if ((count = GetDataBlock(fd, &buf[2])) <= 0)
+			done = TRUE;
+
+		last_byte = 2 + count;
+		curbit = (curbit - lastbit) + 16;
+		lastbit = (2+count)*8 ;
+	}
+
+	ret = 0;
+	for (i = curbit, j = 0; j < code_size; ++i, ++j)
+		ret |= ((buf[ i / 8 ] & (1 << (i % 8))) != 0) << j;
+
+	curbit += code_size;
+	return ret;
 }
 
-static int
-GetCode(gdIOCtx *fd, int code_size, int flag)
+static int GetCode(gdIOCtx *fd, int code_size, int flag) /* {{{ */
 {
- int rv;
+	int rv;
 
- rv = GetCode_(fd,code_size,flag);
- if (VERBOSE) php_gd_error_ex(E_NOTICE, "[GetCode(,%d,%d) returning %d]",code_size,flag,rv);
- return(rv);
+	rv = GetCode_(fd,code_size,flag);
+	if (VERBOSE) php_gd_error_ex(E_NOTICE, "[GetCode(,%d,%d) returning %d]",code_size,flag,rv);
+	return(rv);
 }
+/* }}} */
 
 #define STACK_SIZE ((1<<(MAX_LWZ_BITS))*2)
-static int
-LWZReadByte_(gdIOCtx *fd, int flag, int input_code_size)
+static int LWZReadByte_(gdIOCtx *fd, int flag, int input_code_size) /* {{{ */
 {
-       static int      fresh = FALSE;
-       int             code, incode;
-       static int      code_size, set_code_size;
-       static int      max_code, max_code_size;
-       static int      firstcode, oldcode;
-       static int      clear_code, end_code;
-       static int      table[2][(1<< MAX_LWZ_BITS)];
-       static int      stack[STACK_SIZE], *sp;
-       register int    i;
-
-       if (flag) {
-               set_code_size = input_code_size;
-               code_size = set_code_size+1;
-               clear_code = 1 << set_code_size ;
-               end_code = clear_code + 1;
-               max_code_size = 2*clear_code;
-               max_code = clear_code+2;
-
-               GetCode(fd, 0, TRUE);
-
-               fresh = TRUE;
-
-               for (i = 0; i < clear_code; ++i) {
-                       table[0][i] = 0;
-                       table[1][i] = i;
-               }
-               for (; i < (1<<MAX_LWZ_BITS); ++i)
-                       table[0][i] = table[1][0] = 0;
-
-               sp = stack;
-
-               return 0;
-       } else if (fresh) {
-               fresh = FALSE;
-               do {
-                       firstcode = oldcode =
-                               GetCode(fd, code_size, FALSE);
-               } while (firstcode == clear_code);
-               return firstcode;
-       }
-
-       if (sp > stack)
-               return *--sp;
-
-       while ((code = GetCode(fd, code_size, FALSE)) >= 0) {
-               if (code == clear_code) {
-                       for (i = 0; i < clear_code; ++i) {
-                               table[0][i] = 0;
-                               table[1][i] = i;
-                       }
-                       for (; i < (1<<MAX_LWZ_BITS); ++i)
-                               table[0][i] = table[1][i] = 0;
-                       code_size = set_code_size+1;
-                       max_code_size = 2*clear_code;
-                       max_code = clear_code+2;
-                       sp = stack;
-                       firstcode = oldcode =
-                                       GetCode(fd, code_size, FALSE);
-                       return firstcode;
-               } else if (code == end_code) {
-                       int             count;
-                       unsigned char   buf[260];
-
-                       if (ZeroDataBlock)
-                               return -2;
-
-                       while ((count = GetDataBlock(fd, buf)) > 0)
-                               ;
-
-                       if (count != 0)
-                       return -2;
-               }
-
-               incode = code;
-
-	       if (sp == (stack + STACK_SIZE)) {
-		       /* Bad compressed data stream */
-		       return -1;
-	       }
-
-               if (code >= max_code) {
-                       *sp++ = firstcode;
-                       code = oldcode;
-               }
-
-               while (code >= clear_code) {
-		       if (sp == (stack + STACK_SIZE)) {
-			       /* Bad compressed data stream */
-			       return -1;
-		       }
-                       *sp++ = table[1][code];
-                       if (code == table[0][code]) {
-                               /* Oh well */
-                       }
-                       code = table[0][code];
-               }
-
-               *sp++ = firstcode = table[1][code];
-
-               if ((code = max_code) <(1<<MAX_LWZ_BITS)) {
-                       table[0][code] = oldcode;
-                       table[1][code] = firstcode;
-                       ++max_code;
-                       if ((max_code >= max_code_size) &&
-                               (max_code_size < (1<<MAX_LWZ_BITS))) {
-                               max_code_size *= 2;
-                               ++code_size;
-                       }
-               }
-
-               oldcode = incode;
-
-               if (sp > stack)
-                       return *--sp;
-       }
-       return code;
+	static int      fresh = FALSE;
+	int             code, incode;
+	static int      code_size, set_code_size;
+	static int      max_code, max_code_size;
+	static int      firstcode, oldcode;
+	static int      clear_code, end_code;
+	static int      table[2][(1<< MAX_LWZ_BITS)];
+	static int      stack[STACK_SIZE], *sp;
+	register int    i;
+
+	if (flag) {
+		set_code_size = input_code_size;
+		code_size = set_code_size+1;
+		clear_code = 1 << set_code_size ;
+		end_code = clear_code + 1;
+		max_code_size = 2*clear_code;
+		max_code = clear_code+2;
+
+		GetCode(fd, 0, TRUE);
+
+		fresh = TRUE;
+
+		for (i = 0; i < clear_code; ++i) {
+			table[0][i] = 0;
+			table[1][i] = i;
+		}
+		for (; i < (1<<MAX_LWZ_BITS); ++i)
+			table[0][i] = table[1][0] = 0;
+
+		sp = stack;
+
+		return 0;
+	} else if (fresh) {
+		fresh = FALSE;
+		do {
+			firstcode = oldcode =
+				GetCode(fd, code_size, FALSE);
+		} while (firstcode == clear_code);
+		return firstcode;
+	}
+
+	if (sp > stack)
+		return *--sp;
+
+	while ((code = GetCode(fd, code_size, FALSE)) >= 0) {
+		if (code == clear_code) {
+			for (i = 0; i < clear_code; ++i) {
+				table[0][i] = 0;
+				table[1][i] = i;
+			}
+			for (; i < (1<<MAX_LWZ_BITS); ++i)
+				table[0][i] = table[1][i] = 0;
+			code_size = set_code_size+1;
+			max_code_size = 2*clear_code;
+			max_code = clear_code+2;
+			sp = stack;
+			firstcode = oldcode =
+				GetCode(fd, code_size, FALSE);
+			return firstcode;
+		} else if (code == end_code) {
+			int             count;
+			unsigned char   buf[260];
+
+			if (ZeroDataBlock)
+				return -2;
+
+			while ((count = GetDataBlock(fd, buf)) > 0)
+				;
+
+			if (count != 0)
+				return -2;
+		}
+
+		incode = code;
+
+		if (sp == (stack + STACK_SIZE)) {
+			/* Bad compressed data stream */
+			return -1;
+		}
+
+		if (code >= max_code) {
+			*sp++ = firstcode;
+			code = oldcode;
+		}
+
+		while (code >= clear_code) {
+			if (sp == (stack + STACK_SIZE)) {
+				/* Bad compressed data stream */
+				return -1;
+			}
+			*sp++ = table[1][code];
+			if (code == table[0][code]) {
+				/* Oh well */
+			}
+			code = table[0][code];
+		}
+
+		*sp++ = firstcode = table[1][code];
+
+		if ((code = max_code) <(1<<MAX_LWZ_BITS)) {
+			table[0][code] = oldcode;
+			table[1][code] = firstcode;
+			++max_code;
+			if ((max_code >= max_code_size) &&
+					(max_code_size < (1<<MAX_LWZ_BITS))) {
+				max_code_size *= 2;
+				++code_size;
+			}
+		}
+
+		oldcode = incode;
+
+		if (sp > stack)
+			return *--sp;
+	}
+	return code;
 }
+/* }}} */
 
-static int
-LWZReadByte(gdIOCtx *fd, int flag, int input_code_size)
+static int LWZReadByte(gdIOCtx *fd, int flag, int input_code_size) /* {{{ */
 {
- int rv;
+	int rv;
 
- rv = LWZReadByte_(fd,flag,input_code_size);
- if (VERBOSE) php_gd_error_ex(E_NOTICE, "[LWZReadByte(,%d,%d) returning %d]",flag,input_code_size,rv);
- return(rv);
+	rv = LWZReadByte_(fd,flag,input_code_size);
+	if (VERBOSE) php_gd_error_ex(E_NOTICE, "[LWZReadByte(,%d,%d) returning %d]",flag,input_code_size,rv);
+	return(rv);
 }
+/* }}} */
 
-static void
-ReadImage(gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace) /*1.4//, int ignore) */
+static void ReadImage(gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace) /* {{{ */ /*1.4//, int ignore) */
 {
-       unsigned char   c;
-       int             v;
-       int             xpos = 0, ypos = 0, pass = 0;
-       int i;
-
-       /*
-       **  Initialize the Compression routines
-       */
-       if (! ReadOK(fd,&c,1)) {
-               return;
-       }
+	unsigned char   c;
+	int             v;
+	int             xpos = 0, ypos = 0, pass = 0;
+	int i;
+
+
+	/*
+	 **  Initialize the Compression routines
+	 */
+	if (! ReadOK(fd,&c,1)) {
+		return;
+	}
 
 	if (c > MAX_LWZ_BITS) {
+		return;	
+	}
+
+	/* Stash the color map into the image */
+	for (i=0; (i<gdMaxColors); i++) {
+		im->red[i] = cmap[CM_RED][i];
+		im->green[i] = cmap[CM_GREEN][i];
+		im->blue[i] = cmap[CM_BLUE][i];
+		im->open[i] = 1;
+	}
+	/* Many (perhaps most) of these colors will remain marked open. */
+	im->colorsTotal = gdMaxColors;
+	if (LWZReadByte(fd, TRUE, c) < 0) {
 		return;
 	}
 
-       /* Stash the color map into the image */
-       for (i=0; (i<gdMaxColors); i++) {
-               im->red[i] = cmap[CM_RED][i];
-               im->green[i] = cmap[CM_GREEN][i];
-               im->blue[i] = cmap[CM_BLUE][i];
-               im->open[i] = 1;
-       }
-       /* Many (perhaps most) of these colors will remain marked open. */
-       im->colorsTotal = gdMaxColors;
-
-       if (LWZReadByte(fd, TRUE, c) < 0) {
-               return;
-       }
-
-       /*
-       **  If this is an "uninteresting picture" ignore it.
-       **  REMOVED For 1.4
-       */
-       /*if (ignore) { */
-       /*        while (LWZReadByte(fd, FALSE, c) >= 0) */
-       /*                ; */
-       /*        return; */
-       /*} */
-
-       while ((v = LWZReadByte(fd,FALSE,c)) >= 0 ) {
-               /* This how we recognize which colors are actually used. */
-               if (im->open[v]) {
-                       im->open[v] = 0;
-               }
-               gdImageSetPixel(im, xpos, ypos, v);
-               ++xpos;
-               if (xpos == len) {
-                       xpos = 0;
-                       if (interlace) {
-                               switch (pass) {
-                               case 0:
-                               case 1:
-                                       ypos += 8; break;
-                               case 2:
-                                       ypos += 4; break;
-                               case 3:
-                                       ypos += 2; break;
-                               }
-
-                               if (ypos >= height) {
-                                       ++pass;
-                                       switch (pass) {
-                                       case 1:
-                                               ypos = 4; break;
-                                       case 2:
-                                               ypos = 2; break;
-                                       case 3:
-                                               ypos = 1; break;
-                                       default:
-                                               goto fini;
-                                       }
-                               }
-                       } else {
-                               ++ypos;
-                       }
-               }
-               if (ypos >= height)
-                       break;
-       }
+	/*
+	 **  If this is an "uninteresting picture" ignore it.
+	 **  REMOVED For 1.4
+	 */
+	/*if (ignore) { */
+	/*        while (LWZReadByte(fd, FALSE, c) >= 0) */
+	/*                ; */
+	/*        return; */
+	/*} */
+
+	while ((v = LWZReadByte(fd,FALSE,c)) >= 0 ) {
+		/* This how we recognize which colors are actually used. */
+		if (im->open[v]) {
+			im->open[v] = 0;
+		}
+		gdImageSetPixel(im, xpos, ypos, v);
+		++xpos;
+		if (xpos == len) {
+			xpos = 0;
+			if (interlace) {
+				switch (pass) {
+					case 0:
+					case 1:
+						ypos += 8; break;
+					case 2:
+						ypos += 4; break;
+					case 3:
+						ypos += 2; break;
+				}
+
+				if (ypos >= height) {
+					++pass;
+					switch (pass) {
+						case 1:
+							ypos = 4; break;
+						case 2:
+							ypos = 2; break;
+						case 3:
+							ypos = 1; break;
+						default:
+							goto fini;
+					}
+				}
+			} else {
+				++ypos;
+			}
+		}
+		if (ypos >= height)
+			break;
+	}
 
 fini:
-       if (LWZReadByte(fd,FALSE,c)>=0) {
-               /* Ignore extra */
-       }
+	if (LWZReadByte(fd,FALSE,c)>=0) {
+		/* Ignore extra */
+	}
 }
-
+/* }}} */
diff --git a/ext/gd/libgd/gd_gif_out.c b/ext/gd/libgd/gd_gif_out.c
index f6b4ff7e6..1fe36880a 100644
--- a/ext/gd/libgd/gd_gif_out.c
+++ b/ext/gd/libgd/gd_gif_out.c
@@ -264,11 +264,11 @@ GIFEncode(gdIOCtxPtr fp, int GWidth, int GHeight, int GInterlace, int Background
         int ColorMapSize;
         int InitCodeSize;
         int i;
-	GifCtx ctx;
-	
-	memset(&ctx, 0, sizeof(ctx));
+		GifCtx ctx;
+
+		memset(&ctx, 0, sizeof(ctx));
         ctx.Interlace = GInterlace;
-	ctx.in_count = 1;
+		ctx.in_count = 1;
 
         ColorMapSize = 1 << BitsPerPixel;
 
diff --git a/ext/gd/libgd/gd_png.c b/ext/gd/libgd/gd_png.c
index fcc9a008a..b99c33c8c 100644
--- a/ext/gd/libgd/gd_png.c
+++ b/ext/gd/libgd/gd_png.c
@@ -131,7 +131,10 @@ gdImagePtr gdImageCreateFromPngCtx (gdIOCtx * infile)
 	  /* first do a quick check that the file really is a PNG image; could
 	   * have used slightly more general png_sig_cmp() function instead
 	   */
-	gdGetBuf(sig, 8, infile);
+	if (gdGetBuf(sig, 8, infile) < 8) {
+		return NULL;
+	}
+
 	if (!png_check_sig (sig, 8)) { /* bad signature */
 		return NULL;
 	}
diff --git a/ext/gd/libgd/gdfontg.c b/ext/gd/libgd/gdfontg.c
index 61c8c2710..edddd0990 100644
--- a/ext/gd/libgd/gdfontg.c
+++ b/ext/gd/libgd/gdfontg.c
@@ -13,7 +13,7 @@
 
 #include "gdfontg.h"
 
-char gdFontGiantData[] =
+static const char gdFontGiantData[] =
 {
 /* Char 0 */
   0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -4376,7 +4376,7 @@ gdFont gdFontGiantRep =
   0,
   9,
   15,
-  gdFontGiantData
+  (char*)gdFontGiantData
 };
 
 gdFontPtr gdFontGiant = &gdFontGiantRep;
diff --git a/ext/gd/libgd/gdfontl.c b/ext/gd/libgd/gdfontl.c
index 6da54e1a1..093954ba3 100644
--- a/ext/gd/libgd/gdfontl.c
+++ b/ext/gd/libgd/gdfontl.c
@@ -14,7 +14,7 @@
 
 #include "gdfontl.h"
 
-char gdFontLargeData[] =
+static const char gdFontLargeData[] =
 {
 /* Char 0 */
   0, 0, 0, 0, 0, 0, 0, 0,
@@ -4633,7 +4633,7 @@ gdFont gdFontLargeRep =
   0,
   8,
   16,
-  gdFontLargeData
+  (char*)gdFontLargeData
 };
 
 gdFontPtr gdFontLarge = &gdFontLargeRep;
diff --git a/ext/gd/libgd/gdfontmb.c b/ext/gd/libgd/gdfontmb.c
index dab7c0589..b60110507 100644
--- a/ext/gd/libgd/gdfontmb.c
+++ b/ext/gd/libgd/gdfontmb.c
@@ -12,7 +12,7 @@
 
 #include "gdfontmb.h"
 
-char gdFontMediumBoldData[] =
+static const char gdFontMediumBoldData[] =
 {
 /* Char 0 */
   0, 0, 0, 0, 0, 0, 0,
@@ -3863,7 +3863,7 @@ gdFont gdFontMediumBoldRep =
   0,
   7,
   13,
-  gdFontMediumBoldData
+  (char*)gdFontMediumBoldData
 };
 
 gdFontPtr gdFontMediumBold = &gdFontMediumBoldRep;
diff --git a/ext/gd/libgd/gdfonts.c b/ext/gd/libgd/gdfonts.c
index 165cf70c5..bcc0717ca 100644
--- a/ext/gd/libgd/gdfonts.c
+++ b/ext/gd/libgd/gdfonts.c
@@ -12,7 +12,7 @@
 
 #include "gdfonts.h"
 
-char gdFontSmallData[] =
+static const char gdFontSmallData[] =
 {
 /* Char 0 */
   0, 0, 0, 0, 0, 0,
@@ -3863,7 +3863,7 @@ gdFont gdFontSmallRep =
   0,
   6,
   13,
-  gdFontSmallData
+  (char*)gdFontSmallData
 };
 
 gdFontPtr gdFontSmall = &gdFontSmallRep;
diff --git a/ext/gd/libgd/gdfontt.c b/ext/gd/libgd/gdfontt.c
index 2e6d24150..d4e0cf957 100644
--- a/ext/gd/libgd/gdfontt.c
+++ b/ext/gd/libgd/gdfontt.c
@@ -13,7 +13,7 @@
 
 #include "gdfontt.h"
 
-char gdFontTinyData[] =
+static const char gdFontTinyData[] =
 {
 /* Char 0 */
   0, 0, 0, 0, 0,
@@ -2584,7 +2584,7 @@ gdFont gdFontTinyRep =
   0,
   5,
   8,
-  gdFontTinyData
+  (char*)gdFontTinyData
 };
 
 gdFontPtr gdFontTiny = &gdFontTinyRep;
diff --git a/ext/gd/libgd/gdft.c b/ext/gd/libgd/gdft.c
index a09bdcba6..30ac2768c 100644
--- a/ext/gd/libgd/gdft.c
+++ b/ext/gd/libgd/gdft.c
@@ -207,12 +207,28 @@ static int gdTcl_UtfToUniChar (char *str, Tcl_UniChar * chPtr)
 
 		byte = *((unsigned char *) (str + 1));
 		if (byte == '#') {
-			for (i = 2; i < 8; i++) {
-				byte = *((unsigned char *) (str + i));
-				if (byte >= '0' && byte <= '9') {
-					n = (n * 10) + (byte - '0');
-				} else {
-					break;
+			byte = *((unsigned char *) (str + 2));
+			if (byte == 'x' || byte == 'X') {
+				for (i = 3; i < 8; i++) {
+					byte = *((unsigned char *) (str + i));
+					if (byte >= 'A' && byte <= 'F')
+						byte = byte - 'A' + 10;
+					else if (byte >= 'a' && byte <= 'f')
+						byte = byte - 'a' + 10;
+					else if (byte >= '0' && byte <= '9')
+						byte = byte - '0';
+					else
+						break;
+					n = (n * 16) + byte;
+				}
+			} else {
+				for (i = 2; i < 8; i++) {
+					byte = *((unsigned char *) (str + i));
+					if (byte >= '0' && byte <= '9') {
+						n = (n * 10) + (byte - '0');
+					} else {
+						break;
+					}
 				}
 			}
 			if (byte == ';') {
@@ -518,7 +534,7 @@ static void * tweenColorFetch (char **error, void *key)
 	pixel = a->pixel = b->pixel;
 	bg = a->bgcolor = b->bgcolor;
 	fg = a->fgcolor = b->fgcolor;
-	im = b->im;
+	im = a->im = b->im;
 
 	/* if fg is specified by a negative color idx, then don't antialias */
 	if (fg < 0) {
diff --git a/ext/gd/libgd/gdtables.c b/ext/gd/libgd/gdtables.c
index 1e81f3e9e..e34d8fc7c 100644
--- a/ext/gd/libgd/gdtables.c
+++ b/ext/gd/libgd/gdtables.c
@@ -5,7 +5,7 @@
 
 #include "php_compat.h"
 
-int gdCosT[] =
+const int gdCosT[] =
 {
   1024,
   1023,
@@ -369,7 +369,7 @@ int gdCosT[] =
   1023
 };
 
-int gdSinT[] =
+const int gdSinT[] =
 {
   0,
   17,