Gecko [ nrupathungauniversityblr.ac.in ]

Name	Size	Permission
msinttypes	[ DIR ]	drwxr-xr-x
CMakeLists.txt	3.23 KB	-rwxr-xr-x
COPYING	2.25 KB	-rwxr-xr-x
Makefile.am	1.96 KB	-rwxr-xr-x
annotate.c	4.38 KB	-rwxr-xr-x
bdftogd	3.91 KB	-rwxr-xr-x
bmp.h	2.39 KB	-rwxr-xr-x
circletexttest.c	1.49 KB	-rwxr-xr-x
config.h.cmake	3.58 KB	-rwxr-xr-x
demoin.png	9.79 KB	-rwxr-xr-x
depcomp	11.84 KB	-rwxr-xr-x
entities.h	4.81 KB	-rwxr-xr-x
entities.html	41.11 KB	-rwxr-xr-x
entities.tcl	1.35 KB	-rwxr-xr-x
fontconfigtest.c	1.34 KB	-rwxr-xr-x
fontsizetest.c	2.3 KB	-rwxr-xr-x
fontwheeltest.c	3.23 KB	-rwxr-xr-x
gd.c	89.58 KB	-rwxr-xr-x
gd.h	50.14 KB	-rwxr-xr-x
gd2copypal.c	1.25 KB	-rwxr-xr-x
gd2time.c	1.19 KB	-rwxr-xr-x
gd2togif.c	939 B	-rwxr-xr-x
gd2topng.c	1.38 KB	-rwxr-xr-x
gd_bmp.c	25.78 KB	-rwxr-xr-x
gd_color.c	798 B	-rwxr-xr-x
gd_color.h	189 B	-rwxr-xr-x
gd_color_map.c	22.71 KB	-rwxr-xr-x
gd_color_map.h	478 B	-rwxr-xr-x
gd_color_map_test.c	570 B	-rwxr-xr-x
gd_color_match.c	1.49 KB	-rwxr-xr-x
gd_crop.c	5.75 KB	-rwxr-xr-x
gd_errors.h	1.47 KB	-rwxr-xr-x
gd_filename.c	6.41 KB	-rwxr-xr-x
gd_filter.c	21 KB	-rwxr-xr-x
gd_gd.c	7.1 KB	-rwxr-xr-x
gd_gd2.c	25.85 KB	-rwxr-xr-x
gd_gif_in.c	14.79 KB	-rwxr-xr-x
gd_gif_out.c	41 KB	-rwxr-xr-x
gd_intern.h	1.95 KB	-rwxr-xr-x
gd_interpolation.c	59.19 KB	-rwxr-xr-x
gd_io.c	3.42 KB	-rwxr-xr-x
gd_io.h	3.05 KB	-rwxr-xr-x
gd_io_dp.c	7.95 KB	-rwxr-xr-x
gd_io_file.c	2.41 KB	-rwxr-xr-x
gd_io_ss.c	2.66 KB	-rwxr-xr-x
gd_io_stream.cxx	4.11 KB	-rwxr-xr-x
gd_io_stream.h	3.63 KB	-rwxr-xr-x
gd_jpeg.c	34.5 KB	-rwxr-xr-x
gd_matrix.c	7.93 KB	-rwxr-xr-x
gd_nnquant.c	15 KB	-rwxr-xr-x
gd_nnquant.h	527 B	-rwxr-xr-x
gd_png.c	30.58 KB	-rwxr-xr-x
gd_rotate.c	12.25 KB	-rwxr-xr-x
gd_security.c	692 B	-rwxr-xr-x
gd_ss.c	1.27 KB	-rwxr-xr-x
gd_tga.c	8.61 KB	-rwxr-xr-x
gd_tga.h	1.66 KB	-rwxr-xr-x
gd_tiff.c	25.85 KB	-rwxr-xr-x
gd_topal.c	55.18 KB	-rwxr-xr-x
gd_transform.c	1.48 KB	-rwxr-xr-x
gd_version.c	827 B	-rwxr-xr-x
gd_wbmp.c	6.54 KB	-rwxr-xr-x
gd_webp.c	4.25 KB	-rwxr-xr-x
gd_xbm.c	5.68 KB	-rwxr-xr-x
gdcache.c	5.14 KB	-rwxr-xr-x
gdcache.h	2.83 KB	-rwxr-xr-x
gdcmpgif.c	1.86 KB	-rwxr-xr-x
gddemo.c	5.42 KB	-rwxr-xr-x
gdfontg.c	109.84 KB	-rwxr-xr-x
gdfontg.h	553 B	-rwxr-xr-x
gdfontl.c	104.83 KB	-rwxr-xr-x
gdfontl.h	551 B	-rwxr-xr-x
gdfontmb.c	76.33 KB	-rwxr-xr-x
gdfontmb.h	519 B	-rwxr-xr-x
gdfonts.c	66.55 KB	-rwxr-xr-x
gdfonts.h	515 B	-rwxr-xr-x
gdfontt.c	36.82 KB	-rwxr-xr-x
gdfontt.h	546 B	-rwxr-xr-x
gdft.c	49.23 KB	-rwxr-xr-x
gdfx.c	13.52 KB	-rwxr-xr-x
gdfx.h	2.34 KB	-rwxr-xr-x
gdhelpers.c	1.51 KB	-rwxr-xr-x
gdhelpers.h	2.31 KB	-rwxr-xr-x
gdkanji.c	11.97 KB	-rwxr-xr-x
gdparttopng.c	1.23 KB	-rwxr-xr-x
gdpp.cxx	6.43 KB	-rwxr-xr-x
gdpp.h	50.94 KB	-rwxr-xr-x
gdtables.c	4.67 KB	-rwxr-xr-x
gdtest.c	10.27 KB	-rwxr-xr-x
gdtestft.c	5.54 KB	-rwxr-xr-x
gdtopng.c	1.01 KB	-rwxr-xr-x
gdxpm.c	4.64 KB	-rwxr-xr-x
gifanimtest.c	682 B	-rwxr-xr-x
giftogd2.c	1.12 KB	-rwxr-xr-x
jisx0208.h	73.71 KB	-rwxr-xr-x
pngtogd.c	1.03 KB	-rwxr-xr-x
pngtogd2.c	1.23 KB	-rwxr-xr-x
snprintf.c	585 B	-rwxr-xr-x
testac.c	4.14 KB	-rwxr-xr-x
testtr.c	1.33 KB	-rwxr-xr-x
wbmp.c	6.18 KB	-rwxr-xr-x
wbmp.h	1.2 KB	-rwxr-xr-x
webpng.c	6.44 KB	-rwxr-xr-x

Code Editor : gd_io_dp.c

/*
 * io_dp.c
 *
 * Implements the dynamic pointer interface.
 *
 * Based on GD.pm code by Lincoln Stein for interfacing to libgd.
 * Added support for reading as well as support for 'tell' and 'seek'.
 *
 * As will all I/O modules, most functions are for local use only (called
 * via function pointers in the I/O context).
 *
 * gdDPExtractData is the exception to this: it will return the pointer to
 * the internal data, and reset the internal storage.
 *
 * Written/Modified 1999, Philip Warner.
 */

#ifdef HAVE_CONFIG_H
#	include "config.h"
#endif

#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "gd.h"
#include "gdhelpers.h"

#define TRUE	1
#define FALSE	0

/* this is used for creating images in main memory */
typedef struct dpStruct {
	void *data;
	int logicalSize;
	int realSize;
	int dataGood;
	int pos;
	int freeOK;
}
dynamicPtr;

typedef struct dpIOCtx {
	gdIOCtx ctx;
	dynamicPtr *dp;
}
dpIOCtx;

typedef struct dpIOCtx *dpIOCtxPtr;

/* these functions operate on in-memory dynamic pointers */
static int allocDynamic(dynamicPtr *dp, int initialSize, void *data);
static int appendDynamic(dynamicPtr *dp, const void *src, int size);
static int gdReallocDynamic(dynamicPtr *dp, int required);
static int trimDynamic(dynamicPtr *dp);
static void gdFreeDynamicCtx(struct gdIOCtx *ctx);
static dynamicPtr *newDynamic(int initialSize, void *data, int freeOKFlag);

static int dynamicPutbuf(struct gdIOCtx *, const void *, int);
static void dynamicPutchar(struct gdIOCtx *, int a);

static int dynamicGetbuf(gdIOCtxPtr ctx, void *buf, int len);
static int dynamicGetchar(gdIOCtxPtr ctx);

static int dynamicSeek(struct gdIOCtx *, const int);
static long dynamicTell(struct gdIOCtx *);

/*
	Function: gdNewDynamicCtx

Return data as a dynamic pointer.
*/
BGD_DECLARE(gdIOCtx *) gdNewDynamicCtx(int initialSize, void *data)
{
	/* 2.0.23: Phil Moore: 'return' keyword was missing! */
	return gdNewDynamicCtxEx(initialSize, data, 1);
}

/*
	Function: gdNewDynamicCtxEx
*/
BGD_DECLARE(gdIOCtx *) gdNewDynamicCtxEx(int initialSize, void *data, int freeOKFlag)
{
	dpIOCtx *ctx;
	dynamicPtr *dp;

ctx = (dpIOCtx *)gdMalloc(sizeof (dpIOCtx));
	if(ctx == NULL) {
		return NULL;
	}

dp = newDynamic(initialSize, data, freeOKFlag);
	if(!dp) {
		gdFree (ctx);
		return NULL;
	};

ctx->dp = dp;

ctx->ctx.getC = dynamicGetchar;
	ctx->ctx.putC = dynamicPutchar;

ctx->ctx.getBuf = dynamicGetbuf;
	ctx->ctx.putBuf = dynamicPutbuf;

ctx->ctx.seek = dynamicSeek;
	ctx->ctx.tell = dynamicTell;

ctx->ctx.gd_free = gdFreeDynamicCtx;

return (gdIOCtx *)ctx;
}

/*
	Function: gdDPExtractData
*/
BGD_DECLARE(void *) gdDPExtractData (struct gdIOCtx *ctx, int *size)
{
	dynamicPtr *dp;
	dpIOCtx *dctx;
	void *data;

dctx = (dpIOCtx *)ctx;
	dp = dctx->dp;

/* clean up the data block and return it */
	if(dp->dataGood) {
		trimDynamic(dp);
		*size = dp->logicalSize;
		data = dp->data;
	} else {
		*size = 0;
		data = NULL;
		/* 2.0.21: never free memory we don't own */
		if((dp->data != NULL) && (dp->freeOK)) {
			gdFree(dp->data);
		}
	}

dp->data = NULL;
	dp->realSize = 0;
	dp->logicalSize = 0;

return data;
}

static void gdFreeDynamicCtx(struct gdIOCtx *ctx)
{
	dynamicPtr *dp;
	dpIOCtx *dctx;

dctx = (dpIOCtx *)ctx;
	dp = dctx->dp;

gdFree(ctx);

/* clean up the data block and return it */
	/* 2.0.21: never free memory we don't own */
	if((dp->data != NULL) && (dp->freeOK)) {
		gdFree(dp->data);
		dp->data = NULL;
	}

dp->realSize = 0;
	dp->logicalSize = 0;

gdFree(dp);
}

static long dynamicTell(struct gdIOCtx *ctx)
{
	dpIOCtx *dctx;

dctx = (dpIOCtx *)ctx;
	return (dctx->dp->pos);
}

static int dynamicSeek(struct gdIOCtx *ctx, const int pos)
{
	int bytesNeeded;
	dynamicPtr *dp;
	dpIOCtx *dctx;

dctx = (dpIOCtx *)ctx;
	dp = dctx->dp;

if(!dp->dataGood) {
		return FALSE;
	}

bytesNeeded = pos;
	if(bytesNeeded > dp->realSize) {
		/* 2.0.21 */
		if(!dp->freeOK) {
			return FALSE;
		}

if(overflow2(dp->realSize, 2)) {
			return FALSE;
		}

if(!gdReallocDynamic(dp, dp->realSize * 2)) {
			dp->dataGood = FALSE;
			return FALSE;
		}
	}

/* if we get here, we can be sure that we have enough bytes
	 * to copy safely */

/* Extend the logical size if we seek beyond EOF. */
	if(pos > dp->logicalSize) {
		dp->logicalSize = pos;
	};

dp->pos = pos;

return TRUE;
}

/* return data as a dynamic pointer */
static dynamicPtr *newDynamic(int initialSize, void *data, int freeOKFlag)
{
	dynamicPtr *dp;

dp = (dynamicPtr *) gdMalloc(sizeof (dynamicPtr));
	if(dp == NULL) {
		return NULL;
	}

if(!allocDynamic(dp, initialSize, data)) {
		gdFree(dp);
		return NULL;
	}

dp->pos = 0;
	dp->freeOK = freeOKFlag;

return dp;
}

static int dynamicPutbuf(struct gdIOCtx *ctx, const void *buf, int size)
{
	dpIOCtx *dctx;
	dctx = (dpIOCtx *)ctx;

appendDynamic(dctx->dp, buf, size);

if(dctx->dp->dataGood) {
		return size;
	} else {
		return -1;
	};
}

static void dynamicPutchar(struct gdIOCtx *ctx, int a)
{
	unsigned char b;
	dpIOCtxPtr dctx;

b = a;
	dctx = (dpIOCtxPtr) ctx;

appendDynamic(dctx->dp, &b, 1);
}

static int dynamicGetbuf(gdIOCtxPtr ctx, void *buf, int len)
{
	int rlen, remain;
	dpIOCtxPtr dctx;
	dynamicPtr *dp;

dctx = (dpIOCtxPtr) ctx;
	dp = dctx->dp;

remain = dp->logicalSize - dp->pos;
	if(remain >= len) {
		rlen = len;
	} else {
		if(remain == 0) {
			/* 2.0.34: EOF is incorrect. We use 0 for
			 * errors and EOF, just like fileGetbuf,
			 * which is a simple fread() wrapper.
			 * TBB. Original bug report: Daniel Cowgill. */
			return 0; /* NOT EOF */
		}

rlen = remain;
	}

memcpy(buf, (void *) ((char *)dp->data + dp->pos), rlen);
	dp->pos += rlen;

return rlen;
}

static int dynamicGetchar(gdIOCtxPtr ctx)
{
	unsigned char b;
	int rv;

rv = dynamicGetbuf(ctx, &b, 1);

if(rv != 1) {
		return EOF;
	} else {
		return b; /* (b & 0xff); */
	}
}

/**********************************************************************
 * InitDynamic - Return a dynamically resizable void*
 **********************************************************************/
static int allocDynamic(dynamicPtr *dp, int initialSize, void *data)
{
	if(data == NULL) {
		dp->logicalSize = 0;
		dp->dataGood = FALSE;
		dp->data = gdMalloc(initialSize);
	} else {
		dp->logicalSize = initialSize;
		dp->dataGood = TRUE;
		dp->data = data;
	}

if(dp->data != NULL) {
		dp->realSize = initialSize;
		dp->dataGood = TRUE;
		dp->pos = 0;
		return TRUE;
	} else {
		dp->realSize = 0;
		return FALSE;
	}
}

/* append bytes to the end of a dynamic pointer */
static int appendDynamic(dynamicPtr * dp, const void *src, int size)
{
	int bytesNeeded;
	char *tmp;

if(!dp->dataGood) {
		return FALSE;
	}

/* bytesNeeded = dp->logicalSize + size; */
	bytesNeeded = dp->pos + size;

if(bytesNeeded > dp->realSize) {
		/* 2.0.21 */
		if(!dp->freeOK) {
			return FALSE;
		}

if(overflow2(dp->realSize, 2)) {
			return FALSE;
		}

if(!gdReallocDynamic(dp, bytesNeeded * 2)) {
			dp->dataGood = FALSE;
			return FALSE;
		}
	}

/* if we get here, we can be sure that we have enough bytes
	 * to copy safely */

/*printf("Mem OK Size: %d, Pos: %d\n", dp->realSize, dp->pos); */

tmp = (char *)dp->data;
	memcpy ((void *)(tmp + (dp->pos)), src, size);
	dp->pos += size;

if(dp->pos > dp->logicalSize) {
		dp->logicalSize = dp->pos;
	};

return TRUE;
}

/* grow (or shrink) dynamic pointer */
static int gdReallocDynamic(dynamicPtr *dp, int required)
{
	void *newPtr;

/* First try gdRealloc().  If that doesn't work, make a new
	 * memory block and copy. */
	if((newPtr = gdRealloc(dp->data, required))) {
		dp->realSize = required;
		dp->data = newPtr;
		return TRUE;
	}

/* create a new pointer */
	newPtr = gdMalloc(required);
	if(!newPtr) {
		dp->dataGood = FALSE;
		return FALSE;
	}

/* copy the old data into it */
	memcpy(newPtr, dp->data, dp->logicalSize);
	gdFree(dp->data);
	dp->data = newPtr;

dp->realSize = required;
	return TRUE;
}

/* trim pointer so that its real and logical sizes match */
static int trimDynamic(dynamicPtr *dp)
{
	/* 2.0.21: we don't reallocate memory we don't own */
	if(!dp->freeOK) {
		return TRUE;
	}

return gdReallocDynamic(dp, dp->logicalSize);
}

${this.title}

Code Editor : gd_io_dp.c