Document all BGD_DECLARE'd functions

We add only minimal documentation comments for now, but at least that lets
Natural Docs add the function prototypes to the documentation.

src/gd.c

@@ -120,11 +120,17 @@ void gd_error_ex(int priority, const char *format, ...)
 	va_end(args);
 }
 
+/*
+	Function: gdSetErrorMethod
+*/
 BGD_DECLARE(void) gdSetErrorMethod(gdErrorMethod error_method)
 {
 	gd_error_method = error_method;
 }
 
+/*
+	Function: gdClearErrorMethod
+*/
 BGD_DECLARE(void) gdClearErrorMethod(void)
 {
 	gd_error_method = gd_stderr_error;
@@ -132,6 +138,10 @@ BGD_DECLARE(void) gdClearErrorMethod(void)
 
 static void gdImageBrushApply (gdImagePtr im, int x, int y);
 static void gdImageTileApply (gdImagePtr im, int x, int y);
+
+/*
+	Function: gdImageGetTrueColorPixel
+*/
 BGD_DECLARE(int) gdImageGetTrueColorPixel (gdImagePtr im, int x, int y);
 
 
@@ -385,11 +395,17 @@ BGD_DECLARE(void) gdImageDestroy (gdImagePtr im)
 	gdFree (im);
 }
 
+/*
+	Function: gdImageColorClosest
+*/
 BGD_DECLARE(int) gdImageColorClosest (gdImagePtr im, int r, int g, int b)
 {
 	return gdImageColorClosestAlpha (im, r, g, b, gdAlphaOpaque);
 }
 
+/*
+	Function: gdImageColorClosestAlpha
+*/
 BGD_DECLARE(int) gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a)
 {
 	int i;
@@ -557,6 +573,9 @@ HWB_to_RGB (HWBType HWB, RGBType * RGB)
 }
 #endif
 
+/*
+	Function: gdImageColorClosestHWB
+*/
 BGD_DECLARE(int) gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b)
 {
 	int i;
@@ -582,11 +601,17 @@ BGD_DECLARE(int) gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b)
 	return ct;
 }
 
+/*
+	Function: gdImageColorExact
+*/
 BGD_DECLARE(int) gdImageColorExact (gdImagePtr im, int r, int g, int b)
 {
 	return gdImageColorExactAlpha (im, r, g, b, gdAlphaOpaque);
 }
 
+/*
+	Function: gdImageColorExactAlpha
+*/
 BGD_DECLARE(int) gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a)
 {
 	int i;
@@ -605,11 +630,17 @@ BGD_DECLARE(int) gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int
 	return -1;
 }
 
+/*
+	Function: gdImageColorAllocate
+*/
 BGD_DECLARE(int) gdImageColorAllocate (gdImagePtr im, int r, int g, int b)
 {
 	return gdImageColorAllocateAlpha (im, r, g, b, gdAlphaOpaque);
 }
 
+/*
+	Function: gdImageColorAllocateAlpha
+*/
 BGD_DECLARE(int) gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a)
 {
 	int i;
@@ -639,21 +670,24 @@ BGD_DECLARE(int) gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b,
 }
 
 /*
- * gdImageColorResolve is an alternative for the code fragment:
+	Function: gdImageColorResolve
- *
+
- *      if ((color=gdImageColorExact(im,R,G,B)) < 0)
+	gdImageColorResolve is an alternative for the code fragment
- *        if ((color=gdImageColorAllocate(im,R,G,B)) < 0)
+	| if ((color=gdImageColorExact(im,R,G,B)) < 0)
- *          color=gdImageColorClosest(im,R,G,B);
+	|   if ((color=gdImageColorAllocate(im,R,G,B)) < 0)
- *
+	|     color=gdImageColorClosest(im,R,G,B);
- * in a single function.    Its advantage is that it is guaranteed to
+	in a single function.    Its advantage is that it is guaranteed to
- * return a color index in one search over the color table.
+	return a color index in one search over the color table.
- */
+*/
 
 BGD_DECLARE(int) gdImageColorResolve (gdImagePtr im, int r, int g, int b)
 {
 	return gdImageColorResolveAlpha (im, r, g, b, gdAlphaOpaque);
 }
 
+/*
+	Function: gdImageColorResolveAlpha
+*/
 BGD_DECLARE(int) gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a)
 {
 	int c;
@@ -705,6 +739,9 @@ BGD_DECLARE(int) gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, i
 	return op;			/* Return newly allocated color */
 }
 
+/*
+	Function: gdImageColorDeallocate
+*/
 BGD_DECLARE(void) gdImageColorDeallocate (gdImagePtr im, int color)
 {
 	if (im->trueColor || (color >= gdMaxColors) || (color < 0)) {
@@ -714,6 +751,9 @@ BGD_DECLARE(void) gdImageColorDeallocate (gdImagePtr im, int color)
 	im->open[color] = 1;
 }
 
+/*
+	Function: gdImageColorTransparent
+*/
 BGD_DECLARE(void) gdImageColorTransparent (gdImagePtr im, int color)
 {
 	if (color < 0) {
@@ -734,6 +774,9 @@ BGD_DECLARE(void) gdImageColorTransparent (gdImagePtr im, int color)
 	im->transparent = color;
 }
 
+/*
+	Function: gdImagePaletteCopy
+*/
 BGD_DECLARE(void) gdImagePaletteCopy (gdImagePtr to, gdImagePtr from)
 {
 	int i;
@@ -786,6 +829,9 @@ BGD_DECLARE(void) gdImagePaletteCopy (gdImagePtr to, gdImagePtr from)
 
 }
 
+/*
+	Function: gdImageColorReplace
+*/
 BGD_DECLARE(int) gdImageColorReplace (gdImagePtr im, int src, int dst)
 {
 	register int x, y;
@@ -817,6 +863,9 @@ BGD_DECLARE(int) gdImageColorReplace (gdImagePtr im, int src, int dst)
 	return n;
 }
 
+/*
+	Function: gdImageColorReplaceThreshold
+*/
 BGD_DECLARE(int) gdImageColorReplaceThreshold (gdImagePtr im, int src, int dst, float threshold)
 {
 	register int x, y;
@@ -855,6 +904,9 @@ static int colorCmp (const void *x, const void *y)
 	return (a > b) - (a < b);
 }
 
+/*
+	Function: gdImageColorReplaceArray
+*/
 BGD_DECLARE(int) gdImageColorReplaceArray (gdImagePtr im, int len, int *src, int *dst)
 {
 	register int x, y;
@@ -904,6 +956,9 @@ BGD_DECLARE(int) gdImageColorReplaceArray (gdImagePtr im, int len, int *src, int
 	return n;
 }
 
+/*
+	Function: gdImageColorReplaceCallback
+*/
 BGD_DECLARE(int) gdImageColorReplaceCallback (gdImagePtr im, gdCallbackImageColor callback)
 {
 	int c, d, n = 0;
@@ -1029,6 +1084,9 @@ clip_1d (int *x0, int *y0, int *x1, int *y1, int mindim, int maxdim)
 
 /* end of line clipping code */
 
+/*
+	Function: gdImageSetPixel
+*/
 BGD_DECLARE(void) gdImageSetPixel (gdImagePtr im, int x, int y, int color)
 {
 	int p;
@@ -1220,6 +1278,9 @@ gdImageTileApply (gdImagePtr im, int x, int y)
 	}
 }
 
+/*
+	Function: gdImageGetPixel
+*/
 BGD_DECLARE(int) gdImageGetPixel (gdImagePtr im, int x, int y)
 {
 	if (gdImageBoundsSafeMacro (im, x, y)) {
@@ -1233,6 +1294,9 @@ BGD_DECLARE(int) gdImageGetPixel (gdImagePtr im, int x, int y)
 	}
 }
 
+/*
+	Function: gdImageGetTrueColorPixel
+*/
 BGD_DECLARE(int) gdImageGetTrueColorPixel (gdImagePtr im, int x, int y)
 {
 	int p = gdImageGetPixel (im, x, y);
@@ -1245,9 +1309,13 @@ BGD_DECLARE(int) gdImageGetTrueColorPixel (gdImagePtr im, int x, int y)
 	}
 }
 
+/*
+	Function: gdImageAABlend
+	
+	NO-OP, kept for library compatibility.
+*/
 BGD_DECLARE(void) gdImageAABlend (gdImagePtr im)
 {
-	/* NO-OP, kept for library compatibility. */
 	(void)im;
 }
 
@@ -1294,7 +1362,11 @@ static void gdImageVLine(gdImagePtr im, int x, int y1, int y2, int col)
 	return;
 }
 
-/* Bresenham as presented in Foley & Van Dam */
+/*
+	Function: gdImageLine
+	
+	Bresenham as presented in Foley & Van Dam.
+*/
 BGD_DECLARE(void) gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
 {
 	int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
@@ -1462,6 +1534,9 @@ BGD_DECLARE(void) gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, in
 static void dashedSet (gdImagePtr im, int x, int y, int color,
 					   int *onP, int *dashStepP, int wid, int vert);
 
+/*
+	Function: gdImageDashedLine
+*/
 BGD_DECLARE(void) gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
 {
 	int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
@@ -1603,11 +1678,17 @@ dashedSet (gdImagePtr im, int x, int y, int color,
 	*onP = on;
 }
 
+/*
+	Function: gdImageBoundsSafe
+*/
 BGD_DECLARE(int) gdImageBoundsSafe (gdImagePtr im, int x, int y)
 {
 	return gdImageBoundsSafeMacro (im, x, y);
 }
 
+/*
+	Function: gdImageChar
+*/
 BGD_DECLARE(void) gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
 {
 	int cx, cy;
@@ -1634,6 +1715,9 @@ BGD_DECLARE(void) gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c,
 	}
 }
 
+/*
+	Function: gdImageCharUp
+*/
 BGD_DECLARE(void) gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
 {
 	int cx, cy;
@@ -1660,6 +1744,9 @@ BGD_DECLARE(void) gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, int c
 	}
 }
 
+/*
+	Function: gdImageString
+*/
 BGD_DECLARE(void) gdImageString (gdImagePtr im, gdFontPtr f,
 								 int x, int y, unsigned char *s, int color)
 {
@@ -1672,6 +1759,9 @@ BGD_DECLARE(void) gdImageString (gdImagePtr im, gdFontPtr f,
 	}
 }
 
+/*
+	Function: gdImageStringUp
+*/
 BGD_DECLARE(void) gdImageStringUp (gdImagePtr im, gdFontPtr f,
 								   int x, int y, unsigned char *s, int color)
 {
@@ -1686,6 +1776,9 @@ BGD_DECLARE(void) gdImageStringUp (gdImagePtr im, gdFontPtr f,
 
 static int strlen16 (unsigned short *s);
 
+/*
+	Function: gdImageString16
+*/
 BGD_DECLARE(void) gdImageString16 (gdImagePtr im, gdFontPtr f,
 								   int x, int y, unsigned short *s, int color)
 {
@@ -1698,6 +1791,9 @@ BGD_DECLARE(void) gdImageString16 (gdImagePtr im, gdFontPtr f,
 	}
 }
 
+/*
+	Function: gdImageStringUp16
+*/
 BGD_DECLARE(void) gdImageStringUp16 (gdImagePtr im, gdFontPtr f,
 									 int x, int y, unsigned short *s, int color)
 {
@@ -1738,12 +1834,18 @@ lsqrt (long n)
    cx and cy are the center in pixels; w and h are the horizontal
    and vertical diameter in pixels. */
 
+/*
+	Function: gdImageArc
+*/
 BGD_DECLARE(void) gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e,
 							  int color)
 {
 	gdImageFilledArc (im, cx, cy, w, h, s, e, color, gdNoFill);
 }
 
+/*
+	Function: gdImageFilledArc
+*/
 BGD_DECLARE(void) gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e,
 									int color, int style)
 {
@@ -1844,6 +1946,9 @@ BGD_DECLARE(void) gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h,
 	}
 }
 
+/*
+	Function: gdImageEllipse
+*/
 BGD_DECLARE(void) gdImageEllipse(gdImagePtr im, int mx, int my, int w, int h, int c)
 {
 	int x=0,mx1=0,mx2=0,my1=0,my2=0;
@@ -1888,6 +1993,9 @@ BGD_DECLARE(void) gdImageEllipse(gdImagePtr im, int mx, int my, int w, int h, in
 }
 
 
+/*
+	Function: gdImageFilledEllipse
+*/
 BGD_DECLARE(void) gdImageFilledEllipse (gdImagePtr im, int mx, int my, int w, int h, int c)
 {
 	int x=0,mx1=0,mx2=0,my1=0,my2=0;
@@ -1941,6 +2049,9 @@ BGD_DECLARE(void) gdImageFilledEllipse (gdImagePtr im, int mx, int my, int w, in
 	}
 }
 
+/*
+	Function: gdImageFillToBorder
+*/
 BGD_DECLARE(void) gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color)
 {
 	int lastBorder;
@@ -2086,6 +2197,10 @@ struct seg {
 	{sp--; Y = sp->y+(DY = sp->dy); XL = sp->xl; XR = sp->xr;}
 
 static void _gdImageFillTiled(gdImagePtr im, int x, int y, int nc);
+
+/*
+	Function: gdImageFill
+*/
 BGD_DECLARE(void) gdImageFill(gdImagePtr im, int x, int y, int nc)
 {
 	int l, x1, x2, dy;
@@ -2279,6 +2394,9 @@ skip:
 	gdFree(stack);
 }
 
+/*
+	Function: gdImageRectangle
+*/
 BGD_DECLARE(void) gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
 {
 	int thick = im->thick;
@@ -2450,12 +2568,18 @@ static void _gdImageFilledVRectangle (gdImagePtr im, int x1, int y1, int x2, int
 	}
 }
 
+/*
+	Function: gdImageFilledRectangle
+*/
 BGD_DECLARE(void) gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2,
 		int color)
 {
 	_gdImageFilledVRectangle(im, x1, y1, x2, y2, color);
 }
 
+/*
+	Function: gdImageClone
+*/
 BGD_DECLARE(gdImagePtr) gdImageClone (gdImagePtr src) {
 	gdImagePtr dst;
 	register int i, x;
@@ -2551,6 +2675,9 @@ BGD_DECLARE(gdImagePtr) gdImageClone (gdImagePtr src) {
 	return dst;
 }
 
+/*
+	Function: gdImageCopy
+*/
 BGD_DECLARE(void) gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX,
 							   int srcY, int w, int h)
 {
@@ -2638,8 +2765,12 @@ BGD_DECLARE(void) gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dst
 	}
 }
 
-/* This function is a substitute for real alpha channel operations,
+/*
-   so it doesn't pay attention to the alpha channel. */
+	Function: gdImageCopyMerge
+
+	This function is a substitute for real alpha channel operations,
+	so it doesn't pay attention to the alpha channel.
+*/
 BGD_DECLARE(void) gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
 									int srcX, int srcY, int w, int h, int pct)
 {
@@ -2682,8 +2813,12 @@ BGD_DECLARE(void) gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, in
 	}
 }
 
-/* This function is a substitute for real alpha channel operations,
+/*
-   so it doesn't pay attention to the alpha channel. */
+	Function: gdImageCopyMergeGray
+
+	This function is a substitute for real alpha channel operations,
+	so it doesn't pay attention to the alpha channel.
+*/
 BGD_DECLARE(void) gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
 										int srcX, int srcY, int w, int h, int pct)
 {
@@ -2742,6 +2877,9 @@ BGD_DECLARE(void) gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX
 	}
 }
 
+/*
+	Function: gdImageCopyResized
+*/
 BGD_DECLARE(void) gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
 									  int srcX, int srcY, int dstW, int dstH, int srcW,
 									  int srcH)
@@ -2878,6 +3016,9 @@ BGD_DECLARE(void) gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX,
 	coordinates allow accurate rotation of
 	objects of odd-numbered width or height. */
 
+/*
+	Function: gdImageCopyRotated
+*/
 BGD_DECLARE(void) gdImageCopyRotated (gdImagePtr dst,
 									  gdImagePtr src,
 									  double dstX, double dstY,
@@ -2961,6 +3102,9 @@ BGD_DECLARE(void) gdImageCopyRotated (gdImagePtr dst,
 #define floor2(exp) ((long) exp)
 /*#define floor2(exp) floor(exp)*/
 
+/*
+	Function: gdImageCopyResampled
+*/
 BGD_DECLARE(void) gdImageCopyResampled (gdImagePtr dst,
 										gdImagePtr src,
 										int dstX, int dstY,
@@ -3063,6 +3207,9 @@ BGD_DECLARE(void) gdImageCopyResampled (gdImagePtr dst,
 	}
 }
 
+/*
+	Function: gdImagePolygon
+*/
 BGD_DECLARE(void) gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c)
 {
 	if (n <= 0) {
@@ -3074,6 +3221,9 @@ BGD_DECLARE(void) gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c)
 	gdImageOpenPolygon (im, p, n, c);
 }
 
+/*
+	Function: gdImageOpenPolygon
+*/
 BGD_DECLARE(void) gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
 {
 	int i;
@@ -3101,6 +3251,9 @@ BGD_DECLARE(void) gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
 /* That could help to adjust intersections  to produce a nice */
 /* interior_extrema. */
 
+/*
+	Function: gdImageFilledPolygon
+*/
 BGD_DECLARE(void) gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
 {
 	int i;
@@ -3244,6 +3397,9 @@ BGD_DECLARE(void) gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int
 
 static void gdImageSetAAPixelColor(gdImagePtr im, int x, int y, int color, int t);
 
+/*
+	Function: gdImageSetStyle
+*/
 BGD_DECLARE(void) gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels)
 {
 	if (im->style) {
@@ -3261,11 +3417,17 @@ BGD_DECLARE(void) gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels)
 	im->stylePos = 0;
 }
 
+/*
+	Function: gdImageSetThickness
+*/
 BGD_DECLARE(void) gdImageSetThickness (gdImagePtr im, int thickness)
 {
 	im->thick = thickness;
 }
 
+/*
+	Function: gdImageSetBrush
+*/
 BGD_DECLARE(void) gdImageSetBrush (gdImagePtr im, gdImagePtr brush)
 {
 	int i;
@@ -3283,6 +3445,9 @@ BGD_DECLARE(void) gdImageSetBrush (gdImagePtr im, gdImagePtr brush)
 	}
 }
 
+/*
+	Function: gdImageSetTile
+*/
 BGD_DECLARE(void) gdImageSetTile (gdImagePtr im, gdImagePtr tile)
 {
 	int i;
@@ -3300,6 +3465,9 @@ BGD_DECLARE(void) gdImageSetTile (gdImagePtr im, gdImagePtr tile)
 	}
 }
 
+/*
+	Function: gdImageSetAntiAliased
+*/
 BGD_DECLARE(void) gdImageSetAntiAliased (gdImagePtr im, int c)
 {
 	im->AA = 1;
@@ -3307,6 +3475,9 @@ BGD_DECLARE(void) gdImageSetAntiAliased (gdImagePtr im, int c)
 	im->AA_dont_blend = -1;
 }
 
+/*
+	Function: gdImageSetAntiAliasedDontBlend
+*/
 BGD_DECLARE(void) gdImageSetAntiAliasedDontBlend (gdImagePtr im, int c, int dont_blend)
 {
 	im->AA = 1;
@@ -3314,11 +3485,17 @@ BGD_DECLARE(void) gdImageSetAntiAliasedDontBlend (gdImagePtr im, int c, int dont
 	im->AA_dont_blend = dont_blend;
 }
 
+/*
+	Function: gdImageInterlace
+*/
 BGD_DECLARE(void) gdImageInterlace (gdImagePtr im, int interlaceArg)
 {
 	im->interlace = interlaceArg;
 }
 
+/*
+	Function: gdImageCompare
+*/
 BGD_DECLARE(int) gdImageCompare (gdImagePtr im1, gdImagePtr im2)
 {
 	int x, y;
@@ -3401,6 +3578,9 @@ BGD_DECLARE(int) gdImageCompare (gdImagePtr im1, gdImagePtr im2)
 	of gdAlphaBlend(), which merges alpha in the
 	destination color much better. */
 
+/*
+	Function: gdAlphaBlend
+*/
 BGD_DECLARE(int) gdAlphaBlend (int dst, int src)
 {
 	int src_alpha = gdTrueColorGetAlpha(src);
@@ -3447,6 +3627,10 @@ BGD_DECLARE(int) gdAlphaBlend (int dst, int src)
 }
 
 static int gdAlphaOverlayColor (int src, int dst, int max );
+
+/*
+	Function: gdLayerOverlay
+*/
 BGD_DECLARE(int) gdLayerOverlay (int dst, int src)
 {
 	int a1, a2;
@@ -3472,7 +3656,11 @@ static int gdAlphaOverlayColor (int src, int dst, int max )
 	}
 }
 
-/* Apply 'multiply' effect */
+/*
+	Function: gdLayerMultiply
+
+	Apply 'multiply' effect.
+*/
 BGD_DECLARE(int) gdLayerMultiply (int dst, int src)
 {
 	int a1, a2, r1, r2, g1, g2, b1, b2;
@@ -3495,16 +3683,25 @@ BGD_DECLARE(int) gdLayerMultiply (int dst, int src)
 		);
 }
 
+/*
+	Function: gdImageAlphaBlending
+*/
 BGD_DECLARE(void) gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg)
 {
 	im->alphaBlendingFlag = alphaBlendingArg;
 }
 
+/*
+	Function: gdImageSaveAlpha
+*/
 BGD_DECLARE(void) gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg)
 {
 	im->saveAlphaFlag = saveAlphaArg;
 }
 
+/*
+	Function: gdImageSetClip
+*/
 BGD_DECLARE(void) gdImageSetClip (gdImagePtr im, int x1, int y1, int x2, int y2)
 {
 	if (x1 < 0) {
@@ -3537,6 +3734,9 @@ BGD_DECLARE(void) gdImageSetClip (gdImagePtr im, int x1, int y1, int x2, int y2)
 	im->cy2 = y2;
 }
 
+/*
+	Function: gdImageGetClip
+*/
 BGD_DECLARE(void) gdImageGetClip (gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P)
 {
 	*x1P = im->cx1;
@@ -3545,6 +3745,9 @@ BGD_DECLARE(void) gdImageGetClip (gdImagePtr im, int *x1P, int *y1P, int *x2P, i
 	*y2P = im->cy2;
 }
 
+/*
+	Function: gdImageSetResolution
+*/
 BGD_DECLARE(void) gdImageSetResolution(gdImagePtr im, const unsigned int res_x, const unsigned int res_y)
 {
 	if (res_x > 0) im->res_x = res_x;
@@ -3702,7 +3905,11 @@ static void gdImageAALine (gdImagePtr im, int x1, int y1, int x2, int y2, int co
 }
 
 
-/* convert a palette image to true color */
+/*
+	Function: gdImagePaletteToTrueColor
+	
+	Convert a palette image to true color.
+*/
 BGD_DECLARE(int) gdImagePaletteToTrueColor(gdImagePtr src)
 {
 	unsigned int y;

src/gd_bmp.c

@@ -60,6 +60,9 @@ static int gdBMPPutInt(gdIOCtx *out, int w)
 	return 0;
 }
 
+/*
+	Function: gdImageBmpPtr
+*/
 BGD_DECLARE(void *) gdImageBmpPtr(gdImagePtr im, int *size, int compression)
 {
 	void *rv;
@@ -71,6 +74,9 @@ BGD_DECLARE(void *) gdImageBmpPtr(gdImagePtr im, int *size, int compression)
 	return rv;
 }
 
+/*
+	Function: gdImageBmp
+*/
 BGD_DECLARE(void) gdImageBmp(gdImagePtr im, FILE *outFile, int compression)
 {
 	gdIOCtx *out = gdNewFileCtx(outFile);
@@ -79,6 +85,9 @@ BGD_DECLARE(void) gdImageBmp(gdImagePtr im, FILE *outFile, int compression)
 	out->gd_free(out);
 }
 
+/*
+	Function: gdImageBmpCtx
+*/
 BGD_DECLARE(void) gdImageBmpCtx(gdImagePtr im, gdIOCtxPtr out, int compression)
 {
 	int bitmap_size = 0, info_size, total_size, padding;
@@ -397,6 +406,9 @@ static int build_rle_packet(unsigned char *row, int packet_type, int length, uns
 	return compressed_size;
 }
 
+/*
+	Function: gdImageCreateFromBmp
+*/
 BGD_DECLARE(gdImagePtr) gdImageCreateFromBmp(FILE * inFile)
 {
 	gdImagePtr im = 0;
@@ -407,6 +419,9 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromBmp(FILE * inFile)
 	return im;
 }
 
+/*
+	Function: gdImageCreateFromBmpPtr
+*/
 BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpPtr(int size, void *data)
 {
 	gdImagePtr im;
@@ -417,6 +432,9 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpPtr(int size, void *data)
 	return im;
 }
 
+/*
+	Function: gdImageCreateFromBmpCtx
+*/
 BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpCtx(gdIOCtxPtr infile)
 {
 	bmp_hdr_t *hdr;

src/gd_color_map.c

@@ -767,6 +767,9 @@ BGD_EXPORT_DATA_PROT gdColorMap GD_COLOR_MAP_X11 = {
 	(gdColorMapEntry *)GD_COLOR_MAP_X11_ENTRIES
 };
 
+/*
+	Function: gdColorMapLookup
+*/
 BGD_DECLARE(int)
 gdColorMapLookup(const gdColorMap color_map, const char *color_name, int *r, int *g, int *b)
 {

src/gd_color_match.c

@@ -5,8 +5,10 @@
 #include "gd.h"
 #include "gdhelpers.h"
 
-/* bring the palette colors in im2 to be closer to im1
+/*
- *
+	Function: gdImageColorMatch
+
+	Bring the palette colors in im2 to be closer to im1.
  */
 BGD_DECLARE(int) gdImageColorMatch (gdImagePtr im1, gdImagePtr im2)
 {

src/gd_crop.c

@@ -18,6 +18,9 @@
 
 static int gdGuessBackgroundColorFromCorners(gdImagePtr im, int *color);
 
+/*
+	Function: gdImageCrop
+ */
 BGD_DECLARE(gdImagePtr) gdImageCrop(gdImagePtr src, const gdRect *crop)
 {
 	gdImagePtr dst;
@@ -29,6 +32,9 @@ BGD_DECLARE(gdImagePtr) gdImageCrop(gdImagePtr src, const gdRect *crop)
 	return dst;
 }
 
+/*
+	Function: gdImageCropAuto
+ */
 BGD_DECLARE(gdImagePtr) gdImageCropAuto(gdImagePtr im, const unsigned int mode)
 {
 	const int width = gdImageSX(im);
@@ -117,6 +123,9 @@ BGD_DECLARE(gdImagePtr) gdImageCropAuto(gdImagePtr im, const unsigned int mode)
 	return gdImageCrop(im, &crop);
 }
 
+/*
+	Function: gdImageCropThreshold
+ */
 BGD_DECLARE(gdImagePtr) gdImageCropThreshold(gdImagePtr im, const unsigned int color, const float threshold)
 {
 	const int width = gdImageSX(im);

src/gd_filter.c

@@ -34,6 +34,9 @@ typedef int (BGD_STDCALL *FuncPtr)(gdImagePtr, int, int);
 # define GD_SCATTER_SEED() (unsigned int)(time(0) * getpid())
 #endif
 
+/*
+	Function: gdImageScatter
+ */
 BGD_DECLARE(int) gdImageScatter(gdImagePtr im, int sub, int plus)
 {
 	gdScatter s;
@@ -45,6 +48,9 @@ BGD_DECLARE(int) gdImageScatter(gdImagePtr im, int sub, int plus)
 	return gdImageScatterEx(im, &s);
 }
 
+/*
+	Function: gdImageScatterColor
+ */
 BGD_DECLARE(int) gdImageScatterColor(gdImagePtr im, int sub, int plus, int colors[], unsigned int num_colors)
 {
 	gdScatter s;
@@ -57,6 +63,9 @@ BGD_DECLARE(int) gdImageScatterColor(gdImagePtr im, int sub, int plus, int color
 	return gdImageScatterEx(im, &s);
 }
 
+/*
+	Function: gdImageScatterEx
+ */
 BGD_DECLARE(int) gdImageScatterEx(gdImagePtr im, gdScatterPtr scatter)
 {
 	register int x, y;
@@ -116,6 +125,9 @@ BGD_DECLARE(int) gdImageScatterEx(gdImagePtr im, gdScatterPtr scatter)
 	return 1;
 }
 
+/*
+	Function: gdImagePixelate
+ */
 BGD_DECLARE(int) gdImagePixelate(gdImagePtr im, int block_size, const unsigned int mode)
 {
 	int x, y;
@@ -172,7 +184,11 @@ BGD_DECLARE(int) gdImagePixelate(gdImagePtr im, int block_size, const unsigned i
 	return 1;
 }
 
-/* invert src image */
+/*
+	Function: gdImageNegate
+	
+	Invert src image.
+ */
 BGD_DECLARE(int) gdImageNegate(gdImagePtr src)
 {
 	int x, y;
@@ -204,7 +220,11 @@ BGD_DECLARE(int) gdImageNegate(gdImagePtr src)
 	return 1;
 }
 
-/* Convert the image src to a grayscale image */
+/*
+	Function: gdImageGrayScale
+	
+	Convert the image src to a grayscale image.
+ */
 BGD_DECLARE(int) gdImageGrayScale(gdImagePtr src)
 {
 	int x, y;
@@ -237,7 +257,11 @@ BGD_DECLARE(int) gdImageGrayScale(gdImagePtr src)
 	return 1;
 }
 
-/* Set the brightness level <level> for the image src */
+/*
+	Function: gdImageBrightness
+	
+	Set the brightness level <level> for the image src.
+ */
 BGD_DECLARE(int) gdImageBrightness(gdImagePtr src, int brightness)
 {
 	int x, y;
@@ -283,6 +307,9 @@ BGD_DECLARE(int) gdImageBrightness(gdImagePtr src, int brightness)
 }
 
 
+/*
+	Function: gdImageContrast
+ */
 BGD_DECLARE(int) gdImageContrast(gdImagePtr src, double contrast)
 {
 	int x, y;
@@ -343,6 +370,9 @@ BGD_DECLARE(int) gdImageContrast(gdImagePtr src, double contrast)
 }
 
 
+/*
+	Function: gdImageColor
+ */
 BGD_DECLARE(int) gdImageColor(gdImagePtr src, const int red, const int green, const int blue, const int alpha)
 {
 	int x, y;
@@ -385,6 +415,9 @@ BGD_DECLARE(int) gdImageColor(gdImagePtr src, const int red, const int green, co
 	return 1;
 }
 
+/*
+	Function: gdImageConvolution
+ */
 BGD_DECLARE(int) gdImageConvolution(gdImagePtr src, float filter[3][3], float filter_div, float offset)
 {
 	int         x, y, i, j, new_a;
@@ -445,6 +478,9 @@ BGD_DECLARE(int) gdImageConvolution(gdImagePtr src, float filter[3][3], float fi
 	return 1;
 }
 
+/*
+	Function: gdImageSelectiveBlur
+ */
 BGD_DECLARE(int) gdImageSelectiveBlur( gdImagePtr src)
 {
 	int         x, y, i, j;
@@ -563,6 +599,9 @@ BGD_DECLARE(int) gdImageSelectiveBlur( gdImagePtr src)
 	return 1;
 }
 
+/*
+	Function: gdImageEdgeDetectQuick
+ */
 BGD_DECLARE(int) gdImageEdgeDetectQuick(gdImagePtr src)
 {
 	float filter[3][3] =	{{-1.0,0.0,-1.0},
@@ -603,6 +642,9 @@ BGD_DECLARE(int) gdImageGaussianBlur(gdImagePtr im)
 	return gdImageConvolution(im, filter, 16, 0);
 }
 
+/*
+	Function: gdImageEmboss
+ */
 BGD_DECLARE(int) gdImageEmboss(gdImagePtr im)
 {
 /*
@@ -617,6 +659,9 @@ BGD_DECLARE(int) gdImageEmboss(gdImagePtr im)
 	return gdImageConvolution(im, filter, 1, 127);
 }
 
+/*
+	Function: gdImageMeanRemoval
+ */
 BGD_DECLARE(int) gdImageMeanRemoval(gdImagePtr im)
 {
 	float filter[3][3] =	{{-1.0,-1.0,-1.0},
@@ -626,6 +671,9 @@ BGD_DECLARE(int) gdImageMeanRemoval(gdImagePtr im)
 	return gdImageConvolution(im, filter, 1, 0);
 }
 
+/*
+	Function: gdImageSmooth
+ */
 BGD_DECLARE(int) gdImageSmooth(gdImagePtr im, float weight)
 {
 	float filter[3][3] =	{{1.0,1.0,1.0},

src/gd_gd.c

@@ -326,6 +326,9 @@ _gdImageGd (gdImagePtr im, gdIOCtx * out)
 	}
 }
 
+/*
+	Function: gdImageGd
+ */
 BGD_DECLARE(void) gdImageGd (gdImagePtr im, FILE * outFile)
 {
 	gdIOCtx *out = gdNewFileCtx (outFile);
@@ -334,6 +337,9 @@ BGD_DECLARE(void) gdImageGd (gdImagePtr im, FILE * outFile)
 	out->gd_free (out);
 }
 
+/*
+	Function: gdImageGdPtr
+ */
 BGD_DECLARE(void *) gdImageGdPtr (gdImagePtr im, int *size)
 {
 	void *rv;

src/gd_gd2.c

@@ -1043,6 +1043,9 @@ fail:
 
 }
 
+/*
+	Function: gdImageGd2
+*/
 BGD_DECLARE(void) gdImageGd2 (gdImagePtr im, FILE * outFile, int cs, int fmt)
 {
 	gdIOCtx *out = gdNewFileCtx (outFile);
@@ -1051,6 +1054,9 @@ BGD_DECLARE(void) gdImageGd2 (gdImagePtr im, FILE * outFile, int cs, int fmt)
 	out->gd_free (out);
 }
 
+/*
+	Function: gdImageGd2Ptr
+*/
 BGD_DECLARE(void *) gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size)
 {
 	void *rv;

src/gd_interpolation.c

@@ -1607,6 +1607,9 @@ gdImageScaleBicubicFixed(gdImagePtr src, const unsigned int width,
 	return dst;
 }
 
+/*
+	Function: gdImageScale
+*/
 BGD_DECLARE(gdImagePtr) gdImageScale(const gdImagePtr src, const unsigned int new_width, const unsigned int new_height)
 {
 	gdImagePtr im_scaled = NULL;
@@ -1793,6 +1796,9 @@ gdImageRotateGeneric(gdImagePtr src, const float degrees, const int bgColor)
 	return dst;
 }
 
+/*
+	Function: gdImageRotateInterpolated
+*/
 BGD_DECLARE(gdImagePtr) gdImageRotateInterpolated(const gdImagePtr src, const float angle, int bgcolor)
 {
 	/* round to two decimals and keep the 100x multiplication to use it in the common square angles 
@@ -2111,6 +2117,9 @@ BGD_DECLARE(int) gdTransformAffineBoundingBox(gdRectPtr src, const double affine
 	return GD_TRUE;
 }
 
+/*
+	Function: gdImageSetInterpolationMethod
+*/
 BGD_DECLARE(int) gdImageSetInterpolationMethod(gdImagePtr im, gdInterpolationMethod id)
 {
 	if (im == NULL || (uintmax_t)id > GD_METHOD_COUNT) {
@@ -2193,9 +2202,13 @@ BGD_DECLARE(int) gdImageSetInterpolationMethod(gdImagePtr im, gdInterpolationMet
 }
 
 
-/* Return the interpolation mode set in 'im'.  This is here so that
+/*
- * the value can be read via a language or VM with an FFI but no
+	Function: gdImageGetInterpolationMethod
- * (portable) way to extract the value from the struct. */
+
+	Return the interpolation mode set in 'im'.  This is here so that
+	the value can be read via a language or VM with an FFI but no
+	(portable) way to extract the value from the struct.
+*/
 BGD_DECLARE(gdInterpolationMethod) gdImageGetInterpolationMethod(gdImagePtr im)
 {
     return im->interpolation_id;

src/gd_io_dp.c

@@ -64,13 +64,20 @@ static int dynamicGetchar(gdIOCtxPtr ctx);
 static int dynamicSeek(struct gdIOCtx *, const int);
 static long dynamicTell(struct gdIOCtx *);
 
-/* return data as a dynamic pointer */
+/*
+	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;
@@ -103,6 +110,9 @@ BGD_DECLARE(gdIOCtx *) gdNewDynamicCtxEx(int initialSize, void *data, int freeOK
 	return (gdIOCtx *)ctx;
 }
 
+/*
+	Function: gdDPExtractData
+*/
 BGD_DECLARE(void *) gdDPExtractData (struct gdIOCtx *ctx, int *size)
 {
 	dynamicPtr *dp;

src/gd_io_file.c

@@ -48,7 +48,11 @@ static int fileSeek(struct gdIOCtx *, const int);
 static long fileTell(struct gdIOCtx *);
 static void gdFreeFileCtx(gdIOCtx *ctx);
 
-/* return data as a dynamic pointer */
+/*
+	Function: gdNewFileCtx
+
+	Return data as a dynamic pointer.
+*/
 BGD_DECLARE(gdIOCtx *) gdNewFileCtx(FILE *f)
 {
 	fileIOCtx *ctx;

src/gd_io_ss.c

@@ -47,7 +47,11 @@ static int sinkPutbuf(gdIOCtx *ctx, const void *buf, int size);
 static void sinkPutchar(gdIOCtx *ctx, int a);
 static void gdFreeSsCtx(gdIOCtx *ctx);
 
-/* return data as a dynamic pointer */
+/*
+	Function: gdNewSSCtx
+
+	Return data as a dynamic pointer.
+*/
 BGD_DECLARE(gdIOCtx *) gdNewSSCtx(gdSourcePtr src, gdSinkPtr snk)
 {
 	ssIOCtxPtr ctx;

src/gd_nnquant.c

@@ -506,6 +506,9 @@ int verbose;
 	if (verbose) gd_error_ex(GD_NOTICE, "finished 1D learning: final alpha=%f !\n",((float)alpha)/initalpha);
 }
 
+/*
+	Function: gdImageNeuQuant
+*/
 BGD_DECLARE(gdImagePtr) gdImageNeuQuant(gdImagePtr im, const int max_color, int sample_factor)
 {
 	const int newcolors = max_color;

src/gd_ss.c

@@ -18,6 +18,9 @@
 #define GD_SS_DBG(s)
 
 #ifdef HAVE_LIBPNG
+/*
+	Function: gdImagePngToSink
+*/
 BGD_DECLARE(void) gdImagePngToSink (gdImagePtr im, gdSinkPtr outSink)
 {
 	gdIOCtx *out = gdNewSSCtx (NULL, outSink);

src/gd_tga.c

@@ -12,10 +12,14 @@
 #include "gd_errors.h"
 #include "gdhelpers.h"
 
-/*!	\brief Creates a gdImage from a TGA file
+/*
- *	Creates a gdImage from a TGA binary file via a gdIOCtx.
+	Function: gdImageCreateFromTga
- *	\param infile Pointer to TGA binary file
+
- *	\return gdImagePtr
+	Creates a gdImage from a TGA file
+
+	Parameters:
+
+		infile - Pointer to TGA binary file
  */
 BGD_DECLARE(gdImagePtr) gdImageCreateFromTga(FILE *fp)
 {
@@ -27,6 +31,9 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromTga(FILE *fp)
 	return image;
 }
 
+/*
+	Function: gdImageCreateFromTgaPtr
+*/
 BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaPtr(int size, void *data)
 {
 	gdImagePtr im;
@@ -38,10 +45,13 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaPtr(int size, void *data)
 }
 
 
-/*!	\brief Creates a gdImage from a gdIOCtx
+/*
- *	Creates a gdImage from a gdIOCtx referencing a TGA binary file.
+	Function: gdImageCreateFromTgaCtx
- *	\param ctx Pointer to a gdIOCtx structure
+
- *	\return gdImagePtr
+	Creates a gdImage from a gdIOCtx referencing a TGA binary file.
+
+	Parameters:
+		ctx - Pointer to a gdIOCtx structure
  */
 BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaCtx(gdIOCtx* ctx)
 {

src/gd_tiff.c

@@ -408,13 +408,15 @@ void tiffWriter(gdImagePtr image, gdIOCtx *out, int bitDepth)
 }
 
 /*
-  gdImageTiffCtx
+	Function: gdImageTiffCtx
-  --------------
+
-  Write the gd image as a tiff file
+	Write the gd image as a tiff file.
-  Parameters are:
+
-  image:  gd image structure;
+	Parameters:
-  out:    the stream where to write
+
- */
+		image - gd image structure;
+		out   - the stream where to write
+*/
 BGD_DECLARE(void) gdImageTiffCtx(gdImagePtr image, gdIOCtx *out)
 {
 	int clipx1P, clipy1P, clipx2P, clipy2P;
@@ -782,10 +784,11 @@ static int createFromTiffRgba(TIFF * tif, gdImagePtr im)
 	return GD_SUCCESS;
 }
 
-/* gdImageCreateFromTiffCtx
+/*
-** ------------------------
+	Function: gdImageCreateFromTiffCtx
-** Create a gdImage from a TIFF file input from an gdIOCtx
+
- */
+	Create a gdImage from a TIFF file input from an gdIOCtx.
+*/
 BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffCtx(gdIOCtx *infile)
 {
 	TIFF *tif;
@@ -991,9 +994,9 @@ error:
 	return im;
 }
 
-/* gdImageCreateFromTIFF
+/*
-** ---------------------
+	Function: gdImageCreateFromTIFF
- */
+*/
 BGD_DECLARE(gdImagePtr) gdImageCreateFromTiff(FILE *inFile)
 {
 	gdImagePtr im;
@@ -1004,6 +1007,9 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromTiff(FILE *inFile)
 	return im;
 }
 
+/*
+	Function: gdImageCreateFromTiffPtr
+*/
 BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffPtr(int size, void *data)
 {
 	gdImagePtr im;
@@ -1014,9 +1020,9 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffPtr(int size, void *data)
 	return im;
 }
 
-/* gdImageTIFF
+/*
-** -----------
+	Function: gdImageTiff
- */
+*/
 BGD_DECLARE(void) gdImageTiff(gdImagePtr im, FILE *outFile)
 {
 	gdIOCtx *out = gdNewFileCtx(outFile);
@@ -1025,9 +1031,9 @@ BGD_DECLARE(void) gdImageTiff(gdImagePtr im, FILE *outFile)
 	out->gd_free(out);
 }
 
-/* gdImageTIFFPtr
+/*
-** --------------
+	Function: gdImageTiffPtr
- */
+*/
 BGD_DECLARE(void *) gdImageTiffPtr(gdImagePtr im, int *size)
 {
 	void *rv;

src/gd_topal.c

@@ -1366,12 +1366,14 @@ zeroHistogram (hist3d histogram)
 
 
 /*
-  Selects quantization method used for subsequent gdImageTrueColorToPalette calls.
+	Function: gdImageTrueColorToPaletteSetMethod
-  See gdPaletteQuantizationMethod enum (e.g. GD_QUANT_NEUQUANT, GD_QUANT_LIQ).
-  Speed is from 1 (highest quality) to 10 (fastest).
-  Speed 0 selects method-specific default (recommended).
 
-  Returns FALSE if the given method is invalid or not available.
+	Selects quantization method used for subsequent gdImageTrueColorToPalette calls.
+	See gdPaletteQuantizationMethod enum (e.g. GD_QUANT_NEUQUANT, GD_QUANT_LIQ).
+	Speed is from 1 (highest quality) to 10 (fastest).
+	Speed 0 selects method-specific default (recommended).
+
+	Returns FALSE if the given method is invalid or not available.
 */
 BGD_DECLARE(int) gdImageTrueColorToPaletteSetMethod (gdImagePtr im, int method, int speed)
 {
@@ -1393,11 +1395,13 @@ BGD_DECLARE(int) gdImageTrueColorToPaletteSetMethod (gdImagePtr im, int method,
 }
 
 /*
-  Chooses quality range that subsequent call to gdImageTrueColorToPalette will aim for.
+	Function: gdImageTrueColorToPaletteSetQuality
-  Min and max quality is in range 1-100 (1 = ugly, 100 = perfect). Max must be higher than min.
+
-  If palette cannot represent image with at least min_quality, then image will remain true-color.
+	Chooses quality range that subsequent call to gdImageTrueColorToPalette will aim for.
-  If palette can represent image with quality better than max_quality, then lower number of colors will be used.
+	Min and max quality is in range 1-100 (1 = ugly, 100 = perfect). Max must be higher than min.
-  This function has effect only when GD_QUANT_LIQ method has been selected.
+	If palette cannot represent image with at least min_quality, then image will remain true-color.
+	If palette can represent image with quality better than max_quality, then lower number of colors will be used.
+	This function has effect only when GD_QUANT_LIQ method has been selected.
 */
 BGD_DECLARE(void) gdImageTrueColorToPaletteSetQuality (gdImagePtr im, int min_quality, int max_quality)
 {
@@ -1410,6 +1414,9 @@ BGD_DECLARE(void) gdImageTrueColorToPaletteSetQuality (gdImagePtr im, int min_qu
 
 static int gdImageTrueColorToPaletteBody (gdImagePtr oim, int dither, int colorsWanted, gdImagePtr *cimP);
 
+/*
+	Function: gdImageCreatePaletteFromTrueColor
+*/
 BGD_DECLARE(gdImagePtr) gdImageCreatePaletteFromTrueColor (gdImagePtr im, int dither, int colorsWanted)
 {
 	gdImagePtr nim;
@@ -1419,6 +1426,9 @@ BGD_DECLARE(gdImagePtr) gdImageCreatePaletteFromTrueColor (gdImagePtr im, int di
 	return NULL;
 }
 
+/*
+	Function: gdImageTrueColorToPalette
+*/
 BGD_DECLARE(int) gdImageTrueColorToPalette (gdImagePtr im, int dither, int colorsWanted)
 {
 	return gdImageTrueColorToPaletteBody(im, dither, colorsWanted, 0);

src/gd_transform.c

@@ -4,6 +4,9 @@
 
 #include "gd.h"
 
+/*
+	Function: gdImageFlipVertical
+*/
 BGD_DECLARE(void) gdImageFlipVertical(gdImagePtr im)
 {
 	register int x, y;
@@ -32,6 +35,9 @@ BGD_DECLARE(void) gdImageFlipVertical(gdImagePtr im)
 	return;
 }
 
+/*
+	Function: gdImageFlipHorizontal
+*/
 BGD_DECLARE(void) gdImageFlipHorizontal(gdImagePtr im)
 {
 
@@ -68,6 +74,9 @@ BGD_DECLARE(void) gdImageFlipHorizontal(gdImagePtr im)
 	}
 }
 
+/*
+	Function: gdImageFlipBoth
+*/
 BGD_DECLARE(void) gdImageFlipBoth(gdImagePtr im)
 {
 	gdImageFlipVertical(im);

src/gd_version.c

@@ -9,25 +9,40 @@
  * so that changes in the shared library will automatically be
  * reflected in executables using it without recompiling them. */
 
+/*
+    Function: gdMajorVersion
+*/
 BGD_DECLARE(int) gdMajorVersion()
 {
     return GD_MAJOR_VERSION;
 }
 
+/*
+    Function: gdMinorVersion
+*/
 BGD_DECLARE(int) gdMinorVersion()
 {
     return GD_MINOR_VERSION;
 }
 
+/*
+    Function: gdReleaseVersion
+*/
 BGD_DECLARE(int) gdReleaseVersion()
 {
     return GD_RELEASE_VERSION;
 }
 
+/*
+    Function: gdExtraVersion
+*/
 BGD_DECLARE(const char *) gdExtraVersion() {
     return GD_EXTRA_VERSION;
 }
 
+/*
+    Function: gdVersionString
+*/
 BGD_DECLARE(const char *) gdVersionString() {
     return GD_VERSION_STRING;
 }

src/gd_wbmp.c

@@ -82,15 +82,17 @@ int gd_getin(void *in)
 	return (gdGetC((gdIOCtx *)in));
 }
 
-/* gdImageWBMPCtx
+/*
- *  --------------
+	Function: gdImageWBMPCtx
- *  Write the image as a wbmp file
+
- *  Parameters are:
+	Write the image as a wbmp file
- *  image:  gd image structure;
+
- *  fg:     the index of the foreground color. any other value will be
+	Parameters:
- *          considered as background and will not be written
+		image - gd image structure
- *  out:    the stream where to write
+		fg    - the index of the foreground color. any other value will be
- */
+				considered as background and will not be written
+		out   - the stream where to write
+*/
 BGD_DECLARE(void) gdImageWBMPCtx(gdImagePtr image, int fg, gdIOCtx *out)
 {
 	int x, y, pos;
@@ -242,8 +244,9 @@ BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPPtr(int size, void *data)
 	return im;
 }
 
-/* gdImageWBMP
+/*
- */
+	Function: gdImageWBMP
+*/
 BGD_DECLARE(void) gdImageWBMP(gdImagePtr im, int fg, FILE *outFile)
 {
 	gdIOCtx *out = gdNewFileCtx(outFile);
@@ -252,8 +255,9 @@ BGD_DECLARE(void) gdImageWBMP(gdImagePtr im, int fg, FILE *outFile)
 	out->gd_free(out);
 }
 
-/* gdImageWBMPPtr
+/*
- */
+	Function: gdImageWBMPPtr
+*/
 BGD_DECLARE(void *) gdImageWBMPPtr(gdImagePtr im, int *size, int fg)
 {
 	void *rv;

src/gd_webp.c

@@ -160,6 +160,9 @@ freeargb:
 	gdFree(argb);
 }
 
+/*
+	Function: gdImageWebpEx
+*/
 BGD_DECLARE(void) gdImageWebpEx (gdImagePtr im, FILE * outFile, int quantization)
 {
 	gdIOCtx *out = gdNewFileCtx(outFile);
@@ -170,6 +173,9 @@ BGD_DECLARE(void) gdImageWebpEx (gdImagePtr im, FILE * outFile, int quantization
 	out->gd_free(out);
 }
 
+/*
+	Function: gdImageWebp
+*/
 BGD_DECLARE(void) gdImageWebp (gdImagePtr im, FILE * outFile)
 {
 	gdIOCtx *out = gdNewFileCtx(outFile);
@@ -180,6 +186,9 @@ BGD_DECLARE(void) gdImageWebp (gdImagePtr im, FILE * outFile)
 	out->gd_free(out);
 }
 
+/*
+	Function: gdImageWebpPtr
+*/
 BGD_DECLARE(void *) gdImageWebpPtr (gdImagePtr im, int *size)
 {
 	void *rv;
@@ -194,6 +203,9 @@ BGD_DECLARE(void *) gdImageWebpPtr (gdImagePtr im, int *size)
 	return rv;
 }
 
+/*
+	Function: gdImageWebpPtrEx
+*/
 BGD_DECLARE(void *) gdImageWebpPtrEx (gdImagePtr im, int *size, int quantization)
 {
 	void *rv;

src/gd_xbm.c

@@ -195,6 +195,9 @@ static void gdCtxPrintf(gdIOCtx * out, const char *format, ...)
 #define gdCtxPuts(out, s) out->putBuf(out, s, strlen(s))
 
 /* {{{ gdImageXbmCtx */
+/*
+    Function: gdImageXbmCtx
+*/
 BGD_DECLARE(void) gdImageXbmCtx(gdImagePtr image, char* file_name, int fg, gdIOCtx * out)
 {
 	int x, y, c, b, sx, sy, p;

src/gdfontg.c

@@ -4382,6 +4382,9 @@ gdFont gdFontGiantRep = {
 
 BGD_EXPORT_DATA_PROT gdFontPtr gdFontGiant = &gdFontGiantRep;
 
+/*
+	Function: gdFontGetGiant
+*/
 BGD_DECLARE(gdFontPtr) gdFontGetGiant (void)
 {
 	return gdFontGiant;

src/gdfontl.c

@@ -4639,6 +4639,9 @@ gdFont gdFontLargeRep = {
 
 BGD_EXPORT_DATA_PROT gdFontPtr gdFontLarge = &gdFontLargeRep;
 
+/*
+	Function: gdFontGetLarge
+*/
 BGD_DECLARE(gdFontPtr)
 gdFontGetLarge (void)
 {

src/gdfontmb.c

@@ -3869,6 +3869,9 @@ gdFont gdFontMediumBoldRep = {
 
 BGD_EXPORT_DATA_PROT gdFontPtr gdFontMediumBold = &gdFontMediumBoldRep;
 
+/*
+	Function: gdFontGetMediumBold
+*/
 BGD_DECLARE(gdFontPtr)
 gdFontGetMediumBold (void)
 {

src/gdfonts.c

@@ -3867,6 +3867,9 @@ gdFont gdFontSmallRep = {
 
 BGD_EXPORT_DATA_PROT gdFontPtr gdFontSmall = &gdFontSmallRep;
 
+/*
+	Function: gdFontGetSmall
+*/
 BGD_DECLARE(gdFontPtr)
 gdFontGetSmall (void)
 {

src/gdfontt.c

@@ -2590,6 +2590,9 @@ gdFont gdFontTinyRep = {
 
 BGD_EXPORT_DATA_PROT gdFontPtr gdFontTiny = &gdFontTinyRep;
 
+/*
+	Function: gdFontGetTiny
+*/
 BGD_DECLARE(gdFontPtr)
 gdFontGetTiny (void)
 {

src/gdft.c

@@ -92,6 +92,9 @@ static char *font_path(char **fontpath, char *name_list);
 #define TRUE !FALSE
 #endif
 
+/*
+	Function: gdImageStringTTF
+*/
 BGD_DECLARE(char *) gdImageStringTTF (gdImage * im, int *brect, int fg, char *fontlist,
                                       double ptsize, double angle, int x, int y, char *string)
 {
@@ -866,11 +869,17 @@ gdft_draw_bitmap (gdCache_head_t * tc_cache, gdImage * im, int fg,
 	return (char *) NULL;
 }
 
+/*
+	Function: gdFreeFontCache
+*/
 BGD_DECLARE(void) gdFreeFontCache ()
 {
 	gdFontCacheShutdown ();
 }
 
+/*
+	Function: gdFontCacheShutdown
+*/
 BGD_DECLARE(void) gdFontCacheShutdown ()
 {
 	if (fontCache) {
@@ -884,9 +893,11 @@ BGD_DECLARE(void) gdFontCacheShutdown ()
 	}
 }
 
-/********************************************************************/
+/*
-/* gdImageStringFT -  render a utf8 string onto a gd image          */
+	Function: gdImageStringFT
 
+	Render a utf8 string onto a gd image.
+*/
 BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist,
                                      double ptsize, double angle, int x, int y, char *string)
 {
@@ -894,6 +905,9 @@ BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fon
 	                          ptsize, angle, x, y, string, 0);
 }
 
+/*
+	Function: gdFontCacheSetup
+*/
 BGD_DECLARE(int) gdFontCacheSetup (void)
 {
 	if (fontCache) {
@@ -1842,6 +1856,9 @@ static char * font_path(char **fontpath, char *name_list)
 	return NULL;
 }
 
+/*
+	Function: gdFTUseFontConfig
+*/
 BGD_DECLARE(int) gdFTUseFontConfig(int flag)
 {
 #ifdef HAVE_LIBFONTCONFIG

src/gdfx.c

@@ -25,6 +25,9 @@
 #define MAXY(x) MAX4(x[1],x[3],x[5],x[7])
 #define MINY(x) MIN4(x[1],x[3],x[5],x[7])
 
+/*
+	Function: gdImageStringFTCircle
+*/
 BGD_DECLARE(char *)
 gdImageStringFTCircle (gdImagePtr im,
                        int cx,
@@ -254,6 +257,9 @@ main (int argc, char *argv[])
 #define SUPERBITS1 1
 #define SUPERBITS2 2
 
+/*
+	Function: gdImageSquareToCircle
+*/
 BGD_DECLARE(gdImagePtr)
 gdImageSquareToCircle (gdImagePtr im, int radius)
 {
@@ -381,16 +387,18 @@ gdImageSubSharpen (int pc, int c, int nc, float inner_coeff, float
 }
 
 /*
-  * Sharpen function added on 2003-11-19
+	Function: gdImageSharpen
-  * by Paul Troughton (paul<dot>troughton<at>ieee<dot>org)
+
-  * Simple 3x3 convolution kernel
+	Sharpen function added on 2003-11-19
-  * Makes use of seperability
+	by Paul Troughton (paul<dot>troughton<at>ieee<dot>org)
-  * Faster, but less flexible, than full-blown unsharp masking
+	Simple 3x3 convolution kernel
-  * pct is sharpening percentage, and can be greater than 100
+	Makes use of seperability
-  * Silently does nothing to non-truecolor images
+	Faster, but less flexible, than full-blown unsharp masking
-  * Silently does nothing for pct<0, as not a useful blurring function
+	pct is sharpening percentage, and can be greater than 100
-  * Leaves transparency/alpha-channel untouched
+	Silently does nothing to non-truecolor images
-  */
+	Silently does nothing for pct<0, as not a useful blurring function
+	Leaves transparency/alpha-channel untouched
+*/
 BGD_DECLARE(void)
 gdImageSharpen (gdImagePtr im, int pct)
 {

src/gdhelpers.c

@@ -90,6 +90,9 @@ gdReallocEx (void *ptr, size_t size)
 	return newPtr;
 }
 
+/*
+	Function: gdFree
+*/
 BGD_DECLARE(void) gdFree (void *ptr)
 {
 	free (ptr);