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.

30 files changed, 539 insertions, 91 deletions

diff --git a/src/gd.c b/src/gd.c
index 9875966..9fe175f 100644
--- a/src/gd.c
+++ b/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:
- *
- *      if ((color=gdImageColorExact(im,R,G,B)) < 0)
- *        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
- * return a color index in one search over the color table.
- */
+	Function: gdImageColorResolve
+
+	gdImageColorResolve is an alternative for the code fragment
+	| if ((color=gdImageColorExact(im,R,G,B)) < 0)
+	|   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
+	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;
diff --git a/src/gd_bmp.c b/src/gd_bmp.c
index 275cdda..e1194c5 100644
--- a/src/gd_bmp.c
+++ b/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;
diff --git a/src/gd_color_map.c b/src/gd_color_map.c
index ff48399..46f3bfa 100644
--- a/src/gd_color_map.c
+++ b/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)
 {
diff --git a/src/gd_color_match.c b/src/gd_color_match.c
index 5f0fd0a..f0842b6 100644
--- a/src/gd_color_match.c
+++ 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)
 {
diff --git a/src/gd_crop.c b/src/gd_crop.c
index d51ad67..6cca819 100644
--- a/src/gd_crop.c
+++ b/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);
diff --git a/src/gd_filter.c b/src/gd_filter.c
index 3ea8732..d3a5918 100644
--- a/src/gd_filter.c
+++ b/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},
diff --git a/src/gd_gd.c b/src/gd_gd.c
index f8d39cb..13defa0 100644
--- a/src/gd_gd.c
+++ b/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;
diff --git a/src/gd_gd2.c b/src/gd_gd2.c
index 2837456..8df93c1 100644
--- a/src/gd_gd2.c
+++ b/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;
diff --git a/src/gd_interpolation.c b/src/gd_interpolation.c
index 438ad41..7e7943d 100644
--- a/src/gd_interpolation.c
+++ b/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
- * (portable) way to extract the value from the struct. */
+/*
+	Function: gdImageGetInterpolationMethod
+
+	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;
diff --git a/src/gd_io_dp.c b/src/gd_io_dp.c
index 8dbcc62..135eda3 100644
--- a/src/gd_io_dp.c
+++ b/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;
diff --git a/src/gd_io_file.c b/src/gd_io_file.c
index d3893e4..40c4f59 100644
--- a/src/gd_io_file.c
+++ b/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;
diff --git a/src/gd_io_ss.c b/src/gd_io_ss.c
index a0cf391..abff844 100644
--- a/src/gd_io_ss.c
+++ b/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;
diff --git a/src/gd_nnquant.c b/src/gd_nnquant.c
index 5466067..d6b2b27 100644
--- a/src/gd_nnquant.c
+++ b/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;
diff --git a/src/gd_ss.c b/src/gd_ss.c
index 9098c9b..248699e 100644
--- a/src/gd_ss.c
+++ b/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);
diff --git a/src/gd_tga.c b/src/gd_tga.c
index 7f85ea4..1705324 100644
--- a/src/gd_tga.c
+++ b/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.
- *	\param infile Pointer to TGA binary file
- *	\return gdImagePtr
+/*
+	Function: gdImageCreateFromTga
+
+	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.
- *	\param ctx Pointer to a gdIOCtx structure
- *	\return gdImagePtr
+/*
+	Function: gdImageCreateFromTgaCtx
+
+	Creates a gdImage from a gdIOCtx referencing a TGA binary file.
+
+	Parameters:
+		ctx - Pointer to a gdIOCtx structure
  */
 BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaCtx(gdIOCtx* ctx)
 {
diff --git a/src/gd_tiff.c b/src/gd_tiff.c
index e4fa07b..26805ff 100644
--- a/src/gd_tiff.c
+++ b/src/gd_tiff.c
@@ -408,13 +408,15 @@ void tiffWriter(gdImagePtr image, gdIOCtx *out, int bitDepth)
 }
 
 /*
-  gdImageTiffCtx
-  --------------
-  Write the gd image as a tiff file
-  Parameters are:
-  image:  gd image structure;
-  out:    the stream where to write
- */
+	Function: gdImageTiffCtx
+
+	Write the gd image as a tiff file.
+
+	Parameters:
+
+		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
-** ------------------------
-** Create a gdImage from a TIFF file input from an gdIOCtx
- */
+/*
+	Function: gdImageCreateFromTiffCtx
+
+	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;
diff --git a/src/gd_topal.c b/src/gd_topal.c
index b094bed..7ff835a 100644
--- a/src/gd_topal.c
+++ b/src/gd_topal.c
@@ -1366,12 +1366,14 @@ zeroHistogram (hist3d histogram)
 
 
 /*
-  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).
+	Function: gdImageTrueColorToPaletteSetMethod
 
-  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.
-  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.
-  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.
+	Function: gdImageTrueColorToPaletteSetQuality
+
+	Chooses quality range that subsequent call to gdImageTrueColorToPalette will aim for.
+	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.
+	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);
diff --git a/src/gd_transform.c b/src/gd_transform.c
index 3841e3e..a126686 100644
--- a/src/gd_transform.c
+++ b/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);
diff --git a/src/gd_version.c b/src/gd_version.c
index 222d428..46725b0 100644
--- a/src/gd_version.c
+++ b/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;
 }
diff --git a/src/gd_wbmp.c b/src/gd_wbmp.c
index 53fbdc2..d9de591 100644
--- a/src/gd_wbmp.c
+++ b/src/gd_wbmp.c
@@ -82,15 +82,17 @@ int gd_getin(void *in)
 	return (gdGetC((gdIOCtx *)in));
 }
 
-/* gdImageWBMPCtx
- *  --------------
- *  Write the image as a wbmp file
- *  Parameters are:
- *  image:  gd image structure;
- *  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
- */
+/*
+	Function: gdImageWBMPCtx
+
+	Write the image as a wbmp file
+
+	Parameters:
+		image - gd image structure
+		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;
diff --git a/src/gd_webp.c b/src/gd_webp.c
index 7202c42..98628cf 100644
--- a/src/gd_webp.c
+++ b/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;
diff --git a/src/gd_xbm.c b/src/gd_xbm.c
index 4110e20..58b5720 100644
--- a/src/gd_xbm.c
+++ b/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;
diff --git a/src/gdfontg.c b/src/gdfontg.c
index 3717860..04f3362 100644
--- a/src/gdfontg.c
+++ b/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;
diff --git a/src/gdfontl.c b/src/gdfontl.c
index a987407..8501b5f 100644
--- a/src/gdfontl.c
+++ b/src/gdfontl.c
@@ -4639,6 +4639,9 @@ gdFont gdFontLargeRep = {
 
 BGD_EXPORT_DATA_PROT gdFontPtr gdFontLarge = &gdFontLargeRep;
 
+/*
+	Function: gdFontGetLarge
+*/
 BGD_DECLARE(gdFontPtr)
 gdFontGetLarge (void)
 {
diff --git a/src/gdfontmb.c b/src/gdfontmb.c
index 349b2db..566cc6d 100644
--- a/src/gdfontmb.c
+++ b/src/gdfontmb.c
@@ -3869,6 +3869,9 @@ gdFont gdFontMediumBoldRep = {
 
 BGD_EXPORT_DATA_PROT gdFontPtr gdFontMediumBold = &gdFontMediumBoldRep;
 
+/*
+	Function: gdFontGetMediumBold
+*/
 BGD_DECLARE(gdFontPtr)
 gdFontGetMediumBold (void)
 {
diff --git a/src/gdfonts.c b/src/gdfonts.c
index f7c2725..f84b2ee 100644
--- a/src/gdfonts.c
+++ b/src/gdfonts.c
@@ -3867,6 +3867,9 @@ gdFont gdFontSmallRep = {
 
 BGD_EXPORT_DATA_PROT gdFontPtr gdFontSmall = &gdFontSmallRep;
 
+/*
+	Function: gdFontGetSmall
+*/
 BGD_DECLARE(gdFontPtr)
 gdFontGetSmall (void)
 {
diff --git a/src/gdfontt.c b/src/gdfontt.c
index c9c6f4a..3c97c4d 100644
--- a/src/gdfontt.c
+++ b/src/gdfontt.c
@@ -2590,6 +2590,9 @@ gdFont gdFontTinyRep = {
 
 BGD_EXPORT_DATA_PROT gdFontPtr gdFontTiny = &gdFontTinyRep;
 
+/*
+	Function: gdFontGetTiny
+*/
 BGD_DECLARE(gdFontPtr)
 gdFontGetTiny (void)
 {
diff --git a/src/gdft.c b/src/gdft.c
index 6f56ef9..9661f2b 100644
--- a/src/gdft.c
+++ b/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
diff --git a/src/gdfx.c b/src/gdfx.c
index 4bb68d9..f145de0 100644
--- a/src/gdfx.c
+++ b/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
-  * by Paul Troughton (paul<dot>troughton<at>ieee<dot>org)
-  * Simple 3x3 convolution kernel
-  * Makes use of seperability
-  * Faster, but less flexible, than full-blown unsharp masking
-  * pct is sharpening percentage, and can be greater than 100
-  * Silently does nothing to non-truecolor images
-  * Silently does nothing for pct<0, as not a useful blurring function
-  * Leaves transparency/alpha-channel untouched
-  */
+	Function: gdImageSharpen
+
+	Sharpen function added on 2003-11-19
+	by Paul Troughton (paul<dot>troughton<at>ieee<dot>org)
+	Simple 3x3 convolution kernel
+	Makes use of seperability
+	Faster, but less flexible, than full-blown unsharp masking
+	pct is sharpening percentage, and can be greater than 100
+	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)
 {
diff --git a/src/gdhelpers.c b/src/gdhelpers.c
index 3c063d9..c371e78 100644
--- a/src/gdhelpers.c
+++ b/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);