Strip trailing whitespace

Performed with: find * -type f | xargs perl -i -p -e 's{[ \t]+$}{}'
git diff -w & git diff -b show no diffs from this change

Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com>

10 files changed, 94 insertions, 94 deletions

diff --git a/src/bitmap/bdfread.c b/src/bitmap/bdfread.c
index 2464c03..0fed688 100644
--- a/src/bitmap/bdfread.c
+++ b/src/bitmap/bdfread.c
@@ -76,7 +76,7 @@ extern int  bdfFileLineNum;
 /***====================================================================***/
 
 static Bool
-bdfReadBitmap(CharInfoPtr pCI, FontFilePtr file, int bit, int byte, 
+bdfReadBitmap(CharInfoPtr pCI, FontFilePtr file, int bit, int byte,
 	      int glyph, int scan, CARD32 *sizes)
 {
     int         widthBits,
@@ -99,7 +99,7 @@ bdfReadBitmap(CharInfoPtr pCI, FontFilePtr file, int bit, int byte,
     if (widthBytes * height > 0) {
 	picture = malloc(widthBytes * height);
 	if (!picture) {
-          bdfError("Couldn't allocate picture (%d*%d)\n", widthBytes, height);        
+          bdfError("Couldn't allocate picture (%d*%d)\n", widthBytes, height);
 	    goto BAILOUT;
       }
     } else
@@ -247,7 +247,7 @@ bdfFreeFontBits(FontPtr pFont)
 
 
 static Bool
-bdfReadCharacters(FontFilePtr file, FontPtr pFont, bdfFileState *pState, 
+bdfReadCharacters(FontFilePtr file, FontPtr pFont, bdfFileState *pState,
 		  int bit, int byte, int glyph, int scan)
 {
     unsigned char *line;
@@ -515,7 +515,7 @@ bdfReadCharacters(FontFilePtr file, FontPtr pFont, bdfFileState *pState,
                         if (!bitmapFont->encoding[SEGMENT_MAJOR(i)])
                             goto BAILOUT;
                     }
-                    ACCESSENCODINGL(bitmapFont->encoding,i) = 
+                    ACCESSENCODINGL(bitmapFont->encoding,i) =
                         bdfEncoding[char_row][char_col];
                 }
                 i++;
@@ -782,7 +782,7 @@ bdfUnloadFont(FontPtr pFont)
 }
 
 int
-bdfReadFont(FontPtr pFont, FontFilePtr file, 
+bdfReadFont(FontPtr pFont, FontFilePtr file,
 	    int bit, int byte, int glyph, int scan)
 {
     bdfFileState state;
@@ -816,7 +816,7 @@ bdfReadFont(FontPtr pFont, FontFilePtr file,
       bdfError("Couldn't allocate bitmapExtra (%d)\n", sizeof(BitmapExtraRec));
         goto BAILOUT;
     }
-    
+
     bitmapFont->bitmapExtra->glyphNames = 0;
     bitmapFont->bitmapExtra->sWidths = 0;
 
@@ -836,7 +836,7 @@ bdfReadFont(FontPtr pFont, FontFilePtr file,
 	    cols = pFont->info.lastCol - pFont->info.firstCol + 1;
 	    r = r - pFont->info.firstRow;
 	    c = c - pFont->info.firstCol;
-	    bitmapFont->pDefault = ACCESSENCODING(bitmapFont->encoding, 
+	    bitmapFont->pDefault = ACCESSENCODING(bitmapFont->encoding,
                                                  r * cols + c);
 	}
     }
@@ -859,7 +859,7 @@ bdfReadFont(FontPtr pFont, FontFilePtr file,
         bdfError("Failed to add bitmap ink metrics\n");
         goto BAILOUT;
       }
-    }    
+    }
     if (bitmapFont->bitmapExtra)
 	bitmapFont->bitmapExtra->info.inkMetrics = pFont->info.inkMetrics;
 
@@ -924,7 +924,7 @@ bdfPadToTerminal(FontPtr pFont)
 
     bitmapFont = (BitmapFontPtr) pFont->fontPrivate;
 
-    bzero(&new, sizeof(CharInfoRec)); 
+    bzero(&new, sizeof(CharInfoRec));
     new.metrics.ascent = pFont->info.fontAscent;
     new.metrics.descent = pFont->info.fontDescent;
     new.metrics.leftSideBearing = 0;
diff --git a/src/bitmap/bdfutils.c b/src/bitmap/bdfutils.c
index 1d6cc72..a0106b7 100644
--- a/src/bitmap/bdfutils.c
+++ b/src/bitmap/bdfutils.c
@@ -276,7 +276,7 @@ static char *SpecialAtoms[] = {
 };
 
 Bool
-bdfSpecialProperty(FontPtr pFont, FontPropPtr prop, 
+bdfSpecialProperty(FontPtr pFont, FontPropPtr prop,
 		   char isString, bdfFileState *bdfState)
 {
     char      **special;
diff --git a/src/bitmap/bitmap.c b/src/bitmap/bitmap.c
index 1ceb4bb..9b20faf 100644
--- a/src/bitmap/bitmap.c
+++ b/src/bitmap/bitmap.c
@@ -36,8 +36,8 @@ in this Software without prior written authorization from The Open Group.
 #include <X11/fonts/bitmap.h>
 
 int
-bitmapGetGlyphs(FontPtr pFont, unsigned long count, unsigned char *chars, 
-		FontEncoding charEncoding, 
+bitmapGetGlyphs(FontPtr pFont, unsigned long count, unsigned char *chars,
+		FontEncoding charEncoding,
 		unsigned long *glyphCount, 	/* RETURN */
 		CharInfoPtr *glyphs) 		/* RETURN */
 {
@@ -126,8 +126,8 @@ bitmapGetGlyphs(FontPtr pFont, unsigned long count, unsigned char *chars,
 static CharInfoRec nonExistantChar;
 
 int
-bitmapGetMetrics(FontPtr pFont, unsigned long count, unsigned char *chars, 
-		 FontEncoding charEncoding, 
+bitmapGetMetrics(FontPtr pFont, unsigned long count, unsigned char *chars,
+		 FontEncoding charEncoding,
 		 unsigned long *glyphCount,	/* RETURN */
 		 xCharInfo **glyphs)		/* RETURN */
 {
diff --git a/src/bitmap/bitmapfunc.c b/src/bitmap/bitmapfunc.c
index 47ce488..603d5d9 100644
--- a/src/bitmap/bitmapfunc.c
+++ b/src/bitmap/bitmapfunc.c
@@ -56,10 +56,10 @@ in this Software without prior written authorization from The Open Group.
 #include "snfstr.h"
 
 typedef struct _BitmapFileFunctions {
-    int         (*ReadFont) (FontPtr /* pFont */, FontFilePtr /* file */,  
-			     int /* bit */, int /* byte */, 
+    int         (*ReadFont) (FontPtr /* pFont */, FontFilePtr /* file */,
+			     int /* bit */, int /* byte */,
 			     int /* glyph */, int /* scan */);
-    int         (*ReadInfo) (  FontInfoPtr /* pFontInfo */, 
+    int         (*ReadInfo) (  FontInfoPtr /* pFontInfo */,
 			       FontFilePtr /* file */ );
 }           BitmapFileFunctionsRec, *BitmapFileFunctionsPtr;
 
@@ -107,8 +107,8 @@ static BitmapFileFunctionsRec readers[] = {
 #define CAPABILITIES (CAP_MATRIX | CAP_CHARSUBSETTING)
 
 static int
-BitmapOpenBitmap (FontPathElementPtr fpe, FontPtr *ppFont, int flags, 
-		  FontEntryPtr entry, char *fileName, 
+BitmapOpenBitmap (FontPathElementPtr fpe, FontPtr *ppFont, int flags,
+		  FontEntryPtr entry, char *fileName,
 		  fsBitmapFormat format, fsBitmapFormatMask fmask,
 		  FontPtr non_cachable_font) /* We don't do licensing */
 {
@@ -152,7 +152,7 @@ BitmapOpenBitmap (FontPathElementPtr fpe, FontPtr *ppFont, int flags,
 }
 
 static int
-BitmapGetInfoBitmap (FontPathElementPtr fpe, FontInfoPtr pFontInfo, 
+BitmapGetInfoBitmap (FontPathElementPtr fpe, FontInfoPtr pFontInfo,
 		     FontEntryPtr entry, char *fileName)
 {
     FontFilePtr file;
diff --git a/src/bitmap/bitscale.c b/src/bitmap/bitscale.c
index 50818c6..b857237 100644
--- a/src/bitmap/bitscale.c
+++ b/src/bitmap/bitscale.c
@@ -63,11 +63,11 @@ from The Open Group.
 extern unsigned long serverGeneration;
 
 static void bitmapUnloadScalable (FontPtr pFont);
-static void ScaleBitmap ( FontPtr pFont, CharInfoPtr opci, 
-			  CharInfoPtr pci, double *inv_xform, 
+static void ScaleBitmap ( FontPtr pFont, CharInfoPtr opci,
+			  CharInfoPtr pci, double *inv_xform,
 			  double widthMult, double heightMult );
-static FontPtr BitmapScaleBitmaps(FontPtr pf, FontPtr opf, 
-				  double widthMult, double heightMult,   
+static FontPtr BitmapScaleBitmaps(FontPtr pf, FontPtr opf,
+				  double widthMult, double heightMult,
 				  FontScalablePtr vals);
 
 enum scaleType {
@@ -83,12 +83,12 @@ typedef struct _fontProp {
     enum scaleType type;
 } fontProp;
 
-static FontEntryPtr FindBestToScale ( FontPathElementPtr fpe, 
-				      FontEntryPtr entry, 
-				      FontScalablePtr vals, 
-				      FontScalablePtr best, 
-				      double *dxp, double *dyp, 
-				      double *sdxp, double *sdyp, 
+static FontEntryPtr FindBestToScale ( FontPathElementPtr fpe,
+				      FontEntryPtr entry,
+				      FontScalablePtr vals,
+				      FontScalablePtr best,
+				      double *dxp, double *dyp,
+				      double *sdxp, double *sdyp,
 				      FontPathElementPtr *fpep );
 
 static unsigned long bitscaleGeneration = 0;	/* initialization flag */
@@ -231,8 +231,8 @@ get_matrix_vertical_component(double *matrix)
 
 
 static Bool
-ComputeScaleFactors(FontScalablePtr from, FontScalablePtr to, 
-		    double *dx, double *dy, double *sdx, double *sdy, 
+ComputeScaleFactors(FontScalablePtr from, FontScalablePtr to,
+		    double *dx, double *dy, double *sdx, double *sdy,
 		    double *rescale_x)
 {
     double srcpixelset, destpixelset, srcpixel, destpixel;
@@ -318,10 +318,10 @@ else \
     score += (int)(((double)(8 * s)) * m);
 
 static FontEntryPtr
-FindBestToScale(FontPathElementPtr fpe, FontEntryPtr entry, 
-		FontScalablePtr vals, FontScalablePtr best, 
-		double *dxp, double *dyp, 
-		double *sdxp, double *sdyp, 
+FindBestToScale(FontPathElementPtr fpe, FontEntryPtr entry,
+		FontScalablePtr vals, FontScalablePtr best,
+		double *dxp, double *dyp,
+		double *sdxp, double *sdyp,
 		FontPathElementPtr *fpep)
 {
     FontScalableRec temp;
@@ -425,7 +425,7 @@ FindBestToScale(FontPathElementPtr fpe, FontEntryPtr entry,
 		    ((score == best_score) &&
 		     ((dy_amount < best_dy_amount) ||
  		      ((dy_amount == best_dy_amount) &&
- 		       (dx_amount < best_dx_amount))))) 
+ 		       (dx_amount < best_dx_amount)))))
 	    {
 		best_fpe = FontFileBitmapSources.fpe[source];
 	    	best_scaled = scaled;
@@ -525,8 +525,8 @@ doround(double x)
 }
 
 static int
-computeProps(FontPropPtr pf, char *wasStringProp, 
-	     FontPropPtr npf, char *isStringProp, 
+computeProps(FontPropPtr pf, char *wasStringProp,
+	     FontPropPtr npf, char *isStringProp,
 	     unsigned int nprops, double xfactor, double yfactor,
 	     double sXfactor, double sYfactor)
 {
@@ -580,13 +580,13 @@ computeProps(FontPropPtr pf, char *wasStringProp,
 static int
 ComputeScaledProperties(FontInfoPtr sourceFontInfo, /* the font to be scaled */
 			char *name, 		/* name of resulting font */
-			FontScalablePtr vals, 
+			FontScalablePtr vals,
 			double dx, double dy, 	/* scale factors in x and y */
 			double sdx, double sdy, /* directions */
 			long sWidth, 		/* 1000-pixel average width */
-			FontPropPtr *pProps, 	/* returns properties; 
+			FontPropPtr *pProps, 	/* returns properties;
 						   preallocated */
-			char **pIsStringProp) 	/* return booleans; 
+			char **pIsStringProp) 	/* return booleans;
 						   preallocated */
 {
     int         n;
@@ -692,8 +692,8 @@ ComputeScaledProperties(FontInfoPtr sourceFontInfo, /* the font to be scaled */
 
 
 static int
-compute_xform_matrix(FontScalablePtr vals, double dx, double dy, 
-		     double *xform, double *inv_xform, 
+compute_xform_matrix(FontScalablePtr vals, double dx, double dy,
+		     double *xform, double *inv_xform,
 		     double *xmult, double *ymult)
 {
     double det;
@@ -752,17 +752,17 @@ compute_xform_matrix(FontScalablePtr vals, double dx, double dy,
  *  returns a pointer to the new scaled font, or NULL (due to AllocError).
  */
 static FontPtr
-ScaleFont(FontPtr opf,            /* originating font */                    
-	  double widthMult, 	  /* glyphs width scale factor */           
-	  double heightMult, 	  /* glyphs height scale factor */          
-	  double sWidthMult, 	  /* scalable glyphs width scale factor */  
-	  double sHeightMult, 	  /* scalable glyphs height scale factor */ 
-	  FontScalablePtr vals,	                                            
-	  double *newWidthMult,   /* return: X component of glyphs width    
-				     scale factor */                        
-	  double *newHeightMult,  /* return: Y component of glyphs height   
-				     scale factor */                        
-	  long *sWidth)		  /* return: average 1000-pixel width */    
+ScaleFont(FontPtr opf,            /* originating font */
+	  double widthMult, 	  /* glyphs width scale factor */
+	  double heightMult, 	  /* glyphs height scale factor */
+	  double sWidthMult, 	  /* scalable glyphs width scale factor */
+	  double sHeightMult, 	  /* scalable glyphs height scale factor */
+	  FontScalablePtr vals,
+	  double *newWidthMult,   /* return: X component of glyphs width
+				     scale factor */
+	  double *newHeightMult,  /* return: Y component of glyphs height
+				     scale factor */
+	  long *sWidth)		  /* return: average 1000-pixel width */
 {
     FontPtr     pf;
     FontInfoPtr pfi,
@@ -1015,7 +1015,7 @@ ScaleFont(FontPtr opf,            /* originating font */
 		if (pci->metrics.ascent == -pci->metrics.descent)
 		    pci->metrics.ascent++;
 	    }
-    
+
 	    pci++;
 	}
     }
@@ -1039,7 +1039,7 @@ ScaleFont(FontPtr opf,            /* originating font */
 	    	pfi->minbounds.field = pci->metrics.field; \
 	    if (pfi->maxbounds.field < pci->metrics.field) \
 	    	pfi->maxbounds.field = pci->metrics.field
-    
+
 	    MINMAX(leftSideBearing);
 	    MINMAX(rightSideBearing);
 	    MINMAX(ascent);
@@ -1093,7 +1093,7 @@ ScaleFont(FontPtr opf,            /* originating font */
 	    cols = pfi->lastCol - pfi->firstCol + 1;
 	    r = r - pfi->firstRow;
 	    c = c - pfi->firstCol;
-	    bitmapFont->pDefault = 
+	    bitmapFont->pDefault =
                 ACCESSENCODING(bitmapFont->encoding, r * cols + c);
 	}
     }
@@ -1117,7 +1117,7 @@ bail:
 }
 
 static void
-ScaleBitmap(FontPtr pFont, CharInfoPtr opci, CharInfoPtr pci, 
+ScaleBitmap(FontPtr pFont, CharInfoPtr opci, CharInfoPtr pci,
 	    double *inv_xform, double widthMult, double heightMult)
 {
     register char  *bitmap,		/* The bits */
@@ -1394,7 +1394,7 @@ ScaleBitmap(FontPtr pFont, CharInfoPtr opci, CharInfoPtr pci,
 	    {
 		register int x = xValue >> 16, y = yValue >> 16;
 		int pixvalue, error;
-    
+
 		pixvalue = ((x >= 0 && x < width && y >= 0 && y < height) ?
 			    char_grayscale[x + y * (width + 1)] : 0) +
 			   thisrow[col] / 16;
@@ -1436,7 +1436,7 @@ ScaleBitmap(FontPtr pFont, CharInfoPtr opci, CharInfoPtr pci,
 	    for (col = 0; col < newWidth; col++)
 	    {
 		register int x = xValue >> 16, y = yValue >> 16;
-    
+
 		if (x >= 0 && x < width && y >= 0 && y < height)
 		{
 		    /* Use point-sampling for rescaling. */
@@ -1543,13 +1543,13 @@ bail:
 
 /* ARGSUSED */
 int
-BitmapOpenScalable (FontPathElementPtr fpe, 
-		    FontPtr *pFont, 
-		    int flags, 
-		    FontEntryPtr entry, 
+BitmapOpenScalable (FontPathElementPtr fpe,
+		    FontPtr *pFont,
+		    int flags,
+		    FontEntryPtr entry,
 		    char *fileName, /* unused */
-		    FontScalablePtr vals, 
-		    fsBitmapFormat format, 
+		    FontScalablePtr vals,
+		    fsBitmapFormat format,
 		    fsBitmapFormatMask fmask,
 		    FontPtr non_cachable_font)	/* We don't do licensing */
 {
@@ -1635,11 +1635,11 @@ BitmapOpenScalable (FontPathElementPtr fpe,
 }
 
 int
-BitmapGetInfoScalable (FontPathElementPtr fpe, 
-		       FontInfoPtr pFontInfo, 
-		       FontEntryPtr entry, 
-		       FontNamePtr fontName, 
-		       char *fileName, 
+BitmapGetInfoScalable (FontPathElementPtr fpe,
+		       FontInfoPtr pFontInfo,
+		       FontEntryPtr entry,
+		       FontNamePtr fontName,
+		       char *fileName,
 		       FontScalablePtr vals)
 {
     FontPtr pfont;
diff --git a/src/bitmap/fontink.c b/src/bitmap/fontink.c
index ad7091f..f4898da 100644
--- a/src/bitmap/fontink.c
+++ b/src/bitmap/fontink.c
@@ -98,7 +98,7 @@ FontCharInkMetrics(FontPtr pFont, CharInfoPtr pCI, xCharInfo *pInk)
 found_ascent:
     pInk->ascent = vpos - descent + 1;
 
-    p = ((unsigned char *) pCI->bits) + bitmapByteWidthPadded * 
+    p = ((unsigned char *) pCI->bits) + bitmapByteWidthPadded *
 	(descent + ascent - 1) + bitmapByteWidth;
 
     for (vpos = descent + ascent; --vpos >= 0;) {
diff --git a/src/bitmap/pcfread.c b/src/bitmap/pcfread.c
index 32f9856..92b6348 100644
--- a/src/bitmap/pcfread.c
+++ b/src/bitmap/pcfread.c
@@ -56,7 +56,7 @@ pcfError(const char* message, ...)
     vfprintf(stderr, message, args);
     va_end(args);
 }
-                              
+
 /* Read PCF font files */
 
 static void pcfUnloadFont ( FontPtr pFont );
@@ -197,7 +197,7 @@ pcfGetCompressedMetric(FontFilePtr file, CARD32 format, xCharInfo *metric)
  * in the font file
  */
 static Bool
-pcfSeekToType(FontFilePtr file, PCFTablePtr tables, int ntables, 
+pcfSeekToType(FontFilePtr file, PCFTablePtr tables, int ntables,
 	      CARD32 type, CARD32 *formatp, CARD32 *sizep)
 {
     int         i;
@@ -228,14 +228,14 @@ pcfHasType (PCFTablePtr tables, int ntables, CARD32 type)
 }
 
 /*
- * pcfGetProperties 
+ * pcfGetProperties
  *
  * Reads the font properties from the font file, filling in the FontInfo rec
  * supplied.  Used by by both ReadFont and ReadFontInfo routines.
  */
 
 static Bool
-pcfGetProperties(FontInfoPtr pFontInfo, FontFilePtr file, 
+pcfGetProperties(FontInfoPtr pFontInfo, FontFilePtr file,
 		 PCFTablePtr tables, int ntables)
 {
     FontPropPtr props = 0;
@@ -274,7 +274,7 @@ pcfGetProperties(FontInfoPtr pFontInfo, FontFilePtr file,
 	props[i].name = pcfGetINT32(file, format);
 	isStringProp[i] = pcfGetINT8(file, format);
 	props[i].value = pcfGetINT32(file, format);
-	if (props[i].name < 0 
+	if (props[i].name < 0
 	    || (isStringProp[i] != 0 && isStringProp[i] != 1)
 	    || (isStringProp[i] && props[i].value < 0)) {
 	    pcfError("pcfGetProperties(): invalid file format %d %d %d\n",
@@ -334,7 +334,7 @@ Bail:
  */
 
 static Bool
-pcfGetAccel(FontInfoPtr pFontInfo, FontFilePtr file, 
+pcfGetAccel(FontInfoPtr pFontInfo, FontFilePtr file,
 	    PCFTablePtr tables, int ntables, CARD32 type)
 {
     CARD32      format;
@@ -345,7 +345,7 @@ pcfGetAccel(FontInfoPtr pFontInfo, FontFilePtr file,
 	goto Bail;
     format = pcfGetLSB32(file);
     if (!PCF_FORMAT_MATCH(format, PCF_DEFAULT_FORMAT) &&
-	!PCF_FORMAT_MATCH(format, PCF_ACCEL_W_INKBOUNDS)) 
+	!PCF_FORMAT_MATCH(format, PCF_ACCEL_W_INKBOUNDS))
     {
 	goto Bail;
     }
@@ -382,7 +382,7 @@ Bail:
 }
 
 int
-pcfReadFont(FontPtr pFont, FontFilePtr file, 
+pcfReadFont(FontPtr pFont, FontFilePtr file,
 	    int bit, int byte, int glyph, int scan)
 {
     CARD32      format;
@@ -454,7 +454,7 @@ pcfReadFont(FontPtr pFont, FontFilePtr file,
 	    if (!pcfGetCompressedMetric(file, format, &(metrics + i)->metrics))
 		goto Bail;
 	}
-    
+
     /* bitmaps */
 
     if (!pcfSeekToType(file, tables, ntables, PCF_BITMAPS, &format, &size))
@@ -482,7 +482,7 @@ pcfReadFont(FontPtr pFont, FontFilePtr file,
 	if (IS_EOF(file)) goto Bail;
 	if (bitmapSizes[i] < 0) goto Bail;
     }
-    
+
     sizebitmaps = bitmapSizes[PCF_GLYPH_PAD_INDEX(format)];
     /* guard against completely empty font */
     bitmaps = malloc(sizebitmaps ? sizebitmaps : 1);
@@ -559,7 +559,7 @@ pcfReadFont(FontPtr pFont, FontFilePtr file,
 	/* nmetrics already checked */
 	ink_metrics = malloc(nink_metrics * sizeof(xCharInfo));
       if (!ink_metrics) {
-          pcfError("pcfReadFont(): Couldn't allocate ink_metrics (%d*%d)\n", nink_metrics, sizeof(xCharInfo));       
+          pcfError("pcfReadFont(): Couldn't allocate ink_metrics (%d*%d)\n", nink_metrics, sizeof(xCharInfo));
 	    goto Bail;
       }
 	for (i = 0; i < nink_metrics; i++)
@@ -595,10 +595,10 @@ pcfReadFont(FontPtr pFont, FontFilePtr file,
 
     encoding = calloc(NUM_SEGMENTS(nencoding), sizeof(CharInfoPtr*));
     if (!encoding) {
-      pcfError("pcfReadFont(): Couldn't allocate encoding (%d*%d)\n", nencoding, sizeof(CharInfoPtr));    
+      pcfError("pcfReadFont(): Couldn't allocate encoding (%d*%d)\n", nencoding, sizeof(CharInfoPtr));
 	goto Bail;
     }
-    
+
     pFont->info.allExist = TRUE;
     for (i = 0; i < nencoding; i++) {
 	encodingOffset = pcfGetINT16(file, format);
diff --git a/src/bitmap/pcfwrite.c b/src/bitmap/pcfwrite.c
index 3ac07b3..b4abff4 100644
--- a/src/bitmap/pcfwrite.c
+++ b/src/bitmap/pcfwrite.c
@@ -430,8 +430,8 @@ pcfWriteFont(FontPtr pFont, FontFilePtr file)
 	    pcfPutINT16(file, format, pFont->info.defaultCh);
 	    for (i = 0; i < nencodings; i++) {
 		if (ACCESSENCODING(bitmapFont->encoding,i))
-		    pcfPutINT16(file, format, 
-                                ACCESSENCODING(bitmapFont->encoding, i) - 
+		    pcfPutINT16(file, format,
+                                ACCESSENCODING(bitmapFont->encoding, i) -
                                   bitmapFont->metrics);
 		else
 		    pcfPutINT16(file, format, 0xFFFF);
diff --git a/src/bitmap/snfread.c b/src/bitmap/snfread.c
index d003cc5..2f51c48 100644
--- a/src/bitmap/snfread.c
+++ b/src/bitmap/snfread.c
@@ -71,7 +71,7 @@ snfError(const char* message, ...)
     vfprintf(stderr, message, args);
     va_end(args);
 }
-              
+
 static void snfUnloadFont(FontPtr pFont);
 
 static int
@@ -211,7 +211,7 @@ SnfGetFormat (int *bit, int *byte, int *glyph, int *scan)
 }
 
 int
-snfReadFont(FontPtr pFont, FontFilePtr file, 
+snfReadFont(FontPtr pFont, FontFilePtr file,
 	    int bit, int byte, int glyph, int scan)
 {
     snfFontInfoRec fi;
@@ -239,7 +239,7 @@ snfReadFont(FontPtr pFont, FontFilePtr file,
     /*
      * we'll allocate one chunk of memory and split it among the various parts
      * of the font:
-     * 
+     *
      * BitmapFontRec CharInfoRec's Glyphs Encoding DIX Properties Ink CharInfoRec's
      *
      * If the glyphpad is not the same as the font file, then the glyphs
@@ -253,7 +253,7 @@ snfReadFont(FontPtr pFont, FontFilePtr file,
     metrics_off = bytestoalloc;
     bytestoalloc += num_chars * sizeof(CharInfoRec);	/* metrics */
     encoding_off = bytestoalloc;
-    bytestoalloc += NUM_SEGMENTS(num_chars) * sizeof(CharInfoPtr**);	
+    bytestoalloc += NUM_SEGMENTS(num_chars) * sizeof(CharInfoPtr**);
                                                 /* encoding */
     props_off = bytestoalloc;
     bytestoalloc += fi.nProps * sizeof(FontPropRec);	/* props */
@@ -299,7 +299,7 @@ snfReadFont(FontPtr pFont, FontFilePtr file,
      */
 
     ret = Successful;
-    memset(bitmapFont->encoding, 0, 
+    memset(bitmapFont->encoding, 0,
            NUM_SEGMENTS(num_chars)*sizeof(CharInfoPtr*));
     for (i = 0; ret == Successful && i < num_chars; i++) {
 	ret = snfReadCharInfo(file, &bitmapFont->metrics[i], bitmaps);
diff --git a/src/bitmap/snfstr.h b/src/bitmap/snfstr.h
index 148bb1f..8f39ded 100644
--- a/src/bitmap/snfstr.h
+++ b/src/bitmap/snfstr.h
@@ -175,7 +175,7 @@ typedef struct _snfFontInfo {
 }           snfFontInfoRec;
 
 extern void SnfSetFormat ( int bit, int byte, int glyph, int scan );
-extern int snfReadFont ( FontPtr pFont, FontFilePtr file, 
+extern int snfReadFont ( FontPtr pFont, FontFilePtr file,
 			 int bit, int byte, int glyph, int scan );
 extern int snfReadFontInfo ( FontInfoPtr pFontInfo, FontFilePtr file );