Attachment 32420 Details for Bug 53582 – file.diff

[patch] file.diff

file.diff (text/plain), 94.44 KB, created by tkato on 2003-06-21 13:20:15 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: tkato

Created: 2003-06-21 13:20:15 UTC

Size: 94.44 KB

patch

obsolete

>diff -urN /usr/ports/graphics/gd/Makefile graphics/gd/Makefile
>--- /usr/ports/graphics/gd/Makefile	Sat Apr 12 22:48:28 2003
>+++ graphics/gd/Makefile	Sat Jun 21 20:18:03 2003
>@@ -6,52 +6,48 @@
> #
> 
> PORTNAME=	gd
>-PORTVERSION=	1.8.4
>-PORTREVISION=	6
>+PORTVERSION=	2.0.15
> CATEGORIES+=	graphics
> MASTER_SITES=	http://www.boutell.com/gd/http/ \
> 		ftp://ftp.boutell.com/pub/boutell/gd/ \
>-		http://virtual-estates.net/~mi/port-stuff/ \
> 		${MASTER_SITE_RINGSERVER}
> MASTER_SITE_SUBDIR=	graphics/gd
>-DISTFILES=	${DISTNAME}${EXTRACT_SUFX} gd_gif_in.c.bz2
>-EXTRACT_ONLY=	${DISTNAME}${EXTRACT_SUFX}
> 
> MAINTAINER?=	ports@FreeBSD.org
> COMMENT?=	A graphics library for fast image creation
> 
>-BUILD_DEPENDS=	freetype-config:${PORTSDIR}/print/freetype2     # XXX
>-LIB_DEPENDS=	jpeg:${PORTSDIR}/graphics/jpeg \
>-		png:${PORTSDIR}/graphics/png \
>-		freetype:${PORTSDIR}/print/freetype2
>-.if !exists(/usr/bin/bzip2)
>-BUILD_DEPENDS+=	bzip2:${PORTSDIR}/archivers/bzip2
>-.endif
>-
>-FREETYPE_CONFIG?=       ${LOCALBASE}/bin/freetype-config
>+LIB_DEPENDS=	jpeg.9:${PORTSDIR}/graphics/jpeg \
>+		png.5:${PORTSDIR}/graphics/png \
>+		freetype.9:${PORTSDIR}/print/freetype2
> 
>-USE_REINPLACE=	yes
>-MAKE_ENV=	FREETYPE_CONFIG="${FREETYPE_CONFIG}"
>+MAKE_ENV=	WRKSRC="${WRKSRC}"
>+MAKEFILE=	${FILESDIR}/Makefile.bsd
> INSTALLS_SHLIB=	yes
> 
>-.if defined(WITH_X11)
>+.if !defined(WITHOUT_X11)
> USE_XPM=	yes
> .endif
> 
>+.if defined(HAVE_UNISYS_LICENSE) || \
>+    (defined(USA_RESIDENT) && ${USA_RESIDENT} == "YES")
>+WITH_LZW=	yes
>+.endif
>+
>+.if defined(GD_FONTS)
>+USE_PERL5_BUILD=	yes
>+SCRIPTS_ENV+=	GD_FONTS="${GD_FONTS}"
>+.endif
>+
> pre-everything::
>-.if !defined(WITH_X11)
>-	@${ECHO_MSG}
>-	@${ECHO_MSG} "If you want to compile with Xpm support,"
>-	@${ECHO_MSG} "hit Ctrl-C right now and use \"make WITH_X11=yes\""
>-	@${ECHO_MSG}
>+.if !defined(WITH_LZW)
>+	@${ECHO_MSG} "************************************************************"
>+	@${ECHO_MSG} "*      If you live outside US and Canada, you can define   *"
>+	@${ECHO_MSG} "*      WITH_LZW to enable GIF compression support.         *"
>+	@${ECHO_MSG} "************************************************************"
> .endif
> 
> post-extract:
>-	@${BZIP2_CMD} -dc ${DISTDIR}/${DIST_SUBDIR}/gd_gif_in.c.bz2 \
>-		> ${WRKSRC}/gd_gif_in.c
>-
>-post-patch:
>-	@${REINPLACE_CMD} -e 's|<malloc.h>|<stdlib.h>|g' ${WRKSRC}/gdcache.h
>+	@${CP} ${FILESDIR}/g* ${WRKSRC}
> 
> post-install:
> .if !defined(NOPORTDOCS)
>diff -urN /usr/ports/graphics/gd/distinfo graphics/gd/distinfo
>--- /usr/ports/graphics/gd/distinfo	Tue Aug 21 10:30:32 2001
>+++ graphics/gd/distinfo	Sat Jun 21 19:53:40 2003
>@@ -1,2 +1 @@
>-MD5 (gd-1.8.4.tar.gz) = 2aef76e79f206f9798233f025f5dd28d
>-MD5 (gd_gif_in.c.bz2) = 54132aea09471bb997672436dd9a1a96
>+MD5 (gd-2.0.15.tar.gz) = 6ededf633b4fd054662ec123c7825fbb
>diff -urN /usr/ports/graphics/gd/files/Makefile.bsd graphics/gd/files/Makefile.bsd
>--- /usr/ports/graphics/gd/files/Makefile.bsd	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/Makefile.bsd	Sat Jun 21 20:19:07 2003
>@@ -0,0 +1,60 @@
>+PROGS!=	${MAKE} -V BIN_PROGRAMS -f ${WRKSRC}/makefile.sample
>+PROGS+=	gd2togif gdcmpgif giftogd2
>+PROGS+=	annotate	# new utility, not included in makefile.sample
>+TESTS=	gdtest gddemo gd2time gdtestft testac fontsizetest fontwheeltest
>+SRCS=	gd.c gd_gd.c gd_gd2.c gd_io.c gd_io_dp.c gd_io_file.c \
>+	gd_io_ss.c gd_jpeg.c gd_png.c gd_ss.c gd_topal.c \
>+	gd_wbmp.c gdcache.c gdfontg.c gdfontl.c gdfontmb.c \
>+	gdfonts.c gdfontt.c gdft.c gdhelpers.c gdhelpers.h \
>+	gdkanji.c gdtables.c gdxpm.c jisx0208.h \
>+	wbmp.c wbmp.h
>+SRCS+=	gd_gif_in.c gd_gif_out.c gd_biggif_out.c gd_lzw_out.c
>+MAKEDIR=/usr/share/mk
>+LIB=gd
>+SHLIB_MAJOR=4
>+SHLIB_MINOR=0
>+INCS=	gd.h gd_io.h gdcache.h gdfontg.h gdfontl.h gdfontmb.h \
>+	gdfonts.h gdfontt.h
>+SHLIB_NAME!=	${MAKE} -V SHLIB_NAME LIB=${LIB} \
>+	SHLIB_MAJOR=${SHLIB_MAJOR} SHLIB_MINOR=${SHLIB_MINOR} -f ${MAKEDIR}/bsd.lib.mk
>+
>+CFLAGS+=-I${.CURDIR} -I${LOCALBASE}/include/freetype2/ \
>+	-I${LOCALBASE}/include/freetype2/freetype -I${LOCALBASE}/include \
>+	-DHAVE_LIBPNG -DHAVE_LIBJPEG -DHAVE_LIBFREETYPE -DHAVE_LIBZ
>+LDADD=	-L${LOCALBASE}/lib -lpng -lz -ljpeg -lfreetype -lm
>+
>+.ifndef WITHOUT_X11
>+CFLAGS+=-I${X11BASE}/include/X11 -I${X11BASE}/include -DHAVE_XPM
>+LDADD+=	-L${X11BASE}/lib -lXpm -lX11
>+.endif
>+
>+.ifdef WITH_LZW
>+CFLAGS+=-DLZW_LICENCED
>+.endif
>+
>+# The package comes with tests, but without any sort of test-harness,
>+# to run them all automaticly. So building tests is disabled here.	-mi
>+all: lib${LIB}.a ${SHLIB_NAME} ${PROGS} # ${TESTS}
>+
>+lib${LIB}.a ${SHLIB_NAME}: ${SRCS}
>+	${MAKE} LIB=${LIB} SRCS="${SRCS}" \
>+		SHLIB_MAJOR=${SHLIB_MAJOR} SHLIB_MINOR=${SHLIB_MINOR} \
>+		CFLAGS="${CFLAGS}" -ECFLAGS LDADD="${LDADD}" \
>+		-f ${MAKEDIR}/bsd.lib.mk ${.TARGET}
>+
>+${PROGS} ${TESTS}: ${SHLIB_NAME} lib${LIB}.a
>+	${MAKE} PROG=${.TARGET} NOMAN=1 LDADD="-L. -lgd" \
>+		CFLAGS="${CFLAGS}" -ECFLAGS -f ${MAKEDIR}/bsd.prog.mk
>+
>+install:
>+	mkdir -p ${PREFIX}/include
>+	${MAKE} LIB=${LIB} LIBDIR=${PREFIX}/lib NOPROFILE=true \
>+		SHLIB_MAJOR=${SHLIB_MAJOR} SHLIB_MINOR=${SHLIB_MINOR} \
>+		-f ${MAKEDIR}/bsd.lib.mk install
>+	cd ${.CURDIR} && ${BSD_INSTALL_DATA} ${INCS} ${PREFIX}/include
>+	cd ${.CURDIR} && ${BSD_INSTALL_PROGRAM} ${PROGS} ${PREFIX}/bin/
>+	${BSD_INSTALL_SCRIPT} ${.CURDIR}/bdftogd ${PREFIX}/bin/
>+
>+.if exists(${.CURDIR}/Makefile.fonts)
>+.include "Makefile.fonts"
>+.endif
>diff -urN /usr/ports/graphics/gd/files/gd2togif.c graphics/gd/files/gd2togif.c
>--- /usr/ports/graphics/gd/files/gd2togif.c	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/gd2togif.c	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,40 @@
>+#include <stdio.h>
>+#include "gd.h"
>+
>+/* A short program which converts a .gif file into a .gd file, for
>+	your convenience in creating images on the fly from a
>+	basis image that must be loaded quickly. The .gd format
>+	is not intended to be a general-purpose format. */
>+
>+int main(int argc, char **argv)
>+{
>+	gdImagePtr im;
>+	FILE *in, *out;
>+	if (argc != 3) {
>+		fprintf(stderr, "Usage: gd2togif filename.gd2 filename.gif\n");
>+		exit(1);
>+	}
>+	in = fopen(argv[1], "rb");
>+	if (!in) {
>+		fprintf(stderr, "Input file does not exist!\n");
>+		exit(1);
>+	}
>+	im = gdImageCreateFromGd2(in);
>+	fclose(in);
>+	if (!im) {
>+		fprintf(stderr, "Input is not in GIF format!\n");
>+		exit(1);
>+	}
>+	out = fopen(argv[2], "wb");
>+	if (!out) {
>+		fprintf(stderr, "Output file cannot be written to!\n");
>+		gdImageDestroy(im);
>+		exit(1);	
>+	}
>+	gdImageGif(im, out);
>+	fclose(out);
>+	gdImageDestroy(im);
>+
>+	return 0;
>+}
>+
>diff -urN /usr/ports/graphics/gd/files/gd_biggif_out.c graphics/gd/files/gd_biggif_out.c
>--- /usr/ports/graphics/gd/files/gd_biggif_out.c	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/gd_biggif_out.c	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,823 @@
>+#include <stdio.h>
>+#include <math.h>
>+#include <string.h>
>+#include <stdlib.h>
>+#include "gd.h"
>+
>+/*
>+** Wrapper functions for this module.
>+*/
>+
>+void gdImageBigGif(gdImagePtr im, FILE *outFile)
>+{
>+        gdIOCtx   *out = gdNewFileCtx(outFile);
>+        gdImageBigGifCtx(im, out);
>+	out->gd_free(out);
>+}
>+
>+void* gdImageBigGifPtr(gdImagePtr im, int *size)
>+{
>+	void	*rv;
>+        gdIOCtx   *out = gdNewDynamicCtx(2048, NULL);
>+        gdImageBigGifCtx(im, out);
>+	rv = gdDPExtractData(out,size);
>+ 	out->gd_free(out);
>+	return rv;
>+}
>+
>+/* Code drawn from ppmtogif.c, from the pbmplus package
>+**
>+** Based on GIFENCOD by David Rowley <mgardi@watdscu.waterloo.edu>. A
>+** Lempel-Zim compression based on "compress".
>+**
>+** Modified by Marcel Wijkstra <wijkstra@fwi.uva.nl>
>+**
>+** Copyright (C) 1989 by Jef Poskanzer.
>+**
>+** Permission to use, copy, modify, and distribute this software and its
>+** documentation for any purpose and without fee is hereby granted, provided
>+** that the above copyright notice appear in all copies and that both that
>+** copyright notice and this permission notice appear in supporting
>+** documentation.  This software is provided "as is" without express or
>+** implied warranty.
>+**
>+** The Graphics Interchange Format(c) is the Copyright property of
>+** CompuServe Incorporated.  GIF(sm) is a Service Mark property of
>+** CompuServe Incorporated.
>+*
>+*  Heavily modified by Mouse, 1998-02-12.  
>+*  Remove LZW compression.
>+*  Added miGIF run length compression.
>+*
>+*/
>+
>+/*
>+ * a code_int must be able to hold 2**GIFBITS values of type int, and also -1
>+ */
>+typedef int code_int;
>+
>+static int colorstobpp(int colors);
>+static void BumpPixel (void);
>+static int GIFNextPixel (gdImagePtr im);
>+static void GIFEncode (gdIOCtx *fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im);
>+/*static void Putword (int w, gdIOCtx *fp); */
>+static void GIFcompress (int, gdIOCtx *, gdImagePtr, int);
>+static void output (code_int code);
>+
>+/* UNUSED
>+* static void char_init (void);
>+* static void char_out (int c);
>+*/
>+
>+/* Allows for reuse */
>+static void init_statics(void);
>+
>+void gdImageBigGifCtx(gdImagePtr im, gdIOCtx *out)
>+{
>+	int interlace, transparent, BitsPerPixel;
>+
>+	interlace = im->interlace;
>+	transparent = im->transparent;
>+
>+	BitsPerPixel = colorstobpp(im->colorsTotal);
>+	/* Clear any old values in statics strewn through the GIF code */
>+	init_statics();
>+	/* All set, let's do it. */
>+	GIFEncode(
>+		out, im->sx, im->sy, interlace, 0, transparent, BitsPerPixel,
>+		im->red, im->green, im->blue, im);
>+}
>+
>+static int
>+colorstobpp(int colors)
>+{
>+    int bpp = 0;
>+
>+    if ( colors <= 2 )
>+        bpp = 1;
>+    else if ( colors <= 4 )
>+        bpp = 2;
>+    else if ( colors <= 8 )
>+        bpp = 3;
>+    else if ( colors <= 16 )
>+        bpp = 4;
>+    else if ( colors <= 32 )
>+        bpp = 5;
>+    else if ( colors <= 64 )
>+        bpp = 6;
>+    else if ( colors <= 128 )
>+        bpp = 7;
>+    else if ( colors <= 256 )
>+        bpp = 8;
>+    return bpp;
>+    }
>+
>+/*****************************************************************************
>+ *
>+ * GIFENCODE.C    - GIF Image compression interface
>+ *
>+ * GIFEncode( FName, GHeight, GWidth, GInterlace, Background, Transparent,
>+ *            BitsPerPixel, Red, Green, Blue, gdImagePtr )
>+ *
>+ *****************************************************************************/
>+
>+#define TRUE 1
>+#define FALSE 0
>+
>+static int Width, Height;
>+static int curx, cury;
>+static long CountDown;
>+static int Pass = 0;
>+static int Interlace;
>+
>+/*
>+ * Bump the 'curx' and 'cury' to point to the next pixel
>+ */
>+static void
>+BumpPixel(void)
>+{
>+        /*
>+         * Bump the current X position
>+         */
>+        ++curx;
>+
>+        /*
>+         * If we are at the end of a scan line, set curx back to the beginning
>+         * If we are interlaced, bump the cury to the appropriate spot,
>+         * otherwise, just increment it.
>+         */
>+        if( curx == Width ) {
>+                curx = 0;
>+
>+                if( !Interlace )
>+                        ++cury;
>+                else {
>+                     switch( Pass ) {
>+
>+                       case 0:
>+                          cury += 8;
>+                          if( cury >= Height ) {
>+                                ++Pass;
>+                                cury = 4;
>+                          }
>+                          break;
>+
>+                       case 1:
>+                          cury += 8;
>+                          if( cury >= Height ) {
>+                                ++Pass;
>+                                cury = 2;
>+                          }
>+                          break;
>+
>+                       case 2:
>+                          cury += 4;
>+                          if( cury >= Height ) {
>+                             ++Pass;
>+                             cury = 1;
>+                          }
>+                          break;
>+
>+                       case 3:
>+                          cury += 2;
>+                          break;
>+                        }
>+                }
>+        }
>+}
>+
>+/*
>+ * Return the next pixel from the image
>+ */
>+static int
>+GIFNextPixel(gdImagePtr im)
>+{
>+        int r;
>+
>+        if( CountDown == 0 )
>+                return EOF;
>+
>+        --CountDown;
>+
>+        r = gdImageGetPixel(im, curx, cury);
>+
>+        BumpPixel();
>+
>+        return r;
>+}
>+
>+/* public */
>+
>+static void
>+GIFEncode(gdIOCtx *fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im)
>+{
>+        int B;
>+        int RWidth, RHeight;
>+        int LeftOfs, TopOfs;
>+        int Resolution;
>+        int ColorMapSize;
>+        int InitCodeSize;
>+        int i;
>+
>+        Interlace = GInterlace;
>+
>+        ColorMapSize = 1 << BitsPerPixel;
>+
>+        RWidth = Width = GWidth;
>+        RHeight = Height = GHeight;
>+        LeftOfs = TopOfs = 0;
>+
>+        Resolution = BitsPerPixel;
>+
>+        /*
>+         * Calculate number of bits we are expecting
>+         */
>+        CountDown = (long)Width * (long)Height;
>+
>+        /*
>+         * Indicate which pass we are on (if interlace)
>+         */
>+        Pass = 0;
>+
>+        /*
>+         * The initial code size
>+         */
>+        if( BitsPerPixel <= 1 )
>+                InitCodeSize = 2;
>+        else
>+                InitCodeSize = BitsPerPixel;
>+
>+        /*
>+         * Set up the current x and y position
>+         */
>+        curx = cury = 0;
>+
>+        /*
>+         * Write the Magic header
>+         */
>+        gdPutBuf( Transparent < 0 ? "GIF87a" : "GIF89a", 6, fp );
>+
>+        /*
>+         * Write out the screen width and height
>+         */
>+        Putword( RWidth, fp );
>+        Putword( RHeight, fp );
>+
>+        /*
>+         * Indicate that there is a global colour map
>+         */
>+        B = 0x80;       /* Yes, there is a color map */
>+
>+        /*
>+         * OR in the resolution
>+         */
>+        B |= (Resolution - 1) << 4;
>+
>+        /*
>+         * OR in the Bits per Pixel
>+         */
>+        B |= (BitsPerPixel - 1);
>+
>+        /*
>+         * Write it out
>+         */
>+        gdPutC( B, fp );
>+
>+        /*
>+         * Write out the Background colour
>+         */
>+        gdPutC( Background, fp );
>+
>+        /*
>+         * Byte of 0's (future expansion)
>+         */
>+        gdPutC( 0, fp );
>+
>+        /*
>+         * Write out the Global Colour Map
>+         */
>+        for( i=0; i<ColorMapSize; ++i ) {
>+                gdPutC( Red[i], fp );
>+                gdPutC( Green[i], fp );
>+                gdPutC( Blue[i], fp );
>+        }
>+
>+	/*
>+	 * Write out extension for transparent colour index, if necessary.
>+	 */
>+	if ( Transparent >= 0 ) {
>+	    gdPutC( '!', fp );
>+	    gdPutC( 0xf9, fp );
>+	    gdPutC( 4, fp );
>+	    gdPutC( 1, fp );
>+	    gdPutC( 0, fp );
>+	    gdPutC( 0, fp );
>+	    gdPutC( (unsigned char) Transparent, fp );
>+	    gdPutC( 0, fp );
>+	}
>+
>+        /*
>+         * Write an Image separator
>+         */
>+        gdPutC( ',', fp );
>+
>+        /*
>+         * Write the Image header
>+         */
>+
>+        Putword( LeftOfs, fp );
>+        Putword( TopOfs, fp );
>+        Putword( Width, fp );
>+        Putword( Height, fp );
>+
>+        /*
>+         * Write out whether or not the image is interlaced
>+         */
>+        if( Interlace )
>+                gdPutC( 0x40, fp );
>+        else
>+                gdPutC( 0x00, fp );
>+
>+        /*
>+         * Write out the initial code size
>+         */
>+        gdPutC( InitCodeSize, fp );
>+
>+        /*
>+         * Go and actually compress the data
>+         */
>+        GIFcompress( InitCodeSize+1, fp, im, Background );
>+
>+        /*
>+         * Write out a Zero-length packet (to end the series)
>+         */
>+        gdPutC( 0, fp );
>+
>+        /*
>+         * Write the GIF file terminator
>+         */
>+        gdPutC( ';', fp );
>+}
>+
>+/* Write out a word to the GIF file */
>+/*static void */
>+/*Putword(int w, gdIOCtx *fp) */
>+/*{ */
>+/*        fputc( w & 0xff, fp ); */
>+/*        fputc( (w / 256) & 0xff, fp ); */
>+/*} */
>+
>+#define GIFBITS 12
>+
>+/*-----------------------------------------------------------------------
>+ *
>+ * miGIF Compression - mouse and ivo's GIF-compatible compression
>+ *
>+ *          -run length encoding compression routines-
>+ *
>+ * Copyright (C) 1998 Hutchison Avenue Software Corporation
>+ *               http://www.hasc.com
>+ *               info@hasc.com
>+ *
>+ * Permission to use, copy, modify, and distribute this software and its
>+ * documentation for any purpose and without fee is hereby granted, provided
>+ * that the above copyright notice appear in all copies and that both that
>+ * copyright notice and this permission notice appear in supporting
>+ * documentation.  This software is provided "AS IS." The Hutchison Avenue 
>+ * Software Corporation disclaims all warranties, either express or implied, 
>+ * including but not limited to implied warranties of merchantability and 
>+ * fitness for a particular purpose, with respect to this code and accompanying
>+ * documentation. 
>+ * 
>+ * The miGIF compression routines do not, strictly speaking, generate files 
>+ * conforming to the GIF spec, since the image data is not LZW-compressed 
>+ * (this is the point: in order to avoid transgression of the Unisys patent 
>+ * on the LZW algorithm.)  However, miGIF generates data streams that any 
>+ * reasonably sane LZW decompresser will decompress to what we want.
>+ *
>+ * miGIF compression uses run length encoding. It compresses horizontal runs 
>+ * of pixels of the same color. This type of compression gives good results
>+ * on images with many runs, for example images with lines, text and solid 
>+ * shapes on a solid-colored background. It gives little or no compression 
>+ * on images with few runs, for example digital or scanned photos.
>+ *
>+ *                               der Mouse
>+ *                      mouse@rodents.montreal.qc.ca
>+ *            7D C8 61 52 5D E7 2D 39  4E F1 31 3E E8 B3 27 4B
>+ *
>+ *                             ivo@hasc.com
>+ *
>+ * The Graphics Interchange Format(c) is the Copyright property of
>+ * CompuServe Incorporated.  GIF(sm) is a Service Mark property of
>+ * CompuServe Incorporated.
>+ *
>+ */
>+
>+static int rl_pixel;
>+static int rl_basecode;
>+static int rl_count;
>+static int rl_table_pixel;
>+static int rl_table_max;
>+static int just_cleared;
>+static int out_bits;
>+static int out_bits_init;
>+static int out_count;
>+static int out_bump;
>+static int out_bump_init;
>+static int out_clear;
>+static int out_clear_init;
>+static int max_ocodes;
>+static int code_clear;
>+static int code_eof;
>+static unsigned int obuf;
>+static int obits;
>+static gdIOCtx *ofile;
>+static unsigned char oblock[256];
>+static int oblen;
>+
>+/* Used only when debugging GIF compression code */
>+/* #define DEBUGGING_ENVARS */
>+
>+#ifdef DEBUGGING_ENVARS
>+
>+static int verbose_set = 0;
>+static int verbose;
>+#define VERBOSE (verbose_set?verbose:set_verbose())
>+
>+static int set_verbose(void)
>+{
>+ verbose = !!getenv("GIF_VERBOSE");
>+ verbose_set = 1;
>+ return(verbose);
>+}
>+
>+#else
>+
>+#define VERBOSE 0
>+
>+#endif
>+
>+
>+static const char *binformat(unsigned int v, int nbits)
>+{
>+ static char bufs[8][64];
>+ static int bhand = 0;
>+ unsigned int bit;
>+ int bno;
>+ char *bp;
>+
>+ bhand --;
>+ if (bhand < 0) bhand = (sizeof(bufs)/sizeof(bufs[0]))-1;
>+ bp = &bufs[bhand][0];
>+ for (bno=nbits-1,bit=1U<<bno;bno>=0;bno--,bit>>=1)
>+  { *bp++ = (v & bit) ? '1' : '0';
>+    if (((bno&3) == 0) && (bno != 0)) *bp++ = '.';
>+  }
>+ *bp = '\0';
>+ return(&bufs[bhand][0]);
>+}
>+
>+static void write_block(void)
>+{
>+ int i;
>+
>+ if (VERBOSE)
>+  { printf("write_block %d:",oblen);
>+    for (i=0;i<oblen;i++) printf(" %02x",oblock[i]);
>+    printf("\n");
>+  }
>+ gdPutC(oblen,ofile);
>+ gdPutBuf(&oblock[0],oblen,ofile);
>+ oblen = 0;
>+}
>+
>+static void block_out(unsigned char c)
>+{
>+ if (VERBOSE) printf("block_out %s\n",binformat(c,8));
>+ oblock[oblen++] = c;
>+ if (oblen >= 255) write_block();
>+}
>+
>+static void block_flush(void)
>+{
>+ if (VERBOSE) printf("block_flush\n");
>+ if (oblen > 0) write_block();
>+}
>+
>+static void output(int val)
>+{
>+ if (VERBOSE) printf("output %s [%s %d %d]\n",binformat(val,out_bits),binformat(obuf,obits),obits,out_bits);
>+ obuf |= val << obits;
>+ obits += out_bits;
>+ while (obits >= 8)
>+  { block_out(obuf&0xff);
>+    obuf >>= 8;
>+    obits -= 8;
>+  }
>+ if (VERBOSE) printf("output leaving [%s %d]\n",binformat(obuf,obits),obits);
>+}
>+
>+static void output_flush(void)
>+{
>+ if (VERBOSE) printf("output_flush\n");
>+ if (obits > 0) block_out(obuf);
>+ block_flush();
>+}
>+
>+static void did_clear(void)
>+{
>+ if (VERBOSE) printf("did_clear\n");
>+ out_bits = out_bits_init;
>+ out_bump = out_bump_init;
>+ out_clear = out_clear_init;
>+ out_count = 0;
>+ rl_table_max = 0;
>+ just_cleared = 1;
>+}
>+
>+static void output_plain(int c)
>+{
>+ if (VERBOSE) printf("output_plain %s\n",binformat(c,out_bits));
>+ just_cleared = 0;
>+ output(c);
>+ out_count ++;
>+ if (out_count >= out_bump)
>+  { out_bits ++;
>+    out_bump += 1 << (out_bits - 1);
>+  }
>+ if (out_count >= out_clear)
>+  { output(code_clear);
>+    did_clear();
>+  }
>+}
>+
>+static unsigned int isqrt(unsigned int x)
>+{
>+ unsigned int r;
>+ unsigned int v;
>+
>+ if (x < 2) return(x);
>+ for (v=x,r=1;v;v>>=2,r<<=1) ;
>+ while (1)
>+  { v = ((x / r) + r) / 2;
>+    if ((v == r) || (v == r+1)) return(r);
>+    r = v;
>+  }
>+}
>+
>+static unsigned int compute_triangle_count(unsigned int count, unsigned int nrepcodes)
>+{
>+ unsigned int perrep;
>+ unsigned int cost;
>+
>+ cost = 0;
>+ perrep = (nrepcodes * (nrepcodes+1)) / 2;
>+ while (count >= perrep)
>+  { cost += nrepcodes;
>+    count -= perrep;
>+  }
>+ if (count > 0)
>+  { unsigned int n;
>+    n = isqrt(count);
>+    while ((n*(n+1)) >= 2*count) n --;
>+    while ((n*(n+1)) < 2*count) n ++;
>+    cost += n;
>+  }
>+ return(cost);
>+}
>+
>+static void max_out_clear(void)
>+{
>+ out_clear = max_ocodes;
>+}
>+
>+static void reset_out_clear(void)
>+{
>+ out_clear = out_clear_init;
>+ if (out_count >= out_clear)
>+  { output(code_clear);
>+    did_clear();
>+  }
>+}
>+
>+static void rl_flush_fromclear(int count)
>+{
>+ int n;
>+
>+ if (VERBOSE) printf("rl_flush_fromclear %d\n",count);
>+ max_out_clear();
>+ rl_table_pixel = rl_pixel;
>+ n = 1;
>+ while (count > 0)
>+  { if (n == 1)
>+     { rl_table_max = 1;
>+       output_plain(rl_pixel);
>+       count --;
>+     }
>+    else if (count >= n)
>+     { rl_table_max = n;
>+       output_plain(rl_basecode+n-2);
>+       count -= n;
>+     }
>+    else if (count == 1)
>+     { rl_table_max ++;
>+       output_plain(rl_pixel);
>+       count = 0;
>+     }
>+    else
>+     { rl_table_max ++;
>+       output_plain(rl_basecode+count-2);
>+       count = 0;
>+     }
>+    if (out_count == 0) n = 1; else n ++;
>+  }
>+ reset_out_clear();
>+ if (VERBOSE) printf("rl_flush_fromclear leaving table_max=%d\n",rl_table_max);
>+}
>+
>+static void rl_flush_clearorrep(int count)
>+{
>+ int withclr;
>+
>+ if (VERBOSE) printf("rl_flush_clearorrep %d\n",count);
>+ withclr = 1 + compute_triangle_count(count,max_ocodes);
>+ if (withclr < count)
>+  { output(code_clear);
>+    did_clear();
>+    rl_flush_fromclear(count);
>+  }
>+ else
>+  { for (;count>0;count--) output_plain(rl_pixel);
>+  }
>+}
>+
>+static void rl_flush_withtable(int count)
>+{
>+ int repmax;
>+ int repleft;
>+ int leftover;
>+
>+ if (VERBOSE) printf("rl_flush_withtable %d\n",count);
>+ repmax = count / rl_table_max;
>+ leftover = count % rl_table_max;
>+ repleft = (leftover ? 1 : 0);
>+ if (out_count+repmax+repleft > max_ocodes)
>+  { repmax = max_ocodes - out_count;
>+    leftover = count - (repmax * rl_table_max);
>+    repleft = 1 + compute_triangle_count(leftover,max_ocodes);
>+  }
>+ if (VERBOSE) printf("rl_flush_withtable repmax=%d leftover=%d repleft=%d\n",repmax,leftover,repleft);
>+ if (1+compute_triangle_count(count,max_ocodes) < repmax+repleft)
>+  { output(code_clear);
>+    did_clear();
>+    rl_flush_fromclear(count);
>+    return;
>+  }
>+ max_out_clear();
>+ for (;repmax>0;repmax--) output_plain(rl_basecode+rl_table_max-2);
>+ if (leftover)
>+  { if (just_cleared)
>+     { rl_flush_fromclear(leftover);
>+     }
>+    else if (leftover == 1)
>+     { output_plain(rl_pixel);
>+     }
>+    else
>+     { output_plain(rl_basecode+leftover-2);
>+     }
>+  }
>+ reset_out_clear();
>+}
>+
>+static void rl_flush(void)
>+{
>+ /* UNUSED int table_reps; */
>+ /* UNUSED int table_extra; */
>+
>+ if (VERBOSE) printf("rl_flush [ %d %d\n",rl_count,rl_pixel);
>+ if (rl_count == 1)
>+  { output_plain(rl_pixel);
>+    rl_count = 0;
>+    if (VERBOSE) printf("rl_flush ]\n");
>+    return;
>+  }
>+ if (just_cleared)
>+  { rl_flush_fromclear(rl_count);
>+  }
>+ else if ((rl_table_max < 2) || (rl_table_pixel != rl_pixel))
>+  { rl_flush_clearorrep(rl_count);
>+  }
>+ else
>+  { rl_flush_withtable(rl_count);
>+  }
>+ if (VERBOSE) printf("rl_flush ]\n");
>+ rl_count = 0;
>+}
>+
>+static void GIFcompress(int init_bits, gdIOCtx *outfile, gdImagePtr im, int background)
>+{
>+ int c;
>+
>+ ofile = outfile;
>+ obuf = 0;
>+ obits = 0;
>+ oblen = 0;
>+ code_clear = 1 << (init_bits - 1);
>+ code_eof = code_clear + 1;
>+ rl_basecode = code_eof + 1;
>+ out_bump_init = (1 << (init_bits - 1)) - 1;
>+ /* for images with a lot of runs, making out_clear_init larger will
>+    give better compression. */ 
>+ out_clear_init = (init_bits <= 3) ? 9 : (out_bump_init-1);
>+#ifdef DEBUGGING_ENVARS
>+  { const char *ocienv;
>+    ocienv = getenv("GIF_OUT_CLEAR_INIT");
>+    if (ocienv)
>+     { out_clear_init = atoi(ocienv);
>+       if (VERBOSE) printf("[overriding out_clear_init to %d]\n",out_clear_init);
>+     }
>+  }
>+#endif
>+ out_bits_init = init_bits;
>+ max_ocodes = (1 << GIFBITS) - ((1 << (out_bits_init - 1)) + 3);
>+ did_clear();
>+ output(code_clear);
>+ rl_count = 0;
>+ while (1)
>+  { c = GIFNextPixel(im);
>+    if ((rl_count > 0) && (c != rl_pixel)) rl_flush();
>+    if (c == EOF) break;
>+    if (rl_pixel == c)
>+     { rl_count ++;
>+     }
>+    else
>+     { rl_pixel = c;
>+       rl_count = 1;
>+     }
>+  }
>+ output(code_eof);
>+ output_flush();
>+}
>+
>+/*-----------------------------------------------------------------------
>+ *
>+ * End of miGIF section  - See copyright notice at start of section.
>+ *
>+ *-----------------------------------------------------------------------
>+*/
>+
>+/******************************************************************************
>+ *
>+ * GIF Specific routines
>+ *
>+ ******************************************************************************/
>+
>+/*
>+ * Number of characters so far in this 'packet'
>+ */
>+static int a_count;
>+
>+/*
>+ * Set up the 'byte output' routine
>+ */
>+
>+/* UNUSED
>+* static void
>+* char_init(void)
>+* {
>+*        a_count = 0;
>+* }
>+*/
>+
>+/*
>+ * Define the storage for the packet accumulator
>+ */
>+
>+/* UNUSED static char accum[ 256 ]; */
>+
>+static void init_statics(void) {
>+	/* Some of these are properly initialized later. What I'm doing
>+		here is making sure code that depends on C's initialization
>+		of statics doesn't break when the code gets called more
>+		than once. */
>+	Width = 0;
>+	Height = 0;
>+	curx = 0;
>+	cury = 0;
>+	CountDown = 0;
>+	Pass = 0;
>+	Interlace = 0;
>+	a_count = 0;
>+}
>+
>+
>+/* +-------------------------------------------------------------------+ */
>+/* | Copyright 1990, 1991, 1993, David Koblas.  (koblas@netcom.com)    | */
>+/* |   Permission to use, copy, modify, and distribute this software   | */
>+/* |   and its documentation for any purpose and without fee is hereby | */
>+/* |   granted, provided that the above copyright notice appear in all | */
>+/* |   copies and that both that copyright notice and this permission  | */
>+/* |   notice appear in supporting documentation.  This software is    | */
>+/* |   provided "as is" without express or implied warranty.           | */
>+/* +-------------------------------------------------------------------+ */
>+
>diff -urN /usr/ports/graphics/gd/files/gd_gif_in.c graphics/gd/files/gd_gif_in.c
>--- /usr/ports/graphics/gd/files/gd_gif_in.c	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/gd_gif_in.c	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,573 @@
>+#include <stdio.h>
>+#include <math.h>
>+#include <string.h>
>+#include <stdlib.h>
>+#include "gd.h"
>+
>+/* Used only when debugging GIF compression code */
>+/* #define DEBUGGING_ENVARS */
>+
>+#ifdef DEBUGGING_ENVARS
>+
>+static int verbose_set = 0;
>+static int verbose;
>+#define VERBOSE (verbose_set?verbose:set_verbose())
>+
>+static int set_verbose(void)
>+{
>+ verbose = !!getenv("GIF_VERBOSE");
>+ verbose_set = 1;
>+ return(verbose);
>+}
>+
>+#else
>+
>+#define VERBOSE 0
>+
>+#endif
>+
>+
>+#define        MAXCOLORMAPSIZE         256
>+
>+#define        TRUE    1
>+#define        FALSE   0
>+
>+#define CM_RED         0
>+#define CM_GREEN       1
>+#define CM_BLUE                2
>+
>+#define        MAX_LWZ_BITS            12
>+
>+#define INTERLACE              0x40
>+#define LOCALCOLORMAP  0x80
>+#define BitSet(byte, bit)      (((byte) & (bit)) == (bit))
>+
>+#define        ReadOK(file,buffer,len) (gdGetBuf(buffer, len, file) != 0)
>+
>+#define LM_to_uint(a,b)                        (((b)<<8)|(a))
>+
>+/* 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;
>+} GifScreen;
>+#endif
>+
>+static struct {
>+       int     transparent;
>+       int     delayTime;
>+       int     inputFlag;
>+       int     disposal;
>+} Gif89 = { -1, -1, -1, 0 };
>+
>+static int ReadColorMap (gdIOCtx *fd, int number, unsigned char (*buffer)[256]);
>+static int DoExtension (gdIOCtx *fd, int label, int *Transparent);
>+static int GetDataBlock (gdIOCtx *fd, unsigned char *buf);
>+static int GetCode (gdIOCtx *fd, int code_size, int flag);
>+static int LWZReadByte (gdIOCtx *fd, int flag, int input_code_size);
>+
>+static void ReadImage (gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace); /*1.4//, int ignore); */
>+
>+int ZeroDataBlock;
>+
>+gdImagePtr gdImageCreateFromGifSource(gdSourcePtr inSource)
>+{
>+        gdIOCtx         *in = gdNewSSCtx(inSource, NULL);
>+        gdImagePtr      im;
>+
>+        im = gdImageCreateFromGifCtx(in);
>+
>+        in->gd_free(in);
>+
>+        return im;
>+}
>+
>+gdImagePtr
>+gdImageCreateFromGif(FILE *fdFile)
>+{
>+        gdIOCtx		*fd = gdNewFileCtx(fdFile);
>+        gdImagePtr    	im = 0;
>+
>+        im = gdImageCreateFromGifCtx(fd);
>+
>+        fd->gd_free(fd);
>+
>+        return im;
>+}
>+
>+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)) {
>+		return 0;
>+	}
>+       if (strncmp((char *)buf,"GIF",3) != 0) {
>+		return 0;
>+	}
>+       strncpy(version, (char *)buf + 3, 3);
>+       version[3] = '\0';
>+
>+       if ((strcmp(version, "87a") != 0) && (strcmp(version, "89a") != 0)) {
>+		return 0;
>+	}
>+       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];
>+
>+       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 */
>+			goto terminated;
>+	       }
>+
>+               if (c == '!') {         /* Extension */
>+                       if (! ReadOK(fd,&c,1)) {
>+                               return 0;
>+                       }
>+                       DoExtension(fd, c, &Transparent);
>+                       continue;
>+               }
>+
>+               if (c != ',') {         /* Not a valid start character */
>+                       continue;
>+               }
>+
>+               /*1.4//++imageCount; */
>+
>+               if (! ReadOK(fd,buf,9)) {
>+	               return 0;
>+               }
>+
>+               useGlobalColormap = ! BitSet(buf[8], LOCALCOLORMAP);
>+
>+               bitPixel = 1<<((buf[8]&0x07)+1);
>+
>+               imw = LM_to_uint(buf[4],buf[5]);
>+               imh = LM_to_uint(buf[6],buf[7]);
>+	       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;
>+       }
>+
>+terminated:
>+       /* Terminator before any image was declared! */
>+       if (!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--) {
>+		if (im->open[i]) {
>+                	im->colorsTotal--;
>+                } else {
>+                	break;
>+                }
>+       } 
>+       return im;
>+}
>+
>+static int
>+ReadColorMap(gdIOCtx *fd, int number, unsigned char (*buffer)[256])
>+{
>+       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] ;
>+       }
>+
>+
>+       return FALSE;
>+}
>+
>+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 int
>+GetDataBlock_(gdIOCtx *fd, unsigned char *buf)
>+{
>+       unsigned char   count;
>+
>+       if (! ReadOK(fd,&count,1)) {
>+               return -1;
>+       }
>+
>+       ZeroDataBlock = count == 0;
>+
>+       if ((count != 0) && (! ReadOK(fd, buf, count))) {
>+               return -1;
>+       }
>+
>+       return count;
>+}
>+
>+static int
>+GetDataBlock(gdIOCtx *fd, unsigned char *buf)
>+{
>+ int rv;
>+ int i;
>+
>+ rv = GetDataBlock_(fd,buf);
>+ if (VERBOSE)
>+  { printf("[GetDataBlock returning %d",rv);
>+    if (rv > 0)
>+     { printf(":");
>+       for (i=0;i<rv;i++) printf(" %02x",buf[i]);
>+     }
>+    printf("]\n");
>+  }
>+ return(rv);
>+}
>+
>+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 int
>+GetCode(gdIOCtx *fd, int code_size, int flag)
>+{
>+ int rv;
>+
>+ rv = GetCode_(fd,code_size,flag);
>+ if (VERBOSE) printf("[GetCode(,%d,%d) returning %d]\n",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      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)
>+{
>+ int rv;
>+
>+ rv = LWZReadByte_(fd,flag,input_code_size);
>+ if (VERBOSE) printf("[LWZReadByte(,%d,%d) returning %d]\n",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) */
>+{
>+       unsigned char   c;      
>+       int             v;
>+       int             xpos = 0, ypos = 0, pass = 0;
>+       int i;
>+       /* 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;
>+       /*
>+       **  Initialize the Compression routines
>+       */
>+       if (! ReadOK(fd,&c,1)) {
>+               return; 
>+       }
>+       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;
>+       }
>+
>+fini:
>+       if (LWZReadByte(fd,FALSE,c)>=0) {
>+               /* Ignore extra */
>+       }
>+}
>+
>diff -urN /usr/ports/graphics/gd/files/gd_gif_out.c graphics/gd/files/gd_gif_out.c
>--- /usr/ports/graphics/gd/files/gd_gif_out.c	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/gd_gif_out.c	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,46 @@
>+#include <stdio.h>
>+#include <math.h>
>+#include <string.h>
>+#include <stdlib.h>
>+#include "gd.h"
>+
>+/*
>+** Wrapper functions for GIF output.
>+*/
>+
>+#define LZW_LICENCED
>+
>+void gdImageGifToSink(gdImagePtr im, gdSinkPtr outSink)
>+{
>+        gdIOCtx   *out = gdNewSSCtx(NULL,outSink);
>+        gdImageGifCtx(im, out);
>+        out->gd_free(out);
>+}
>+
>+void gdImageGifCtx(gdImagePtr im, gdIOCtx *out)
>+{
>+#ifdef LZW_LICENCED
>+	gdImageLzwCtx(im, out);
>+#else
>+        gdImageBigGifCtx(im, out);
>+#endif
>+}
>+
>+void gdImageGif(gdImagePtr im, FILE *outFile)
>+{
>+#ifdef LZW_LICENCED
>+        gdImageLzw(im, outFile);
>+#else
>+        gdImageBigGif(im, outFile);
>+#endif
>+}
>+
>+void* gdImageGifPtr(gdImagePtr im, int *size)
>+{
>+#ifdef LZW_LICENCED
>+        return gdImageLzwPtr(im, size);
>+#else
>+        return gdImageBigGifPtr(im, size);
>+#endif
>+}
>+
>diff -urN /usr/ports/graphics/gd/files/gd_lzw_out.c graphics/gd/files/gd_lzw_out.c
>--- /usr/ports/graphics/gd/files/gd_lzw_out.c	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/gd_lzw_out.c	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,795 @@
>+#include <stdio.h>
>+#include <math.h>
>+#include <string.h>
>+#include <stdlib.h>
>+#include "gd.h"
>+
>+/* Code drawn from ppmtogif.c, from the pbmplus package
>+**
>+** Based on GIFENCOD by David Rowley <mgardi@watdscu.waterloo.edu>. A
>+** Lempel-Zim compression based on "compress".
>+**
>+** Modified by Marcel Wijkstra <wijkstra@fwi.uva.nl>
>+**
>+** Copyright (C) 1989 by Jef Poskanzer.
>+**
>+** Permission to use, copy, modify, and distribute this software and its
>+** documentation for any purpose and without fee is hereby granted, provided
>+** that the above copyright notice appear in all copies and that both that
>+** copyright notice and this permission notice appear in supporting
>+** documentation.  This software is provided "as is" without express or
>+** implied warranty.
>+**
>+** The Graphics Interchange Format(c) is the Copyright property of
>+** CompuServe Incorporated.  GIF(sm) is a Service Mark property of
>+** CompuServe Incorporated.
>+*/
>+
>+/*
>+ * a code_int must be able to hold 2**GIFBITS values of type int, and also -1
>+ */
>+typedef int             code_int;
>+
>+#ifdef SIGNED_COMPARE_SLOW
>+typedef unsigned long int count_int;
>+typedef unsigned short int count_short;
>+#else /*SIGNED_COMPARE_SLOW*/
>+typedef long int          count_int;
>+#endif /*SIGNED_COMPARE_SLOW*/
>+
>+static int colorstobpp(int colors);
>+static void BumpPixel (void);
>+static int GIFNextPixel (gdImagePtr im);
>+static void GIFEncode (gdIOCtx *fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im);
>+/*static void Putword (int w, gdIOCtx *fp); */
>+static void compress (int init_bits, gdIOCtx *outfile, gdImagePtr im);
>+static void output (code_int code);
>+static void cl_block (void);
>+static void cl_hash (register count_int hsize);
>+static void char_init (void);
>+static void char_out (int c);
>+static void flush_char (void);
>+/* Allows for reuse */
>+static void init_statics(void);
>+
>+void gdImageLzwCtx(gdImagePtr im, gdIOCtx *out)
>+{
>+	int interlace, transparent, BitsPerPixel;
>+
>+	interlace = im->interlace;
>+	transparent = im->transparent;
>+
>+	BitsPerPixel = colorstobpp(im->colorsTotal);
>+	/* Clear any old values in statics strewn through the GIF code */
>+	init_statics();
>+	/* All set, let's do it. */
>+	GIFEncode(
>+		out, im->sx, im->sy, interlace, 0, transparent, BitsPerPixel,
>+		im->red, im->green, im->blue, im);
>+}
>+
>+void gdImageLzw(gdImagePtr im, FILE *outFile)
>+{
>+        gdIOCtx   *out = gdNewFileCtx(outFile);
>+        gdImageLzwCtx(im, out);
>+        out->gd_free(out);
>+}
>+
>+void* gdImageLzwPtr(gdImagePtr im, int *size)
>+{
>+	void	*rv;
>+        gdIOCtx   *out = gdNewDynamicCtx(2048, NULL);
>+        gdImageLzwCtx(im, out);
>+        rv = gdDPExtractData(out,size);
>+	out->gd_free(out);
>+	return rv;
>+}
>+
>+
>+
>+static int
>+colorstobpp(int colors)
>+{
>+    int bpp = 0;
>+
>+    if ( colors <= 2 )
>+        bpp = 1;
>+    else if ( colors <= 4 )
>+        bpp = 2;
>+    else if ( colors <= 8 )
>+        bpp = 3;
>+    else if ( colors <= 16 )
>+        bpp = 4;
>+    else if ( colors <= 32 )
>+        bpp = 5;
>+    else if ( colors <= 64 )
>+        bpp = 6;
>+    else if ( colors <= 128 )
>+        bpp = 7;
>+    else if ( colors <= 256 )
>+        bpp = 8;
>+    return bpp;
>+    }
>+
>+/*****************************************************************************
>+ *
>+ * GIFENCODE.C    - GIF Image compression interface
>+ *
>+ * GIFEncode( FName, GHeight, GWidth, GInterlace, Background, Transparent,
>+ *            BitsPerPixel, Red, Green, Blue, gdImagePtr )
>+ *
>+ *****************************************************************************/
>+
>+#define TRUE 1
>+#define FALSE 0
>+
>+static int Width, Height;
>+static int curx, cury;
>+static long CountDown;
>+static int Pass = 0;
>+static int Interlace;
>+
>+/*
>+ * Bump the 'curx' and 'cury' to point to the next pixel
>+ */
>+static void
>+BumpPixel(void)
>+{
>+        /*
>+         * Bump the current X position
>+         */
>+        ++curx;
>+
>+        /*
>+         * If we are at the end of a scan line, set curx back to the beginning
>+         * If we are interlaced, bump the cury to the appropriate spot,
>+         * otherwise, just increment it.
>+         */
>+        if( curx == Width ) {
>+                curx = 0;
>+
>+                if( !Interlace )
>+                        ++cury;
>+                else {
>+                     switch( Pass ) {
>+
>+                       case 0:
>+                          cury += 8;
>+                          if( cury >= Height ) {
>+                                ++Pass;
>+                                cury = 4;
>+                          }
>+                          break;
>+
>+                       case 1:
>+                          cury += 8;
>+                          if( cury >= Height ) {
>+                                ++Pass;
>+                                cury = 2;
>+                          }
>+                          break;
>+
>+                       case 2:
>+                          cury += 4;
>+                          if( cury >= Height ) {
>+                             ++Pass;
>+                             cury = 1;
>+                          }
>+                          break;
>+
>+                       case 3:
>+                          cury += 2;
>+                          break;
>+                        }
>+                }
>+        }
>+}
>+
>+/*
>+ * Return the next pixel from the image
>+ */
>+static int
>+GIFNextPixel(gdImagePtr im)
>+{
>+        int r;
>+
>+        if( CountDown == 0 )
>+                return EOF;
>+
>+        --CountDown;
>+
>+        r = gdImageGetPixel(im, curx, cury);
>+
>+        BumpPixel();
>+
>+        return r;
>+}
>+
>+/* public */
>+
>+static void
>+GIFEncode(gdIOCtx *fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im)
>+{
>+        int B;
>+        int RWidth, RHeight;
>+        int LeftOfs, TopOfs;
>+        int Resolution;
>+        int ColorMapSize;
>+        int InitCodeSize;
>+        int i;
>+
>+        Interlace = GInterlace;
>+
>+        ColorMapSize = 1 << BitsPerPixel;
>+
>+        RWidth = Width = GWidth;
>+        RHeight = Height = GHeight;
>+        LeftOfs = TopOfs = 0;
>+
>+        Resolution = BitsPerPixel;
>+
>+        /*
>+         * Calculate number of bits we are expecting
>+         */
>+        CountDown = (long)Width * (long)Height;
>+
>+        /*
>+         * Indicate which pass we are on (if interlace)
>+         */
>+        Pass = 0;
>+
>+        /*
>+         * The initial code size
>+         */
>+        if( BitsPerPixel <= 1 )
>+                InitCodeSize = 2;
>+        else
>+                InitCodeSize = BitsPerPixel;
>+
>+        /*
>+         * Set up the current x and y position
>+         */
>+        curx = cury = 0;
>+
>+        /*
>+         * Write the Magic header
>+         */
>+        gdPutBuf( Transparent < 0 ? "GIF87a" : "GIF89a", 6, fp );
>+
>+        /*
>+         * Write out the screen width and height
>+         */
>+        Putword( RWidth, fp );
>+        Putword( RHeight, fp );
>+
>+        /*
>+         * Indicate that there is a global colour map
>+         */
>+        B = 0x80;       /* Yes, there is a color map */
>+
>+        /*
>+         * OR in the resolution
>+         */
>+        B |= (Resolution - 1) << 5;
>+
>+        /*
>+         * OR in the Bits per Pixel
>+         */
>+        B |= (BitsPerPixel - 1);
>+
>+        /*
>+         * Write it out
>+         */
>+        gdPutC( B, fp );
>+
>+        /*
>+         * Write out the Background colour
>+         */
>+        gdPutC( Background, fp );
>+
>+        /*
>+         * Byte of 0's (future expansion)
>+         */
>+        gdPutC( 0, fp );
>+
>+        /*
>+         * Write out the Global Colour Map
>+         */
>+        for( i=0; i<ColorMapSize; ++i ) {
>+                gdPutC( Red[i], fp );
>+                gdPutC( Green[i], fp );
>+                gdPutC( Blue[i], fp );
>+        }
>+
>+	/*
>+	 * Write out extension for transparent colour index, if necessary.
>+	 */
>+	if ( Transparent >= 0 ) {
>+	    gdPutC( '!', fp );
>+	    gdPutC( 0xf9, fp );
>+	    gdPutC( 4, fp );
>+	    gdPutC( 1, fp );
>+	    gdPutC( 0, fp );
>+	    gdPutC( 0, fp );
>+	    gdPutC( (unsigned char) Transparent, fp );
>+	    gdPutC( 0, fp );
>+	}
>+
>+        /*
>+         * Write an Image separator
>+         */
>+        gdPutC( ',', fp );
>+
>+        /*
>+         * Write the Image header
>+         */
>+
>+        Putword( LeftOfs, fp );
>+        Putword( TopOfs, fp );
>+        Putword( Width, fp );
>+        Putword( Height, fp );
>+
>+        /*
>+         * Write out whether or not the image is interlaced
>+         */
>+        if( Interlace )
>+                gdPutC( 0x40, fp );
>+        else
>+                gdPutC( 0x00, fp );
>+
>+        /*
>+         * Write out the initial code size
>+         */
>+        gdPutC( InitCodeSize, fp );
>+
>+        /*
>+         * Go and actually compress the data
>+         */
>+        compress( InitCodeSize+1, fp, im );
>+
>+        /*
>+         * Write out a Zero-length packet (to end the series)
>+         */
>+        gdPutC( 0, fp );
>+
>+        /*
>+         * Write the GIF file terminator
>+         */
>+        gdPutC( ';', fp );
>+}
>+
>+/* */
>+/* * Write out a word to the GIF file */
>+/* */
>+/*static void */
>+/*Putword(int w, FILE *fp) */
>+/*{ */
>+/*        fputc( w & 0xff, fp ); */
>+/*        fputc( (w / 256) & 0xff, fp ); */
>+/*} */
>+
>+
>+/***************************************************************************
>+ *
>+ *  GIFCOMPR.C       - GIF Image compression routines
>+ *
>+ *  Lempel-Ziv compression based on 'compress'.  GIF modifications by
>+ *  David Rowley (mgardi@watdcsu.waterloo.edu)
>+ *
>+ ***************************************************************************/
>+
>+/*
>+ * General DEFINEs
>+ */
>+
>+#define GIFBITS    12
>+
>+#define HSIZE  5003            /* 80% occupancy */
>+
>+#ifdef NO_UCHAR
>+ typedef char   char_type;
>+#else /*NO_UCHAR*/
>+ typedef        unsigned char   char_type;
>+#endif /*NO_UCHAR*/
>+
>+/*
>+ *
>+ * GIF Image compression - modified 'compress'
>+ *
>+ * Based on: compress.c - File compression ala IEEE Computer, June 1984.
>+ *
>+ * By Authors:  Spencer W. Thomas       (decvax!harpo!utah-cs!utah-gr!thomas)
>+ *              Jim McKie               (decvax!mcvax!jim)
>+ *              Steve Davies            (decvax!vax135!petsd!peora!srd)
>+ *              Ken Turkowski           (decvax!decwrl!turtlevax!ken)
>+ *              James A. Woods          (decvax!ihnp4!ames!jaw)
>+ *              Joe Orost               (decvax!vax135!petsd!joe)
>+ *
>+ */
>+#include <ctype.h>
>+
>+#define ARGVAL() (*++(*argv) || (--argc && *++argv))
>+
>+static int n_bits;                        /* number of bits/code */
>+static int maxbits = GIFBITS;                /* user settable max # bits/code */
>+static code_int maxcode;                  /* maximum code, given n_bits */
>+static code_int maxmaxcode = (code_int)1 << GIFBITS; /* should NEVER generate this code */
>+#ifdef COMPATIBLE               /* But wrong! */
>+# define MAXCODE(n_bits)        ((code_int) 1 << (n_bits) - 1)
>+#else /*COMPATIBLE*/
>+# define MAXCODE(n_bits)        (((code_int) 1 << (n_bits)) - 1)
>+#endif /*COMPATIBLE*/
>+
>+static count_int htab [HSIZE];
>+static unsigned short codetab [HSIZE];
>+#define HashTabOf(i)       htab[i]
>+#define CodeTabOf(i)    codetab[i]
>+
>+static code_int hsize = HSIZE;                 /* for dynamic table sizing */
>+
>+/*
>+ * To save much memory, we overlay the table used by compress() with those
>+ * used by decompress().  The tab_prefix table is the same size and type
>+ * as the codetab.  The tab_suffix table needs 2**GIFBITS characters.  We
>+ * get this from the beginning of htab.  The output stack uses the rest
>+ * of htab, and contains characters.  There is plenty of room for any
>+ * possible stack (stack used to be 8000 characters).
>+ */
>+
>+#define tab_prefixof(i) CodeTabOf(i)
>+#define tab_suffixof(i)        ((char_type*)(htab))[i]
>+#define de_stack               ((char_type*)&tab_suffixof((code_int)1<<GIFBITS))
>+
>+static code_int free_ent = 0;                  /* first unused entry */
>+
>+/*
>+ * block compression parameters -- after all codes are used up,
>+ * and compression rate changes, start over.
>+ */
>+static int clear_flg = 0;
>+
>+static int offset;
>+static long int in_count = 1;            /* length of input */
>+static long int out_count = 0;           /* # of codes output (for debugging) */
>+
>+/*
>+ * compress stdin to stdout
>+ *
>+ * Algorithm:  use open addressing double hashing (no chaining) on the
>+ * prefix code / next character combination.  We do a variant of Knuth's
>+ * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
>+ * secondary probe.  Here, the modular division first probe is gives way
>+ * to a faster exclusive-or manipulation.  Also do block compression with
>+ * an adaptive reset, whereby the code table is cleared when the compression
>+ * ratio decreases, but after the table fills.  The variable-length output
>+ * codes are re-sized at this point, and a special CLEAR code is generated
>+ * for the decompressor.  Late addition:  construct the table according to
>+ * file size for noticeable speed improvement on small files.  Please direct
>+ * questions about this implementation to ames!jaw.
>+ */
>+
>+static int g_init_bits;
>+static gdIOCtx* g_outfile;
>+
>+static int ClearCode;
>+static int EOFCode;
>+
>+static void
>+compress(int init_bits, gdIOCtx *outfile, gdImagePtr im)
>+{
>+    register long fcode;
>+    register code_int i /* = 0 */;
>+    register int c;
>+    register code_int ent;
>+    register code_int disp;
>+    register code_int hsize_reg;
>+    register int hshift;
>+
>+    /*
>+     * Set up the globals:  g_init_bits - initial number of bits
>+     *                      g_outfile   - pointer to output file
>+     */
>+    g_init_bits = init_bits;
>+    g_outfile = outfile;
>+
>+    /*
>+     * Set up the necessary values
>+     */
>+    offset = 0;
>+    out_count = 0;
>+    clear_flg = 0;
>+    in_count = 1;
>+    maxcode = MAXCODE(n_bits = g_init_bits);
>+
>+    ClearCode = (1 << (init_bits - 1));
>+    EOFCode = ClearCode + 1;
>+    free_ent = ClearCode + 2;
>+
>+    char_init();
>+
>+    ent = GIFNextPixel( im );
>+
>+    hshift = 0;
>+    for ( fcode = (long) hsize;  fcode < 65536L; fcode *= 2L )
>+        ++hshift;
>+    hshift = 8 - hshift;                /* set hash code range bound */
>+
>+    hsize_reg = hsize;
>+    cl_hash( (count_int) hsize_reg);            /* clear hash table */
>+
>+    output( (code_int)ClearCode );
>+
>+#ifdef SIGNED_COMPARE_SLOW
>+    while ( (c = GIFNextPixel( im )) != (unsigned) EOF ) {
>+#else /*SIGNED_COMPARE_SLOW*/
>+    while ( (c = GIFNextPixel( im )) != EOF ) {  /* } */
>+#endif /*SIGNED_COMPARE_SLOW*/
>+
>+        ++in_count;
>+
>+        fcode = (long) (((long) c << maxbits) + ent);
>+        i = (((code_int)c << hshift) ^ ent);    /* xor hashing */
>+
>+        if ( HashTabOf (i) == fcode ) {
>+            ent = CodeTabOf (i);
>+            continue;
>+        } else if ( (long)HashTabOf (i) < 0 )      /* empty slot */
>+            goto nomatch;
>+        disp = hsize_reg - i;           /* secondary hash (after G. Knott) */
>+        if ( i == 0 )
>+            disp = 1;
>+probe:
>+        if ( (i -= disp) < 0 )
>+            i += hsize_reg;
>+
>+        if ( HashTabOf (i) == fcode ) {
>+            ent = CodeTabOf (i);
>+            continue;
>+        }
>+        if ( (long)HashTabOf (i) > 0 )
>+            goto probe;
>+nomatch:
>+        output ( (code_int) ent );
>+        ++out_count;
>+        ent = c;
>+#ifdef SIGNED_COMPARE_SLOW
>+        if ( (unsigned) free_ent < (unsigned) maxmaxcode) {
>+#else /*SIGNED_COMPARE_SLOW*/
>+        if ( free_ent < maxmaxcode ) {  /* } */
>+#endif /*SIGNED_COMPARE_SLOW*/
>+            CodeTabOf (i) = free_ent++; /* code -> hashtable */
>+            HashTabOf (i) = fcode;
>+        } else
>+                cl_block();
>+    }
>+    /*
>+     * Put out the final code.
>+     */
>+    output( (code_int)ent );
>+    ++out_count;
>+    output( (code_int) EOFCode );
>+}
>+
>+/*****************************************************************
>+ * TAG( output )
>+ *
>+ * Output the given code.
>+ * Inputs:
>+ *      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
>+ *              that n_bits =< (long)wordsize - 1.
>+ * Outputs:
>+ *      Outputs code to the file.
>+ * Assumptions:
>+ *      Chars are 8 bits long.
>+ * Algorithm:
>+ *      Maintain a GIFBITS character long buffer (so that 8 codes will
>+ * fit in it exactly).  Use the VAX insv instruction to insert each
>+ * code in turn.  When the buffer fills up empty it and start over.
>+ */
>+
>+static unsigned long cur_accum = 0;
>+static int cur_bits = 0;
>+
>+static unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
>+                                  0x001F, 0x003F, 0x007F, 0x00FF,
>+                                  0x01FF, 0x03FF, 0x07FF, 0x0FFF,
>+                                  0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
>+
>+static void
>+output(code_int code)
>+{
>+    cur_accum &= masks[ cur_bits ];
>+
>+    if( cur_bits > 0 )
>+        cur_accum |= ((long)code << cur_bits);
>+    else
>+        cur_accum = code;
>+
>+    cur_bits += n_bits;
>+
>+    while( cur_bits >= 8 ) {
>+        char_out( (unsigned int)(cur_accum & 0xff) );
>+        cur_accum >>= 8;
>+        cur_bits -= 8;
>+    }
>+
>+    /*
>+     * If the next entry is going to be too big for the code size,
>+     * then increase it, if possible.
>+     */
>+   if ( free_ent > maxcode || clear_flg ) {
>+
>+            if( clear_flg ) {
>+
>+                maxcode = MAXCODE (n_bits = g_init_bits);
>+                clear_flg = 0;
>+
>+            } else {
>+
>+                ++n_bits;
>+                if ( n_bits == maxbits )
>+                    maxcode = maxmaxcode;
>+                else
>+                    maxcode = MAXCODE(n_bits);
>+            }
>+        }
>+
>+    if( code == EOFCode ) {
>+        /*
>+         * At EOF, write the rest of the buffer.
>+         */
>+        while( cur_bits > 0 ) {
>+                char_out( (unsigned int)(cur_accum & 0xff) );
>+                cur_accum >>= 8;
>+                cur_bits -= 8;
>+        }
>+
>+        flush_char();
>+
>+/*        fflush( g_outfile ); */
>+/* */
>+/*        if( ferror( g_outfile ) ) */
>+/*		return; */
>+    }
>+}
>+
>+/*
>+ * Clear out the hash table
>+ */
>+static void
>+cl_block (void)             /* table clear for block compress */
>+{
>+
>+        cl_hash ( (count_int) hsize );
>+        free_ent = ClearCode + 2;
>+        clear_flg = 1;
>+
>+        output( (code_int)ClearCode );
>+}
>+
>+static void
>+cl_hash(register count_int hsize)          /* reset code table */
>+                         
>+{
>+
>+        register count_int *htab_p = htab+hsize;
>+
>+        register long i;
>+        register long m1 = -1;
>+
>+        i = hsize - 16;
>+        do {                            /* might use Sys V memset(3) here */
>+                *(htab_p-16) = m1;
>+                *(htab_p-15) = m1;
>+                *(htab_p-14) = m1;
>+                *(htab_p-13) = m1;
>+                *(htab_p-12) = m1;
>+                *(htab_p-11) = m1;
>+                *(htab_p-10) = m1;
>+                *(htab_p-9) = m1;
>+                *(htab_p-8) = m1;
>+                *(htab_p-7) = m1;
>+                *(htab_p-6) = m1;
>+                *(htab_p-5) = m1;
>+                *(htab_p-4) = m1;
>+                *(htab_p-3) = m1;
>+                *(htab_p-2) = m1;
>+                *(htab_p-1) = m1;
>+                htab_p -= 16;
>+        } while ((i -= 16) >= 0);
>+
>+        for ( i += 16; i > 0; --i )
>+                *--htab_p = m1;
>+}
>+
>+/******************************************************************************
>+ *
>+ * GIF Specific routines
>+ *
>+ ******************************************************************************/
>+
>+/*
>+ * Number of characters so far in this 'packet'
>+ */
>+static int a_count;
>+
>+/*
>+ * Set up the 'byte output' routine
>+ */
>+static void
>+char_init(void)
>+{
>+        a_count = 0;
>+}
>+
>+/*
>+ * Define the storage for the packet accumulator
>+ */
>+static char accum[ 256 ];
>+
>+/*
>+ * Add a character to the end of the current packet, and if it is 254
>+ * characters, flush the packet to disk.
>+ */
>+static void
>+char_out(int c)
>+{
>+        accum[ a_count++ ] = c;
>+        if( a_count >= 254 )
>+                flush_char();
>+}
>+
>+/*
>+ * Flush the packet to disk, and reset the accumulator
>+ */
>+static void
>+flush_char(void)
>+{
>+        if( a_count > 0 ) {
>+                gdPutC( a_count, g_outfile );
>+                gdPutBuf( accum, a_count, g_outfile );
>+                a_count = 0;
>+        }
>+}
>+
>+static void init_statics(void) {
>+	/* Some of these are properly initialized later. What I'm doing
>+		here is making sure code that depends on C's initialization
>+		of statics doesn't break when the code gets called more
>+		than once. */
>+	Width = 0;
>+	Height = 0;
>+	curx = 0;
>+	cury = 0;
>+	CountDown = 0;
>+	Pass = 0;
>+	Interlace = 0;
>+	a_count = 0;
>+	cur_accum = 0;
>+	cur_bits = 0;
>+	g_init_bits = 0;
>+	g_outfile = 0;
>+	ClearCode = 0;
>+	EOFCode = 0;
>+	free_ent = 0;
>+	clear_flg = 0;
>+	offset = 0;
>+	in_count = 1;
>+	out_count = 0;	
>+	hsize = HSIZE;
>+	n_bits = 0;
>+	maxbits = GIFBITS;
>+	maxcode = 0;
>+	maxmaxcode = (code_int)1 << GIFBITS;
>+}
>+
>+
>+/* +-------------------------------------------------------------------+ */
>+/* | Copyright 1990, 1991, 1993, David Koblas.  (koblas@netcom.com)    | */
>+/* |   Permission to use, copy, modify, and distribute this software   | */
>+/* |   and its documentation for any purpose and without fee is hereby | */
>+/* |   granted, provided that the above copyright notice appear in all | */
>+/* |   copies and that both that copyright notice and this permission  | */
>+/* |   notice appear in supporting documentation.  This software is    | */
>+/* |   provided "as is" without express or implied warranty.           | */
>+/* +-------------------------------------------------------------------+ */
>diff -urN /usr/ports/graphics/gd/files/gdcmpgif.c graphics/gd/files/gdcmpgif.c
>--- /usr/ports/graphics/gd/files/gdcmpgif.c	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/gdcmpgif.c	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,85 @@
>+#include <stdio.h>
>+#include <unistd.h> /* For unlink function */
>+#include "gd.h"
>+
>+/* A short program which converts a .png file into a .gd file, for
>+	your convenience in creating images on the fly from a
>+	basis image that must be loaded quickly. The .gd format
>+	is not intended to be a general-purpose format. */
>+
>+void CompareImages(char *msg, gdImagePtr im1, gdImagePtr im2);
>+
>+
>+int main(int argc, char **argv)
>+{
>+	gdImagePtr im1, im2;
>+	FILE *in;
>+
>+	if (argc != 3) {
>+		fprintf(stderr, "Usage: gdcmpgif filename.gif filename.gif\n");
>+		exit(1);
>+	}
>+	in = fopen(argv[1], "rb");
>+	if (!in) {
>+		fprintf(stderr, "Input file does not exist!\n");
>+		exit(1);
>+	}
>+	im1 = gdImageCreateFromGif(in);
>+	fclose(in);
>+
>+	if (!im1) {
>+		fprintf(stderr, "Input is not in GIF format!\n");
>+		exit(1);
>+	}
>+
>+	in = fopen(argv[2], "rb");
>+	if (!in) {
>+		fprintf(stderr, "Input file 2 does not exist!\n");
>+		exit(1);
>+	}
>+	im2 = gdImageCreateFromGif(in);
>+	fclose(in);
>+
>+	if (!im2) {
>+		fprintf(stderr, "Input 2 is not in GIF format!\n");
>+		exit(1);
>+	}
>+
>+	CompareImages("gdcmpgif", im1, im2);
>+
>+	gdImageDestroy(im1);
>+        gdImageDestroy(im2);
>+
>+	return 0;
>+}
>+
>+void CompareImages(char *msg, gdImagePtr im1, gdImagePtr im2)
>+{
>+	int cmpRes;
>+
>+	cmpRes = gdImageCompare(im1, im2);
>+
>+	if (cmpRes & GD_CMP_IMAGE) {
>+		printf("%%%s: ERROR images differ: BAD\n",msg);
>+	} else if (cmpRes != 0) {
>+		printf("%%%s: WARNING images differ: WARNING - Probably OK\n",msg);
>+	} else {
>+		printf("%%%s: OK\n",msg);
>+		return;
>+	}
>+
>+	if (cmpRes & (GD_CMP_SIZE_X + GD_CMP_SIZE_Y)) {
>+		printf("-%s: INFO image sizes differ\n",msg);
>+	}
>+
>+	if (cmpRes & GD_CMP_NUM_COLORS) {
>+		printf("-%s: INFO number of pallette entries differ %d Vs. %d\n",msg,
>+			im1->colorsTotal, im2->colorsTotal);
>+	}
>+
>+	if (cmpRes & GD_CMP_COLOR) {
>+		printf("-%s: INFO actual colours of pixels differ\n",msg);
>+	}
>+}
>+
>+
>diff -urN /usr/ports/graphics/gd/files/giftogd2.c graphics/gd/files/giftogd2.c
>--- /usr/ports/graphics/gd/files/giftogd2.c	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/giftogd2.c	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,48 @@
>+#include <stdio.h>
>+#include <stdlib.h>
>+
>+#include "gd.h"
>+
>+/* A short program which converts a .gif file into a .gd file, for
>+	your convenience in creating images on the fly from a
>+	basis image that must be loaded quickly. The .gd format
>+	is not intended to be a general-purpose format. */
>+
>+int main(int argc, char **argv)
>+{
>+	gdImagePtr im;
>+	FILE *in, *out;
>+	int	cs, fmt;
>+
>+	if (argc != 5) {
>+		fprintf(stderr, "Usage: giftogd2 filename.gif filename.gd2 cs fmt\n");
>+                fprintf(stderr, "    where cs is the chunk size\n");
>+		fprintf(stderr, "          fmt is 1 for raw, 2 for compressed\n");
>+		exit(1);
>+	}
>+	in = fopen(argv[1], "rb");
>+	if (!in) {
>+		fprintf(stderr, "Input file does not exist!\n");
>+		exit(1);
>+	}
>+	im = gdImageCreateFromGif(in);
>+	fclose(in);
>+	if (!im) {
>+		fprintf(stderr, "Input is not in GIF format!\n");
>+		exit(1);
>+	}
>+	out = fopen(argv[2], "wb");
>+	if (!out) {
>+		fprintf(stderr, "Output file cannot be written to!\n");
>+		gdImageDestroy(im);
>+		exit(1);	
>+	}
>+	cs = atoi(argv[3]);
>+	fmt = atoi(argv[4]);
>+	gdImageGd2(im, out, cs, fmt);
>+	fclose(out);
>+	gdImageDestroy(im);
>+
>+	return 0;
>+}
>+
>diff -urN /usr/ports/graphics/gd/files/patch-ac graphics/gd/files/patch-ac
>--- /usr/ports/graphics/gd/files/patch-ac	Sun Dec 16 13:14:31 2001
>+++ graphics/gd/files/patch-ac	Thu Jan  1 09:00:00 1970
>@@ -1,188 +0,0 @@
>---- Makefile.orig	Thu Feb 22 19:03:43 2001
>-+++ Makefile	Sun Dec 16 05:57:07 2001
>-@@ -3,22 +3,30 @@
>- #If you do not have gcc, change the setting for COMPILER, but you must
>- #use an ANSI standard C compiler (NOT the old SunOS 4.1.3 cc
>- #compiler; get gcc if you are still using it). 
>--COMPILER=gcc
>-+COMPILER=${CC}
>- 
>- #If the ar command fails on your system, consult the ar manpage
>- #for your system. 
>--AR=ar
>-+#AR=ar
>- 
>- #If you don't have FreeType, libjpeg and/or Xpm installed, including the
>- #header files, uncomment this (default). You really must install
>- #libpng and zlib to get anywhere if you wish to create PNG images.
>--CFLAGS=-O -DHAVE_LIBPNG -DHAVE_LIBJPEG
>-+CFLAGS+=-DHAVE_LIBPNG -DHAVE_LIBJPEG -DHAVE_LIBFREETYPE
>- 
>- #If you do have FreeType, libjpeg and/or Xpm fully installed, uncomment a
>- #variation of this and comment out the line above. See also LIBS below.
>- #CFLAGS=-O -DHAVE_LIBXPM -DHAVE_LIBPNG -DHAVE_LIBJPEG \
>- #	-DHAVE_LIBFREETYPE -DHAVE_LIBTTF 
>- 
>-+.if defined(WITH_X11)
>-+CFLAGS+=-DHAVE_XPM 
>-+.endif
>-+
>-+.if defined(JISX0208)
>-+CFLAGS+=-DJISX0208
>-+.endif
>-+
>- #To use the old FreeType 1.x library, add this additional #define
>- #to the line above
>- #-DHAVE_LIBTTF 
>-@@ -30,7 +38,7 @@
>- #Some systems are very picky about link order. They don't all agree
>- #on the right order, either.
>- 
>--LIBS=-lgd -lpng -lz -lm
>-+LIBS=-lgd -lpng -lz -ljpeg -lm `$(FREETYPE_CONFIG) --libs`
>- 
>- #If you do have FreeType, JPEG and/or Xpm fully installed, uncomment a 
>- #variation of this and comment out the line above. Note that
>-@@ -38,6 +46,10 @@
>- 
>- #LIBS=-lgd -lpng -lz -ljpeg -lfreetype -lm -lttf
>- 
>-+.if defined(WITH_X11)
>-+LIBS+=-lXpm -lX11
>-+.endif
>-+
>- #Note: for Freetype 1.x, use DHAVE_LIBTTF and -lttf instead.
>- 
>- #Typical install locations for freetype, zlib, xpm, libjpeg and libpng header 
>-@@ -45,7 +57,11 @@
>- #ensure that the version of gd you are installing is used, and not an 
>- #older release in your directory tree somewhere.
>- 
>--INCLUDEDIRS=-I. -I/usr/include/freetype2 -I/usr/include/X11 -I/usr/X11R6/include/X11 -I/usr/local/include 
>-+INCLUDEDIRS=-I. `$(FREETYPE_CONFIG) --cflags` -I${LOCALBASE}/include
>-+
>-+.if defined(WITH_X11)
>-+INCLUDEDIRS+=-I${X11BASE}/include/X11 -I${X11BASE}/include
>-+.endif
>- 
>- #Typical install locations for freetype, zlib, xpm and libpng libraries.
>- #If yours are somewhere else, other than a standard location
>-@@ -55,16 +71,20 @@
>- #on your system can't cause conflicts while building a new one.
>- #This line shouldn't hurt if you don't actually have some of the
>- #optional libraries and directories.
>--LIBDIRS=-L. -L/usr/local/lib -L/usr/lib/X11 -L/usr/X11R6/lib
>-+LIBDIRS=-L. -L${LOCALBASE}/lib -Wl,--rpath,${LOCALBASE}/lib
>-+
>-+.if defined(WITH_X11)
>-+LIBDIRS+=-L${X11BASE}/lib -Wl,--rpath,${X11BASE}/lib
>-+.endif
>- 
>- #Location where libgd.a should be installed by "make install".
>--INSTALL_LIB=/usr/local/lib
>-+INSTALL_LIB=${PREFIX}/lib
>- 
>- #Location where .h files should be installed by "make install".
>--INSTALL_INCLUDE=/usr/local/include
>-+INSTALL_INCLUDE=${PREFIX}/include/gd
>- 
>- #Location where useful non-test programs should be installed by "make install".
>--INSTALL_BIN=/usr/local/bin
>-+INSTALL_BIN=${PREFIX}/bin
>- 
>- #
>- #
>-@@ -74,34 +94,43 @@
>- 
>- VERSION=1.8.4
>- 
>--CC=$(COMPILER) $(INCLUDEDIRS)
>--LINK=$(CC) $(LIBDIRS) $(LIBS)
>-+CFLAGS+=$(INCLUDEDIRS)
>- 
>- PROGRAMS=$(BIN_PROGRAMS) $(TEST_PROGRAMS)
>- 
>- BIN_PROGRAMS=pngtogd pngtogd2 gdtopng gd2topng gd2copypal gdparttopng webpng
>- TEST_PROGRAMS=gdtest gddemo gd2time gdtestft gdtestttf
>- 
>--all: libgd.a $(PROGRAMS)
>-+SOVER=2
>-+
>-+.SUFFIXES: .c .so .o
>- 
>--install: libgd.a $(BIN_PROGRAMS)
>--	sh ./install-item 644 libgd.a $(INSTALL_LIB)/libgd.a
>--	sh ./install-item 755 pngtogd $(INSTALL_BIN)/pngtogd
>--	sh ./install-item 755 pngtogd2 $(INSTALL_BIN)/pngtogd2
>--	sh ./install-item 755 gdtopng $(INSTALL_BIN)/gdtopng
>--	sh ./install-item 755 gd2topng $(INSTALL_BIN)/gd2topng
>--	sh ./install-item 755 gd2copypal $(INSTALL_BIN)/gd2copypal
>--	sh ./install-item 755 gdparttopng $(INSTALL_BIN)/gdparttopng
>--	sh ./install-item 755 webpng $(INSTALL_BIN)/webpng
>--	sh ./install-item 755 bdftogd $(INSTALL_BIN)/bdftogd
>--	sh ./install-item 644 gd.h $(INSTALL_INCLUDE)/gd.h
>--	sh ./install-item 644 gdcache.h $(INSTALL_INCLUDE)/gdcache.h
>--	sh ./install-item 644 gd_io.h $(INSTALL_INCLUDE)/gd_io.h
>--	sh ./install-item 644 gdfontg.h $(INSTALL_INCLUDE)/gdfontg.h
>--	sh ./install-item 644 gdfontl.h $(INSTALL_INCLUDE)/gdfontl.h
>--	sh ./install-item 644 gdfontmb.h $(INSTALL_INCLUDE)/gdfontmb.h
>--	sh ./install-item 644 gdfonts.h $(INSTALL_INCLUDE)/gdfonts.h
>--	sh ./install-item 644 gdfontt.h $(INSTALL_INCLUDE)/gdfontt.h
>-+.c.so:
>-+	$(CC) -fpic -DPIC $(CFLAGS) -o $@ -c $<
>-+
>-+all: libgd.a libgd.so.$(SOVER) $(PROGRAMS)
>-+
>-+install: libgd.a libgd.so.$(SOVER) $(BIN_PROGRAMS)
>-+	-mkdir -p $(INSTALL_LIB) $(INSTALL_INCLUDE) $(INSTALL_BIN)
>-+	${BSD_INSTALL_DATA} libgd.a $(INSTALL_LIB)/libgd.a
>-+	${BSD_INSTALL_DATA} libgd.so.$(SOVER) $(INSTALL_LIB)/libgd.so.$(SOVER)
>-+	-ln -sf libgd.so.$(SOVER) $(INSTALL_LIB)/libgd.so
>-+	${BSD_INSTALL_PROGRAM} pngtogd $(INSTALL_BIN)/pngtogd
>-+	${BSD_INSTALL_PROGRAM} pngtogd2 $(INSTALL_BIN)/pngtogd2
>-+	${BSD_INSTALL_PROGRAM} gdtopng $(INSTALL_BIN)/gdtopng
>-+	${BSD_INSTALL_PROGRAM} gd2topng $(INSTALL_BIN)/gd2topng
>-+	${BSD_INSTALL_PROGRAM} gd2copypal $(INSTALL_BIN)/gd2copypal
>-+	${BSD_INSTALL_PROGRAM} gdparttopng $(INSTALL_BIN)/gdparttopng
>-+	${BSD_INSTALL_PROGRAM} webpng $(INSTALL_BIN)/webpng
>-+	${BSD_INSTALL_SCRIPT} bdftogd $(INSTALL_BIN)/bdftogd
>-+	${BSD_INSTALL_DATA} gd.h $(INSTALL_INCLUDE)/gd.h
>-+	${BSD_INSTALL_DATA} gdcache.h $(INSTALL_INCLUDE)/gdcache.h
>-+	${BSD_INSTALL_DATA} gd_io.h $(INSTALL_INCLUDE)/gd_io.h
>-+	${BSD_INSTALL_DATA} gdfontg.h $(INSTALL_INCLUDE)/gdfontg.h
>-+	${BSD_INSTALL_DATA} gdfontl.h $(INSTALL_INCLUDE)/gdfontl.h
>-+	${BSD_INSTALL_DATA} gdfontmb.h $(INSTALL_INCLUDE)/gdfontmb.h
>-+	${BSD_INSTALL_DATA} gdfonts.h $(INSTALL_INCLUDE)/gdfonts.h
>-+	${BSD_INSTALL_DATA} gdfontt.h $(INSTALL_INCLUDE)/gdfontt.h
>- 
>- gddemo: gddemo.o libgd.a
>- 	$(CC) gddemo.o -o gddemo	$(LIBDIRS) $(LIBS)
>-@@ -138,18 +167,21 @@
>- gdtestttf: gdtestttf.o libgd.a
>- 	$(CC) --verbose gdtestttf.o -o gdtestttf $(LIBDIRS) $(LIBS)
>- 
>--libgd.a: gd.o gd_gd.o gd_gd2.o gd_io.o gd_io_dp.o gd_io_file.o gd_ss.o \
>-+OBJS= gd.o gd_gd.o gd_gd2.o gd_io.o gd_io_dp.o gd_io_file.o gd_ss.o \
>- 	gd_io_ss.o gd_png.o gd_jpeg.o gdxpm.o gdfontt.o gdfonts.o gdfontmb.o gdfontl.o \
>- 	gdfontg.o gdtables.o gdft.o gdttf.o gdcache.o gdkanji.o wbmp.o \
>--	gd_wbmp.o gdhelpers.o gd.h gdfontt.h gdfonts.h gdfontmb.h gdfontl.h \
>-+	gd_wbmp.o gdhelpers.o gd_gif_in.o
>-+INCS= gd.h gdfontt.h gdfonts.h gdfontmb.h gdfontl.h \
>- 	gdfontg.h gdhelpers.h
>-+
>-+libgd.a:	$(INCS) $(OBJS)
>- 	rm -f libgd.a
>--	$(AR) rc libgd.a gd.o gd_gd.o gd_gd2.o gd_io.o gd_io_dp.o \
>--		gd_io_file.o gd_ss.o gd_io_ss.o gd_png.o gd_jpeg.o gdxpm.o \
>--		gdfontt.o gdfonts.o gdfontmb.o gdfontl.o gdfontg.o \
>--		gdtables.o gdft.o gdttf.o gdcache.o gdkanji.o wbmp.o \
>--		gd_wbmp.o gdhelpers.o
>-+	$(AR) rc libgd.a $(OBJS)
>- 	-ranlib libgd.a
>-+
>-+libgd.so.$(SOVER):	$(INCS) $(OBJS:.o=.so)
>-+	$(CC) -shared -Wl,-x,-soname,$@ -o $@ $(OBJS:.o=.so) $(LIBDIRS) $(LIBS)
>-+	ln -sf libgd.so.$(SOVER) libgd.so
>- 
>- clean:
>- 	rm -f *.o *.a ${PROGRAMS} test/gdtest.jpg test/gdtest.wbmp
>diff -urN /usr/ports/graphics/gd/files/patch-gd.h graphics/gd/files/patch-gd.h
>--- /usr/ports/graphics/gd/files/patch-gd.h	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/patch-gd.h	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,41 @@
>+--- gd.h	Thu Jan 16 11:28:09 2003
>++++ gd.h	Mon Mar 24 16:26:14 2003
>+@@ -209,4 +209,8 @@
>+   gdImagePtr gdImageCreateFromPngSource (gdSourcePtr in);
>+ 
>++  gdImagePtr gdImageCreateFromGif(FILE *fd);
>++  gdImagePtr gdImageCreateFromGifCtx(gdIOCtxPtr in);
>++  gdImagePtr gdImageCreateFromGifSource(gdSourcePtr in);
>++
>+   gdImagePtr gdImageCreateFromGd (FILE * in);
>+   gdImagePtr gdImageCreateFromGdCtx (gdIOCtxPtr in);
>+@@ -300,4 +304,5 @@
>+ 
>+   void gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c);
>++  void gdImageOpenPolygon(gdImagePtr im, gdPointPtr p, int n, int c);
>+   void gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c);
>+ 
>+@@ -395,4 +400,13 @@
>+   void *gdImageJpegPtr (gdImagePtr im, int *size, int quality);
>+ 
>++  void gdImageLzw(gdImagePtr im, FILE *out);
>++  void* gdImageLzwPtr(gdImagePtr im, int *size);
>++  void gdImageLzwCtx(gdImagePtr im, gdIOCtxPtr out);
>++
>++  void gdImageBigGif(gdImagePtr im, FILE *out);
>++  void* gdImageBigGifPtr(gdImagePtr im, int *size);
>++  void gdImageBigGifCtx(gdImagePtr im, gdIOCtxPtr out);
>++
>++
>+ /* A custom data sink. For backwards compatibility. Use
>+ 	gdIOCtx instead. */
>+@@ -408,4 +422,9 @@
>+ 
>+   void gdImagePngToSink (gdImagePtr im, gdSinkPtr out);
>++
>++  void gdImageGif(gdImagePtr im, FILE *out);
>++  void* gdImageGifPtr(gdImagePtr im, int *size);
>++  void gdImageGifCtx(gdImagePtr im, gdIOCtxPtr out);
>++  void gdImageGifToSink(gdImagePtr im, gdSinkPtr out);
>+ 
>+   void gdImageGd (gdImagePtr im, FILE * out);
>diff -urN /usr/ports/graphics/gd/files/patch-gdft.c graphics/gd/files/patch-gdft.c
>--- /usr/ports/graphics/gd/files/patch-gdft.c	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/patch-gdft.c	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,92 @@
>+--- gdft.c	Thu Jan 16 13:29:32 2003
>++++ gdft.c	Mon Mar 24 17:09:54 2003
>+@@ -546,8 +546,8 @@
>+ 	  a->tweencolor = gdTrueColorAlpha (gdTrueColorGetRed (fg),
>+ 					    gdTrueColorGetGreen (fg),
>+ 					    gdTrueColorGetBlue (fg),
>+-					    gdAlphaMax -
>+-					    (gdTrueColorGetAlpha (fg) *
>++					    gdAlphaMax - ((gdAlphaMax -
>++					    gdTrueColorGetAlpha (fg)) *
>+ 					     pixel / NUMCOLORS));
>+ 	}
>+       else
>+@@ -680,10 +680,14 @@
>+       if (y >= im->sy || y < 0)
>+ 	continue;
>+ 
>+-      for (col = 0; col < bitmap.width; col++, pc++)
>+-	{
>+-	  if (bitmap.pixel_mode == ft_pixel_mode_grays)
>+-	    {
>++      for (col = 0; col < bitmap.width; col++, pc++) {
>++	x = pen_x + col;
>++	/* clip if out of bounds */
>++	if (x >= im->sx || x < 0)
>++	  continue;
>++
>++	switch(bitmap.pixel_mode) {
>++	case ft_pixel_mode_grays:
>+ 	      /*
>+ 	       * Round to NUMCOLORS levels of antialiasing for
>+ 	       * index color images since only 256 colors are
>+@@ -692,44 +696,38 @@
>+ 	      tc_key.pixel = ((bitmap.buffer[pc] * NUMCOLORS)
>+ 			      + bitmap.num_grays / 2)
>+ 		/ (bitmap.num_grays - 1);
>+-	    }
>+-	  else if (bitmap.pixel_mode == ft_pixel_mode_mono)
>+-	    {
>+-	      tc_key.pixel = ((bitmap.buffer[pc / 8]
>+-			       << (pc % 8)) & 128) ? NUMCOLORS : 0;
>++	      break;
>++	case ft_pixel_mode_mono:
>+ 	      /* 2.0.5: mode_mono fix from Giuliano Pochini */
>+ 	      tc_key.pixel =
>+ 		((bitmap.
>+ 		  buffer[(col >> 3) +
>+ 			 pcr]) & (1 << (~col & 0x07))) ? NUMCOLORS : 0;
>+-	    }
>+-	  else
>+-	    {
>++	      break;
>++	default:
>+ 	      return "Unsupported ft_pixel_mode";
>+-	    }
>++	}
>++
>+ 	  if (tc_key.pixel > 0)	/* if not background */
>+ 	    {
>+-	      x = pen_x + col;
>+-
>+-	      /* clip if out of bounds */
>+-	      if (x >= im->sx || x < 0)
>+-		continue;
>+-	      /* get pixel location in gd buffer */
>+-	      pixel = &im->pixels[y][x];
>+-	      if (tc_key.pixel == NUMCOLORS)
>+-		{
>++	      if (im->trueColor) {
>++		tc_elem = (tweencolor_t *)gdCacheGet(tc_cache, &tc_key);
>++		gdImageSetPixel(im, x, y, tc_elem->tweencolor);
>++	      } else {
>++	        /* get pixel location in gd buffer */
>++	        pixel = &im->pixels[y][x];
>++	        if (tc_key.pixel == NUMCOLORS)
>+ 		  /* use fg color directly. gd 2.0.2: watch out for
>+ 		     negative indexes (thanks to David Marwood). */
>+ 		  *pixel = (fg < 0) ? -fg : fg;
>+-		}
>+-	      else
>+-		{
>++	        else {
>+ 		  /* find antialised color */
>+ 
>+ 		  tc_key.bgcolor = *pixel;
>+ 		  tc_elem = (tweencolor_t *) gdCacheGet (tc_cache, &tc_key);
>+ 		  *pixel = tc_elem->tweencolor;
>+ 		}
>++	      }
>+ 	    }
>+ 	}
>+     }
>diff -urN /usr/ports/graphics/gd/files/patch-gdkanji.c graphics/gd/files/patch-gdkanji.c
>--- /usr/ports/graphics/gd/files/patch-gdkanji.c	Mon Feb 12 18:34:33 2001
>+++ graphics/gd/files/patch-gdkanji.c	Thu Jan  1 09:00:00 1970
>@@ -1,87 +0,0 @@
>---- gdkanji.c.orig	Fri Feb  2 05:23:56 2001
>-+++ gdkanji.c	Wed Feb  7 20:59:08 2001
>-@@ -103,14 +103,18 @@
>- unsigned char *str;
>- #endif
>- {
>--	static int whatcode;
>-+	static int whatcode = ASCII;
>-+	int oldcode = ASCII;
>- 	int c, i;
>- 	char *lang = NULL;
>- 
>- 	c = '\1';
>- 	i = 0;
>- 
>--	if (whatcode == 0) whatcode = ASCII;
>-+	if (whatcode != EUCORSJIS && whatcode != ASCII) {
>-+		oldcode = whatcode;
>-+		whatcode = ASCII;
>-+	}
>- 	
>- 	while ((whatcode == EUCORSJIS || whatcode == ASCII) && c != '\0') {
>- 		if ((c = str[i++]) != '\0') {
>-@@ -167,7 +171,7 @@
>- 				if ((c >= 64 && c <= 126) || (c >= 128 && c <= 160))
>- 					whatcode = SJIS;
>- 				else
>--				if (c >= 253 && c >= 254) whatcode = EUC;
>-+				if (c >= 253 && c <= 254) whatcode = EUC;
>- 				else
>- 				if (c >= 161 && c <= 252) whatcode = EUCORSJIS;
>- 			}
>-@@ -184,6 +188,8 @@
>- 		debug("Kanji code detected at %d byte.", i);
>- #endif
>- 
>-+	if (whatcode == EUCORSJIS && oldcode != ASCII) whatcode = oldcode;
>-+
>- 	if (whatcode == EUCORSJIS) {
>- 		if (getenv ("LC_ALL")) lang = getenv ("LC_ALL");
>- 		else
>-@@ -310,7 +316,7 @@
>- 			error("invalid code specification: \"%s\" or \"%s\"",
>- 								EUCSTR, code);
>- #endif
>--		strcpy(to, from);
>-+		ustrcpy(to, from);
>- 		return;
>- 	}
>- 
>-@@ -328,7 +334,7 @@
>- 		else
>- #endif
>- 			error("something happen");
>--		strcpy(to, from);
>-+		ustrcpy(to, from);
>- 		return;
>- 	}
>- 
>-@@ -526,11 +532,10 @@
>- 
>- 	t = (unsigned char *)gdMalloc(BUFSIZ);
>- 	any2eucjp(t, s, BUFSIZ);
>--	i = strlen(t);
>-+	i = strlen((const char *)t);
>- 	gdFree(t);
>- 	return i;
>- }
>--#endif
>- 
>- #ifdef DEBUG
>- int main()
>-@@ -543,7 +548,7 @@
>- 	while ( (c = fgetc(stdin)) != '\n' && i < BUFSIZ ) input[i++] = c;
>- 	input[i] = '\0';
>- 
>--	printf("input : %d bytes\n", strlen(input));
>-+	printf("input : %d bytes\n", strlen((const char *)input));
>- 	printf("output: %d bytes\n", strwidth(input));
>- 
>- 	output = (unsigned char *)gdMalloc(BUFSIZ);
>-@@ -555,4 +560,5 @@
>- 
>- 	return 0;
>- }
>-+#endif
>- #endif
>diff -urN /usr/ports/graphics/gd/files/patch-gdtest.c graphics/gd/files/patch-gdtest.c
>--- /usr/ports/graphics/gd/files/patch-gdtest.c	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/patch-gdtest.c	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,81 @@
>+--- gdtest.c.orig	Thu Apr 25 14:16:47 2002
>++++ gdtest.c	Tue Nov  6 15:53:38 2001
>+@@ -84,6 +84,35 @@
>+   gdImageDestroy (im2);
>+   ctx->gd_free (ctx);
>+ 
>++        /* */
>++        /* Send to GIF File then Ptr */
>++        /* */
>++        sprintf(of, "%s.gif", argv[1]);
>++        out = fopen(of, "wb");
>++        gdImageGif(im, out);
>++        fclose(out);
>++
>++        in = fopen(of, "rb");
>++        if (!in) {
>++                fprintf(stderr, "GIF Output file does not exist!\n");
>++                exit(1);
>++        }
>++        im2 = gdImageCreateFromGif(in);
>++        fclose(in);
>++
>++        CompareImages("GD->GIF File->GD", ref, im2);
>++
>++        unlink(of);
>++        gdImageDestroy(im2);
>++
>++	iptr = gdImageGifPtr(im,&sz);
>++	ctx = gdNewDynamicCtx(sz,iptr);
>++	im2 = gdImageCreateFromGifCtx(ctx);
>++
>++        CompareImages("GD->GIF ptr->GD", ref, im2);
>++
>++	gdImageDestroy(im2);
>++	ctx->gd_free(ctx);
>+ 
>+   /* */
>+   /* Send to GD2 File then Ptr */
>+@@ -200,7 +229,30 @@
>+       gdImageDestroy (im2);
>+     };
>+ 
>+-  unlink (of);
>++	/*
>++	** Test gdImageCreateFromGifSource
>++	**/
>++
>++	in = fopen(of, "rb");
>++
>++	if (!in)
>++	  {
>++		fprintf (stderr, "GD Source: ERROR - GD Source input file does not exist - Sink may have failed!\n");
>++	  };
>++
>++	imgsrc.source = freadWrapper;
>++	imgsrc.context = in;
>++	im2 = gdImageCreateFromGifSource(&imgsrc);
>++	fclose(in);
>++
>++	if (im2 == NULL) {
>++		printf("GD Source (GIF): ERROR Null returned by gdImageCreateFromGifSource\n");
>++	} else {
>++		CompareImages("GD Source (GIF)", ref, im2);
>++		gdImageDestroy(im2);
>++	};
>++
>++	unlink(of);
>+ 
>+   /* */
>+   /*  Test Extraction */
>+@@ -266,6 +318,10 @@
>+ 
>+   printf ("[Merged Image has %d colours]\n", im2->colorsTotal);
>+   CompareImages ("Merged (gdtest.png, gdtest_merge.png)", im2, im3);
>++
>++  out = fopen ("test/gdtest_merge_out.png", "wb");
>++  gdImagePng(im2, out);
>++  close(out);
>+ 
>+   gdImageDestroy (im2);
>+   gdImageDestroy (im3);
>diff -urN /usr/ports/graphics/gd/files/patch-gdttf.c graphics/gd/files/patch-gdttf.c
>--- /usr/ports/graphics/gd/files/patch-gdttf.c	Mon Feb 12 18:34:33 2001
>+++ graphics/gd/files/patch-gdttf.c	Thu Jan  1 09:00:00 1970
>@@ -1,17 +0,0 @@
>---- gdttf.c.orig	Fri Feb  2 05:23:56 2001
>-+++ gdttf.c	Wed Feb  7 20:57:34 2001
>-@@ -221,11 +221,10 @@
>-     byte = *((unsigned char *) str);
>- #ifdef JISX0208
>-     if (0xA1 <= byte && byte <= 0xFE) {
>--	int jiscode, ku, ten;
>-+	int ku, ten;
>- 
>--	jiscode = 0x100 * (byte & 0x7F) + (str[1] & 0x7F);
>--	ku = (jiscode >> 8) - 0x20;
>--	ten = (jiscode % 256) - 0x20;
>-+	ku = (byte & 0x7F) - 0x20;
>-+	ten = (str[1] & 0x7F) - 0x20;
>- 	if ( (ku < 1 || ku > 92) || (ten < 1 || ten > 94) ) {
>-     		*chPtr = (Tcl_UniChar) byte;
>-     		return 1;
>diff -urN /usr/ports/graphics/gd/files/patch-gif graphics/gd/files/patch-gif
>--- /usr/ports/graphics/gd/files/patch-gif	Tue Aug 21 10:30:32 2001
>+++ graphics/gd/files/patch-gif	Thu Jan  1 09:00:00 1970
>@@ -1,15 +0,0 @@
>-This  patch  together  with  the old  implementation  (from  gd-1.5)  of
>-gd_gif_in.c restore GD's ability to read GIF images. The writing of such
>-images is troubled because of Unisys' zeal in patent enforcement.
>-
>---- gd.h	Tue Feb  6 14:44:01 2001
>-+++ gd.h	Fri Jul 27 16:10:38 2001
>-@@ -95,2 +95,4 @@
>- gdImagePtr gdImageCreate(int sx, int sy);
>-+gdImagePtr gdImageCreateFromGif(FILE *fd);
>-+gdImagePtr gdImageCreateFromGifCtx(gdIOCtxPtr in);
>- gdImagePtr gdImageCreateFromPng(FILE *fd);
>---- gd_gif_in.c	Fri Jul 27 16:13:45 2001
>-+++ gd_gif_in.c	Fri Jul 27 16:14:46 2001
>-@@ -6,1 +6,0 @@
>--#include "io.h"
>diff -urN /usr/ports/graphics/gd/files/patch-index.html graphics/gd/files/patch-index.html
>--- /usr/ports/graphics/gd/files/patch-index.html	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/files/patch-index.html	Sat Jun 21 19:47:39 2003
>@@ -0,0 +1,71 @@
>+--- index.html	Mon Nov 25 11:39:31 2002
>++++ index.html	Wed Nov 27 12:47:38 2002
>+@@ -35,4 +35,9 @@
>+ modern image formats such as PNG and JPEG as soon as possible.
>+ 
>++<p>Note, that the FreeBSD port of gd2 includes support for GIF files
>++ported from the earlier releases of gd. If the WITH_LZW was defined at
>++build time, the software will also use LZW-compression when creating
>++GIF files.
>++
>+ <p>
>+ gd 2.0.8 <strong>requires</strong> that the following libraries 
>+@@ -116,4 +121,18 @@
>+ Portions relating to WBMP copyright 2000, 2001, 2002 Maurice Szmurlo and Johan Van 
>+ den Brande.
>++
>++<p>
>++GIF decompression code copyright 1990, 1991, 1993, by David Koblas
>++(koblas@netcom.com).
>++<p>
>++Non-LZW-based GIF compression code copyright 1998, by Hutchison Avenue
>++Software Corporation (<a href="http://www.hasc.com">http://www.hasc.com/</a>,
>++info@hasc.com).
>++<p>
>++LZW-based GIF compression code David Rowley.
>++Obtaining a license for the Unisys LZW compression patent is
>++entirely between the user and Unisys. The authors of gd can provide
>++NO assistance in this matter.
>++
>+ <p>
>+ <strong>Permission has been granted to copy, distribute and modify gd in any
>+@@ -192,5 +211,22 @@
>+ <li><a href="http://martin.gleeson.com/fly/">fly</a>, by Martin Gleeson
>+ </ul>
>+-<P>
>++
>++<P><A NAME="gifpatch"><H3>What does the FreeBSD port add?</H3></A>
>++
>++<p>This version reinstates GIF support. Specifically, the following
>++functions are added: gdImageGif, gdImageGifPtr, gdImageGifCtx,
>++gdImageGifToSink, gdImageCreateFromGif, gdImageCreateFromGifCtx,
>++gdImageCreateFromGifSource.
>++The can be used just like the corresponding functions for the other
>++image formats.
>++
>++<p>Other functions added, but not documented, are: gdImageLzw,
>++gdImageLzwPtr, gdImageLzwCtx, gdImageBigGif, gdImageBigGifPtr,
>++gdImageBigGifCtx.
>++
>++<p>The <a href=#gdImageOpenPolygon>gdImageOpenPolygon</a> is added.
>++This is basically the same as <a href=#gdImagePolygon>gdImagePolygon</A>,
>++but it does not join the start and end points. It is required by GD.pm.
>++
>+ <A NAME="whatsnew2.0.8"><H3>What's new in version 2.0.8?</H3></A>
>+ <P>
>+@@ -1058,5 +1094,6 @@
>+ <DD>
>+ Represents a point in the coordinate space of the image; used
>+-by <A HREF="#gdImagePolygon">gdImagePolygon</A> and
>++by <A HREF="#gdImagePolygon">gdImagePolygon</A>,
>++<A HREF="#gdImageOpenPolygon">gdImageOpenPolygon</A>, and
>+ <A HREF="#gdImageFilledPolygon">gdImageFilledPolygon</A>.
>+ <PRE>
>+@@ -1068,5 +1105,6 @@
>+ <DD>
>+ A pointer to a <A HREF="#gdPoint">gdPoint</A> structure; passed
>+-as an argument to <A HREF="#gdImagePolygon">gdImagePolygon</A>
>++as an argument to <A HREF="#gdImagePolygon">gdImagePolygon</A>,
>++<A HREF="#gdImageOpenPolygon">gdImageOpenPolygon</A>,
>+ and <A HREF="#gdImageFilledPolygon">gdImageFilledPolygon</A>.
>+ </DL>
>diff -urN /usr/ports/graphics/gd/pkg-descr graphics/gd/pkg-descr
>--- /usr/ports/graphics/gd/pkg-descr	Mon Nov  1 10:01:02 1999
>+++ graphics/gd/pkg-descr	Sat Jun 21 19:47:39 2003
>@@ -1,23 +1,16 @@
>-DESCRIPTION
>+gd is a graphics library. It allows your code to quickly draw images
>+complete with lines, arcs, text, multiple colors, cut and paste from
>+other images, and flood fills, and write out the result as a PNG, GIF
>+or JPEG file. This is particularly useful in World Wide Web applications,
>+where PNG, GIF and JPEG are three of the formats accepted for inline
>+images by most browsers.
> 
>-	gd is a graphics library. It allows your code to quickly draw images
>-	complete with lines, arcs, text, multiple colors, cut and paste from
>-	other images, and flood fills, and write out the result as a .PNG file.
>-	This is particularly useful in World Wide Web applications, where .PNG
>-	is the format used for inline images. 
>-
>-	gd is not a paint program. If you are looking for a paint program, you
>-	are looking in the wrong place. If you are not a programmer, you are
>-	looking in the wrong place.
>-
>-	gd does not provide for every possible desirable graphics operation.
>-	It is not necessary or desirable for gd to become a kitchen-sink
>-	graphics package, but version 1.7.3 incorporates most of the commonly
>-	requested features for an 8-bit 2D package. Support for truecolor
>-	images, JPEG and truecolor PNG is planned for version 2.0.
>-
>-AUTHOR
>-	gd was written by Thomas Boutell and is currently distributed by 
>-	boutell.com, Inc. 
>+gd does  not provide for every possible desirable graphics operation,
>+but version 2.0 does include most frequently requested features,
>+including both truecolor and palette images, resampling (smooth
>+resizing of truecolor images) and so forth.
> 
> WWW: http://www.boutell.com/gd/
>+
>+- Alex Dupre
>+sysadmin@alexdupre.com
>diff -urN /usr/ports/graphics/gd/pkg-plist graphics/gd/pkg-plist
>--- /usr/ports/graphics/gd/pkg-plist	Fri Oct 26 21:07:02 2001
>+++ graphics/gd/pkg-plist	Sat Jun 21 19:47:39 2003
>@@ -1,22 +1,25 @@
>+bin/annotate
> bin/bdftogd
> bin/gd2copypal
>+bin/gd2togif
> bin/gd2topng
>+bin/gdcmpgif
> bin/gdparttopng
> bin/gdtopng
>+bin/giftogd2
> bin/pngtogd
> bin/pngtogd2
> bin/webpng
>-include/gd/gd.h
>-include/gd/gd_io.h
>-include/gd/gdcache.h
>-include/gd/gdfontg.h
>-include/gd/gdfontl.h
>-include/gd/gdfontmb.h
>-include/gd/gdfonts.h
>-include/gd/gdfontt.h
>+include/gd.h
>+include/gd_io.h
>+include/gdcache.h
>+include/gdfontg.h
>+include/gdfontl.h
>+include/gdfontmb.h
>+include/gdfonts.h
>+include/gdfontt.h
> lib/libgd.a
> lib/libgd.so
>-lib/libgd.so.2
>+lib/libgd.so.4
> %%PORTDOCS%%share/doc/gd/index.html
> %%PORTDOCS%%@dirrm share/doc/gd
>-@dirrm include/gd
>diff -urN /usr/ports/graphics/gd/scripts/configure graphics/gd/scripts/configure
>--- /usr/ports/graphics/gd/scripts/configure	Thu Jan  1 09:00:00 1970
>+++ graphics/gd/scripts/configure	Sat Jun 21 20:12:12 2003
>@@ -0,0 +1,44 @@
>+#!/bin/sh
>+# $FreeBSD$
>+
>+# The GD_FONTS environment variable can be set to specify the gzipped
>+# tar-ball containing the fonts in bdf format and the bdf file names.
>+#
>+# For example:
>+# GD_FONTS="/usr/ports/distfiles/x-koi8u.tgz koi6x10.bdf koi8x13.bdf \
>+#	koi9x15.bdf koi12x24.bdf koi10x20.bdf"
>+#
>+# This can be usefull for slave ports, like ukrainian/gd, which may
>+# now provide alternative fonts easily.
>+
>+#	TODO: . handle multiple archiving formats: tgz, tar.bz2, zip
>+#	      . allow for passing already extracted font-files
>+
>+if [ -z "$GD_FONTS" ]
>+then
>+	echo "GD_FONTS can be set to specify an alternative list of .bdf files"
>+	echo "See $0 for details..."
>+	exit 0
>+fi
>+
>+set $GD_FONTS
>+#
>+# The  tarball is  the  first argument,  the  tiny, small,  medium-bold,
>+# large, and giant fonts follow.
>+#
>+
>+tarball=$1
>+shift
>+tar -xvzpf $tarball -C $WRKSRC $@
>+
>+rm -f $WRKSRC/Makefile.fonts
>+
>+for font in Tiny Small MediumBold Large Giant
>+do
>+	f=`echo $font | tr -d [[:lower:]] | tr [[:upper:]] [[:lower:]]`
>+	rm -f $WRKSRC/gdfont$f.[ch]
>+	printf 'gdfont%s.c gdfont%s.h: %s\
>+		perl ${.CURDIR}/bdftogd gdFont%s font%s < %s\n' \
>+		$f $f $1 $font $f $1 >> $WRKSRC/Makefile.fonts
>+	shift
>+done

Actions: View | Diff

Attachments on bug 53582: 32420