Remove trailing whitespaces

28 files changed, 951 insertions, 951 deletions

diff --git a/backend/dvi/mdvi-lib/afmparse.c b/backend/dvi/mdvi-lib/afmparse.c
index f90e5575..f8d840b7 100644
--- a/backend/dvi/mdvi-lib/afmparse.c
+++ b/backend/dvi/mdvi-lib/afmparse.c
@@ -2,25 +2,25 @@
  * (C) 1988, 1989, 1990 by Adobe Systems Incorporated. All rights reserved.
  *
  * This file may be freely copied and redistributed as long as:
- *   1) This entire notice continues to be included in the file, 
+ *   1) This entire notice continues to be included in the file,
  *   2) If the file has been modified in any way, a notice of such
  *      modification is conspicuously indicated.
  *
  * PostScript, Display PostScript, and Adobe are registered trademarks of
  * Adobe Systems Incorporated.
- * 
+ *
  * ************************************************************************
  * THE INFORMATION BELOW IS FURNISHED AS IS, IS SUBJECT TO CHANGE WITHOUT
  * NOTICE, AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY ADOBE SYSTEMS
- * INCORPORATED. ADOBE SYSTEMS INCORPORATED ASSUMES NO RESPONSIBILITY OR 
- * LIABILITY FOR ANY ERRORS OR INACCURACIES, MAKES NO WARRANTY OF ANY 
- * KIND (EXPRESS, IMPLIED OR STATUTORY) WITH RESPECT TO THIS INFORMATION, 
- * AND EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES OF MERCHANTABILITY, 
+ * INCORPORATED. ADOBE SYSTEMS INCORPORATED ASSUMES NO RESPONSIBILITY OR
+ * LIABILITY FOR ANY ERRORS OR INACCURACIES, MAKES NO WARRANTY OF ANY
+ * KIND (EXPRESS, IMPLIED OR STATUTORY) WITH RESPECT TO THIS INFORMATION,
+ * AND EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR PARTICULAR PURPOSES AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  * ************************************************************************
  */
 
-/* 
+/*
  * modified for MDVI:
  *   - some names changed to avoid conflicts with T1lib
  *   - changed to ANSI C prototypes, as used by MDVI
@@ -28,13 +28,13 @@
  */
 
 /* parseAFM.c
- * 
+ *
  * This file is used in conjuction with the parseAFM.h header file.
  * This file contains several procedures that are used to parse AFM
  * files. It is intended to work with an application program that needs
  * font metric information. The program can be used as is by making a
  * procedure call to "parseFile" (passing in the expected parameters)
- * and having it fill in a data structure with the data from the 
+ * and having it fill in a data structure with the data from the
  * AFM file, or an application developer may wish to customize this
  * code.
  *
@@ -70,7 +70,7 @@
 #include <math.h>
 #include "afmparse.h"
 #undef VERSION
- 
+
 #define lineterm EOL	/* line terminating character */
 #define normalEOF 1	/* return code from parsing routines used only */
 			/* in this module */
@@ -88,39 +88,39 @@
 static char *ident = NULL; /* storage buffer for keywords */
 
 
-/* "shorts" for fast case statement 
+/* "shorts" for fast case statement
  * The values of each of these enumerated items correspond to an entry in the
- * table of strings defined below. Therefore, if you add a new string as 
+ * table of strings defined below. Therefore, if you add a new string as
  * new keyword into the keyStrings table, you must also add a corresponding
  * parseKey AND it MUST be in the same position!
  *
  * IMPORTANT: since the sorting algorithm is a binary search, the strings of
- * keywords must be placed in lexicographical order, below. [Therefore, the 
- * enumerated items are not necessarily in lexicographical order, depending 
- * on the name chosen. BUT, they must be placed in the same position as the 
- * corresponding key string.] The NOPE shall remain in the last position, 
- * since it does not correspond to any key string, and it is used in the 
+ * keywords must be placed in lexicographical order, below. [Therefore, the
+ * enumerated items are not necessarily in lexicographical order, depending
+ * on the name chosen. BUT, they must be placed in the same position as the
+ * corresponding key string.] The NOPE shall remain in the last position,
+ * since it does not correspond to any key string, and it is used in the
  * "recognize" procedure to calculate how many possible keys there are.
  */
 
 enum parseKey {
-  ASCENDER, CHARBBOX, CODE, COMPCHAR, CAPHEIGHT, COMMENT, 
-  DESCENDER, ENCODINGSCHEME, ENDCHARMETRICS, ENDCOMPOSITES, 
-  ENDFONTMETRICS, ENDKERNDATA, ENDKERNPAIRS, ENDTRACKKERN, 
-  FAMILYNAME, FONTBBOX, FONTNAME, FULLNAME, ISFIXEDPITCH, 
-  ITALICANGLE, KERNPAIR, KERNPAIRXAMT, LIGATURE, CHARNAME, 
-  NOTICE, COMPCHARPIECE, STARTCHARMETRICS, STARTCOMPOSITES, 
-  STARTFONTMETRICS, STARTKERNDATA, STARTKERNPAIRS, 
-  STARTTRACKKERN, TRACKKERN, UNDERLINEPOSITION, 
+  ASCENDER, CHARBBOX, CODE, COMPCHAR, CAPHEIGHT, COMMENT,
+  DESCENDER, ENCODINGSCHEME, ENDCHARMETRICS, ENDCOMPOSITES,
+  ENDFONTMETRICS, ENDKERNDATA, ENDKERNPAIRS, ENDTRACKKERN,
+  FAMILYNAME, FONTBBOX, FONTNAME, FULLNAME, ISFIXEDPITCH,
+  ITALICANGLE, KERNPAIR, KERNPAIRXAMT, LIGATURE, CHARNAME,
+  NOTICE, COMPCHARPIECE, STARTCHARMETRICS, STARTCOMPOSITES,
+  STARTFONTMETRICS, STARTKERNDATA, STARTKERNPAIRS,
+  STARTTRACKKERN, TRACKKERN, UNDERLINEPOSITION,
   UNDERLINETHICKNESS, VERSION, XYWIDTH, XWIDTH, WEIGHT, XHEIGHT,
   NOPE } ;
 
-/* keywords for the system:  
+/* keywords for the system:
  * This a table of all of the current strings that are vaild AFM keys.
  * Each entry can be referenced by the appropriate parseKey value (an
- * enumerated data type defined above). If you add a new keyword here, 
+ * enumerated data type defined above). If you add a new keyword here,
  * a corresponding parseKey MUST be added to the enumerated data type
- * defined above, AND it MUST be added in the same position as the 
+ * defined above, AND it MUST be added in the same position as the
  * string is in this table.
  *
  * IMPORTANT: since the sorting algorithm is a binary search, the keywords
@@ -130,36 +130,36 @@ enum parseKey {
 
 static char *keyStrings[] = {
   "Ascender", "B", "C", "CC", "CapHeight", "Comment",
-  "Descender", "EncodingScheme", "EndCharMetrics", "EndComposites", 
-  "EndFontMetrics", "EndKernData", "EndKernPairs", "EndTrackKern", 
-  "FamilyName", "FontBBox", "FontName", "FullName", "IsFixedPitch", 
-  "ItalicAngle", "KP", "KPX", "L", "N", 
-  "Notice", "PCC", "StartCharMetrics", "StartComposites", 
-  "StartFontMetrics", "StartKernData", "StartKernPairs", 
-  "StartTrackKern", "TrackKern", "UnderlinePosition", 
+  "Descender", "EncodingScheme", "EndCharMetrics", "EndComposites",
+  "EndFontMetrics", "EndKernData", "EndKernPairs", "EndTrackKern",
+  "FamilyName", "FontBBox", "FontName", "FullName", "IsFixedPitch",
+  "ItalicAngle", "KP", "KPX", "L", "N",
+  "Notice", "PCC", "StartCharMetrics", "StartComposites",
+  "StartFontMetrics", "StartKernData", "StartKernPairs",
+  "StartTrackKern", "TrackKern", "UnderlinePosition",
   "UnderlineThickness", "Version", "W", "WX", "Weight", "XHeight",
   NULL };
-  
-/*************************** PARSING ROUTINES **************/ 
-  
+
+/*************************** PARSING ROUTINES **************/
+
 /*************************** token *************************/
 
 /*  A "AFM File Conventions" tokenizer. That means that it will
  *  return the next token delimited by white space.  See also
- *  the `linetoken' routine, which does a similar thing but 
+ *  the `linetoken' routine, which does a similar thing but
  *  reads all tokens until the next end-of-line.
  */
- 
+
 static char *token(FILE *stream)
 {
     int ch, idx;
 
     /* skip over white space */
-    while ((ch = fgetc(stream)) == ' ' || ch == lineterm || 
+    while ((ch = fgetc(stream)) == ' ' || ch == lineterm ||
             ch == ',' || ch == '\t' || ch == ';');
-    
+
     idx = 0;
-    while (ch != EOF && ch != ' ' && ch != lineterm 
+    while (ch != EOF && ch != ' ' && ch != lineterm
            && ch != '\t' && ch != ':' && ch != ';' && idx < (MAX_NAME - 1))
     {
         ident[idx++] = ch;
@@ -170,7 +170,7 @@ static char *token(FILE *stream)
     if (idx >= 1 && ch != ':' ) ungetc(ch, stream);
     if (idx < 1 ) ident[idx++] = ch;	/* single-character token */
     ident[idx] = 0;
-    
+
     return(ident);	/* returns pointer to the token */
 
 } /* token */
@@ -187,15 +187,15 @@ static char *linetoken(FILE *stream)
 {
     int ch, idx;
 
-    while ((ch = fgetc(stream)) == ' ' || ch == '\t' ); 
-    
+    while ((ch = fgetc(stream)) == ' ' || ch == '\t' );
+
     idx = 0;
     while (ch != EOF && ch != lineterm && idx < (MAX_NAME - 1))
     {
         ident[idx++] = ch;
         ch = fgetc(stream);
     } /* while */
-    
+
     ungetc(ch, stream);
     ident[idx] = 0;
 
@@ -207,7 +207,7 @@ static char *linetoken(FILE *stream)
 /*************************** recognize *************************/
 
 /*  This function tries to match a string to a known list of
- *  valid AFM entries (check the keyStrings array above). 
+ *  valid AFM entries (check the keyStrings array above).
  *  "ident" contains everything from white space through the
  *  next space, tab, or ":" character.
  *
@@ -231,7 +231,7 @@ static enum parseKey recognize(char *ident)
 
     if (found) return (enum parseKey) midpoint;
     else return NOPE;
-    
+
 } /* recognize */
 
 
@@ -240,32 +240,32 @@ static enum parseKey recognize(char *ident)
 /*  This function is called by "parseFile". It will parse the AFM File
  *  up to the "StartCharMetrics" keyword, which essentially marks the
  *  end of the Global Font Information and the beginning of the character
- *  metrics information. 
+ *  metrics information.
  *
  *  If the caller of "parseFile" specified that it wanted the Global
  *  Font Information (as defined by the "AFM File Specification"
- *  document), then that information will be stored in the returned 
+ *  document), then that information will be stored in the returned
  *  data structure.
  *
- *  Any Global Font Information entries that are not found in a 
+ *  Any Global Font Information entries that are not found in a
  *  given file, will have the usual default initialization value
  *  for its type (i.e. entries of type int will be 0, etc).
  *
- *  This function returns an error code specifying whether there was 
- *  a premature EOF or a parsing error. This return value is used by 
+ *  This function returns an error code specifying whether there was
+ *  a premature EOF or a parsing error. This return value is used by
  *  parseFile to determine if there is more file to parse.
  */
- 
+
 static BOOL parseGlobals(FILE *fp, GlobalFontInfo *gfi)
-{  
+{
     BOOL cont = TRUE, save = (gfi != NULL);
     int error = ok;
     register char *keyword;
-    
+
     while (cont)
     {
         keyword = token(fp);
-        
+
         if (keyword == NULL)
           /* Have reached an early and unexpected EOF. */
           /* Set flag and stop parsing */
@@ -273,15 +273,15 @@ static BOOL parseGlobals(FILE *fp, GlobalFontInfo *gfi)
             error = earlyEOF;
             break;   /* get out of loop */
         }
-        if (!save)	
+        if (!save)
           /* get tokens until the end of the Global Font info section */
           /* without saving any of the data */
-            switch (recognize(keyword))  
-            {				
+            switch (recognize(keyword))
+            {
                 case STARTCHARMETRICS:
                     cont = FALSE;
                     break;
-                case ENDFONTMETRICS:	
+                case ENDFONTMETRICS:
                     cont = FALSE;
                     error = normalEOF;
                     break;
@@ -308,20 +308,20 @@ static BOOL parseGlobals(FILE *fp, GlobalFontInfo *gfi)
                     break;
                 case ENCODINGSCHEME:
                     keyword = token(fp);
-                    gfi->encodingScheme = (char *) 
+                    gfi->encodingScheme = (char *)
                     	malloc(strlen(keyword) + 1);
                     strcpy(gfi->encodingScheme, keyword);
-                    break; 
+                    break;
                 case FULLNAME:
                     keyword = linetoken(fp);
                     gfi->fullName = (char *) malloc(strlen(keyword) + 1);
                     strcpy(gfi->fullName, keyword);
-                    break; 
-                case FAMILYNAME:           
+                    break;
+                case FAMILYNAME:
                    keyword = linetoken(fp);
                     gfi->familyName = (char *) malloc(strlen(keyword) + 1);
                     strcpy(gfi->familyName, keyword);
-                    break; 
+                    break;
                 case WEIGHT:
                     keyword = token(fp);
                     gfi->weight = (char *) malloc(strlen(keyword) + 1);
@@ -336,13 +336,13 @@ static BOOL parseGlobals(FILE *fp, GlobalFontInfo *gfi)
                     keyword = token(fp);
                     if (MATCH(keyword, False))
                         gfi->isFixedPitch = 0;
-                    else 
+                    else
                         gfi->isFixedPitch = 1;
-                    break; 
+                    break;
 	            case UNDERLINEPOSITION:
                     keyword = token(fp);
 	                gfi->underlinePosition = atoi(keyword);
-                    break; 
+                    break;
                 case UNDERLINETHICKNESS:
                     keyword = token(fp);
                     gfi->underlineThickness = atoi(keyword);
@@ -351,12 +351,12 @@ static BOOL parseGlobals(FILE *fp, GlobalFontInfo *gfi)
                     keyword = token(fp);
                     gfi->version = (char *) malloc(strlen(keyword) + 1);
                     strcpy(gfi->version, keyword);
-                    break; 
+                    break;
                 case NOTICE:
                     keyword = linetoken(fp);
                     gfi->notice = (char *) malloc(strlen(keyword) + 1);
                     strcpy(gfi->notice, keyword);
-                    break; 
+                    break;
                 case FONTBBOX:
                     keyword = token(fp);
                     gfi->fontBBox.llx = atoi(keyword);
@@ -396,10 +396,10 @@ static BOOL parseGlobals(FILE *fp, GlobalFontInfo *gfi)
                     break;
             } /* switch */
     } /* while */
-    
+
     return(error);
-    
-} /* parseGlobals */    
+
+} /* parseGlobals */
 
 
 
@@ -409,26 +409,26 @@ static BOOL parseGlobals(FILE *fp, GlobalFontInfo *gfi)
 /*  Unmapped character codes are (at Adobe Systems) assigned the
  *  width of the space character (if one exists) else they get the
  *  value of 250 ems. This function initializes all entries in the
- *  char widths array to have this value. Then any mapped character 
- *  codes will be replaced with the width of the appropriate character 
+ *  char widths array to have this value. Then any mapped character
+ *  codes will be replaced with the width of the appropriate character
  *  when parsing the character metric section.
- 
+
  *  This function parses the Character Metrics Section looking
  *  for a space character (by comparing character names). If found,
  *  the width of the space character will be used to initialize the
- *  values in the array of character widths. 
+ *  values in the array of character widths.
  *
  *  Before returning, the position of the read/write pointer of the
  *  file is reset to be where it was upon entering this function.
  */
- 
+
 static int initializeArray(FILE *fp, int *cwi)
-{  
+{
     BOOL cont = TRUE, found = FALSE;
     long opos = ftell(fp);
     int code = 0, width = 0, i = 0, error = 0;
     register char *keyword;
-  
+
     while (cont)
     {
         keyword = token(fp);
@@ -448,67 +448,67 @@ static int initializeArray(FILE *fp, int *cwi)
             case XWIDTH:
                 width = atoi(token(fp));
                 break;
-            case CHARNAME: 
+            case CHARNAME:
                 keyword = token(fp);
                 if (MATCH(keyword, Space))
-                {    
+                {
                     cont = FALSE;
                     found = TRUE;
-                } 
-                break;            
+                }
+                break;
             case ENDCHARMETRICS:
                 cont = FALSE;
-                break; 
+                break;
             case ENDFONTMETRICS:
                 cont = FALSE;
                 error = normalEOF;
                 break;
             case NOPE:
-            default: 
+            default:
                 error = parseError;
                 break;
         } /* switch */
     } /* while */
-    
+
     if (!found)
         width = 250;
-    
+
     for (i = 0; i < 256; ++i)
         cwi[i] = width;
-    
+
     fseek(fp, opos, 0);
-    
+
     return(error);
-        
-} /* initializeArray */    
+
+} /* initializeArray */
 #endif /* unused */
 
 /************************* parseCharWidths **************************/
 
 /*  This function is called by "parseFile". It will parse the AFM File
- *  up to the "EndCharMetrics" keyword. It will save the character 
+ *  up to the "EndCharMetrics" keyword. It will save the character
  *  width info (as opposed to all of the character metric information)
  *  if requested by the caller of parseFile. Otherwise, it will just
  *  parse through the section without saving any information.
  *
- *  If data is to be saved, parseCharWidths is passed in a pointer 
+ *  If data is to be saved, parseCharWidths is passed in a pointer
  *  to an array of widths that has already been initialized by the
  *  standard value for unmapped character codes. This function parses
  *  the Character Metrics section only storing the width information
  *  for the encoded characters into the array using the character code
  *  as the index into that array.
  *
- *  This function returns an error code specifying whether there was 
- *  a premature EOF or a parsing error. This return value is used by 
+ *  This function returns an error code specifying whether there was
+ *  a premature EOF or a parsing error. This return value is used by
  *  parseFile to determine if there is more file to parse.
  */
- 
+
 static int parseCharWidths(FILE *fp, int *cwi)
-{  
+{
     BOOL cont = TRUE, save = (cwi != NULL);
     int pos = 0, error = ok;
     register char *keyword;
-    
+
     while (cont)
     {
         keyword = token(fp);
@@ -519,19 +519,19 @@ static int parseCharWidths(FILE *fp, int *cwi)
             error = earlyEOF;
             break; /* get out of loop */
         }
-        if (!save)	
+        if (!save)
           /* get tokens until the end of the Char Metrics section without */
           /* saving any of the data*/
-            switch (recognize(keyword))  
-            {				
+            switch (recognize(keyword))
+            {
                 case ENDCHARMETRICS:
                     cont = FALSE;
-                    break; 
+                    break;
                 case ENDFONTMETRICS:
                     cont = FALSE;
                     error = normalEOF;
                     break;
-                default: 
+                default:
                     break;
             } /* switch */
         else
@@ -558,15 +558,15 @@ static int parseCharWidths(FILE *fp, int *cwi)
                     break;
                 case ENDCHARMETRICS:
                     cont = FALSE;
-                    break; 
+                    break;
                 case ENDFONTMETRICS:
                     cont = FALSE;
                     error = normalEOF;
                     break;
                 case CHARNAME:	/* eat values (so doesn't cause parseError) */
-                    keyword = token(fp); 
+                    keyword = token(fp);
                     break;
-            	case CHARBBOX: 
+            	case CHARBBOX:
                     keyword = token(fp); keyword = token(fp);
                     keyword = token(fp); keyword = token(fp);
 		    break;
@@ -574,15 +574,15 @@ static int parseCharWidths(FILE *fp, int *cwi)
                     keyword = token(fp); keyword = token(fp);
 		    break;
                 case NOPE:
-                default: 
+                default:
                     error = parseError;
                     break;
             } /* switch */
     } /* while */
-    
+
     return(error);
-    
-} /* parseCharWidths */    
+
+} /* parseCharWidths */
 
 
 /************************* parseCharMetrics ************************/
@@ -594,21 +594,21 @@ static int parseCharWidths(FILE *fp, int *cwi)
  *  parseCharMetrics is passed in a pointer to an array of records
  *  to hold information on a per character basis. This function
  *  parses the Character Metrics section storing all character
- *  metric information for the ALL characters (mapped and unmapped) 
+ *  metric information for the ALL characters (mapped and unmapped)
  *  into the array.
  *
- *  This function returns an error code specifying whether there was 
- *  a premature EOF or a parsing error. This return value is used by 
+ *  This function returns an error code specifying whether there was
+ *  a premature EOF or a parsing error. This return value is used by
  *  parseFile to determine if there is more file to parse.
  */
- 
+
 static int parseCharMetrics(FILE *fp, FontInfo *fi)
-{  
+{
     BOOL cont = TRUE, firstTime = TRUE;
     int error = ok, count = 0;
     register CharMetricInfo *temp = fi->cmi;
     register char *keyword;
-  
+
     while (cont)
     {
         keyword = token(fp);
@@ -621,10 +621,10 @@ static int parseCharMetrics(FILE *fp, FontInfo *fi)
         {
             case COMMENT:
                 keyword = linetoken(fp);
-                break; 
+                break;
             case CODE:
                 if (count < fi->numOfChars)
-                { 
+                {
                     if (firstTime) firstTime = FALSE;
                     else temp++;
                     temp->code = atoi(token(fp));
@@ -639,16 +639,16 @@ static int parseCharMetrics(FILE *fp, FontInfo *fi)
             case XYWIDTH:
                 temp->wx = atoi(token(fp));
                 temp->wy = atoi(token(fp));
-                break;                 
-            case XWIDTH: 
+                break;
+            case XWIDTH:
                 temp->wx = atoi(token(fp));
                 break;
-            case CHARNAME: 
+            case CHARNAME:
                 keyword = token(fp);
                 temp->name = (char *) malloc(strlen(keyword) + 1);
                 strcpy(temp->name, keyword);
-                break;            
-            case CHARBBOX: 
+                break;
+            case CHARBBOX:
                 temp->charBBox.llx = atoi(token(fp));
                 temp->charBBox.lly = atoi(token(fp));
                 temp->charBBox.urx = atoi(token(fp));
@@ -657,14 +657,14 @@ static int parseCharMetrics(FILE *fp, FontInfo *fi)
             case LIGATURE: {
                 Ligature **tail = &(temp->ligs);
                 Ligature *node = *tail;
-                
+
                 if (*tail != NULL)
                 {
                     while (node->next != NULL)
                         node = node->next;
-                    tail = &(node->next); 
+                    tail = &(node->next);
                 }
-                
+
                 *tail = (Ligature *) calloc(1, sizeof(Ligature));
                 keyword = token(fp);
                 (*tail)->succ = (char *) malloc(strlen(keyword) + 1);
@@ -675,52 +675,52 @@ static int parseCharMetrics(FILE *fp, FontInfo *fi)
                 break; }
             case ENDCHARMETRICS:
                 cont = FALSE;;
-                break; 
-            case ENDFONTMETRICS: 
+                break;
+            case ENDFONTMETRICS:
                 cont = FALSE;
                 error = normalEOF;
-                break; 
+                break;
             case NOPE:
             default:
-                error = parseError; 
-                break; 
+                error = parseError;
+                break;
         } /* switch */
     } /* while */
-    
+
     if ((error == ok) && (count != fi->numOfChars))
         error = parseError;
-    
+
     return(error);
-    
-} /* parseCharMetrics */    
+
+} /* parseCharMetrics */
 
 
 
 /************************* parseTrackKernData ***********************/
 
-/*  This function is called by "parseFile". It will parse the AFM File 
+/*  This function is called by "parseFile". It will parse the AFM File
  *  up to the "EndTrackKern" or "EndKernData" keywords. It will save the
  *  track kerning data if requested by the caller of parseFile.
  *
  *  parseTrackKernData is passed in a pointer to the FontInfo record.
- *  If data is to be saved, the FontInfo record will already contain 
+ *  If data is to be saved, the FontInfo record will already contain
  *  a valid pointer to storage for the track kerning data.
  *
- *  This function returns an error code specifying whether there was 
- *  a premature EOF or a parsing error. This return value is used by 
+ *  This function returns an error code specifying whether there was
+ *  a premature EOF or a parsing error. This return value is used by
  *  parseFile to determine if there is more file to parse.
  */
- 
+
 static int parseTrackKernData(FILE *fp, FontInfo *fi)
-{  
+{
     BOOL cont = TRUE, save = (fi->tkd != NULL);
     int pos = 0, error = ok, tcount = 0;
     register char *keyword;
-  
+
     while (cont)
     {
         keyword = token(fp);
-        
+
         if (keyword == NULL)
         {
             error = earlyEOF;
@@ -789,40 +789,40 @@ static int parseTrackKernData(FILE *fp, FontInfo *fi)
                     break;
             } /* switch */
     } /* while */
-    
+
     if (error == ok && tcount != fi->numOfTracks)
         error = parseError;
-        
+
     return(error);
-    
-} /* parseTrackKernData */    
+
+} /* parseTrackKernData */
 
 
 /************************* parsePairKernData ************************/
 
-/*  This function is called by "parseFile". It will parse the AFM File 
+/*  This function is called by "parseFile". It will parse the AFM File
  *  up to the "EndKernPairs" or "EndKernData" keywords. It will save
  *  the pair kerning data if requested by the caller of parseFile.
  *
  *  parsePairKernData is passed in a pointer to the FontInfo record.
- *  If data is to be saved, the FontInfo record will already contain 
+ *  If data is to be saved, the FontInfo record will already contain
  *  a valid pointer to storage for the pair kerning data.
  *
- *  This function returns an error code specifying whether there was 
- *  a premature EOF or a parsing error. This return value is used by 
+ *  This function returns an error code specifying whether there was
+ *  a premature EOF or a parsing error. This return value is used by
  *  parseFile to determine if there is more file to parse.
  */
- 
+
 static int parsePairKernData(FILE *fp, FontInfo *fi)
-{  
+{
     BOOL cont = TRUE, save = (fi->pkd != NULL);
     int pos = 0, error = ok, pcount = 0;
     register char *keyword;
-  
+
     while (cont)
     {
         keyword = token(fp);
-        
+
         if (keyword == NULL)
         {
             error = earlyEOF;
@@ -856,11 +856,11 @@ static int parsePairKernData(FILE *fp, FontInfo *fi)
                     if (pcount < fi->numOfPairs)
                     {
                         keyword = token(fp);
-                        fi->pkd[pos].name1 = (char *) 
+                        fi->pkd[pos].name1 = (char *)
                             malloc(strlen(keyword) + 1);
                         strcpy(fi->pkd[pos].name1, keyword);
                         keyword = token(fp);
-                        fi->pkd[pos].name2 = (char *) 
+                        fi->pkd[pos].name2 = (char *)
                             malloc(strlen(keyword) + 1);
                         strcpy(fi->pkd[pos].name2, keyword);
                         keyword = token(fp);
@@ -879,11 +879,11 @@ static int parsePairKernData(FILE *fp, FontInfo *fi)
                     if (pcount < fi->numOfPairs)
                     {
                         keyword = token(fp);
-                        fi->pkd[pos].name1 = (char *) 
+                        fi->pkd[pos].name1 = (char *)
                             malloc(strlen(keyword) + 1);
                         strcpy(fi->pkd[pos].name1, keyword);
                         keyword = token(fp);
-                        fi->pkd[pos].name2 = (char *) 
+                        fi->pkd[pos].name2 = (char *)
                             malloc(strlen(keyword) + 1);
                         strcpy(fi->pkd[pos].name2, keyword);
                         keyword = token(fp);
@@ -910,39 +910,39 @@ static int parsePairKernData(FILE *fp, FontInfo *fi)
                     break;
             } /* switch */
     } /* while */
-    
+
     if (error == ok && pcount != fi->numOfPairs)
         error = parseError;
-        
+
     return(error);
-    
-} /* parsePairKernData */    
+
+} /* parsePairKernData */
 
 
 /************************* parseCompCharData **************************/
 
-/*  This function is called by "parseFile". It will parse the AFM File 
- *  up to the "EndComposites" keyword. It will save the composite 
+/*  This function is called by "parseFile". It will parse the AFM File
+ *  up to the "EndComposites" keyword. It will save the composite
  *  character data if requested by the caller of parseFile.
  *
- *  parseCompCharData is passed in a pointer to the FontInfo record, and 
+ *  parseCompCharData is passed in a pointer to the FontInfo record, and
  *  a boolean representing if the data should be saved.
  *
  *  This function will create the appropriate amount of storage for
  *  the composite character data and store a pointer to the storage
  *  in the FontInfo record.
  *
- *  This function returns an error code specifying whether there was 
- *  a premature EOF or a parsing error. This return value is used by 
+ *  This function returns an error code specifying whether there was
+ *  a premature EOF or a parsing error. This return value is used by
  *  parseFile to determine if there is more file to parse.
  */
- 
+
 static int parseCompCharData(FILE *fp, FontInfo *fi)
-{  
+{
     BOOL cont = TRUE, firstTime = TRUE, save = (fi->ccd != NULL);
     int pos = 0, j = 0, error = ok, ccount = 0, pcount = 0;
     register char *keyword;
-  
+
     while (cont)
     {
         keyword = token(fp);
@@ -990,7 +990,7 @@ static int parseCompCharData(FILE *fp, FontInfo *fi)
                         pcount = 0;
                         if (firstTime) firstTime = FALSE;
                         else pos++;
-                        fi->ccd[pos].ccName = (char *) 
+                        fi->ccd[pos].ccName = (char *)
                             malloc(strlen(keyword) + 1);
                         strcpy(fi->ccd[pos].ccName, keyword);
                         keyword = token(fp);
@@ -1010,7 +1010,7 @@ static int parseCompCharData(FILE *fp, FontInfo *fi)
                     if (pcount < fi->ccd[pos].numOfPieces)
                     {
                         keyword = token(fp);
-                        fi->ccd[pos].pieces[j].pccName = (char *) 
+                        fi->ccd[pos].pieces[j].pccName = (char *)
                                 malloc(strlen(keyword) + 1);
                         strcpy(fi->ccd[pos].pieces[j].pccName, keyword);
                         keyword = token(fp);
@@ -1035,23 +1035,23 @@ static int parseCompCharData(FILE *fp, FontInfo *fi)
                     break;
             } /* switch */
     } /* while */
-    
+
     if (error == ok && ccount != fi->numOfComps)
         error = parseError;
-    
+
     return(error);
-    
-} /* parseCompCharData */    
+
+} /* parseCompCharData */
 
 
 
 
-/*************************** 'PUBLIC' FUNCTION ********************/ 
+/*************************** 'PUBLIC' FUNCTION ********************/
 
 
 /*************************** parseFile *****************************/
 
-/*  parseFile is the only 'public' procedure available. It is called 
+/*  parseFile is the only 'public' procedure available. It is called
  *  from an application wishing to get information from an AFM file.
  *  The caller of this function is responsible for locating and opening
  *  an AFM file and handling all errors associated with that task.
@@ -1061,43 +1061,43 @@ static int parseCompCharData(FILE *fp, FontInfo *fi)
  *  the data requested filled in), and a mask specifying which
  *  data from the AFM File should be saved in the FontInfo structure.
  *
- *  The file will be parsed and the requested data will be stored in 
+ *  The file will be parsed and the requested data will be stored in
  *  a record of type FontInfo (refer to ParseAFM.h).
  *
- *  parseFile returns an error code as defined in parseAFM.h. 
+ *  parseFile returns an error code as defined in parseAFM.h.
  *
- *  The position of the read/write pointer associated with the file 
+ *  The position of the read/write pointer associated with the file
  *  pointer upon return of this function is undefined.
  */
 
 extern int afm_parse_file(FILE *fp, FontInfo **fi, FLAGS flags)
 {
-    
+
     int code = ok; 	/* return code from each of the parsing routines */
     int error = ok;	/* used as the return code from this function */
-    
-    register char *keyword; /* used to store a token */	 
-    
-   			      
-    /* storage data for the global variable ident */			      
-    ident = (char *) calloc(MAX_NAME, sizeof(char)); 
-    if (ident == NULL) {error = storageProblem; return(error);}      
-  
+
+    register char *keyword; /* used to store a token */
+
+
+    /* storage data for the global variable ident */
+    ident = (char *) calloc(MAX_NAME, sizeof(char));
+    if (ident == NULL) {error = storageProblem; return(error);}
+
     (*fi) = (FontInfo *) calloc(1, sizeof(FontInfo));
-    if ((*fi) == NULL) {error = storageProblem; return(error);}      
-  
-    if (flags & P_G) 
+    if ((*fi) == NULL) {error = storageProblem; return(error);}
+
+    if (flags & P_G)
     {
         (*fi)->gfi = (GlobalFontInfo *) calloc(1, sizeof(GlobalFontInfo));
-        if ((*fi)->gfi == NULL) {error = storageProblem; return(error);}      
+        if ((*fi)->gfi == NULL) {error = storageProblem; return(error);}
     }
-    
+
     /* The AFM File begins with Global Font Information. This section */
-    /* will be parsed whether or not information should be saved. */     
-    code = parseGlobals(fp, (*fi)->gfi); 
-    
+    /* will be parsed whether or not information should be saved. */
+    code = parseGlobals(fp, (*fi)->gfi);
+
     if (code < 0) error = code;
-    
+
     /* The Global Font Information is followed by the Character Metrics */
     /* section. Which procedure is used to parse this section depends on */
     /* how much information should be saved. If all of the metrics info */
@@ -1105,25 +1105,25 @@ extern int afm_parse_file(FILE *fp, FontInfo **fi, FLAGS flags)
     /* is wanted, parseCharWidths is called. parseCharWidths will also */
     /* be called in the case that no character data is to be saved, just */
     /* to parse through the section. */
-  
+
     if ((code != normalEOF) && (code != earlyEOF))
     {
         (*fi)->numOfChars = atoi(token(fp));
 	    if (flags & (P_M ^ P_W))
         {
-            (*fi)->cmi = (CharMetricInfo *) 
+            (*fi)->cmi = (CharMetricInfo *)
                       calloc((*fi)->numOfChars, sizeof(CharMetricInfo));
            if ((*fi)->cmi == NULL) {error = storageProblem; return(error);}
-            code = parseCharMetrics(fp, *fi);             
+            code = parseCharMetrics(fp, *fi);
         }
         else
         {
             if (flags & P_W)
-            { 
-                (*fi)->cwi = (int *) calloc(256, sizeof(int)); 
-                if ((*fi)->cwi == NULL) 
+            {
+                (*fi)->cwi = (int *) calloc(256, sizeof(int));
+                if ((*fi)->cwi == NULL)
                 {
-                	error = storageProblem; 
+                	error = storageProblem;
                 	return(error);
                 }
             }
@@ -1131,15 +1131,15 @@ extern int afm_parse_file(FILE *fp, FontInfo **fi, FLAGS flags)
             code = parseCharWidths(fp, (*fi)->cwi);
         } /* else */
     } /* if */
-    
+
     if ((error != earlyEOF) && (code < 0)) error = code;
-    
+
     /* The remaining sections of the AFM are optional. This code will */
     /* look at the next keyword in the file to determine what section */
     /* is next, and then allocate the appropriate amount of storage */
     /* for the data (if the data is to be saved) and call the */
     /* appropriate parsing routine to parse the section. */
-    
+
     while ((code != normalEOF) && (code != earlyEOF))
     {
         keyword = token(fp);
@@ -1161,11 +1161,11 @@ extern int afm_parse_file(FILE *fp, FontInfo **fi, FLAGS flags)
                 if (flags & P_T)
                 {
                     (*fi)->numOfTracks = atoi(keyword);
-                    (*fi)->tkd = (TrackKernData *) 
+                    (*fi)->tkd = (TrackKernData *)
                         calloc((*fi)->numOfTracks, sizeof(TrackKernData));
-                    if ((*fi)->tkd == NULL) 
+                    if ((*fi)->tkd == NULL)
                     {
-                    	error = storageProblem; 
+                    	error = storageProblem;
                     	return(error);
                     }
                 } /* if */
@@ -1176,11 +1176,11 @@ extern int afm_parse_file(FILE *fp, FontInfo **fi, FLAGS flags)
                 if (flags & P_P)
                 {
                     (*fi)->numOfPairs = atoi(keyword);
-                    (*fi)->pkd = (PairKernData *) 
+                    (*fi)->pkd = (PairKernData *)
                         calloc((*fi)->numOfPairs, sizeof(PairKernData));
-                    if ((*fi)->pkd == NULL) 
+                    if ((*fi)->pkd == NULL)
                     {
-                    	error = storageProblem; 
+                    	error = storageProblem;
                     	return(error);
                     }
                 } /* if */
@@ -1189,18 +1189,18 @@ extern int afm_parse_file(FILE *fp, FontInfo **fi, FLAGS flags)
             case STARTCOMPOSITES:
                 keyword = token(fp);
                 if (flags & P_C)
-                { 
+                {
                     (*fi)->numOfComps = atoi(keyword);
-                    (*fi)->ccd = (CompCharData *) 
+                    (*fi)->ccd = (CompCharData *)
                         calloc((*fi)->numOfComps, sizeof(CompCharData));
-                    if ((*fi)->ccd == NULL) 
+                    if ((*fi)->ccd == NULL)
                     {
-                    	error = storageProblem; 
+                    	error = storageProblem;
                     	return(error);
                     }
                 } /* if */
-                code = parseCompCharData(fp, *fi); 
-                break;    
+                code = parseCompCharData(fp, *fi);
+                break;
             case ENDFONTMETRICS:
                 code = normalEOF;
                 break;
@@ -1209,17 +1209,17 @@ extern int afm_parse_file(FILE *fp, FontInfo **fi, FLAGS flags)
                 code = parseError;
                 break;
         } /* switch */
-        
+
         if ((error != earlyEOF) && (code < 0)) error = code;
-        
+
     } /* while */
-  
+
     if ((error != earlyEOF) && (code < 0)) error = code;
-    
+
     if (ident != NULL) { free(ident); ident = NULL; }
-        
+
     return(error);
-  
+
 } /* parseFile */
 
 /* added for MDVI: this function was copied from `parseAFMclient.c' */
@@ -1229,7 +1229,7 @@ void afm_free_fontinfo(FontInfo *fi)
     if (fi != NULL)
     {
         if (fi->gfi != NULL)
-        { 
+        {
             free(fi->gfi->afmVersion); fi->gfi->afmVersion = NULL;
             free(fi->gfi->fontName); fi->gfi->fontName = NULL;
             free(fi->gfi->fullName); fi->gfi->fullName = NULL;
@@ -1240,16 +1240,16 @@ void afm_free_fontinfo(FontInfo *fi)
             free(fi->gfi->encodingScheme); fi->gfi->encodingScheme = NULL;
             free(fi->gfi); fi->gfi = NULL;
         }
-  
+
         if (fi->cwi != NULL)
         { free(fi->cwi); fi->cwi = NULL; }
 
         if (fi->cmi != NULL)
-        { 
+        {
             int i = 0;
             CharMetricInfo *temp = fi->cmi;
             Ligature *node = temp->ligs;
-            
+
             for (i = 0; i < fi->numOfChars; ++i)
             {
                 for (node = temp->ligs; node != NULL; node = node->next)
@@ -1257,47 +1257,47 @@ void afm_free_fontinfo(FontInfo *fi)
                     free(node->succ); node->succ = NULL;
                     free(node->lig); node->lig = NULL;
                 }
-                
+
                 free(temp->name); temp->name = NULL;
                 temp++;
             }
-            
+
             free(fi->cmi); fi->cmi = NULL;
         }
 
         if (fi->tkd != NULL)
         { free(fi->tkd); fi->tkd = NULL; }
-  
+
         if (fi->pkd != NULL)
-        { 
+        {
             free(fi->pkd->name1); fi->pkd->name1 = NULL;
             free(fi->pkd->name2); fi->pkd->name2 = NULL;
             free(fi->pkd); fi->pkd = NULL;
         }
 
         if (fi->ccd != NULL)
-        { 
+        {
             int i = 0, j = 0;
     	    CompCharData *ccd = fi->ccd;
-    	    
+
     	    for (i = 0; i < fi->numOfComps; ++i)
     	    {
     	        for (j = 0; j < ccd[i].numOfPieces; ++j)
     	        {
-    	            free(ccd[i].pieces[j].pccName); 
+    	            free(ccd[i].pieces[j].pccName);
     	            ccd[i].pieces[j].pccName = NULL;
     	        }
-    	        
+
     	        free(ccd[i].ccName); ccd[i].ccName = NULL;
     	    }
-    
+
             free(fi->ccd); fi->ccd = NULL;
         }
-        
+
         free(fi);
 
-    } /* if */ 
-  
+    } /* if */
+
 } /* afm_free_fontinfo */
 
 #endif /* WITH_AFM_FILES */
diff --git a/backend/dvi/mdvi-lib/afmparse.h b/backend/dvi/mdvi-lib/afmparse.h
index 6cce780c..164c3567 100644
--- a/backend/dvi/mdvi-lib/afmparse.h
+++ b/backend/dvi/mdvi-lib/afmparse.h
@@ -3,20 +3,20 @@
  * (C) 1988, 1989 by Adobe Systems Incorporated. All rights reserved.
  *
  * This file may be freely copied and redistributed as long as:
- *   1) This entire notice continues to be included in the file, 
+ *   1) This entire notice continues to be included in the file,
  *   2) If the file has been modified in any way, a notice of such
  *      modification is conspicuously indicated.
  *
  * PostScript, Display PostScript, and Adobe are registered trademarks of
  * Adobe Systems Incorporated.
- * 
+ *
  * ************************************************************************
  * THE INFORMATION BELOW IS FURNISHED AS IS, IS SUBJECT TO CHANGE WITHOUT
  * NOTICE, AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY ADOBE SYSTEMS
- * INCORPORATED. ADOBE SYSTEMS INCORPORATED ASSUMES NO RESPONSIBILITY OR 
- * LIABILITY FOR ANY ERRORS OR INACCURACIES, MAKES NO WARRANTY OF ANY 
- * KIND (EXPRESS, IMPLIED OR STATUTORY) WITH RESPECT TO THIS INFORMATION, 
- * AND EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES OF MERCHANTABILITY, 
+ * INCORPORATED. ADOBE SYSTEMS INCORPORATED ASSUMES NO RESPONSIBILITY OR
+ * LIABILITY FOR ANY ERRORS OR INACCURACIES, MAKES NO WARRANTY OF ANY
+ * KIND (EXPRESS, IMPLIED OR STATUTORY) WITH RESPECT TO THIS INFORMATION,
+ * AND EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR PARTICULAR PURPOSES AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  * ************************************************************************
  */
@@ -27,23 +27,23 @@
  * Together these files provide the functionality to parse Adobe Font
  * Metrics files and store the information in predefined data structures.
  * It is intended to work with an application program that needs font metric
- * information. The program can be used as is by making a procedure call to 
+ * information. The program can be used as is by making a procedure call to
  * parse an AFM file and have the data stored, or an application developer
- * may wish to customize the code. 
+ * may wish to customize the code.
  *
- * This header file defines the data structures used as well as the key 
+ * This header file defines the data structures used as well as the key
  * strings that are currently recognized by this version of the AFM parser.
- * This program is based on the document "Adobe Font Metrics Files, 
+ * This program is based on the document "Adobe Font Metrics Files,
  * Specification Version 2.0".
  *
  * AFM files are separated into distinct sections of different data. Because
  * of this, the parseAFM program can parse a specified file to only save
- * certain sections of information based on the application's needs. A record 
+ * certain sections of information based on the application's needs. A record
  * containing the requested information will be returned to the application.
- * 
+ *
  * AFM files are divided into five sections of data:
  *	1) The Global Font Information
- *	2) The Character Metrics Information 
+ *	2) The Character Metrics Information
  *	3) The Track Kerning Data
  *	4) The Pair-Wise Kerning Data
  *	5) The Composite Character Data
@@ -52,22 +52,22 @@
  * of what other sections are requested. In addition, in recognizing that
  * many applications will want ONLY the x-width of characters and not all
  * of the other character metrics information, there is a way to receive
- * only the width information so as not to pay the storage cost for the 
- * unwanted data. An application should never request both the 
- * "quick and dirty" char metrics (widths only) and the Character Metrics 
- * Information since the Character Metrics Information will contain all 
+ * only the width information so as not to pay the storage cost for the
+ * unwanted data. An application should never request both the
+ * "quick and dirty" char metrics (widths only) and the Character Metrics
+ * Information since the Character Metrics Information will contain all
  * of the character widths as well.
- * 
- * There is a procedure in parseAFM.c, called parseFile, that can be 
+ *
+ * There is a procedure in parseAFM.c, called parseFile, that can be
  * called from any application wishing to get information from the AFM File.
  * This procedure expects 3 parameters: a vaild file descriptor, a pointer
- * to a (FontInfo *) variable (for which space will be allocated and then 
+ * to a (FontInfo *) variable (for which space will be allocated and then
  * will be filled in with the data requested), and a mask specifying
  * which data from the AFM File should be saved in the FontInfo structure.
- * 
+ *
  * The flags that can be used to set the appropriate mask are defined below.
- * In addition, several commonly used masks have already been defined. 
- * 
+ * In addition, several commonly used masks have already been defined.
+ *
  * History:
  *	original: DSM  Thu Oct 20 17:39:59 PDT 1988
  *  modified: DSM  Mon Jul  3 14:17:50 PDT 1989
@@ -99,25 +99,25 @@
 #define P_C	0x20	/* 0010 0000 */   /* Composite Char Info   */
 
 /* Commonly used flags */
-#define P_GW	(P_G | P_W) 
+#define P_GW	(P_G | P_W)
 #define P_GM	(P_G | P_M)
 #define P_GMP	(P_G | P_M | P_P)
-#define P_GMK	(P_G | P_M | P_P | P_T) 
+#define P_GMK	(P_G | P_M | P_P | P_T)
 #define P_ALL	(P_G | P_M | P_P | P_T | P_C)
 
 /* Possible return codes from the parseFile procedure.
- * 
+ *
  * ok means there were no problems parsing the file.
  *
  * parseError means that there was some kind of parsing error, but the
  * parser went on. This could include problems like the count for any given
  * section does not add up to how many entries there actually were, or
  * there was a key that was not recognized. The return record may contain
- * vaild data or it may not. 
+ * vaild data or it may not.
  *
  * earlyEOF means that an End of File was encountered before expected. This
  * may mean that the AFM file had been truncated, or improperly formed.
- * 
+ *
  * storageProblem means that there were problems allocating storage for
  * the data structures that would have contained the AFM data.
  */
@@ -128,15 +128,15 @@
 
 /************************* TYPES *********************************/
 /* Below are all of the data structure definitions. These structures
- * try to map as closely as possible to grouping and naming of data 
+ * try to map as closely as possible to grouping and naming of data
  * in the AFM Files.
  */
 
-/* Bounding box definition. Used for the Font BBox as well as the 
+/* Bounding box definition. Used for the Font BBox as well as the
  * Character BBox.
  */
 typedef struct
-{ 
+{
    int llx;	/* lower left x-position  */
    int lly;	/* lower left y-position  */
    int urx;	/* upper right x-position */
@@ -144,12 +144,12 @@ typedef struct
 } BBox;
 
 /* Global Font information.
- * The key that each field is associated with is in comments. For an 
+ * The key that each field is associated with is in comments. For an
  * explanation about each key and its value please refer to the AFM
- * documentation (full title & version given above). 
+ * documentation (full title & version given above).
  */
 typedef struct
-{  
+{
    char *afmVersion;		/* key: StartFontMetrics */
    char *fontName;		/* key: FontName */
    char *fullName;		/* key: FullName */
@@ -178,15 +178,15 @@ typedef struct _t_ligature
     struct _t_ligature *next;
 } Ligature;
 
-/* Character Metric Information. This structure is used only if ALL 
+/* Character Metric Information. This structure is used only if ALL
  * character metric information is requested. If only the character
  * widths is requested, then only an array of the character x-widths
  * is returned.
  *
- * The key that each field is associated with is in comments. For an 
- * explanation about each key and its value please refer to the 
+ * The key that each field is associated with is in comments. For an
+ * explanation about each key and its value please refer to the
  * Character Metrics section of the AFM documentation (full title
- * & version given above). 
+ * & version given above).
  */
 typedef struct
 {
@@ -199,19 +199,19 @@ typedef struct
 } CharMetricInfo;
 
 /* Track kerning data structure.
- * The fields of this record are the five values associated with every 
+ * The fields of this record are the five values associated with every
  * TrackKern entry.
- *  
- * For an explanation about each value please refer to the 
+ *
+ * For an explanation about each value please refer to the
  * Track Kerning section of the AFM documentation (full title
- * & version given above). 
+ * & version given above).
  */
-typedef struct 
+typedef struct
 {
-    int degree;  
-    float minPtSize, 
-          minKernAmt, 
-          maxPtSize, 
+    int degree;
+    float minPtSize,
+          minKernAmt,
+          maxPtSize,
           maxKernAmt;
 } TrackKernData;
 
@@ -219,11 +219,11 @@ typedef struct
  * The fields of this record are the four values associated with every
  * KP entry. For KPX entries, the yamt will be zero.
  *
- * For an explanation about each value please refer to the 
+ * For an explanation about each value please refer to the
  * Pair Kerning section of the AFM documentation (full title
- * & version given above). 
+ * & version given above).
  */
-typedef struct 
+typedef struct
 {
     char *name1;
     char *name2;
@@ -234,10 +234,10 @@ typedef struct
 /* PCC is a piece of a composite character. This is a sub structure of a
  * compCharData described below.
  * These fields will be filled in with the values from the key PCC.
- * 
- * For an explanation about each key and its value please refer to the 
+ *
+ * For an explanation about each key and its value please refer to the
  * Composite Character section of the AFM documentation (full title
- * & version given above).  
+ * & version given above).
  */
 typedef struct
 {
@@ -246,15 +246,15 @@ typedef struct
         deltay;
 } Pcc;
 
-/* Composite Character Information data structure. 
+/* Composite Character Information data structure.
  * The fields ccName and numOfPieces are filled with the values associated
  * with the key CC. The field pieces points to an array (size = numOfPieces)
  * of information about each of the parts of the composite character. That
  * array is filled in with the values from the key PCC.
- * 
- * For an explanation about each key and its value please refer to the 
+ *
+ * For an explanation about each key and its value please refer to the
  * Composite Character section of the AFM documentation (full title
- * & version given above).  
+ * & version given above).
  */
 typedef struct
 {
@@ -270,9 +270,9 @@ typedef struct
  *  parseFile function.
  */
 typedef struct
-{ 
+{
     GlobalFontInfo *gfi;	/* ptr to a GlobalFontInfo record */
-    int *cwi;			/* ptr to 256 element array of just char widths */ 
+    int *cwi;			/* ptr to 256 element array of just char widths */
     int numOfChars;		/* number of entries in char metrics array */
     CharMetricInfo *cmi;	/* ptr to char metrics array */
     int numOfTracks;		/* number to entries in track kerning array */
@@ -289,7 +289,7 @@ typedef struct
  *
  *  "fp" should be a valid file pointer to an AFM file.
  *
- *  "fi" is a pointer to a pointer to a FontInfo record sturcture 
+ *  "fi" is a pointer to a pointer to a FontInfo record sturcture
  *  (defined above). Storage for the FontInfo structure will be
  *  allocated in parseFile and the structure will be filled in
  *  with the requested data from the AFM File.
@@ -301,7 +301,7 @@ typedef struct
  *  The possible return codes from parseFile are defined above.
  */
 
-extern int afm_parse_file __PROTO((FILE *, FontInfo **, FLAGS)); 
+extern int afm_parse_file __PROTO((FILE *, FontInfo **, FLAGS));
 extern void afm_free_fontinfo __PROTO((FontInfo *));
 
 #endif /* _MDVI_PARSEAFM_H */
diff --git a/backend/dvi/mdvi-lib/bitmap.c b/backend/dvi/mdvi-lib/bitmap.c
index 4417a75b..de1de6a7 100644
--- a/backend/dvi/mdvi-lib/bitmap.c
+++ b/backend/dvi/mdvi-lib/bitmap.c
@@ -48,7 +48,7 @@ static BmUnit bit_masks[] = {
 #define SHOW_OP_DATA	(DEBUGGING(BITMAP_OPS) && DEBUGGING(BITMAP_DATA))
 #endif
 
-/* 
+/*
  * Some useful macros to manipulate bitmap data
  * SEGMENT(m,n) = bit mask for a segment of `m' contiguous bits
  * starting at column `n'. These macros assume that
@@ -118,7 +118,7 @@ static Uchar bit_swap[] = {
 };
 
 
-/* 
+/*
  * next we have three bitmap functions to convert bitmaps in LSB bit order
  * with 8, 16 and 32 bits per unit, to our internal format. The differences
  * are minimal, but writing a generic function to handle all unit sizes is
@@ -132,8 +132,8 @@ BITMAP	*bitmap_convert_lsb8(Uchar *bits, int w, int h, int stride)
 	Uchar	*unit;
 	register Uchar *curr;
 	int	bytes;
-	
-	DEBUG((DBG_BITMAP_OPS, "convert LSB %dx%d@8 -> bitmap\n", w, h));	
+
+	DEBUG((DBG_BITMAP_OPS, "convert LSB %dx%d@8 -> bitmap\n", w, h));
 
 	bm = bitmap_alloc_raw(w, h);
 
@@ -141,14 +141,14 @@ BITMAP	*bitmap_convert_lsb8(Uchar *bits, int w, int h, int stride)
 	bytes = ROUND(w, 8);
 	unit  = (Uchar *)bm->data;
 	curr = bits;
-	/* we try to do this as fast as we can */	
+	/* we try to do this as fast as we can */
 	for(i = 0; i < h; i++) {
 #ifdef WORD_LITTLE_ENDIAN
 		memcpy(unit, curr, bytes);
 		curr += stride;
 #else
 		int	j;
-		
+
 		for(j = 0; j < bytes; curr++, j++)
 			unit[j] = bit_swap[*curr];
 		cur += stride - bytes;
@@ -168,7 +168,7 @@ BITMAP	*bitmap_convert_msb8(Uchar *data, int w, int h, int stride)
 	Uchar	*curr;
 	int	i;
 	int	bytes;
-	
+
 	bm = bitmap_alloc(w, h);
 	bytes = ROUND(w, 8);
 	unit = (Uchar *)bm->data;
@@ -176,7 +176,7 @@ BITMAP	*bitmap_convert_msb8(Uchar *data, int w, int h, int stride)
 	for(i = 0; i < h; i++) {
 #ifdef WORD_LITTLE_ENDIAN
 		int	j;
-		
+
 		for(j = 0; j < bytes; curr++, j++)
 			unit[j] = bit_swap[*curr];
 		curr += stride - bytes;
@@ -197,7 +197,7 @@ BITMAP	*bitmap_copy(BITMAP *bm)
 {
 	BITMAP	*nb = bitmap_alloc(bm->width, bm->height);
 
-	DEBUG((DBG_BITMAP_OPS, "copy %dx%d\n", bm->width, bm->height));	
+	DEBUG((DBG_BITMAP_OPS, "copy %dx%d\n", bm->width, bm->height));
 	memcpy(nb->data, bm->data, bm->height * bm->stride);
 	return nb;
 }
@@ -205,7 +205,7 @@ BITMAP	*bitmap_copy(BITMAP *bm)
 BITMAP	*bitmap_alloc(int w, int h)
 {
 	BITMAP	*bm;
-	
+
 	bm = xalloc(BITMAP);
 	bm->width = w;
 	bm->height = h;
@@ -214,14 +214,14 @@ BITMAP	*bitmap_alloc(int w, int h)
 		bm->data = (BmUnit *)mdvi_calloc(h, bm->stride);
 	else
 		bm->data = NULL;
-	
+
 	return bm;
 }
 
 BITMAP	*bitmap_alloc_raw(int w, int h)
 {
 	BITMAP	*bm;
-	
+
 	bm = xalloc(BITMAP);
 	bm->width = w;
 	bm->height = h;
@@ -230,7 +230,7 @@ BITMAP	*bitmap_alloc_raw(int w, int h)
 		bm->data = (BmUnit *)mdvi_malloc(h * bm->stride);
 	else
 		bm->data = NULL;
-	
+
 	return bm;
 }
 
@@ -250,7 +250,7 @@ void	bitmap_print(FILE *out, BITMAP *bm)
 	};
 	int	sub;
 
-	a = bm->data;	
+	a = bm->data;
 	fprintf(out, "    ");
 	if(bm->width > 10) {
 		putchar('0');
@@ -292,10 +292,10 @@ void bitmap_set_col(BITMAP *bm, int row, int col, int count, int state)
 {
 	BmUnit	*ptr;
 	BmUnit	mask;
-	
+
 	ptr = __bm_unit_ptr(bm, col, row);
 	mask = FIRSTMASKAT(col);
-	
+
 	while(count-- > 0) {
 		if(state)
 			*ptr |= mask;
@@ -306,7 +306,7 @@ void bitmap_set_col(BITMAP *bm, int row, int col, int count, int state)
 	}
 }
 
-/* 
+/*
  * to use this function you should first make sure that
  * there is room for `count' bits in the scanline
  *
@@ -333,11 +333,11 @@ void	bitmap_paint_bits(BmUnit *ptr, int n, int count)
 		*ptr++ = bit_masks[BITMAP_BITS];
 
 	/* paint the tail */
-	if(count > 0) 
+	if(count > 0)
 		*ptr |= SEGMENT(count, 0);
 }
 
-/* 
+/*
  * same as paint_bits but clears pixels instead of painting them. Written
  * as a separate function for efficiency reasons.
  */
@@ -365,7 +365,7 @@ void bitmap_clear_bits(BmUnit *ptr, int n, int count)
 void	bitmap_set_row(BITMAP *bm, int row, int col, int count, int state)
 {
 	BmUnit	*ptr;
-	
+
 	ptr = __bm_unit_ptr(bm, col, row);
 	if(state)
 		bitmap_paint_bits(ptr, col & (BITMAP_BITS-1), count);
@@ -388,13 +388,13 @@ void bitmap_flip_horizontally(BITMAP *bm)
 	nb.height = bm->height;
 	nb.stride = bm->stride;
 	nb.data = mdvi_calloc(bm->height, bm->stride);
-		
+
 	fptr = bm->data;
 	tptr = __bm_unit_ptr(&nb, nb.width-1, 0);
 	for(h = 0; h < bm->height; h++) {
 		BmUnit	*fline, *tline;
-		
-		fline = fptr; 
+
+		fline = fptr;
 		tline = tptr;
 		fmask = FIRSTMASK;
 		tmask = FIRSTMASKAT(nb.width-1);
@@ -434,13 +434,13 @@ void	bitmap_flip_vertically(BITMAP *bm)
 	nb.height = bm->height;
 	nb.stride = bm->stride;
 	nb.data = mdvi_calloc(bm->height, bm->stride);
-	
+
 	fptr = bm->data;
 	tptr = __bm_unit_ptr(&nb, 0, nb.height-1);
 	for(h = 0; h < bm->height; h++) {
 		BmUnit	*fline, *tline;
-		
-		fline = fptr; 
+
+		fline = fptr;
 		tline = tptr;
 		fmask = FIRSTMASK;
 		for(w = 0; w < bm->width; w++) {
@@ -470,18 +470,18 @@ void	bitmap_flip_diagonally(BITMAP *bm)
 	BmUnit	*fptr, *tptr;
 	BmUnit	fmask, tmask;
 	int	w, h;
-	
+
 	nb.width = bm->width;
 	nb.height = bm->height;
 	nb.stride = bm->stride;
 	nb.data = mdvi_calloc(bm->height, bm->stride);
-	
+
 	fptr = bm->data;
 	tptr = __bm_unit_ptr(&nb, nb.width-1, nb.height-1);
 	for(h = 0; h < bm->height; h++) {
 		BmUnit	*fline, *tline;
-		
-		fline = fptr; 
+
+		fline = fptr;
 		tline = tptr;
 		fmask = FIRSTMASK;
 		tmask = FIRSTMASKAT(nb.width-1);
@@ -516,19 +516,19 @@ void	bitmap_rotate_clockwise(BITMAP *bm)
 	BmUnit	*fptr, *tptr;
 	BmUnit	fmask, tmask;
 	int	w, h;
-	
+
 	nb.width = bm->height;
 	nb.height = bm->width;
 	nb.stride = BM_BYTES_PER_LINE(&nb);
 	nb.data = mdvi_calloc(nb.height, nb.stride);
-	
+
 	fptr = bm->data;
 	tptr = __bm_unit_ptr(&nb, nb.width - 1, 0);
-	
+
 	tmask = FIRSTMASKAT(nb.width-1);
 	for(h = 0; h < bm->height; h++) {
 		BmUnit	*fline, *tline;
-		
+
 		fmask = FIRSTMASK;
 		fline = fptr;
 		tline = tptr;
@@ -556,7 +556,7 @@ void	bitmap_rotate_clockwise(BITMAP *bm)
 	mdvi_free(bm->data);
 	bm->data = nb.data;
 	bm->width = nb.width;
-	bm->height = nb.height;	
+	bm->height = nb.height;
 	bm->stride = nb.stride;
 	if(SHOW_OP_DATA)
 		bitmap_print(stderr, bm);
@@ -568,19 +568,19 @@ void	bitmap_rotate_counter_clockwise(BITMAP *bm)
 	BmUnit	*fptr, *tptr;
 	BmUnit	fmask, tmask;
 	int	w, h;
-	
+
 	nb.width = bm->height;
 	nb.height = bm->width;
 	nb.stride = BM_BYTES_PER_LINE(&nb);
 	nb.data = mdvi_calloc(nb.height, nb.stride);
-	
+
 	fptr = bm->data;
 	tptr = __bm_unit_ptr(&nb, 0, nb.height - 1);
 
 	tmask = FIRSTMASK;
 	for(h = 0; h < bm->height; h++) {
 		BmUnit	*fline, *tline;
-		
+
 		fmask = FIRSTMASK;
 		fline = fptr;
 		tline = tptr;
@@ -608,7 +608,7 @@ void	bitmap_rotate_counter_clockwise(BITMAP *bm)
 	mdvi_free(bm->data);
 	bm->data = nb.data;
 	bm->width = nb.width;
-	bm->height = nb.height;	
+	bm->height = nb.height;
 	bm->stride = nb.stride;
 	if(SHOW_OP_DATA)
 		bitmap_print(stderr, bm);
@@ -620,16 +620,16 @@ void	bitmap_flip_rotate_clockwise(BITMAP *bm)
 	BmUnit	*fptr, *tptr;
 	BmUnit	fmask, tmask;
 	int	w, h;
-	
+
 	nb.width = bm->height;
 	nb.height = bm->width;
 	nb.stride = BM_BYTES_PER_LINE(&nb);
 	nb.data = mdvi_calloc(nb.height, nb.stride);
-	
+
 	fptr = bm->data;
 	tptr = __bm_unit_ptr(&nb, nb.width-1, nb.height-1);
 
-	tmask = FIRSTMASKAT(nb.width-1);	
+	tmask = FIRSTMASKAT(nb.width-1);
 	for(h = 0; h < bm->height; h++) {
 		BmUnit	*fline, *tline;
 
@@ -659,7 +659,7 @@ void	bitmap_flip_rotate_clockwise(BITMAP *bm)
 	mdvi_free(bm->data);
 	bm->data = nb.data;
 	bm->width = nb.width;
-	bm->height = nb.height;	
+	bm->height = nb.height;
 	bm->stride = nb.stride;
 	if(SHOW_OP_DATA)
 		bitmap_print(stderr, bm);
@@ -671,16 +671,16 @@ void	bitmap_flip_rotate_counter_clockwise(BITMAP *bm)
 	BmUnit	*fptr, *tptr;
 	BmUnit	fmask, tmask;
 	int	w, h;
-	
+
 	nb.width = bm->height;
 	nb.height = bm->width;
 	nb.stride = BM_BYTES_PER_LINE(&nb);
 	nb.data = mdvi_calloc(nb.height, nb.stride);
-	
+
 	fptr = bm->data;
 	tptr = nb.data;
 	tmask = FIRSTMASK;
-	
+
 	for(h = 0; h < bm->height; h++) {
 		BmUnit	*fline, *tline;
 
@@ -711,7 +711,7 @@ void	bitmap_flip_rotate_counter_clockwise(BITMAP *bm)
 	mdvi_free(bm->data);
 	bm->data = nb.data;
 	bm->width = nb.width;
-	bm->height = nb.height;	
+	bm->height = nb.height;
 	bm->stride = nb.stride;
 	if(SHOW_OP_DATA)
 		bitmap_print(stderr, bm);
@@ -751,7 +751,7 @@ void	bitmap_transform(BITMAP *map, DviOrientation orient)
 /*
  * Count the number of non-zero bits in a box of dimensions w x h, starting
  * at column `step' in row `data'.
- * 
+ *
  * Shamelessly stolen from xdvi.
  */
 static int do_sample(BmUnit *data, int stride, int step, int w, int h)
@@ -760,7 +760,7 @@ static int do_sample(BmUnit *data, int stride, int step, int w, int h)
 	int	shift, n;
 	int	bits_left;
 	int	wid;
-	
+
 	ptr = data + step / BITMAP_BITS;
 	end = bm_offset(data, h * stride);
 	shift = FIRSTSHIFTAT(step);
@@ -800,17 +800,17 @@ static int do_sample(BmUnit *data, int stride, int step, int w, int h)
 	return n;
 }
 
-void	mdvi_shrink_box(DviContext *dvi, DviFont *font, 
+void	mdvi_shrink_box(DviContext *dvi, DviFont *font,
 	DviFontChar *pk, DviGlyph *dest)
 {
 	int	x, y, z;
 	DviGlyph *glyph;
 	int	hs, vs;
-	
+
 	hs = dvi->params.hshrink;
 	vs = dvi->params.vshrink;
 	glyph = &pk->glyph;
-	
+
 	x = (int)glyph->x / hs;
 	if((int)glyph->x - x * hs > 0)
 		x++;
@@ -844,15 +844,15 @@ void	mdvi_shrink_glyph(DviContext *dvi, DviFont *font,
 	int	x, y;
 	int	w, h;
 	int	hs, vs;
-	
+
 	hs = dvi->params.hshrink;
 	vs = dvi->params.vshrink;
-	
+
 	min_sample = vs * hs * dvi->params.density / 100;
 
 	glyph = &pk->glyph;
 	oldmap = (BITMAP *)glyph->data;
-		
+
 	x = (int)glyph->x / hs;
 	init_cols = (int)glyph->x - x * hs;
 	if(init_cols <= 0)
@@ -910,7 +910,7 @@ void	mdvi_shrink_glyph(DviContext *dvi, DviFont *font,
 		old_ptr = bm_offset(old_ptr, rows * old_stride);
 		rows_left -= rows;
 		rows = vs;
-	}	
+	}
 	DEBUG((DBG_BITMAPS, "shrink_glyph: (%dw,%dh,%dx,%dy) -> (%dw,%dh,%dx,%dy)\n",
 		glyph->w, glyph->h, glyph->x, glyph->y,
 		dest->w, dest->h, dest->x, dest->y));
@@ -939,10 +939,10 @@ void	mdvi_shrink_glyph_grey(DviContext *dvi, DviFont *font,
 	hs = dvi->params.hshrink;
 	vs = dvi->params.vshrink;
 	dev = &dvi->device;
-	
+
 	glyph = &pk->glyph;
 	map = (BITMAP *)glyph->data;
-	
+
 	x = (int)glyph->x / hs;
 	init_cols = (int)glyph->x - x * hs;
 	if(init_cols <= 0)
@@ -960,18 +960,18 @@ void	mdvi_shrink_glyph_grey(DviContext *dvi, DviFont *font,
 	}
 	h = y + ROUND((int)glyph->h - cols, vs) + 1;
 	ASSERT(w && h);
-	
+
 	/* before touching anything, do this */
 	image = dev->create_image(dev->device_data, w, h, BITMAP_BITS);
 	if(image == NULL) {
 		mdvi_shrink_glyph(dvi, font, pk, dest);
 		return;
 	}
-	
+
 	/* save these colors */
 	pk->fg = MDVI_CURRFG(dvi);
 	pk->bg = MDVI_CURRBG(dvi);
-	
+
 	samplemax = vs * hs;
 	npixels = samplemax + 1;
 	pixels = get_color_table(&dvi->device, npixels, pk->fg, pk->bg,
@@ -982,7 +982,7 @@ void	mdvi_shrink_glyph_grey(DviContext *dvi, DviFont *font,
 		colortab[1] = pk->bg;
 		pixels = &colortab[0];
 	}
-	
+
 	/* setup the new glyph */
 	dest->data = image;
 	dest->x = x;
@@ -1021,7 +1021,7 @@ void	mdvi_shrink_glyph_grey(DviContext *dvi, DviFont *font,
 		rows = vs;
 		y++;
 	}
-	
+
 	for(; y < h; y++) {
 		for(x = 0; x < w; x++)
 			dev->put_pixel(image, x, y, pixels[0]);
diff --git a/backend/dvi/mdvi-lib/bitmap.h b/backend/dvi/mdvi-lib/bitmap.h
index 4d98fecd..7b722bb4 100644
--- a/backend/dvi/mdvi-lib/bitmap.h
+++ b/backend/dvi/mdvi-lib/bitmap.h
@@ -54,7 +54,7 @@ typedef struct {
 #define __bm_unit_ptr(b,x,y) \
 	bm_offset((b)->data, (y) * (b)->stride + \
 	((x) / BITMAP_BITS) * BITMAP_BYTES)
-	
+
 #define __bm_unit(b,x,y)    __bm_unit_ptr((b), (x), (y))[0]
 
 #define BM_GETPIXEL(b,x,y)  __bm_unit((b), (x), (y))
@@ -91,7 +91,7 @@ typedef struct {
        }
     }
 /* end of sample code */
-#endif          
+#endif
 
 /* bitmaps are stored in native byte order */
 #ifdef WORD_BIG_ENDIAN
@@ -116,9 +116,9 @@ extern BITMAP	*bitmap_alloc __PROTO((int, int));
 extern BITMAP	*bitmap_alloc_raw __PROTO((int, int));
 extern void	bitmap_destroy __PROTO((BITMAP *));
 
-/* 
- * set_row(bm, row, col, count, state): 
- *   sets `count' pixels to state `onoff', starting from pixel 
+/*
+ * set_row(bm, row, col, count, state):
+ *   sets `count' pixels to state `onoff', starting from pixel
  *   at position (col, row). All pixels must lie in the same
  *   row.
  */
diff --git a/backend/dvi/mdvi-lib/color.c b/backend/dvi/mdvi-lib/color.c
index c28107fd..ef6036a9 100644
--- a/backend/dvi/mdvi-lib/color.c
+++ b/backend/dvi/mdvi-lib/color.c
@@ -47,7 +47,7 @@ void	mdvi_push_color(DviContext *dvi, Ulong fg, Ulong bg)
 void	mdvi_pop_color(DviContext *dvi)
 {
 	Ulong	fg, bg;
-	
+
 	if(dvi->color_top == 0)
 		return;
 	dvi->color_top--;
@@ -81,7 +81,7 @@ static int		cc_entries;
 
 
 /* create a color table */
-Ulong	*get_color_table(DviDevice *dev, 
+Ulong	*get_color_table(DviDevice *dev,
 			 int nlevels, Ulong fg, Ulong bg, double gamma, int density)
 {
 	ColorCache	*cc, *tofree;
@@ -109,7 +109,7 @@ Ulong	*get_color_table(DviDevice *dev,
 
 	DEBUG((DBG_DEVICE, "Adding color table to cache (fg=%lu, bg=%lu, n=%d)\n",
 		fg, bg, nlevels));
-		
+
 	/* no entry was found in the cache, create a new one */
 	if(cc_entries < CCSIZE) {
 		cc = &color_cache[cc_entries++];
@@ -119,7 +119,7 @@ Ulong	*get_color_table(DviDevice *dev,
 		mdvi_free(cc->pixels);
 	}
 	pixels = xnalloc(Ulong, nlevels);
-	status = dev->alloc_colors(dev->device_data, 
+	status = dev->alloc_colors(dev->device_data,
 		pixels, nlevels, fg, bg, gamma, density);
 	if(status < 0) {
 		mdvi_free(pixels);
@@ -132,5 +132,5 @@ Ulong	*get_color_table(DviDevice *dev,
 	cc->nlevels = nlevels;
 	cc->pixels = pixels;
 	cc->hits = 1;
-	return pixels;	
+	return pixels;
 }
diff --git a/backend/dvi/mdvi-lib/color.h b/backend/dvi/mdvi-lib/color.h
index 35b2f923..cbc3c0ef 100644
--- a/backend/dvi/mdvi-lib/color.h
+++ b/backend/dvi/mdvi-lib/color.h
@@ -22,7 +22,7 @@
 
 #include "common.h"
 
-extern Ulong	*get_color_table(DviDevice *dev, 
+extern Ulong	*get_color_table(DviDevice *dev,
 				 int nlevels, Ulong fg, Ulong bg, double gamma, int density);
 
 extern void mdvi_set_color __PROTO((DviContext *, Ulong, Ulong));
diff --git a/backend/dvi/mdvi-lib/common.c b/backend/dvi/mdvi-lib/common.c
index 97b34b56..847a307d 100644
--- a/backend/dvi/mdvi-lib/common.c
+++ b/backend/dvi/mdvi-lib/common.c
@@ -25,8 +25,8 @@
 long	fsgetn(FILE *p, size_t n)
 {
 	long	v;
-	
-	v = fgetbyte(p);	
+
+	v = fgetbyte(p);
 	if(v & 0x80)
 		v -= 0x100;
 	while(--n > 0)
@@ -37,7 +37,7 @@ long	fsgetn(FILE *p, size_t n)
 Ulong	fugetn(FILE *p, size_t n)
 {
 	Ulong	v;
-	
+
 	v = fgetbyte(p);
 	while(--n > 0)
 		v = (v << 8) | fgetbyte(p);
@@ -47,7 +47,7 @@ Ulong	fugetn(FILE *p, size_t n)
 long	msgetn(const Uchar *p, size_t n)
 {
 	long	v = (long)*p++;
-	
+
 	if(v & 0x80)
 		v -= 0x100;
 	while(--n > 0)
@@ -68,7 +68,7 @@ char	*read_string(FILE *in, int s, char *buffer, size_t len)
 {
 	int	n;
 	char	*str;
-	
+
 	n = fugetn(in, s ? s : 1);
 	if((str = buffer) == NULL || n + 1 > len)
 		str = mdvi_malloc(n + 1);
@@ -83,7 +83,7 @@ char	*read_string(FILE *in, int s, char *buffer, size_t len)
 size_t	read_bcpl(FILE *in, char *buffer, size_t maxlen, size_t wanted)
 {
 	size_t	i;
-	
+
 	i = (int)fuget1(in);
 	if(maxlen && i > maxlen)
 		i = maxlen;
@@ -99,7 +99,7 @@ char	*read_alloc_bcpl(FILE *in, size_t maxlen, size_t *size)
 {
 	size_t	i;
 	char	*buffer;
-	
+
 	i = (size_t)fuget1(in);
 	if(maxlen && i > maxlen)
 		i = maxlen;
@@ -121,7 +121,7 @@ void	buff_free(Buffer *buf)
 {
 	if(buf->data)
 		mdvi_free(buf->data);
-	buff_init(buf);	
+	buff_init(buf);
 }
 
 void	buff_init(Buffer *buf)
@@ -149,7 +149,7 @@ char	*buff_gets(Buffer *buf, size_t *length)
 	char	*ptr;
 	char	*ret;
 	size_t	len;
-	
+
 	ptr = strchr(buf->data, '\n');
 	if(ptr == NULL)
 		return NULL;
@@ -163,6 +163,6 @@ char	*buff_gets(Buffer *buf, size_t *length)
 	}
 	ret[len] = 0;
 	if(length) *length = len;
-	return ret;	
+	return ret;
 }
 
diff --git a/backend/dvi/mdvi-lib/dviread.c b/backend/dvi/mdvi-lib/dviread.c
index d0143205..c1cb21f6 100644
--- a/backend/dvi/mdvi-lib/dviread.c
+++ b/backend/dvi/mdvi-lib/dviread.c
@@ -53,37 +53,37 @@ DVICMDDEF(undefined);
 DVICMDDEF(unexpected);
 
 static const DviCommand dvi_commands[] = {
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
-	set_char, set_char, set_char, set_char, 
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
+	set_char, set_char, set_char, set_char,
 	set_char, set_char, set_char, set_char,	/* 0 - 127 */
 	set_char, set_char, set_char, set_char, /* 128 - 131 */
 	set_rule,				/* 132 */
@@ -122,7 +122,7 @@ static const DviCommand dvi_commands[] = {
 	unexpected,				/* 247 (PRE) */
 	unexpected,				/* 248 (POST) */
 	unexpected,				/* 249 (POST_POST) */
-	undefined, undefined, undefined, 
+	undefined, undefined, undefined,
 	undefined, undefined, undefined		/* 250 - 255 */
 };
 
@@ -172,7 +172,7 @@ static void dummy_dev_set_color(void *a, Ulong b, Ulong c)
 static void dvierr(DviContext *dvi, const char *format, ...)
 {
 	va_list	ap;
-	
+
 	va_start(ap, format);
 	fprintf(stderr, "%s[%d]: Error: ",
 		dvi->filename, dvi->currpage);
@@ -183,7 +183,7 @@ static void dvierr(DviContext *dvi, const char *format, ...)
 static void dviwarn(DviContext *dvi, const char *format, ...)
 {
 	va_list	ap;
-	
+
 	fprintf(stderr, "%s[%d]: Warning: ",
 		dvi->filename, dvi->currpage);
 	va_start(ap, format);
@@ -195,15 +195,15 @@ static void dviwarn(DviContext *dvi, const char *format, ...)
 	((d)->buffer.pos + (n) > (d)->buffer.length)
 
 static int get_bytes(DviContext *dvi, size_t n)
-{	
-	/* 
+{
+	/*
 	 * caller wants to read `n' bytes from dvi->buffer + dvi->pos.
-	 * Make sure there is enough data to satisfy the request 
+	 * Make sure there is enough data to satisfy the request
 	 */
 	if(NEEDBYTES(dvi, n)) {
 		size_t	required;
 		int	newlen;
-		
+
 		if(dvi->buffer.frozen || dvi->in == NULL || feof(dvi->in)) {
 			/* this is EOF */
 			dviwarn(dvi, _("unexpected EOF\n"));
@@ -251,7 +251,7 @@ static int get_bytes(DviContext *dvi, size_t n)
 static int dskip(DviContext *dvi, long offset)
 {
 	ASSERT(offset > 0);
-	
+
 	if(NEEDBYTES(dvi, offset) && get_bytes(dvi, offset) == -1)
 		return -1;
 	dvi->buffer.pos += offset;
@@ -283,8 +283,8 @@ static long dugetn(DviContext *dvi, size_t n)
 {
 	long	val;
 
-	if(NEEDBYTES(dvi, n) && get_bytes(dvi, n) == -1)	
-		return -1;	
+	if(NEEDBYTES(dvi, n) && get_bytes(dvi, n) == -1)
+		return -1;
 	val = mugetn(dvi->buffer.data + dvi->buffer.pos, n);
 	dvi->buffer.pos += n;
 	return val;
@@ -292,8 +292,8 @@ static long dugetn(DviContext *dvi, size_t n)
 
 static long dtell(DviContext *dvi)
 {
-	return dvi->depth ? 
-		dvi->buffer.pos : 
+	return dvi->depth ?
+		dvi->buffer.pos :
 		ftell(dvi->in) - dvi->buffer.length + dvi->buffer.pos;
 }
 
@@ -321,7 +321,7 @@ static void dviprint(DviContext *dvi, const char *command, int sub, const char *
 {
 	int	i;
 	va_list	ap;
-	
+
 	printf("%s: ", dvi->filename);
 	for(i = 0; i < dvi->depth; i++)
 		printf("  ");
@@ -341,7 +341,7 @@ static void dviprint(DviContext *dvi, const char *command, int sub, const char *
 int	mdvi_find_tex_page(DviContext *dvi, int tex_page)
 {
 	int	i;
-	
+
 	for(i = 0; i < dvi->npages; i++)
 		if(dvi->pagemap[i][1] == tex_page)
 			return i;
@@ -373,7 +373,7 @@ static int sort_dvi_down(const void *p1, const void *p2)
 void	mdvi_sort_pages(DviContext *dvi, DviPageSort type)
 {
 	int	(*sortfunc) __PROTO((const void *, const void *));
-	
+
 	switch(type) {
 	case MDVI_PAGE_SORT_UP:
 		sortfunc = sort_up;
@@ -395,7 +395,7 @@ void	mdvi_sort_pages(DviContext *dvi, DviPageSort type)
 		sortfunc = NULL;
 		break;
 	}
-	
+
 	if(sortfunc)
 		qsort(dvi->pagemap, dvi->npages, sizeof(PageNum), sortfunc);
 }
@@ -411,7 +411,7 @@ static DviFontRef *define_font(DviContext *dvi, int op)
 	int	n;
 	char	*name;
 	DviFontRef *ref;
-	
+
 	arg = dugetn(dvi, op - DVI_FNT_DEF1 + 1);
 	checksum = duget4(dvi);
 	scale = duget4(dvi);
@@ -439,7 +439,7 @@ static char *opendvi(const char *name)
 {
 	int	len;
 	char	*file;
-	
+
 	len = strlen(name);
 	/* if file ends with .dvi and it exists, that's it */
 	if(len >= 4 && STREQ(name+len-4, ".dvi")) {
@@ -447,7 +447,7 @@ static char *opendvi(const char *name)
 		if(access(name, R_OK) == 0)
 			return mdvi_strdup(name);
 	}
-		
+
 	/* try appending .dvi */
 	file = mdvi_malloc(len + 5);
 	strcpy(file, name);
@@ -468,7 +468,7 @@ int	mdvi_reload(DviContext *dvi, DviParams *np)
 {
 	DviContext *newdvi;
 	DviParams  *pars;
-	
+
 	/* close our file */
 	if(dvi->in) {
 		fclose(dvi->in);
@@ -476,8 +476,8 @@ int	mdvi_reload(DviContext *dvi, DviParams *np)
 	}
 
 	pars = np ? np : &dvi->params;
-	DEBUG((DBG_DVI, "%s: reloading\n", dvi->filename));	
-	
+	DEBUG((DBG_DVI, "%s: reloading\n", dvi->filename));
+
 	/* load it again */
 	newdvi = mdvi_init_context(pars, dvi->pagesel, dvi->filename);
 	if(newdvi == NULL) {
@@ -508,7 +508,7 @@ int	mdvi_reload(DviContext *dvi, DviParams *np)
 
 	if(dvi->fileid) mdvi_free(dvi->fileid);
 	dvi->fileid = newdvi->fileid;
-		
+
 	dvi->dvi_page_w = newdvi->dvi_page_w;
 	dvi->dvi_page_h = newdvi->dvi_page_h;
 
@@ -517,25 +517,25 @@ int	mdvi_reload(DviContext *dvi, DviParams *np)
 	dvi->npages = newdvi->npages;
 	if(dvi->currpage > dvi->npages-1)
 		dvi->currpage = 0;
-		
+
 	mdvi_free(dvi->stack);
 	dvi->stack = newdvi->stack;
 	dvi->stacksize = newdvi->stacksize;
 
 	/* remove fonts that are not being used anymore */
 	font_free_unused(&dvi->device);
-		
-	mdvi_free(newdvi->filename);		
+
+	mdvi_free(newdvi->filename);
 	mdvi_free(newdvi);
 
 	DEBUG((DBG_DVI, "%s: reload successful\n", dvi->filename));
 	if(dvi->device.refresh)
 		dvi->device.refresh(dvi, dvi->device.device_data);
-	
+
 	return 0;
 }
 
-/* function to change parameters ia DVI context 
+/* function to change parameters ia DVI context
  * The DVI context is modified ONLY if this function is successful */
 int mdvi_configure(DviContext *dvi, DviParamCode option, ...)
 {
@@ -543,12 +543,12 @@ int mdvi_configure(DviContext *dvi, DviParamCode option, ...)
 	int	reset_all;
 	int	reset_font;
 	DviParams np;
-	
+
 	va_start(ap, option);
 
 	reset_font = 0;
 	reset_all  = 0;
-	np = dvi->params; /* structure copy */	
+	np = dvi->params; /* structure copy */
 	while(option != MDVI_PARAM_LAST) {
 		switch(option) {
 		case MDVI_SET_DPI:
@@ -613,7 +613,7 @@ int mdvi_configure(DviContext *dvi, DviParamCode option, ...)
 		option = va_arg(ap, DviParamCode);
 	}
 	va_end(ap);
-	
+
 	/* check that all values make sense */
 	if(np.dpi <= 0 || np.vdpi <= 0)
 		return -1;
@@ -624,11 +624,11 @@ int mdvi_configure(DviContext *dvi, DviParamCode option, ...)
 	if(np.hshrink < 1 || np.vshrink < 1)
 		return -1;
 	if(np.hdrift < 0 || np.vdrift < 0)
-		return -1;	
+		return -1;
 	if(np.fg == np.bg)
 		return -1;
 
-	/* 
+	/*
 	 * If the dpi or the magnification change, we basically have to reload
 	 * the DVI file again from scratch.
 	 */
@@ -650,7 +650,7 @@ int mdvi_configure(DviContext *dvi, DviParamCode option, ...)
 	if(reset_font) {
 		font_reset_chain_glyphs(&dvi->device, dvi->fonts, reset_font);
 	}
-	dvi->params = np;	
+	dvi->params = np;
 	if((reset_font & MDVI_FONTSEL_GLYPH) && dvi->device.refresh) {
 		dvi->device.refresh(dvi, dvi->device.device_data);
 		return 0;
@@ -659,8 +659,8 @@ int mdvi_configure(DviContext *dvi, DviParamCode option, ...)
 	return 1;
 }
 /*
- * Read the initial data from the DVI file. If something is wrong with the 
- * file, we just spit out an error message and refuse to load the file, 
+ * Read the initial data from the DVI file. If something is wrong with the
+ * file, we just spit out an error message and refuse to load the file,
  * without giving any details. This makes sense because DVI files are ok
  * 99.99% of the time, and dvitype(1) can be used to check the other 0.01%.
  */
@@ -677,7 +677,7 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 
 	/*
 	 * 1. Open the file and initialize the DVI context
-	 */	
+	 */
 
 	filename = opendvi(file);
 	if(filename == NULL) {
@@ -695,13 +695,13 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 	dvi->pagemap = NULL;
 	dvi->filename = filename;
 	dvi->stack = NULL;
-	dvi->modtime = get_mtime(fileno(p));	
+	dvi->modtime = get_mtime(fileno(p));
 	dvi->buffer.data = NULL;
 	dvi->pagesel = spec;
 	dvi->in = p; /* now we can use the dget*() functions */
 
-	/* 
-	 * 2. Read the preamble, extract scaling information, and 
+	/*
+	 * 2. Read the preamble, extract scaling information, and
 	 *    setup the DVI parameters.
 	 */
 
@@ -710,7 +710,7 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 	if((arg = fuget1(p)) != DVI_ID) {
 		mdvi_error(_("%s: unsupported DVI format (version %u)\n"),
 			   file, arg);
-		goto error; /* jump to the end of this routine, 
+		goto error; /* jump to the end of this routine,
 			     * where we handle errors */
 	}
 	/* get dimensions */
@@ -721,8 +721,8 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 	/* check that these numbers make sense */
 	if(!dvi->num || !dvi->den || !dvi->dvimag)
 		goto bad_dvi;
-	
-	dvi->params.mag = 
+
+	dvi->params.mag =
 		(par->mag > 0 ? par->mag : (double)dvi->dvimag / 1000.0);
 	dvi->params.hdrift  = par->hdrift;
 	dvi->params.vdrift  = par->vdrift;
@@ -764,7 +764,7 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 	fread(dvi->fileid, 1, n, p);
 	dvi->fileid[n] = 0;
 	DEBUG((DBG_DVI, "%s: %s\n", filename, dvi->fileid));
-	
+
 	/*
 	 * 3. Read postamble, extract page information (number of
 	 *    pages, dimensions) and stack depth.
@@ -772,7 +772,7 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 
 	/* jump to the end of the file */
 	if(fseek(p, (long)-1, SEEK_END) == -1)
-		goto error;	
+		goto error;
 	for(n = 0; (op = fuget1(p)) == DVI_TRAILER; n++)
 		if(fseek(p, (long)-2, SEEK_CUR) < 0)
 			break;
@@ -795,7 +795,7 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 	dvi->npages = fuget2(p);
 	DEBUG((DBG_DVI, "%s: from postamble: stack depth %d, %d page%s\n",
 		filename, dvi->stacksize, dvi->npages, dvi->npages > 1 ? "s" : ""));
-	
+
 	/*
 	 * 4. Process font definitions.
 	 */
@@ -803,7 +803,7 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 	/* process font definitions */
 	dvi->nfonts = 0;
 	dvi->fontmap = NULL;
-	/* 
+	/*
 	 * CAREFUL: here we need to use the dvi->buffer, but it might leave the
 	 * the file cursor in the wrong position after reading fonts (because of
 	 * buffering). It's ok, though, because after the font definitions we read
@@ -812,7 +812,7 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 	 */
 	while((op = duget1(dvi)) != DVI_POST_POST) {
 		DviFontRef *ref;
-		
+
 		if(op == DVI_NOOP)
 			continue;
 		else if(op < DVI_FNT_DEF1 || op > DVI_FNT_DEF4)
@@ -826,7 +826,7 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 	}
 	/* we don't need the buffer anymore */
 	dreset(dvi);
-	
+
 	if(op != DVI_POST_POST)
 		goto bad_dvi;
 	font_finish_definitions(dvi);
@@ -840,14 +840,14 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 
 	dvi->pagemap = xnalloc(PageNum, dvi->npages);
 	memzero(dvi->pagemap, sizeof(PageNum) * dvi->npages);
-		
+
 	n = dvi->npages - 1;
 	pagecount = n;
 	while(offset != -1) {
 		int	i;
 		PageNum page;
 
-		fseek(p, offset, SEEK_SET);		
+		fseek(p, offset, SEEK_SET);
 		op = fuget1(p);
 		if(op != DVI_BOP || n < 0)
 			goto bad_dvi;
@@ -875,7 +875,7 @@ DviContext *mdvi_init_context(DviParams *par, DviPageSpec *spec, const char *fil
 		DEBUG((DBG_DVI, "%d of %d pages selected\n",
 			dvi->npages - pagecount, dvi->npages));
 		dvi->npages -= pagecount;
-		memmove(dvi->pagemap, &dvi->pagemap[pagecount], 
+		memmove(dvi->pagemap, &dvi->pagemap[pagecount],
 			dvi->npages * sizeof(PageNum));
 	}
 
@@ -934,7 +934,7 @@ void	mdvi_destroy_context(DviContext *dvi)
 		mdvi_free(dvi->buffer.data);
 	if(dvi->color_stack)
 		mdvi_free(dvi->color_stack);
-	
+
 	mdvi_free(dvi);
 }
 
@@ -955,13 +955,13 @@ static int	mdvi_run_macro(DviContext *dvi, Uchar *macro, size_t len)
 	int	opcode;
 	int	oldtop;
 
-	dvi->depth++;	
+	dvi->depth++;
 	push(dvi, DVI_PUSH);
 	dvi->pos.w = 0;
 	dvi->pos.x = 0;
 	dvi->pos.y = 0;
 	dvi->pos.z = 0;
-	
+
 	/* save our state */
 	curr = dvi->currfont;
 	fonts = dvi->fonts;
@@ -982,7 +982,7 @@ static int	mdvi_run_macro(DviContext *dvi, Uchar *macro, size_t len)
 			break;
 	}
 	if(opcode != DVI_EOP)
-		dviwarn(dvi, _("%s: vf macro had errors\n"), 
+		dviwarn(dvi, _("%s: vf macro had errors\n"),
 			curr->ref->fontname);
 	if(dvi->stacktop != oldtop)
 		dviwarn(dvi, _("%s: stack not empty after vf macro\n"),
@@ -1005,7 +1005,7 @@ int	mdvi_dopage(DviContext *dvi, int pageno)
 	int	ppi;
 	int	reloaded = 0;
 
-again:	
+again:
 	if(dvi->in == NULL) {
 		/* try reopening the file */
 		dvi->in = fopen(dvi->filename, "rb");
@@ -1017,7 +1017,7 @@ again:
 		}
 		DEBUG((DBG_FILES, "reopen(%s) -> Ok\n", dvi->filename));
 	}
-	
+
 	/* check if we need to reload the file */
 	if(!reloaded && get_mtime(fileno(dvi->in)) > dvi->modtime) {
 		mdvi_reload(dvi, &dvi->params);
@@ -1025,20 +1025,20 @@ again:
 		reloaded = 1;
 		goto again;
 	}
-	
+
 	if(pageno < 0 || pageno > dvi->npages-1) {
 		mdvi_error(_("%s: page %d out of range\n"),
 			   dvi->filename, pageno);
 		return -1;
 	}
-	
+
 	fseek(dvi->in, (long)dvi->pagemap[pageno][0], SEEK_SET);
 	if((op = fuget1(dvi->in)) != DVI_BOP) {
 		mdvi_error(_("%s: bad offset at page %d\n"),
 			   dvi->filename, pageno+1);
 		return -1;
 	}
-	
+
 	/* skip bop */
 	fseek(dvi->in, (long)44, SEEK_CUR);
 
@@ -1048,7 +1048,7 @@ again:
 	dvi->stacktop = 0;
 	dvi->currpage = pageno;
 	dvi->curr_layer = 0;
-	
+
 	if(dvi->buffer.data && !dvi->buffer.frozen)
 		mdvi_free(dvi->buffer.data);
 
@@ -1062,7 +1062,7 @@ again:
 	/* reset color stack */
 	mdvi_reset_color(dvi);
 #endif
-		
+
 	/* set max horizontal and vertical drift (from dvips) */
 	if(dvi->params.hdrift < 0) {
 		ppi = dvi->params.dpi / dvi->params.hshrink; /* shrunk pixels per inch */
@@ -1085,13 +1085,13 @@ again:
 
 	dvi->params.thinsp   = FROUND(0.025 * dvi->params.dpi / dvi->params.conv);
 	dvi->params.vsmallsp = FROUND(0.025 * dvi->params.vdpi / dvi->params.vconv);
-		
+
 	/* execute all the commands in the page */
 	while((op = duget1(dvi)) != DVI_EOP) {
 		if(dvi_commands[op](dvi, op) < 0)
 			break;
 	}
-	
+
 	fflush(stdout);
 	fflush(stderr);
 	if(op != DVI_EOP)
@@ -1104,7 +1104,7 @@ again:
 static int inline move_vertical(DviContext *dvi, int amount)
 {
 	int	rvv;
-	
+
 	dvi->pos.v += amount;
 	rvv = vpixel_round(dvi, dvi->pos.v);
 	if(!dvi->params.vdrift)
@@ -1113,7 +1113,7 @@ static int inline move_vertical(DviContext *dvi, int amount)
 		return rvv;
 	else {
 		int	newvv;
-		
+
 		newvv = dvi->pos.vv + vpixel_round(dvi, amount);
 		if(rvv - newvv > dvi->params.vdrift)
 			return rvv - dvi->params.vdrift;
@@ -1121,13 +1121,13 @@ static int inline move_vertical(DviContext *dvi, int amount)
 			return rvv + dvi->params.vdrift;
 		else
 			return newvv;
-	}	
+	}
 }
 
 static int inline move_horizontal(DviContext *dvi, int amount)
 {
 	int	rhh;
-	
+
 	dvi->pos.h += amount;
 	rhh = pixel_round(dvi, dvi->pos.h);
 	if(!dvi->params.hdrift)
@@ -1136,7 +1136,7 @@ static int inline move_horizontal(DviContext *dvi, int amount)
 		return rhh;
 	else {
 		int	newhh;
-		
+
 		newhh = dvi->pos.hh + pixel_round(dvi, amount);
 		if(rhh - newhh > dvi->params.hdrift)
 			return rhh - dvi->params.hdrift;
@@ -1144,7 +1144,7 @@ static int inline move_horizontal(DviContext *dvi, int amount)
 			return rhh + dvi->params.hdrift;
 		else
 			return newhh;
-	}	
+	}
 }
 
 static void inline fix_after_horizontal(DviContext *dvi)
@@ -1167,7 +1167,7 @@ static void inline fix_after_horizontal(DviContext *dvi)
 	(b) > 0 ? (b) : -(b), (c)
 
 static void draw_shrink_rule (DviContext *dvi, int x, int y, Uint w, Uint h, int f)
-{		
+{
 	Ulong fg, bg;
 
 	fg = dvi->curr_fg;
@@ -1176,11 +1176,11 @@ static void draw_shrink_rule (DviContext *dvi, int x, int y, Uint w, Uint h, int
 	mdvi_push_color (dvi, fg, bg);
 	dvi->device.draw_rule(dvi, x, y, w, h, f);
 	mdvi_pop_color (dvi);
-	
+
 	return;
 }
 
-/* 
+/*
  * The only commands that actually draw something are:
  *   set_char, set_rule
  */
@@ -1189,7 +1189,7 @@ static void draw_box(DviContext *dvi, DviFontChar *ch)
 {
 	DviGlyph *glyph = NULL;
 	int	x, y, w, h;
-		
+
 	if(!MDVI_GLYPH_UNSET(ch->shrunk.data))
 		glyph = &ch->shrunk;
 	else if(!MDVI_GLYPH_UNSET(ch->grey.data))
@@ -1237,7 +1237,7 @@ static void draw_box(DviContext *dvi, DviFontChar *ch)
 		y = h - y;
 		break;
 	}
-		
+
 	draw_shrink_rule(dvi, dvi->pos.hh - x, dvi->pos.vv - y, w, h, 1);
 }
 
@@ -1248,7 +1248,7 @@ int	set_char(DviContext *dvi, int opcode)
 	int	hh;
 	DviFontChar *ch;
 	DviFont	*font;
-	
+
 	if(opcode < 128)
 		num = opcode;
 	else
@@ -1263,18 +1263,18 @@ int	set_char(DviContext *dvi, int opcode)
 		/* try to display something anyway */
 		ch = FONTCHAR(font, num);
 		if(!glyph_present(ch)) {
-			dviwarn(dvi, 
-			_("requested character %d does not exist in `%s'\n"), 
+			dviwarn(dvi,
+			_("requested character %d does not exist in `%s'\n"),
 				num, font->fontname);
 			return 0;
 		}
 		draw_box(dvi, ch);
 	} else if(dvi->curr_layer <= dvi->params.layer) {
 		if(ISVIRTUAL(font))
-			mdvi_run_macro(dvi, (Uchar *)font->private + 
+			mdvi_run_macro(dvi, (Uchar *)font->private +
 				ch->offset, ch->width);
 		else if(ch->width && ch->height)
-			dvi->device.draw_glyph(dvi, ch, 
+			dvi->device.draw_glyph(dvi, ch,
 				dvi->pos.hh, dvi->pos.vv);
 	}
 	if(opcode >= DVI_PUT1 && opcode <= DVI_PUT4) {
@@ -1292,7 +1292,7 @@ int	set_char(DviContext *dvi, int opcode)
 		dvi->pos.hh = hh;
 		fix_after_horizontal(dvi);
 	}
-	
+
 	return 0;
 }
 
@@ -1300,11 +1300,11 @@ int	set_rule(DviContext *dvi, int opcode)
 {
 	Int32	a, b;
 	int	h, w;
-	
+
 	a = dsget4(dvi);
 	b = dsget4(dvi); w = rule_round(dvi, b);
 	if(a > 0 && b > 0) {
-		h = vrule_round(dvi, a); 
+		h = vrule_round(dvi, a);
 		SHOWCMD((dvi, opcode == DVI_SET_RULE ? "setrule" : "putrule", -1,
 			"width %d, height %d (%dx%d pixels)\n",
 			b, a, w, h));
@@ -1314,11 +1314,11 @@ int	set_rule(DviContext *dvi, int opcode)
 			draw_shrink_rule(dvi,
 					 dvi->pos.hh, dvi->pos.vv - h + 1, w, h, 1);
 		}
-	} else { 
+	} else {
 		SHOWCMD((dvi, opcode == DVI_SET_RULE ? "setrule" : "putrule", -1,
 			"(moving left only, by %d)\n", b));
 	}
-			
+
 	if(opcode == DVI_SET_RULE) {
 		dvi->pos.h  += b;
 		dvi->pos.hh += w;
@@ -1345,7 +1345,7 @@ int	push(DviContext *dvi, int opcode)
 	memcpy(&dvi->stack[dvi->stacktop], &dvi->pos, sizeof(DviState));
 	SHOWCMD((dvi, "push", -1,
 		"level %d: (h=%d,v=%d,w=%d,x=%d,y=%d,z=%d,hh=%d,vv=%d)\n",
-		dvi->stacktop, 
+		dvi->stacktop,
 		dvi->pos.h, dvi->pos.v, dvi->pos.w, dvi->pos.x,
 		dvi->pos.y, dvi->pos.z, dvi->pos.hh, dvi->pos.vv));
 	dvi->stacktop++;
@@ -1361,7 +1361,7 @@ int	pop(DviContext *dvi, int opcode)
 	memcpy(&dvi->pos, &dvi->stack[dvi->stacktop-1], sizeof(DviState));
 	SHOWCMD((dvi, "pop", -1,
 		"level %d: (h=%d,v=%d,w=%d,x=%d,y=%d,z=%d,hh=%d,vv=%d)\n",
-		dvi->stacktop, 
+		dvi->stacktop,
 		dvi->pos.h, dvi->pos.v, dvi->pos.w, dvi->pos.x,
 		dvi->pos.y, dvi->pos.z, dvi->pos.hh, dvi->pos.vv));
 	dvi->stacktop--;
@@ -1372,7 +1372,7 @@ int	move_right(DviContext *dvi, int opcode)
 {
 	Int32	arg;
 	int	h, hh;
-	
+
 	arg = dsgetn(dvi, opcode - DVI_RIGHT1 + 1);
 	h = dvi->pos.h;
 	hh = move_horizontal(dvi, arg);
@@ -1387,7 +1387,7 @@ int	move_down(DviContext *dvi, int opcode)
 {
 	Int32	arg;
 	int	v, vv;
-	
+
 	arg = dsgetn(dvi, opcode - DVI_DOWN1 + 1);
 	v = dvi->pos.v;
 	vv = move_vertical(dvi, arg);
@@ -1401,7 +1401,7 @@ int	move_down(DviContext *dvi, int opcode)
 int	move_w(DviContext *dvi, int opcode)
 {
 	int	h, hh;
-	
+
 	if(opcode != DVI_W0)
 		dvi->pos.w = dsgetn(dvi, opcode - DVI_W0);
 	h = dvi->pos.h;
@@ -1416,13 +1416,13 @@ int	move_w(DviContext *dvi, int opcode)
 int	move_x(DviContext *dvi, int opcode)
 {
 	int	h, hh;
-	
+
 	if(opcode != DVI_X0)
 		dvi->pos.x = dsgetn(dvi, opcode - DVI_X0);
 	h = dvi->pos.h;
 	hh = move_horizontal(dvi, dvi->pos.x);
 	SHOWCMD((dvi, "x", opcode - DVI_X0,
-		"%d h:=%d%c%d=%d, hh:=%d\n", 
+		"%d h:=%d%c%d=%d, hh:=%d\n",
 		dvi->pos.x, DBGSUM(h, dvi->pos.x, dvi->pos.h), hh));
 	dvi->pos.hh = hh;
 	return 0;
@@ -1431,13 +1431,13 @@ int	move_x(DviContext *dvi, int opcode)
 int	move_y(DviContext *dvi, int opcode)
 {
 	int	v, vv;
-	
+
 	if(opcode != DVI_Y0)
 		dvi->pos.y = dsgetn(dvi, opcode - DVI_Y0);
 	v = dvi->pos.v;
 	vv = move_vertical(dvi, dvi->pos.y);
 	SHOWCMD((dvi, "y", opcode - DVI_Y0,
-		"%d h:=%d%c%d=%d, hh:=%d\n", 
+		"%d h:=%d%c%d=%d, hh:=%d\n",
 		dvi->pos.y, DBGSUM(v, dvi->pos.y, dvi->pos.v), vv));
 	dvi->pos.vv = vv;
 	return 0;
@@ -1452,7 +1452,7 @@ int	move_z(DviContext *dvi, int opcode)
 	v = dvi->pos.v;
 	vv = move_vertical(dvi, dvi->pos.z);
 	SHOWCMD((dvi, "z", opcode - DVI_Z0,
-		"%d h:=%d%c%d=%d, hh:=%d\n", 
+		"%d h:=%d%c%d=%d, hh:=%d\n",
 		dvi->pos.z, DBGSUM(v, dvi->pos.z, dvi->pos.v), vv));
 	dvi->pos.vv = vv;
 	return 0;
@@ -1462,7 +1462,7 @@ int	sel_font(DviContext *dvi, int opcode)
 {
 	DviFontRef *ref;
 	int	ndx;
-	
+
 	ndx = opcode - DVI_FNT_NUM0;
 	if(dvi->depth)
 		ref = font_find_flat(dvi, ndx);
@@ -1484,7 +1484,7 @@ int	sel_fontn(DviContext *dvi, int opcode)
 {
 	Int32	arg;
 	DviFontRef *ref;
-	
+
 	arg = dugetn(dvi, opcode - DVI_FNT1 + 1);
 	if(dvi->depth)
 		ref = font_find_flat(dvi, arg);
@@ -1495,7 +1495,7 @@ int	sel_fontn(DviContext *dvi, int opcode)
 		return -1;
 	}
 	SHOWCMD((dvi, "fnt", opcode - DVI_FNT1 + 1,
-		"current font is %s (id %d)\n", 
+		"current font is %s (id %d)\n",
 		ref->ref->fontname, arg));
 	dvi->currfont = ref;
 	return 0;
@@ -1505,7 +1505,7 @@ int	special(DviContext *dvi, int opcode)
 {
 	char	*s;
 	Int32	arg;
-	
+
 	arg = dugetn(dvi, opcode - DVI_XXX1 + 1);
 	if (arg <= 0) {
 		dvierr(dvi, _("malformed special length\n"));
@@ -1525,7 +1525,7 @@ int	def_font(DviContext *dvi, int opcode)
 {
 	DviFontRef *ref;
 	Int32	arg;
-	
+
 	arg = dugetn(dvi, opcode - DVI_FNT_DEF1 + 1);
 	if(dvi->depth)
 		ref = font_find_flat(dvi, arg);
diff --git a/backend/dvi/mdvi-lib/files.c b/backend/dvi/mdvi-lib/files.c
index b7065068..fd88be69 100644
--- a/backend/dvi/mdvi-lib/files.c
+++ b/backend/dvi/mdvi-lib/files.c
@@ -26,13 +26,13 @@
 char	*dgets(Dstring *dstr, FILE *in)
 {
 	char	buffer[256];
-	
+
 	dstr->length = 0;
 	if(feof(in))
 		return NULL;
 	while(fgets(buffer, 256, in) != NULL) {
 		int	len = strlen(buffer);
-		
+
  		if(buffer[len-1] == '\n') {
 			dstring_append(dstr, buffer, len - 1);
 			break;
@@ -49,21 +49,21 @@ char	*dgets(Dstring *dstr, FILE *in)
 const char *file_basename(const char *filename)
 {
 	const char *ptr = strrchr(filename, '/');
-	
+
 	return (ptr ? ptr + 1 : filename);
 }
 
 const char *file_extension(const char *filename)
 {
 	const char *ptr = strchr(file_basename(filename), '.');
-	
+
 	return (ptr ? ptr + 1 : NULL);
 }
 
 int	file_readable(const char *filename)
 {
 	int	status = (access(filename, R_OK) == 0);
-	
+
 	DEBUG((DBG_FILES, "file_redable(%s) -> %s\n",
 		filename, status ? "Yes" : "No"));
 	return status;
@@ -72,7 +72,7 @@ int	file_readable(const char *filename)
 int	file_exists(const char *filename)
 {
 	int	status = (access(filename, F_OK) == 0);
-	
+
 	DEBUG((DBG_FILES, "file_exists(%s) -> %s\n",
 		filename, status ? "Yes" : "No"));
 	return status;
diff --git a/backend/dvi/mdvi-lib/font.c b/backend/dvi/mdvi-lib/font.c
index 2f655df0..56e7bae4 100644
--- a/backend/dvi/mdvi-lib/font.c
+++ b/backend/dvi/mdvi-lib/font.c
@@ -48,7 +48,7 @@ int	font_reopen(DviFont *font)
 static int load_font_file(DviParams *params, DviFont *font)
 {
 	int	status;
-			
+
 	if(SEARCH_DONE(font->search))
 		return -1;
 	if(font->in == NULL && font_reopen(font) < 0)
@@ -73,7 +73,7 @@ static int load_font_file(DviParams *params, DviFont *font)
 void	font_drop_one(DviFontRef *ref)
 {
 	DviFont *font;
-	
+
 	font = ref->ref;
 	mdvi_free(ref);
 	/* drop all children */
@@ -82,7 +82,7 @@ void	font_drop_one(DviFontRef *ref)
 		ref->ref->links--;
 	}
 	if(--font->links == 0) {
-		/* 
+		/*
 		 * this font doesn't have any more references, but
 		 * we still keep it around in case a virtual font
 		 * requests it.
@@ -104,7 +104,7 @@ void	font_drop_one(DviFontRef *ref)
 void	font_drop_chain(DviFontRef *head)
 {
 	DviFontRef *ptr;
-	
+
 	for(; (ptr = head); ) {
 		head = ptr->next;
 		font_drop_one(ptr);
@@ -116,15 +116,15 @@ int	font_free_unused(DviDevice *dev)
 	DviFont	*font, *next;
 	int	count = 0;
 
-	DEBUG((DBG_FONTS, "destroying unused fonts\n"));	
+	DEBUG((DBG_FONTS, "destroying unused fonts\n"));
 	for(font = (DviFont *)fontlist.head; font; font = next) {
 		DviFontRef *ref;
-		
+
 		next = font->next;
 		if(font->links)
 			continue;
 		count++;
-		DEBUG((DBG_FONTS, "removing unused %s font `%s'\n", 
+		DEBUG((DBG_FONTS, "removing unused %s font `%s'\n",
 			TYPENAME(font), font->fontname));
 		listh_remove(&fontlist, LIST(font));
 		if(font->in)
@@ -164,7 +164,7 @@ font_reference(
 	DviFont	*font;
 	DviFontRef *ref;
 	DviFontRef *subfont_ref;
-	
+
 	/* see if there is a font with the same characteristics */
 	for(font = (DviFont *)fontlist.head; font; font = font->next) {
 		if(strcmp(name, font->fontname) == 0
@@ -210,7 +210,7 @@ void	font_transform_glyph(DviOrientation orient, DviGlyph *g)
 {
 	BITMAP	*map;
 	int	x, y;
-	
+
 	map = (BITMAP *)g->data;
 	if(MDVI_GLYPH_ISEMPTY(map))
 		map = NULL;
@@ -240,7 +240,7 @@ void	font_transform_glyph(DviOrientation orient, DviGlyph *g)
 		g->y = x;
 		SWAPINT(g->w, g->h);
 		break;
-	case MDVI_ORIENT_RM90: 
+	case MDVI_ORIENT_RM90:
 		if(map) bitmap_rotate_clockwise(map);
 		y = g->h - g->y;
 		x = g->x;
@@ -303,7 +303,7 @@ static int load_one_glyph(DviContext *dvi, DviFont *font, int code)
 	/* check if we have to scale it */
 	if(!font->finfo->scalable && font->hdpi != font->vdpi) {
 		int	hs, vs, d;
-		
+
 		/* we scale it ourselves */
 		d = Max(font->hdpi, font->vdpi);
 		hs = d / font->hdpi;
@@ -311,8 +311,8 @@ static int load_one_glyph(DviContext *dvi, DviFont *font, int code)
 		if(ch->width && ch->height && (hs > 1 || vs > 1)) {
 			int	h, v;
 			DviGlyph glyph;
-			
-			DEBUG((DBG_FONTS, 
+
+			DEBUG((DBG_FONTS,
 				"%s: scaling glyph %d to resolution %dx%d\n",
 				font->fontname, code, font->hdpi, font->vdpi));
 			h = dvi->params.hshrink;
@@ -336,10 +336,10 @@ static int load_one_glyph(DviContext *dvi, DviFont *font, int code)
 			ch->glyph.w = glyph.w;
 			ch->glyph.h = glyph.h;
 		}
-			
+
 	}
 	font_transform_glyph(dvi->params.orientation, &ch->glyph);
-		
+
 	return 0;
 }
 
@@ -351,7 +351,7 @@ again:
 	/* if we have not loaded the font yet, do so now */
 	if(!font->chars && load_font_file(&dvi->params, font) < 0)
 		return NULL;
-	
+
 	/* get the unscaled glyph, maybe loading it from disk */
 	ch = FONTCHAR(font, code);
 	if(!ch || !glyph_present(ch))
@@ -371,16 +371,16 @@ again:
 	   font->finfo->getglyph == NULL ||
 	   (dvi->params.hshrink == 1 && dvi->params.vshrink == 1))
 		return ch;
-	
+
 	/* If the glyph is empty, we just need to shrink the box */
 	if(ch->missing || MDVI_GLYPH_ISEMPTY(ch->glyph.data)) {
 		if(MDVI_GLYPH_UNSET(ch->shrunk.data))
 			mdvi_shrink_box(dvi, font, ch, &ch->shrunk);
 		return ch;
 	} else if(MDVI_ENABLED(dvi, MDVI_PARAM_ANTIALIASED)) {
-		if(ch->grey.data && 
+		if(ch->grey.data &&
 		   !MDVI_GLYPH_ISEMPTY(ch->grey.data) &&
-		   ch->fg == dvi->curr_fg && 
+		   ch->fg == dvi->curr_fg &&
 		   ch->bg == dvi->curr_bg)
 		   	return ch;
 		if(ch->grey.data &&
@@ -424,12 +424,12 @@ void	font_reset_font_glyphs(DviDevice *dev, DviFont *font, int what)
 {
 	int	i;
 	DviFontChar *ch;
-	
+
 	if(what & MDVI_FONTSEL_GLYPH)
-		what |= MDVI_FONTSEL_BITMAP|MDVI_FONTSEL_GREY;	
+		what |= MDVI_FONTSEL_BITMAP|MDVI_FONTSEL_GREY;
 	if(font->subfonts) {
 		DviFontRef *ref;
-		
+
 		for(ref = font->subfonts; ref; ref = ref->next)
 			font_reset_font_glyphs(dev, ref->ref, what);
 	}
@@ -447,12 +447,12 @@ void	font_reset_font_glyphs(DviDevice *dev, DviFont *font, int what)
 	}
 	if((what & MDVI_FONTSEL_GLYPH) && font->finfo->reset)
 		font->finfo->reset(font);
-}	
+}
 
 void	font_reset_chain_glyphs(DviDevice *dev, DviFontRef *head, int what)
 {
 	DviFontRef *ref;
-	
+
 	for(ref = head; ref; ref = ref->next)
 		font_reset_font_glyphs(dev, ref->ref, what);
 }
@@ -466,7 +466,7 @@ void	font_finish_definitions(DviContext *dvi)
 {
 	int	count;
 	DviFontRef **map, *ref;
-	
+
 	/* first get rid of unused fonts */
 	font_free_unused(&dvi->device);
 
@@ -485,7 +485,7 @@ void	font_finish_definitions(DviContext *dvi)
 DviFontRef *font_find_flat(DviContext *dvi, Int32 id)
 {
 	DviFontRef *ref;
-	
+
 	for(ref = dvi->fonts; ref; ref = ref->next)
 		if(ref->fontid == id)
 			break;
@@ -496,13 +496,13 @@ DviFontRef *font_find_mapped(DviContext *dvi, Int32 id)
 {
 	int	lo, hi, n;
 	DviFontRef **map;
-	
+
 	/* do a binary search */
 	lo = 0; hi = dvi->nfonts;
 	map = dvi->fontmap;
 	while(lo < hi) {
 		int	sign;
-		
+
 		n = (hi + lo) >> 1;
 		sign = (map[n]->fontid - id);
 		if(sign == 0)
diff --git a/backend/dvi/mdvi-lib/fontmap.c b/backend/dvi/mdvi-lib/fontmap.c
index 20537c85..553b49da 100644
--- a/backend/dvi/mdvi-lib/fontmap.c
+++ b/backend/dvi/mdvi-lib/fontmap.c
@@ -61,7 +61,7 @@ static int fontmaps_loaded = 0;
 #define ENC_HASH_SIZE	31
 #define PSMAP_HASH_SIZE	57
 
-/* this hash table should be big enough to 
+/* this hash table should be big enough to
  * hold (ideally) one glyph name per bucket */
 #define ENCNAME_HASH_SIZE	131 /* most TeX fonts have 128 glyphs */
 
@@ -70,7 +70,7 @@ static DviEncoding *tex_text_encoding = NULL;
 static DviEncoding *default_encoding = NULL;
 
 /* we keep two hash tables for encodings: one for their base files (e.g.
- * "8r.enc"), and another one for their names (e.g. "TeXBase1Encoding") */ 
+ * "8r.enc"), and another one for their names (e.g. "TeXBase1Encoding") */
 static DviHashTable enctable = MDVI_EMPTY_HASH_TABLE;
 static DviHashTable enctable_file = MDVI_EMPTY_HASH_TABLE;
 
@@ -104,7 +104,7 @@ static void ps_init_default_paths __PROTO((void));
 static int	mdvi_set_default_encoding __PROTO((const char *name));
 static int	mdvi_init_fontmaps __PROTO((void));
 
-/* 
+/*
  * What we do here is allocate one block large enough to hold the entire
  * file (these files are small) minus the leading comments. This is much
  * better than allocating up to 256 tiny strings per encoding vector. */
@@ -116,7 +116,7 @@ static int read_encoding(DviEncoding *enc)
 	char	*name;
 	char	*next;
 	struct stat st;
-	
+
 	ASSERT(enc->private == NULL);
 
 	in = fopen(enc->filename, "rb");
@@ -153,7 +153,7 @@ static int read_encoding(DviEncoding *enc)
 	curr = 0;
 
 	next = name = NULL;
-	DEBUG((DBG_FMAP, "%s: reading encoding vector\n", enc->name));	
+	DEBUG((DBG_FMAP, "%s: reading encoding vector\n", enc->name));
 	for(line = enc->private; *line && curr < 256; line = next) {
 		SKIPSP(line);
 		if(*line == ']') {
@@ -176,13 +176,13 @@ static int read_encoding(DviEncoding *enc)
 
 		/* got a name */
 		if(*next) *next++ = 0;
-		
+
 		if(*name == '/')
 			name++;
 		enc->vector[curr] = name;
 		/* add it to the hash table */
 		if(!STREQ(name, ".notdef")) {
-			mdvi_hash_add(&enc->nametab, MDVI_KEY(name), 
+			mdvi_hash_add(&enc->nametab, MDVI_KEY(name),
 				Int2Ptr(curr + 1), MDVI_HASH_REPLACE);
 		}
 		curr++;
@@ -200,7 +200,7 @@ static int read_encoding(DviEncoding *enc)
 
 static DviEncoding *find_encoding(const char *name)
 {
-	return (DviEncoding *)(encodings.count ? 
+	return (DviEncoding *)(encodings.count ?
 		mdvi_hash_lookup(&enctable, MDVI_KEY(name)) : NULL);
 }
 
@@ -249,15 +249,15 @@ static DviEncoding *register_encoding(const char *basefile, int replace)
 			DEBUG((DBG_FMAP, "%s: already there\n", basefile));
 			return enc; /* no error */
 		}
-	} 
+	}
 
 	/* try our own files first */
-	filename = kpse_find_file(basefile, 
+	filename = kpse_find_file(basefile,
 		kpse_program_text_format, 0);
 
 	/* then try the system-wide ones */
 	if(filename == NULL)
-		filename = kpse_find_file(basefile, 
+		filename = kpse_find_file(basefile,
 			kpse_tex_ps_header_format, 0);
 	if(filename == NULL)
 		filename = kpse_find_file(basefile,
@@ -272,7 +272,7 @@ static DviEncoding *register_encoding(const char *basefile, int replace)
 		mdvi_free(filename);
 		return NULL;
 	}
-	
+
 	/* just lookup the name of the encoding */
 	name = NULL;
 	dstring_init(&input);
@@ -297,13 +297,13 @@ static DviEncoding *register_encoding(const char *basefile, int replace)
 	offset = ftell(in);
 	fclose(in);
 	if(name == NULL || *name == 0) {
-		DEBUG((DBG_FMAP, 
+		DEBUG((DBG_FMAP,
 			"%s: could not determine name of encoding\n",
 			basefile));
 		mdvi_free(filename);
 		return NULL;
 	}
-	
+
 	/* check if the encoding is already there */
 	enc = find_encoding(name);
 	if(enc == tex_text_encoding) {
@@ -347,9 +347,9 @@ static DviEncoding *register_encoding(const char *basefile, int replace)
 	dstring_reset(&input);
 	if(default_encoding == NULL)
 		default_encoding = enc;
-	mdvi_hash_add(&enctable, MDVI_KEY(enc->name), 
+	mdvi_hash_add(&enctable, MDVI_KEY(enc->name),
 		enc, MDVI_HASH_UNCHECKED);
-	mdvi_hash_add(&enctable_file, MDVI_KEY(mdvi_strdup(basefile)), 
+	mdvi_hash_add(&enctable_file, MDVI_KEY(mdvi_strdup(basefile)),
 		enc, MDVI_HASH_REPLACE);
 	listh_prepend(&encodings, LIST(enc));
 	DEBUG((DBG_FMAP, "%s: encoding `%s' registered\n",
@@ -377,7 +377,7 @@ DviEncoding *mdvi_request_encoding(const char *name)
 	if(enc->nametab.nkeys == 0) {
 		int	i;
 
-		DEBUG((DBG_FMAP, "%s: rehashing\n", enc->name));		
+		DEBUG((DBG_FMAP, "%s: rehashing\n", enc->name));
 		for(i = 0; i < 256; i++) {
 			if(enc->vector[i] == NULL)
 				continue;
@@ -404,7 +404,7 @@ void	mdvi_release_encoding(DviEncoding *enc, int should_free)
 int	mdvi_encode_glyph(DviEncoding *enc, const char *name)
 {
 	void	*data;
-	
+
 	data = mdvi_hash_lookup(&enc->nametab, MDVI_KEY(name));
 	if(data == NULL)
 		return -1;
@@ -420,7 +420,7 @@ int	mdvi_encode_glyph(DviEncoding *enc, const char *name)
 static void parse_spec(DviFontMapEnt *ent, char *spec)
 {
 	char	*arg, *command;
-	
+
 	/* this is a ridiculously simple parser, and recognizes only
 	 * things of the form <argument> <command>. Of these, only
 	 * command=SlantFont, ExtendFont and ReEncodeFont are handled */
@@ -429,16 +429,16 @@ static void parse_spec(DviFontMapEnt *ent, char *spec)
 		if(*spec) *spec++ = 0;
 		command = getword(spec, " \t", &spec);
 		if(*spec) *spec++ = 0;
-		if(!arg || !command)	
+		if(!arg || !command)
 			continue;
 		if(STREQ(command, "SlantFont")) {
 			double	x = 10000 * strtod(arg, 0);
-		
-			/* SFROUND evaluates arguments twice */	
+
+			/* SFROUND evaluates arguments twice */
 			ent->slant = SFROUND(x);
 		} else if(STREQ(command, "ExtendFont")) {
 			double	x = 10000 * strtod(arg, 0);
-			
+
 			ent->extend = SFROUND(x);
 		} else if(STREQ(command, "ReEncodeFont")) {
 			if(ent->encoding)
@@ -485,13 +485,13 @@ DviFontMapEnt	*mdvi_load_fontmap(const char *file)
 	}
 	if(in == NULL)
 		return NULL;
-		
+
 	ent = NULL;
 	listh_init(&list);
 	dstring_init(&input);
 	last_encoding = NULL;
 	last_encfile  = NULL;
-		
+
 	while((ptr = dgets(&input, in)) != NULL) {
 		char	*font_file;
 		char	*tex_name;
@@ -502,12 +502,12 @@ DviFontMapEnt	*mdvi_load_fontmap(const char *file)
 
 		lineno++;
 		SKIPSP(ptr);
-		
+
 		/* we skip what dvips does */
-		if(*ptr <= ' ' || *ptr == '*' || *ptr == '#' || 
+		if(*ptr <= ' ' || *ptr == '*' || *ptr == '#' ||
 		   *ptr == ';' || *ptr == '%')
 			continue;
-			
+
 		font_file   = NULL;
 		tex_name    = NULL;
 		ps_name     = NULL;
@@ -522,14 +522,14 @@ DviFontMapEnt	*mdvi_load_fontmap(const char *file)
 		}
 		while(*ptr) {
 			char	*hdr_name = NULL;
-			
+
 			while(*ptr && *ptr <= ' ')
 				ptr++;
 			if(*ptr == 0)
 				break;
 			if(*ptr == '"') {
 				char	*str;
-				
+
 				str = getstring(ptr, " \t", &ptr);
 				if(*ptr) *ptr++ = 0;
 				parse_spec(ent, str);
@@ -557,7 +557,7 @@ DviFontMapEnt	*mdvi_load_fontmap(const char *file)
 
 			if(hdr_name) {
 				const char *ext = file_extension(hdr_name);
-				
+
 				if(is_encoding || (ext && STRCEQ(ext, "enc")))
 					vec_name = hdr_name;
 				else
@@ -576,7 +576,7 @@ DviFontMapEnt	*mdvi_load_fontmap(const char *file)
 
 		/* if we have an encoding file, register it */
 		if(ent->encfile) {
-			/* register_encoding is smart enough not to load the 
+			/* register_encoding is smart enough not to load the
 			 * same file twice */
 			if(!last_encfile || !STREQ(last_encfile, ent->encfile)) {
 				last_encfile  = ent->encfile;
@@ -584,7 +584,7 @@ DviFontMapEnt	*mdvi_load_fontmap(const char *file)
 			}
 			enc = last_encoding;
 		}
-		if(ent->encfile && enc){ 		
+		if(ent->encfile && enc){
 			if(ent->encoding && !STREQ(ent->encoding, enc->name)) {
 				mdvi_warning(
 	_("%s: %d: [%s] requested encoding `%s' does not match vector `%s'\n"),
@@ -593,15 +593,15 @@ DviFontMapEnt	*mdvi_load_fontmap(const char *file)
 			} else if(!ent->encoding)
 				ent->encoding = mdvi_strdup(enc->name);
 		}
-		
+
 		/* add it to the list */
 		/*print_ent(ent);*/
 		listh_append(&list, LIST(ent));
 		ent = NULL;
 	}
-	dstring_reset(&input);	
+	dstring_reset(&input);
 	fclose(in);
-	
+
 	return (DviFontMapEnt *)list.head;
 }
 
@@ -629,7 +629,7 @@ void	mdvi_install_fontmap(DviFontMapEnt *head)
 	for(ent = head; ent; ent = next) {
 		/* add all the entries, overriding old ones */
 		DviFontMapEnt *old;
-		
+
 		old = (DviFontMapEnt *)
 			mdvi_hash_remove(&maptable, MDVI_KEY(ent->fontname));
 		if(old != NULL) {
@@ -639,7 +639,7 @@ void	mdvi_install_fontmap(DviFontMapEnt *head)
 			free_ent(old);
 		}
 		next = ent->next;
-		mdvi_hash_add(&maptable, MDVI_KEY(ent->fontname), 
+		mdvi_hash_add(&maptable, MDVI_KEY(ent->fontname),
 			ent, MDVI_HASH_UNCHECKED);
 		listh_append(&fontmaps, LIST(ent));
 	}
@@ -650,7 +650,7 @@ static void init_static_encoding()
 	DviEncoding	*encoding;
 	int	i;
 
-	DEBUG((DBG_FMAP, "installing static TeX text encoding\n"));	
+	DEBUG((DBG_FMAP, "installing static TeX text encoding\n"));
 	encoding = xalloc(DviEncoding);
 	encoding->private  = "";
 	encoding->filename = "";
@@ -671,7 +671,7 @@ static void init_static_encoding()
 	mdvi_hash_create(&enctable, ENC_HASH_SIZE);
 	mdvi_hash_create(&enctable_file, ENC_HASH_SIZE);
 	enctable_file.hash_free = file_hash_free;
-	mdvi_hash_add(&enctable, MDVI_KEY(encoding->name), 
+	mdvi_hash_add(&enctable, MDVI_KEY(encoding->name),
 		encoding, MDVI_HASH_UNCHECKED);
 	listh_prepend(&encodings, LIST(encoding));
 	tex_text_encoding = encoding;
@@ -720,7 +720,7 @@ static int	mdvi_init_fontmaps(void)
 
 	/* create the fontmap hash table */
 	mdvi_hash_create(&maptable, MAP_HASH_SIZE);
-			
+
 	/* get the name of our configuration file */
 	config = kpse_cnf_get("mdvi-config");
 	if(config == NULL)
@@ -738,13 +738,13 @@ static int	mdvi_init_fontmaps(void)
 	dstring_init(&input);
 	while((line = dgets(&input, in)) != NULL) {
 		char	*arg, *map_file;
-		
+
 		SKIPSP(line);
 		if(*line < ' ' || *line == '#' || *line == '%')
 			continue;
 		if(STRNEQ(line, "fontmap", 7)) {
 			DviFontMapEnt *ent;
-			
+
 			arg = getstring(line + 7, " \t", &line); *line = 0;
 			DEBUG((DBG_FMAP, "%s: loading fontmap\n", arg));
 			ent = mdvi_load_fontmap(arg);
@@ -756,7 +756,7 @@ static int	mdvi_init_fontmaps(void)
 			if(ent == NULL)
 				mdvi_warning(_("%s: could not load fontmap\n"), arg);
 			else {
-				DEBUG((DBG_FMAP, 
+				DEBUG((DBG_FMAP,
 					"%s: installing fontmap\n", arg));
 				mdvi_install_fontmap(ent);
 				count++;
@@ -804,7 +804,7 @@ int	mdvi_query_fontmap(DviFontMapInfo *info, const char *fontname)
 	DviFontMapEnt *ent;
 
 	if(!fontmaps_loaded && mdvi_init_fontmaps() < 0)
-		return -1;		
+		return -1;
 	ent = (DviFontMapEnt *)mdvi_hash_lookup(&maptable, MDVI_KEY(fontname));
 
 	if(ent == NULL)
@@ -815,14 +815,14 @@ int	mdvi_query_fontmap(DviFontMapInfo *info, const char *fontname)
 	info->extend   = ent->extend;
 	info->slant    = ent->slant;
 	info->fullfile = ent->fullfile;
-	
-	return 0;	
+
+	return 0;
 }
 
 int	mdvi_add_fontmap_file(const char *name, const char *fullpath)
 {
 	DviFontMapEnt *ent;
-	
+
 	if(!fontmaps_loaded && mdvi_init_fontmaps() < 0)
 		return -1;
 	ent = (DviFontMapEnt *)mdvi_hash_lookup(&maptable, MDVI_KEY(name));
@@ -856,13 +856,13 @@ void	mdvi_flush_encodings(void)
 	if(tex_text_encoding->nametab.buckets)
 		mdvi_hash_reset(&tex_text_encoding->nametab, 0);
 	mdvi_hash_reset(&enctable, 0);
-	mdvi_hash_reset(&enctable_file, 0);	
+	mdvi_hash_reset(&enctable_file, 0);
 }
 
 void	mdvi_flush_fontmaps(void)
 {
 	DviFontMapEnt *ent;
-	
+
 	if(!fontmaps_loaded)
 		return;
 
@@ -885,7 +885,7 @@ void	ps_init_default_paths(void)
 	ASSERT(psinitialized == 0);
 
 	kppath = getenv("GS_LIB");
-	kfpath = getenv("GS_FONTPATH");	
+	kfpath = getenv("GS_FONTPATH");
 
 	if(kppath != NULL)
 		pslibdir = kpse_path_expand(kppath);
@@ -904,7 +904,7 @@ int	mdvi_ps_read_fontmap(const char *name)
 	Dstring	dstr;
 	char	*line;
 	int	count = 0;
-	
+
 	if(!psinitialized)
 		ps_init_default_paths();
 	if(pslibdir)
@@ -918,17 +918,17 @@ int	mdvi_ps_read_fontmap(const char *name)
 		return -1;
 	}
 	dstring_init(&dstr);
-	
+
 	while((line = dgets(&dstr, in)) != NULL) {
 		char	*name;
 		char	*mapname;
 		const char *ext;
 		PSFontMap *ps;
-		
+
 		SKIPSP(line);
 		/* we're looking for lines of the form
 		 *  /FONT-NAME    (fontfile)
-		 *  /FONT-NAME    /FONT-ALIAS 
+		 *  /FONT-NAME    /FONT-ALIAS
 		 */
 		if(*line != '/')
 			continue;
@@ -936,12 +936,12 @@ int	mdvi_ps_read_fontmap(const char *name)
 		if(*line) *line++ = 0;
 		mapname = getword(line, " \t", &line);
 		if(*line) *line++ = 0;
-		
+
 		if(!name || !mapname || !*name)
 			continue;
 		if(*mapname == '(') {
 			char	*end;
-			
+
 			mapname++;
 			for(end = mapname; *end && *end != ')'; end++);
 			*end = 0;
@@ -960,7 +960,7 @@ int	mdvi_ps_read_fontmap(const char *name)
 		if(ps != NULL) {
 			if(STREQ(ps->mapname, mapname))
 				continue;
-			DEBUG((DBG_FMAP, 
+			DEBUG((DBG_FMAP,
 				"(ps) replacing font `%s' (%s) by `%s'\n",
 				name, ps->mapname, mapname));
 			mdvi_free(ps->mapname);
@@ -984,7 +984,7 @@ int	mdvi_ps_read_fontmap(const char *name)
 	}
 	fclose(in);
 	dstring_reset(&dstr);
-	
+
 	DEBUG((DBG_FMAP, "(ps) %s: %d PostScript fonts registered\n",
 		fullname, count));
 	return 0;
@@ -993,7 +993,7 @@ int	mdvi_ps_read_fontmap(const char *name)
 void	mdvi_ps_flush_fonts(void)
 {
 	PSFontMap *map;
-	
+
 	if(!psinitialized)
 		return;
 	DEBUG((DBG_FMAP, "(ps) flushing PS font map (%d) entries\n",
@@ -1037,11 +1037,11 @@ char	*mdvi_ps_find_font(const char *psname)
 	/* is it an alias? */
 	smap = map;
 	while(recursion_limit-- > 0 && smap && *smap->mapname == '/')
-		smap = (PSFontMap *)mdvi_hash_lookup(&pstable, 
+		smap = (PSFontMap *)mdvi_hash_lookup(&pstable,
 			MDVI_KEY(smap->mapname + 1));
 	if(smap == NULL) {
 		if(recursion_limit == 0)
-			DEBUG((DBG_FMAP, 
+			DEBUG((DBG_FMAP,
 				"(ps) %s: possible loop in PS font map\n",
 				psname));
 		return NULL;
@@ -1055,7 +1055,7 @@ char	*mdvi_ps_find_font(const char *psname)
 		filename = NULL;
 	if(filename)
 		map->fullname = mdvi_strdup(filename);
-		
+
 	return filename;
 }
 
@@ -1071,7 +1071,7 @@ char	*mdvi_ps_find_font(const char *psname)
  *  cache, so the next time it will be found at the first step (when we look
  *  up NAME.afm).
  *
- * The name `_ps_' in this function is not meant to imply that it can be 
+ * The name `_ps_' in this function is not meant to imply that it can be
  * used for Type1 fonts only. It should be usable for TrueType fonts as well.
  *
  * The returned metric info is subjected to the same caching mechanism as
@@ -1094,7 +1094,7 @@ TFMInfo *mdvi_ps_get_metrics(const char *fontname)
 	double	efactor;
 	double	sfactor;
 
-	DEBUG((DBG_FMAP, "(ps) %s: looking for metric data\n", fontname));	
+	DEBUG((DBG_FMAP, "(ps) %s: looking for metric data\n", fontname));
 	info = get_font_metrics(fontname, DviFontAny, NULL);
 	if(info != NULL)
 		return info;
@@ -1102,7 +1102,7 @@ TFMInfo *mdvi_ps_get_metrics(const char *fontname)
 	/* query the fontmap */
 	if(mdvi_query_fontmap(&map, fontname) < 0 || !map.psname)
 		return NULL;
-	
+
 	/* get the PS font */
 	psfont = mdvi_ps_find_font(map.psname);
 	if(psfont == NULL)
@@ -1140,9 +1140,9 @@ TFMInfo *mdvi_ps_get_metrics(const char *fontname)
 	if(info == NULL || (!map.extend && !map.slant))
 		return info;
 
-	/* 
-	 * transform the data as prescribed -- keep in mind that `info' 
-	 * points to CACHED data, so we're modifying the metric cache 
+	/*
+	 * transform the data as prescribed -- keep in mind that `info'
+	 * points to CACHED data, so we're modifying the metric cache
 	 * in place.
 	 */
 
@@ -1174,6 +1174,6 @@ TFMInfo *mdvi_ps_get_metrics(const char *fontname)
 			ch->right   = TRANSFORM(ch->right, ch->height);
 		}
 	}
-	
+
 	return info;
 }
diff --git a/backend/dvi/mdvi-lib/fontsrch.c b/backend/dvi/mdvi-lib/fontsrch.c
index 8ebaa5ca..77cd8704 100644
--- a/backend/dvi/mdvi-lib/fontsrch.c
+++ b/backend/dvi/mdvi-lib/fontsrch.c
@@ -72,7 +72,7 @@ static int initialized = 0;
 static void init_font_classes(void)
 {
 	int	i;
-	
+
 	for(i = 0; i < MAX_CLASS; i++)
 		listh_init(&font_classes[i]);
 	initialized = 1;
@@ -88,7 +88,7 @@ char	**mdvi_list_font_class(int klass)
 	char	**list;
 	int	i, n;
 	DviFontClass *fc;
-	
+
 	if(klass == -1)
 		klass = MAX_CLASS-1;
 	if(klass < 0 || klass >= MAX_CLASS)
@@ -137,7 +137,7 @@ int	mdvi_unregister_font_type(const char *name, int klass)
 
 	if(klass == -1)
 		klass = MAX_CLASS - 1;
-	
+
 	if(klass >= 0 && klass < MAX_CLASS) {
 		k = klass;
 		LIST_FOREACH(fc, DviFontClass, &font_classes[k]) {
@@ -154,12 +154,12 @@ int	mdvi_unregister_font_type(const char *name, int klass)
 		}
 	} else
 		return -1;
-	
+
 	if(fc == NULL || fc->links)
 		return -1;
 	/* remove it */
 	listh_remove(&font_classes[k], LIST(fc));
-	
+
 	/* and destroy it */
 	mdvi_free(fc->info.name);
 	mdvi_free(fc);
@@ -171,9 +171,9 @@ static char *lookup_font(DviFontClass *ptr, const char *name, Ushort *h, Ushort
 	char	*filename;
 
 	/*
-	 * If the font type registered a function to do the lookup, use that. 
+	 * If the font type registered a function to do the lookup, use that.
 	 * Otherwise we use kpathsea.
-	 */	
+	 */
 	if(ptr->info.lookup)
 		filename = ptr->info.lookup(name, h, v);
 	else if(ptr->info.kpse_type <= kpse_any_glyph_format) {
@@ -208,7 +208,7 @@ char	*mdvi_lookup_font(DviFontSearch *search)
 
 	if(search->id < 0)
 		return NULL;
-	
+
 	if(search->curr == NULL) {
 		/* this is the initial search */
 		name = search->wanted_name;
@@ -312,7 +312,7 @@ metrics:
 
 	search->id = -1;
 	search->actual_name = NULL;
-	
+
 	/* tough luck, nothing found */
 	return NULL;
 }
@@ -322,7 +322,7 @@ DviFont	*mdvi_add_font(const char *name, Int32 sum,
 	int hdpi, int vdpi, Int32 scale)
 {
 	DviFont	*font;
-	
+
 	font = xalloc(DviFont);
 	font->fontname = mdvi_strdup(name);
 	SEARCH_INIT(font->search, font->fontname, hdpi, vdpi);
@@ -354,7 +354,7 @@ int	mdvi_font_retry(DviParams *params, DviFont *font)
 	/* try the search again */
 	char	*filename;
 
-	ASSERT(font->search.curr != NULL);	
+	ASSERT(font->search.curr != NULL);
 	/* we won't be using this class anymore */
 	font->search.curr->links--;
 
diff --git a/backend/dvi/mdvi-lib/gf.c b/backend/dvi/mdvi-lib/gf.c
index 00607ff6..d890e156 100644
--- a/backend/dvi/mdvi-lib/gf.c
+++ b/backend/dvi/mdvi-lib/gf.c
@@ -88,7 +88,7 @@ static int gf_read_bitmap(FILE *p, DviFontChar *ch)
 	Int32	par;
 	BmUnit	*line;
 	BITMAP	*map;
-	
+
 	fseek(p, (long)ch->offset, SEEK_SET);
 	op = fuget1(p);
 	if(op == GF_BOC) {
@@ -106,7 +106,7 @@ static int gf_read_bitmap(FILE *p, DviFontChar *ch)
 		min_m = fuget1(p); /* this is max_m - min_m */
 		max_m = fuget1(p);
 		min_n = fuget1(p); /* this is max_n - min_n */
-		max_n = fuget1(p); 
+		max_n = fuget1(p);
 		min_m = max_m - min_m;
 		min_n = max_n - min_n;
 	} else {
@@ -136,18 +136,18 @@ static int gf_read_bitmap(FILE *p, DviFontChar *ch)
 	DEBUG((DBG_BITMAPS, "(gf) reading character %d\n", ch->code));
 	while((op = fuget1(p)) != GF_EOC) {
 		Int32	n;
-		
+
 		if(feof(p))
 			break;
 		if(op == GF_PAINT0) {
 			DEBUG((DBG_BITMAPS, "(gf) Paint0 %s -> %s\n",
-				COLOR(paint_switch), COLOR(!paint_switch)));	
+				COLOR(paint_switch), COLOR(!paint_switch)));
 			paint_switch = !paint_switch;
 		} else if(op <= GF_PAINT3) {
 			if(op < GF_PAINT1)
 				par = op;
 			else
-				par = fugetn(p, op - GF_PAINT1 + 1);			
+				par = fugetn(p, op - GF_PAINT1 + 1);
 			if(y >= ch->height || x + par >= ch->width)
 				goto toobig;
 			/* paint everything between columns x and x + par - 1 */
@@ -159,14 +159,14 @@ static int gf_read_bitmap(FILE *p, DviFontChar *ch)
 			paint_switch = !paint_switch;
 			x += par;
 		} else if(op >= GF_NEW_ROW_0 && op <= GF_NEW_ROW_MAX) {
-			y++; 
+			y++;
 			line = bm_offset(line, bpl);
 			x = op - GF_NEW_ROW_0;
 			paint_switch = BLACK;
 			DEBUG((DBG_BITMAPS, "(gf) new_row_%d\n", x));
 		} else switch(op) {
 			case GF_SKIP0:
-				y++; 
+				y++;
 				line = bm_offset(line, bpl);
 				x = 0;
 				paint_switch = WHITE;
@@ -264,7 +264,7 @@ static int gf_load_font(DviParams *unused, DviFont *font)
 	/* now read character locators in postamble */
 	if(fseek(p, (long)-1, SEEK_END) == -1)
 		return -1;
-	
+
 	n = 0;
 	while((op = fuget1(p)) == GF_TRAILER) {
 		if(fseek(p, (long)-2, SEEK_CUR) < 0)
@@ -306,7 +306,7 @@ static int gf_load_font(DviParams *unused, DviFont *font)
 		DviFontChar *ch;
 		int	cc;
 
-		/* get the character code */		
+		/* get the character code */
 		cc = fuget1(p);
 		if(cc < loc)
 			loc = cc;
@@ -342,11 +342,11 @@ static int gf_load_font(DviParams *unused, DviFont *font)
 		ch->grey.data = NULL;
 		ch->flags = 0;
 		ch->loaded = 0;
-	}	
+	}
 
 	if(op != GF_POST_POST)
 		goto badgf;
-	
+
 	if(loc > 0 || hic < 255) {
 		/* shrink to optimal size */
 		memmove(font->chars, font->chars + loc,
@@ -373,11 +373,11 @@ error:
 static int gf_font_get_glyph(DviParams *params, DviFont *font, int code)
 {
 	DviFontChar	*ch;
-	
+
 	if(code < font->loc || code > font->hic || !font->chars)
 		return -1;
 	ch = &font->chars[code - font->loc];
-	
+
 	if(!ch->loaded) {
 		if(ch->offset == 0)
 			return -1;
diff --git a/backend/dvi/mdvi-lib/hash.c b/backend/dvi/mdvi-lib/hash.c
index d359e3c8..3327fa58 100644
--- a/backend/dvi/mdvi-lib/hash.c
+++ b/backend/dvi/mdvi-lib/hash.c
@@ -33,7 +33,7 @@ static Ulong hash_string(DviHashKey key)
 {
 	Uchar	*p;
 	Ulong	h, g;
-	
+
 	for(h = 0, p = (Uchar *)key; *p; p++) {
 		h = (h << 4UL) + *p;
 		if((g = h & 0xf0000000L) != 0) {
@@ -41,7 +41,7 @@ static Ulong hash_string(DviHashKey key)
 			h ^= g;
 		}
 	}
-		
+
 	return h;
 }
 
@@ -63,7 +63,7 @@ void	mdvi_hash_init(DviHashTable *hash)
 void	mdvi_hash_create(DviHashTable *hash, int size)
 {
 	int	i;
-	
+
 	hash->nbucks = size;
 	hash->buckets = xnalloc(DviHashBucket *, size);
 	for(i = 0; i < size; i++)
@@ -78,9 +78,9 @@ static DviHashBucket *hash_find(DviHashTable *hash, DviHashKey key)
 {
 	Ulong	hval;
 	DviHashBucket *buck;
-	
+
 	hval = (hash->hash_func(key) % hash->nbucks);
-	
+
 	for(buck = hash->buckets[hval]; buck; buck = buck->next)
 		if(hash->hash_comp(buck->key, key) == 0)
 			break;
@@ -92,7 +92,7 @@ int	mdvi_hash_add(DviHashTable *hash, DviHashKey key, void *data, int rep)
 {
 	DviHashBucket *buck = NULL;
 	Ulong	hval;
-	
+
 	if(rep != MDVI_HASH_UNCHECKED) {
 		buck = hash_find(hash, key);
 		if(buck != NULL) {
@@ -112,11 +112,11 @@ int	mdvi_hash_add(DviHashTable *hash, DviHashKey key, void *data, int rep)
 		hash->buckets[hval] = buck;
 		hash->nkeys++;
 	}
-	
+
 	/* save key and data */
 	buck->key = key;
 	buck->data = data;
-	
+
 	return 0;
 }
 
@@ -131,10 +131,10 @@ static DviHashBucket *hash_remove(DviHashTable *hash, DviHashKey key)
 {
 	DviHashBucket *buck, *last;
 	Ulong	hval;
-	
+
 	hval = hash->hash_func(key);
 	hval %= hash->nbucks;
-	
+
 	for(last = NULL, buck = hash->buckets[hval]; buck; buck = buck->next) {
 		if(hash->hash_comp(buck->key, key) == 0)
 			break;
@@ -167,10 +167,10 @@ void	*mdvi_hash_remove_ptr(DviHashTable *hash, DviHashKey key)
 	DviHashBucket *buck, *last;
 	Ulong	hval;
 	void	*ptr;
-	
+
 	hval = hash->hash_func(key);
 	hval %= hash->nbucks;
-	
+
 	for(last = NULL, buck = hash->buckets[hval]; buck; buck = buck->next) {
 		if(buck->key == key)
 			break;
@@ -192,20 +192,20 @@ void	*mdvi_hash_remove_ptr(DviHashTable *hash, DviHashKey key)
 int	mdvi_hash_destroy_key(DviHashTable *hash, DviHashKey key)
 {
 	DviHashBucket *buck = hash_remove(hash, key);
-	
+
 	if(buck == NULL)
 		return -1;
 	if(hash->hash_free)
 		hash->hash_free(buck->key, buck->data);
 	mdvi_free(buck);
-	return 0;	
+	return 0;
 }
 
 void	mdvi_hash_reset(DviHashTable *hash, int reuse)
 {
 	int	i;
 	DviHashBucket *buck;
-	
+
 	/* remove all keys in the hash table */
 	for(i = 0; i < hash->nbucks; i++) {
 		for(; (buck = hash->buckets[i]); ) {
diff --git a/backend/dvi/mdvi-lib/mdvi.h b/backend/dvi/mdvi-lib/mdvi.h
index 37664a76..a05f9278 100644
--- a/backend/dvi/mdvi-lib/mdvi.h
+++ b/backend/dvi/mdvi-lib/mdvi.h
@@ -62,34 +62,34 @@ typedef Ulong	DviColor;
 
 typedef enum {
 	FALSE	= 0,
-	TRUE	= 1	
+	TRUE	= 1
 } DviBool;
 
 #include "hash.h"
 #include "paper.h"
 
-/* 
+/*
  * information about a page:
  *   pagenum[0] = offset to BOP
  *   pagenum[1], ..., pagenum[10] = TeX \counters
  */
 typedef long	PageNum[11];
 
-/* this structure contains the platform-specific information 
+/* this structure contains the platform-specific information
  * required to interpret a DVI file */
 
-typedef void (*DviGlyphDraw)	__PROTO((DviContext *context, 
+typedef void (*DviGlyphDraw)	__PROTO((DviContext *context,
 				          DviFontChar *glyph,
 				          int x, int y));
 
 typedef void (*DviRuleDraw)	__PROTO((DviContext *context,
-				          int x, int y, 
+				          int x, int y,
 				          Uint width, Uint height, int fill));
 
 typedef int (*DviColorScale) 	__PROTO((void *device_data,
-				         Ulong *pixels, 
+				         Ulong *pixels,
 				         int npixels,
-				         Ulong foreground, 
+				         Ulong foreground,
 				         Ulong background,
 				         double gamma,
 				         int density));
@@ -104,7 +104,7 @@ typedef void (*DviDevDestroy)   __PROTO((void *data));
 typedef void (*DviRefresh)      __PROTO((DviContext *dvi, void *device_data));
 typedef void (*DviSetColor)	__PROTO((void *device_data, Ulong, Ulong));
 typedef void (*DviPSDraw)       __PROTO((DviContext *context,
-					 const char *filename, 
+					 const char *filename,
 					 int x, int y,
 					 Uint width, Uint height));
 
@@ -155,7 +155,7 @@ struct _DviGlyph {
 	void	*data;	/* bitmap or XImage */
 };
 
-typedef void (*DviFontShrinkFunc) 
+typedef void (*DviFontShrinkFunc)
 	__PROTO((DviContext *, DviFont *, DviFontChar *, DviGlyph *));
 typedef int (*DviFontLoadFunc) __PROTO((DviParams *, DviFont *));
 typedef int (*DviFontGetGlyphFunc) __PROTO((DviParams *, DviFont *, int));
@@ -351,7 +351,7 @@ struct _DviState {
 	int	w;
 	int	x;
 	int	y;
-	int	z;	
+	int	z;
 };
 
 struct _DviColorPair {
@@ -415,7 +415,7 @@ struct _DviRange {
 };
 
 
-typedef void (*DviSpecialHandler) 
+typedef void (*DviSpecialHandler)
 	__PROTO((DviContext *dvi, const char *prefix, const char *arg));
 
 #define RANGE_HAS_LOWER(x) \
@@ -433,7 +433,7 @@ typedef void (*DviSpecialHandler)
 #define MDVI_PARAM_SHOWUNDEF	8
 #define MDVI_PARAM_DELAYFONTS	16
 
-/* 
+/*
  * The FALLBACK priority class is reserved for font formats that
  * contain no glyph information and are to be used as a last
  * resort (e.g. TFM, AFM)
@@ -553,10 +553,10 @@ extern void mdvi_flush_specials __PROTO((void));
 #define glyph_present(x) ((x) && (x)->offset)
 
 /* create a reference to a font */
-extern DviFontRef *font_reference __PROTO((DviParams *params, 
-                                           Int32 dvi_id, 
-                                           const char *font_name, 
-                                           Int32 checksum, 
+extern DviFontRef *font_reference __PROTO((DviParams *params,
+                                           Int32 dvi_id,
+                                           const char *font_name,
+                                           Int32 checksum,
                                            int xdpi,
                                            int ydpi,
                                            Int32 scale_factor));
diff --git a/backend/dvi/mdvi-lib/pagesel.c b/backend/dvi/mdvi-lib/pagesel.c
index 5a153955..82c59a37 100644
--- a/backend/dvi/mdvi-lib/pagesel.c
+++ b/backend/dvi/mdvi-lib/pagesel.c
@@ -47,7 +47,7 @@ DviRange *mdvi_parse_range(const char *format, DviRange *limit, int *nitems, cha
 	char *	text;
 	DviRange one;
 	DviRange *range;
-	
+
 	quoted = (*format == '{');
 	if(quoted) format++;
 
@@ -59,7 +59,7 @@ DviRange *mdvi_parse_range(const char *format, DviRange *limit, int *nitems, cha
 	lower = 0;
 	upper = 0;
 	type  = MDVI_RANGE_UNBOUNDED;
-	
+
 	if(limit) {
 		switch(limit->type) {
 			case MDVI_RANGE_BOUNDED:
@@ -96,7 +96,7 @@ DviRange *mdvi_parse_range(const char *format, DviRange *limit, int *nitems, cha
 		int	this_type;
 		int	lower_given = 0;
 		int	upper_given = 0;
-		
+
 		if(*cp == 0 || *cp == '.' || (*cp == '}' && quoted))
 			done = 1;
 		else if(*cp != ',')
@@ -109,7 +109,7 @@ DviRange *mdvi_parse_range(const char *format, DviRange *limit, int *nitems, cha
 		f = lower;
 		t = upper;
 		s = 1;
-		
+
 		p = strchr(text, ':');
 		if(p) *p++ = 0;
 		if(*text) {
@@ -165,7 +165,7 @@ finish:
 		one.to   = t;
 		one.from = f;
 		one.step = s;
-		
+
 		if(curr == size) {
 			size += 8;
 			range = mdvi_realloc(range, size * sizeof(DviRange));
@@ -174,7 +174,7 @@ finish:
 		*cp = ch;
 		text = cp + 1;
 	}
-	if(done) 
+	if(done)
 		cp--;
 	if(quoted && *cp == '}')
 		cp++;
@@ -189,7 +189,7 @@ finish:
 
 DviPageSpec *mdvi_parse_page_spec(const char *format)
 {
-	/* 
+	/*
 	 * a page specification looks like this:
 	 *   '{'RANGE_SPEC'}'         for a DVI spec
 	 *   '{'RANGE_SPEC'}' '.' ... for a TeX spec
@@ -199,7 +199,7 @@ DviPageSpec *mdvi_parse_page_spec(const char *format)
 	int	count;
 	int	i;
 	char	*ptr;
-	
+
 	spec = xnalloc(struct _DviPageSpec *, 11);
 	for(i = 0; i < 11; i++)
 		spec[i] = NULL;
@@ -214,7 +214,7 @@ DviPageSpec *mdvi_parse_page_spec(const char *format)
 		}
 	} else
 		range = NULL;
-	
+
 	if(*format == 'D' || *format == 'd' || *ptr != '.')
 		i = 0;
 	else
@@ -226,13 +226,13 @@ DviPageSpec *mdvi_parse_page_spec(const char *format)
 		spec[i]->nranges = count;
 	} else
 		spec[i] = NULL;
-	
+
 	if(*ptr != '.') {
 		if(*ptr)
 			mdvi_warning(_("garbage after DVI page specification ignored\n"));
 		return spec;
 	}
-	
+
 	for(i++; *ptr == '.' && i <= 10; i++) {
 		ptr++;
 		if(*ptr == '*') {
@@ -240,7 +240,7 @@ DviPageSpec *mdvi_parse_page_spec(const char *format)
 			range = NULL;
 		} else {
 			char	*end;
-			
+
 			range = mdvi_parse_range(ptr, NULL, &count, &end);
 			if(end == ptr) {
 				if(range) mdvi_free(range);
@@ -255,13 +255,13 @@ DviPageSpec *mdvi_parse_page_spec(const char *format)
 		} else
 			spec[i] = NULL;
 	}
-	
+
 	if(i > 10)
 		mdvi_warning(_("more than 10 counters in page specification\n"));
 	else if(*ptr)
 		mdvi_warning(_("garbage after TeX page specification ignored\n"));
-	
-	return spec;	
+
+	return spec;
 }
 
 /* returns non-zero if the given page is included by `spec' */
@@ -269,11 +269,11 @@ int	mdvi_page_selected(DviPageSpec *spec, PageNum page, int dvipage)
 {
 	int	i;
 	int	not_found;
-	
+
 	if(spec == NULL)
 		return 1;
 	if(spec[0]) {
-		not_found = mdvi_in_range(spec[0]->ranges, 
+		not_found = mdvi_in_range(spec[0]->ranges,
 			spec[0]->nranges, dvipage);
 		if(not_found < 0)
 			return 0;
@@ -281,7 +281,7 @@ int	mdvi_page_selected(DviPageSpec *spec, PageNum page, int dvipage)
 	for(i = 1; i <= 10; i++) {
 		if(spec[i] == NULL)
 			continue;
-		not_found = mdvi_in_range(spec[i]->ranges, 
+		not_found = mdvi_in_range(spec[i]->ranges,
 			spec[i]->nranges, (int)page[i]);
 		if(not_found < 0)
 			return 0;
@@ -292,7 +292,7 @@ int	mdvi_page_selected(DviPageSpec *spec, PageNum page, int dvipage)
 void	mdvi_free_page_spec(DviPageSpec *spec)
 {
 	int	i;
-	
+
 	for(i = 0; i < 11; i++)
 		if(spec[i]) {
 			mdvi_free(spec[i]->ranges);
@@ -304,7 +304,7 @@ void	mdvi_free_page_spec(DviPageSpec *spec)
 int	mdvi_in_range(DviRange *range, int nitems, int value)
 {
 	DviRange *r;
-	
+
 	for(r = range; r < range + nitems; r++) {
 		int	cond;
 
@@ -330,7 +330,7 @@ int	mdvi_in_range(DviRange *range, int nitems, int value)
 				return (r - range);
 			break;
 		case MDVI_RANGE_UPPER:
-			if(value == r->to)	
+			if(value == r->to)
 				return (r - range);
 			if(r->step < 0)
 				cond = (value > r->to);
@@ -352,12 +352,12 @@ int	mdvi_range_length(DviRange *range, int nitems)
 {
 	int	count = 0;
 	DviRange *r;
-	
+
 	for(r = range; r < range + nitems; r++) {
 		int	n;
 
 		if(r->type != MDVI_RANGE_BOUNDED)
-			return -2;		
+			return -2;
 		n = (r->to - r->from) / r->step;
 		if(n < 0)
 			n = 0;
@@ -395,7 +395,7 @@ int main()
 #if 0
 	char	buf[256];
 	DviRange limit;
-		
+
 	limit.from = 0;
 	limit.to = 100;
 	limit.step = 2;
@@ -405,7 +405,7 @@ int main()
 		char	*end;
 		int	count;
 		int	i;
-		
+
 		printf("Range> "); fflush(stdout);
 		if(fgets(buf, 256, stdin) == NULL)
 			break;
@@ -419,20 +419,20 @@ int main()
 			printf("range is empty\n");
 			continue;
 		}
-		
+
 		for(i = 0; i < count; i++) {
-			printf("Range %d (%d elements):\n", 
+			printf("Range %d (%d elements):\n",
 				i, mdvi_range_length(&range[i], 1));
 			print_range(&range[i]);
 		}
 		if(end && *end)
 			printf("Tail: [%s]\n", end);
-		printf("range has %d elements\n", 
+		printf("range has %d elements\n",
 			mdvi_range_length(range, count));
 #if 1
 		while(1) {
 			int	v;
-			
+
 			printf("Value: "); fflush(stdout);
 			if(fgets(buf, 256, stdin) == NULL)
 				break;
@@ -455,7 +455,7 @@ int main()
 #else
 	DviPageSpec *spec;
 	char	buf[256];
-	
+
 	while(1) {
 		printf("Spec> "); fflush(stdout);
 		if(fgets(buf, 256, stdin) == NULL)
@@ -469,13 +469,13 @@ int main()
 			printf("no spec parsed\n");
 		else {
 			int	i;
-			
+
 			printf("spec = ");
 			for(i = 0; i < 11; i++) {
 				printf("Counter %d:\n", i);
 				if(spec[i]) {
 					int	k;
-					
+
 					for(k = 0; k < spec[i]->nranges; k++)
 						print_range(&spec[i]->ranges[k]);
 				} else
diff --git a/backend/dvi/mdvi-lib/paper.c b/backend/dvi/mdvi-lib/paper.c
index 42cbcd3f..7ba454ab 100644
--- a/backend/dvi/mdvi-lib/paper.c
+++ b/backend/dvi/mdvi-lib/paper.c
@@ -75,7 +75,7 @@ static const DviPaperSpec papers[] = {
 	{"ledger", "17in", "11in"},
 	{"note", "7.5in", "10in"},
 	{"tabloid", "11in", "17in"},
-	{"statement", "5.5in", "8.5in"},	
+	{"statement", "5.5in", "8.5in"},
 	{0, 0, 0}
 };
 
@@ -111,7 +111,7 @@ int	mdvi_get_paper_size(const char *name, DviPaper *paper)
 		paper->name = _("custom");
 		return 0;
 	}
-	
+
 	for(sp = &papers[0]; sp->name; sp++) {
 		if(!sp->width || !sp->height) {
 			paper->pclass = str2class(sp->name);
@@ -132,10 +132,10 @@ DviPaperSpec *mdvi_get_paper_specs(DviPaperClass pclass)
 	int	i;
 	int	first, count;
 	DviPaperSpec *spec, *ptr;
-	
+
 	first = -1;
 	count = 0;
-	if(pclass == MDVI_PAPER_CLASS_ANY || 
+	if(pclass == MDVI_PAPER_CLASS_ANY ||
 	   pclass == MDVI_PAPER_CLASS_CUSTOM) {
 	   	first = 0;
 		count = (sizeof(papers) / sizeof(papers[0])) - 3;
diff --git a/backend/dvi/mdvi-lib/pk.c b/backend/dvi/mdvi-lib/pk.c
index 1b42a319..5e8da5bb 100644
--- a/backend/dvi/mdvi-lib/pk.c
+++ b/backend/dvi/mdvi-lib/pk.c
@@ -112,7 +112,7 @@ static char *pk_lookup(const char *name, Ushort *hdpi, Ushort *vdpi)
 	} else if(filename) {
 		*hdpi = *vdpi = type.dpi;
 	}
-	return filename;	
+	return filename;
 }
 
 static char *pk_lookupn(const char *name, Ushort *hdpi, Ushort *vdpi)
@@ -132,7 +132,7 @@ static char *pk_lookupn(const char *name, Ushort *hdpi, Ushort *vdpi)
 	} else if(filename) {
 		*hdpi = *vdpi = type.dpi;
 	}
-	return filename;	
+	return filename;
 }
 
 static inline int pk_get_nyb(FILE *p, pkread *pk)
@@ -140,10 +140,10 @@ static inline int pk_get_nyb(FILE *p, pkread *pk)
 	unsigned t;
 	int	nb;
 	char	c;
-	
+
 	t = c = pk->currbyte;
 	nb = pk->nybpos;
-	
+
 	switch(nb) {
 	case 0:
 		c = pk->currbyte = fuget1(p);
@@ -157,7 +157,7 @@ static inline int pk_get_nyb(FILE *p, pkread *pk)
 	return (t & 0xf);
 }
 
-/* 
+/*
  * this is a bit cumbersome because we have to pass around
  * the `pkread' data...
  */
@@ -165,7 +165,7 @@ static int pk_packed_num(FILE *p, pkread *pkr, int *repeat)
 {
 	int	i, j;
 	int	dyn_f = pkr->dyn_f;
-	
+
 	i = pk_get_nyb(p, pkr);
 	if(i == 0) {
 		do {
@@ -174,12 +174,12 @@ static int pk_packed_num(FILE *p, pkread *pkr, int *repeat)
 		} while(j == 0);
 		while(i-- > 0)
 			j = (j << 4) + pk_get_nyb(p, pkr);
-		return (j - 15 + ((13 - dyn_f) << 4) + 
+		return (j - 15 + ((13 - dyn_f) << 4) +
 			dyn_f);
 	} else if(i <= dyn_f)
 		return i;
 	else if(i < 14)
-		return ((i - dyn_f - 1) << 4) + 
+		return ((i - dyn_f - 1) << 4) +
 			pk_get_nyb(p, pkr) + dyn_f + 1;
 	else {
 		*repeat = 1;
@@ -198,7 +198,7 @@ static BITMAP *get_bitmap(FILE *p, int w, int h, int flags)
 	BITMAP	*bm;
 	int	bitpos;
 	int	currch;
-		
+
 	flags = 0; /* shut up that compiler */
 	bitpos = -1;
 	if((bm = bitmap_alloc(w, h)) == NULL)
@@ -209,7 +209,7 @@ static BITMAP *get_bitmap(FILE *p, int w, int h, int flags)
 	currch = 0;
 	for(i = 0; i < h; i++) {
 		BmUnit	mask;
-		
+
 		mask = FIRSTMASK;
 		for(j = 0; j < w; j++) {
 			if(bitpos < 0) {
@@ -238,7 +238,7 @@ static BITMAP *get_packed(FILE *p, int w, int h, int flags)
 	int	repeat_count;
 	int	paint;
 	pkread	pkr;
-		
+
 	pkr.nybpos = 0;
 	pkr.currbyte = 0;
 	pkr.dyn_f = PK_DYN_F(flags);
@@ -253,7 +253,7 @@ static BITMAP *get_packed(FILE *p, int w, int h, int flags)
 		w, h, flags));
 	while(row < h) {
 		int	i = 0;
-		
+
 		count = pk_packed_num(p, &pkr, &i);
 		if(i > 0) {
 			if(repeat_count)
@@ -261,11 +261,11 @@ static BITMAP *get_packed(FILE *p, int w, int h, int flags)
 					repeat_count, i);
 			repeat_count = i;
 		}
-		
+
 		if(count >= inrow) {
 			Uchar	*r, *t;
 			BmUnit	*a, mask;
-			
+
 			/* first finish current row */
 			if(paint)
 				bitmap_set_row(bm, row, w - inrow, inrow, paint);
@@ -369,11 +369,11 @@ static int pk_load_font(DviParams *unused, DviFont *font)
 	fuget4(p);
 	fuget4(p);
 	if(feof(p))
-		goto badpk;	
+		goto badpk;
 
 	/* now start reading the font */
 	loc = 256; hic = -1; maxch = 256;
-	
+
 	/* initialize alpha and beta for TFM width computation */
 	TFMPREPARE(font->scale, z, alpha, beta);
 
@@ -389,7 +389,7 @@ static int pk_load_font(DviParams *unused, DviFont *font)
 #ifndef NODEBUG
 				char	*t;
 				int	n;
-				
+
 				i = fugetn(p, flag_byte - PK_X1 + 1);
 				if(i < 256)
 					t = &s[0];
@@ -428,7 +428,7 @@ static int pk_load_font(DviParams *unused, DviFont *font)
 			int	x, y;
 			int	offset;
 			long	tfm;
-			
+
 			switch(flag_byte & 0x7) {
 			case 7:
 				pl = fuget4(p);
@@ -438,13 +438,13 @@ static int pk_load_font(DviParams *unused, DviFont *font)
 				fsget4(p); /* skip dx */
 				fsget4(p); /* skip dy */
 				w  = fuget4(p);
-				h  = fuget4(p); 
+				h  = fuget4(p);
 				x  = fsget4(p);
 				y  = fsget4(p);
 				break;
 			case 4:
 			case 5:
-			case 6:				
+			case 6:
 				pl = (flag_byte % 4) * 65536 + fuget2(p);
 				cc = fuget1(p);
 				offset = ftell(p) + pl;
@@ -484,7 +484,7 @@ static int pk_load_font(DviParams *unused, DviFont *font)
 			if(cc > hic)
 				hic = cc;
 			if(cc > maxch) {
-				font->chars = xresize(font->chars, 
+				font->chars = xresize(font->chars,
 					DviFontChar, cc + 16);
 				for(i = maxch; i < cc + 16; i++)
 					font->chars[i].offset = 0;
@@ -523,13 +523,13 @@ static int pk_load_font(DviParams *unused, DviFont *font)
 
 	/* resize font char data */
 	if(loc > 0 || hic < maxch-1) {
-		memmove(font->chars, font->chars + loc, 
+		memmove(font->chars, font->chars + loc,
 			(hic - loc + 1) * sizeof(DviFontChar));
 		font->chars = xresize(font->chars,
 			DviFontChar, hic - loc + 1);
 	}
 	font->loc = loc;
-	font->hic = hic;		
+	font->hic = hic;
 	return 0;
 
 badpk:
@@ -547,7 +547,7 @@ static int pk_font_get_glyph(DviParams *params, DviFont *font, int code)
 
 	if((ch = FONTCHAR(font, code)) == NULL)
 		return -1;
-	
+
 	if(ch->offset == 0)
 		return -1;
 	DEBUG((DBG_GLYPHS, "(pk) loading glyph for character %d (%dx%d) in font `%s'\n",
@@ -561,11 +561,11 @@ static int pk_font_get_glyph(DviParams *params, DviFont *font, int code)
 		ch->glyph.w = ch->width;
 		ch->glyph.h = ch->height;
 		ch->glyph.data = NULL;
-		return 0; 
+		return 0;
 	}
 	if(fseek(font->in, ch->offset, SEEK_SET) == -1)
 		return -1;
-	ch->glyph.data = get_char(font->in, 
+	ch->glyph.data = get_char(font->in,
 		ch->width, ch->height, ch->flags);
 	if(ch->glyph.data) {
 		/* restore original settings */
diff --git a/backend/dvi/mdvi-lib/setup.c b/backend/dvi/mdvi-lib/setup.c
index ba0c545d..881bed50 100644
--- a/backend/dvi/mdvi-lib/setup.c
+++ b/backend/dvi/mdvi-lib/setup.c
@@ -25,7 +25,7 @@
 #include "mdvi.h"
 #include "private.h"
 
-void	mdvi_init_kpathsea(const char *program, 
+void	mdvi_init_kpathsea(const char *program,
 	const char *mfmode, const char *font, int dpi,
 	const char *texmfcnf)
 {
@@ -33,7 +33,7 @@ void	mdvi_init_kpathsea(const char *program,
 
 	/* Stop meaningless output generation. */
 	kpse_make_tex_discard_errors = FALSE;
-	
+
 	p = strrchr(program, '/');
 	p = (p ? p + 1 : program);
 	kpse_set_program_name(program, p);
diff --git a/backend/dvi/mdvi-lib/sp-epsf.c b/backend/dvi/mdvi-lib/sp-epsf.c
index 4f1b49cb..104c955b 100644
--- a/backend/dvi/mdvi-lib/sp-epsf.c
+++ b/backend/dvi/mdvi-lib/sp-epsf.c
@@ -53,7 +53,7 @@ typedef struct {
 void	epsf_special __PROTO((DviContext *dvi, char *prefix, char *arg));
 
 /* Note: the given strings are modified in place */
-static char *parse_epsf_special(EpsfBox *box, char **ret, 
+static char *parse_epsf_special(EpsfBox *box, char **ret,
 	char *prefix, char *arg)
 {
 	static struct {
@@ -90,11 +90,11 @@ static char *parse_epsf_special(EpsfBox *box, char **ret,
 	double	vsize;
 	double	hscale;
 	double	vscale;
-		
+
 	/* this special has the form
 	 *   ["]file.ps["] [key=valye]*
 	 */
-	
+
 	/* scan the filename */
 	while(*arg == ' ' || *arg == '\t')
 		arg++;
@@ -116,7 +116,7 @@ static char *parse_epsf_special(EpsfBox *box, char **ret,
 		value[i] = atof(keys[i].value);
 		present[i] = 0;
 	}
-	
+
 	buff_init(&buffer);
 	buff_add(&buffer, "@beginspecial ", 0);
 
@@ -128,13 +128,13 @@ static char *parse_epsf_special(EpsfBox *box, char **ret,
 		while(*ptr == ' ' || *ptr == '\t')
 			ptr++;
 		keyname = ptr;
-		
+
 		/* get the whole key=value pair */
 		for(; *ptr && *ptr != ' ' && *ptr != '\t'; ptr++);
-		
+
 		if(*ptr) *ptr++ = 0;
 		/* now we shouldn't touch `ptr' anymore */
-		
+
 		/* now work on this pair */
 		p = strchr(keyname, '=');
 		if(p == NULL)
@@ -174,18 +174,18 @@ static char *parse_epsf_special(EpsfBox *box, char **ret,
 		}
 		if(val)
 			value[i] = atof(val);
-		
+
 		/* put the argument */
 		buff_add(&buffer, val, 0);
 		buff_add(&buffer, " @", 2);
 		buff_add(&buffer, keyname, 0);
 		buff_add(&buffer, " ", 1);
-		
+
 		/* remember that this option was given */
 		present[i] = 0xff;
 	}
 	buff_add(&buffer, " @setspecial", 0);
-	
+
 	/* now compute the bounding box (code comes from dvips) */
 	originx = 0;
 	originy = 0;
@@ -193,7 +193,7 @@ static char *parse_epsf_special(EpsfBox *box, char **ret,
 	vscale = 1;
 	hsize = 0;
 	vsize = 0;
-	
+
 	if(present[HSIZE])
 		hsize = value[HSIZE];
 	if(present[VSIZE])
@@ -220,7 +220,7 @@ static char *parse_epsf_special(EpsfBox *box, char **ret,
 			vscale = value[RHI] / (10.0 * vsize);
 		}
 	}
-	
+
 	box->ox = originx;
 	box->oy = originy;
 	box->bw = hsize * hscale;
@@ -228,7 +228,7 @@ static char *parse_epsf_special(EpsfBox *box, char **ret,
 	box->angle = value[ANGLE];
 
 	*ret = buffer.data;
-	
+
 	return filename;
 }
 
@@ -243,7 +243,7 @@ void	epsf_special(DviContext *dvi, char *prefix, char *arg)
 	int	w, h;
 	double	xf, vf;
 	struct stat buf;
-	
+
 	file = parse_epsf_special(&box, &special, prefix, arg);
 	if (file != NULL)
 		mdvi_free (special);
@@ -272,7 +272,7 @@ void	epsf_special(DviContext *dvi, char *prefix, char *arg)
 	if (tmp) { /* Document directory */
 		int path_len = strlen (dvi->filename) - strlen (tmp + 1);
 		int file_len = strlen (file);
-		
+
 		psfile = mdvi_malloc (path_len + file_len + 1);
 		psfile[0] = '\0';
 		strncat (psfile, dvi->filename, path_len);
@@ -287,7 +287,7 @@ void	epsf_special(DviContext *dvi, char *prefix, char *arg)
 
 		mdvi_free (psfile);
 	}
-			
+
 	psfile = mdvi_build_path_from_cwd (file);
 	if (stat (psfile, &buf) == 0) { /* Current working dir */
 		dvi->device.draw_ps (dvi, psfile, x, y, w, h);
@@ -297,7 +297,7 @@ void	epsf_special(DviContext *dvi, char *prefix, char *arg)
 	}
 
 	mdvi_free (psfile);
-	
+
 	psfile = kpse_find_pict (file);
 	if (psfile) { /* kpse */
 		dvi->device.draw_ps (dvi, psfile, x, y, w, h);
diff --git a/backend/dvi/mdvi-lib/special.c b/backend/dvi/mdvi-lib/special.c
index e4832544..e1f1a618 100644
--- a/backend/dvi/mdvi-lib/special.c
+++ b/backend/dvi/mdvi-lib/special.c
@@ -39,7 +39,7 @@ typedef struct _DviSpecial {
 #endif
 	DviSpecialHandler handler;
 } DviSpecial;
-	
+
 static ListHead specials = {NULL, NULL, 0};
 
 #define SPECIAL(x)	\
@@ -65,7 +65,7 @@ static void register_builtin_specials(void)
 {
 	int	i;
 
-	ASSERT(registered_builtins == 0);	
+	ASSERT(registered_builtins == 0);
 	registered_builtins = 1;
 	for(i = 0; i < NSPECIALS; i++)
 		mdvi_register_special(
@@ -79,7 +79,7 @@ static void register_builtin_specials(void)
 static DviSpecial *find_special_prefix(const char *prefix)
 {
 	DviSpecial *sp;
-	
+
 	/* should have a hash table here, but I'm so lazy */
 	for(sp = (DviSpecial *)specials.head; sp; sp = sp->next) {
 		if(STRCEQ(sp->prefix, prefix))
@@ -88,7 +88,7 @@ static DviSpecial *find_special_prefix(const char *prefix)
 	return sp;
 }
 
-int	mdvi_register_special(const char *label, const char *prefix, 
+int	mdvi_register_special(const char *label, const char *prefix,
 	const char *regex, DviSpecialHandler handler, int replace)
 {
 	DviSpecial *sp;
@@ -127,9 +127,9 @@ int	mdvi_register_special(const char *label, const char *prefix,
 	sp->label = mdvi_strdup(label);
 	sp->plen = strlen(prefix);
 	if(newsp)
-		listh_prepend(&specials, LIST(sp));		
-	DEBUG((DBG_SPECIAL, 
-		"New \\special handler `%s' with prefix `%s'\n", 
+		listh_prepend(&specials, LIST(sp));
+	DEBUG((DBG_SPECIAL,
+		"New \\special handler `%s' with prefix `%s'\n",
 		label, prefix));
 	return 0;
 }
@@ -137,8 +137,8 @@ int	mdvi_register_special(const char *label, const char *prefix,
 int	mdvi_unregister_special(const char *prefix)
 {
 	DviSpecial *sp;
-	
-	sp = find_special_prefix(prefix);	
+
+	sp = find_special_prefix(prefix);
 	if(sp == NULL)
 		return -1;
 	mdvi_free(sp->prefix);
@@ -156,7 +156,7 @@ int	mdvi_unregister_special(const char *prefix)
 int	mdvi_do_special(DviContext *dvi, char *string)
 {
 	char	*prefix;
-	char 	*ptr;	
+	char 	*ptr;
 	DviSpecial *sp;
 
 	if(!registered_builtins) {
@@ -170,7 +170,7 @@ int	mdvi_do_special(DviContext *dvi, char *string)
 		string++;
 
 	DEBUG((DBG_SPECIAL, "Looking for a handler for `%s'\n", string));
-	
+
 	/* now try to find a match */
 	ptr = string;
 	for(sp = (DviSpecial *)specials.head; sp; sp = sp->next) {
@@ -193,13 +193,13 @@ int	mdvi_do_special(DviContext *dvi, char *string)
 	/* extract the prefix */
 	if(ptr == string) {
 		prefix = NULL;
-		DEBUG((DBG_SPECIAL, 
+		DEBUG((DBG_SPECIAL,
 			"REGEX match with `%s' (arg `%s')\n",
 			sp->label, ptr));
 	} else {
 		if(*ptr) *ptr++ = 0;
 		prefix = string;
-		DEBUG((DBG_SPECIAL, 
+		DEBUG((DBG_SPECIAL,
 			"PREFIX match with `%s' (prefix `%s', arg `%s')\n",
 			sp->label, prefix, ptr));
 	}
@@ -213,8 +213,8 @@ int	mdvi_do_special(DviContext *dvi, char *string)
 void	mdvi_flush_specials(void)
 {
 	DviSpecial *sp, *list;
-	
-	
+
+
 	for(list = (DviSpecial *)specials.head; (sp = list); ) {
 		list = sp->next;
 		if(sp->prefix) mdvi_free(sp->prefix);
diff --git a/backend/dvi/mdvi-lib/sysdeps.h b/backend/dvi/mdvi-lib/sysdeps.h
index c77d7651..3955c0dd 100644
--- a/backend/dvi/mdvi-lib/sysdeps.h
+++ b/backend/dvi/mdvi-lib/sysdeps.h
@@ -18,7 +18,7 @@
 #ifndef _SYSDEP_H
 #define _SYSDEP_H 1
 
-/* 
+/*
  * The purpose of this file is to define symbols that describe the
  * system-dependent features we use. Namely, byte order, native integer
  * types of various sizes, and safe pointer<->integer conversion.
@@ -75,7 +75,7 @@ typedef short		Int16;
 #endif	/* SIZEOF_INT != 2 */
 #endif	/* SIZEOF_SHORT != 2 */
 
-/* 
+/*
  * An integer type to convert to and from pointers safely. All we do here is
  * look for an integer type with the same size as a pointer.
  */
diff --git a/backend/dvi/mdvi-lib/t1.c b/backend/dvi/mdvi-lib/t1.c
index d63f055c..12bb01fa 100644
--- a/backend/dvi/mdvi-lib/t1.c
+++ b/backend/dvi/mdvi-lib/t1.c
@@ -16,7 +16,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-/* 
+/*
  * Type1 font support for MDVI
  *
  * We use T1lib only as a rasterizer, not to draw glyphs.
@@ -37,7 +37,7 @@ typedef struct t1info {
 	struct t1info *next;
 	struct t1info *prev;
 	char	*fontname;	/* (short) name of this font */
-	int	t1id;		/* T1lib's id for this font */	
+	int	t1id;		/* T1lib's id for this font */
 	int	hasmetrics;	/* have we processed this font? */
 	TFMInfo *tfminfo;	/* TFM data is shared */
 	DviFontMapInfo mapinfo;
@@ -47,7 +47,7 @@ typedef struct t1info {
 static void  t1_font_remove __PROTO((T1Info *));
 static int   t1_load_font __PROTO((DviParams *, DviFont *));
 static int   t1_font_get_glyph __PROTO((DviParams *, DviFont *, int));
-static void  t1_font_shrink_glyph 
+static void  t1_font_shrink_glyph
 		__PROTO((DviContext *, DviFont *, DviFontChar *, DviGlyph *));
 static void  t1_free_data __PROTO((DviFont *));
 static void  t1_reset_font __PROTO((DviFont *));
@@ -79,10 +79,10 @@ static int t1lib_ydpi = -1;
 static ListHead t1fonts = {NULL, NULL, 0};
 static DviHashTable t1hash;
 
-/* Type1 fonts need their own `lookup' function. Here is how it works: 
+/* Type1 fonts need their own `lookup' function. Here is how it works:
  * First we try to find the font by its given name. If that fails, we
  * query the font maps. A typical font map entry may contain the line
- * 
+ *
  * ptmr8rn Times-Roman ".82 ExtendFont TeXBase1Encoding ReEncodeFont" <8r.enc <ptmr
  *
  * which means: If you're looking for the font `ptmr8rn' load `Times-Roman'
@@ -112,13 +112,13 @@ char	*t1_lookup_font(const char *name, Ushort *hdpi, Ushort *vdpi)
 		return filename;
 	}
 
-	DEBUG((DBG_TYPE1, "(t1) %s: not found, querying font maps\n", name));	
+	DEBUG((DBG_TYPE1, "(t1) %s: not found, querying font maps\n", name));
 	/* now query the fontmap */
 	if(mdvi_query_fontmap(&info, name) < 0) {
 		/* it's not there either */
 		return NULL;
 	}
-	
+
 	/* check what we got */
 	if(info.fullfile) {
 		DEBUG((DBG_TYPE1, "(t1) %s: found `%s' (cached)\n",
@@ -126,15 +126,15 @@ char	*t1_lookup_font(const char *name, Ushort *hdpi, Ushort *vdpi)
 		/* this is a cached lookup */
 		return mdvi_strdup(info.fullfile);
 	}
-	
+
 	/* no file associated to this font? */
 	if(info.fontfile == NULL)
 		return info.psname ? mdvi_ps_find_font(info.psname) : NULL;
-		
+
 	/* let's extract the extension */
 	ext = file_extension(info.fontfile);
 	if(ext && !STREQ(ext, "pfa") && !STREQ(ext, "pfb")) {
-		DEBUG((DBG_TYPE1, 
+		DEBUG((DBG_TYPE1,
 			"(t1) %s: associated name `%s' is not Type1\n",
 			name, info.fontfile));
 		/* it's not a Type1 font */
@@ -160,7 +160,7 @@ char	*t1_lookup_font(const char *name, Ushort *hdpi, Ushort *vdpi)
 		DEBUG((DBG_TYPE1, "(t1) %s: not found\n", name));
 		return NULL;
 	}
-	
+
 	DEBUG((DBG_TYPE1, "(t1) %s: found as `%s'\n", name, filename));
 	/* got it! let's remember this */
 	mdvi_add_fontmap_file(name, filename);
@@ -178,7 +178,7 @@ static void t1_reset_resolution(int xdpi, int ydpi)
 	nfonts = T1_Get_no_fonts();
 #else
 	nfonts = T1_GetNoFonts();
-#endif	
+#endif
 
 	for(i = 0; i < nfonts; i++)
 		T1_DeleteAllSizes(i);
@@ -186,7 +186,7 @@ static void t1_reset_resolution(int xdpi, int ydpi)
 	if(T1_SetDeviceResolutions((float)xdpi, (float)ydpi) < 0)
 		mdvi_warning(_("(t1) failed to reset device resolution\n"));
 	else
-		DEBUG((DBG_TYPE1, 
+		DEBUG((DBG_TYPE1,
 			"(t1) reset successful, new resolution is (%d, %d)\n",
 			xdpi, ydpi));
 	t1lib_xdpi = xdpi;
@@ -196,7 +196,7 @@ static void t1_reset_resolution(int xdpi, int ydpi)
 static void t1_reset_font(DviFont *font)
 {
 	T1Info *info = (T1Info *)font->private;
-	
+
 	if(info == NULL)
 		return;
 	DEBUG((DBG_FONTS, "(t1) resetting font `%s'\n", font->fontname));
@@ -215,19 +215,19 @@ static void t1_transform_font(T1Info *info)
 			mdvi_warning(_("%s: could not encode font\n"), info->fontname);
 	}
 	if(info->mapinfo.slant) {
-		DEBUG((DBG_TYPE1, "(t1) %s: slanting by %.3f\n", 
+		DEBUG((DBG_TYPE1, "(t1) %s: slanting by %.3f\n",
 			info->fontname,
 			MDVI_FMAP_SLANT(&info->mapinfo)));
-		T1_SlantFont(info->t1id, 
+		T1_SlantFont(info->t1id,
 			MDVI_FMAP_SLANT(&info->mapinfo));
 	}
 	if(info->mapinfo.extend) {
 		DEBUG((DBG_TYPE1, "(t1) %s: extending by %.3f\n",
 			info->fontname,
 			MDVI_FMAP_EXTEND(&info->mapinfo)));
-		T1_ExtendFont(info->t1id, 
+		T1_ExtendFont(info->t1id,
 			MDVI_FMAP_EXTEND(&info->mapinfo));
-	}		
+	}
 }
 
 /* if this function is called, we really need this font */
@@ -257,7 +257,7 @@ static int t1_really_load_font(DviParams *params, DviFont *font, T1Info *info)
 	 * data for it */
 	info->tfminfo = mdvi_ps_get_metrics(info->fontname);
 	if(info->tfminfo == NULL) {
-		DEBUG((DBG_FONTS, 
+		DEBUG((DBG_FONTS,
 			"(t1) %s: no metric data, font ignored\n",
 			info->fontname));
 		goto t1_error;
@@ -274,7 +274,7 @@ static int t1_really_load_font(DviParams *params, DviFont *font, T1Info *info)
 	if(old && old->t1id != -1) {
 		/* let's take advantage of T1lib's font sharing */
 		t1id = T1_CopyFont(old->t1id);
-		DEBUG((DBG_TYPE1, "(t1) %s -> %d (CopyFont)\n", 
+		DEBUG((DBG_TYPE1, "(t1) %s -> %d (CopyFont)\n",
 			info->fontname, t1id));
 		copied = 1;
 	} else {
@@ -287,7 +287,7 @@ static int t1_really_load_font(DviParams *params, DviFont *font, T1Info *info)
 		goto t1_error;
 	info->t1id = t1id;
 
-	/* 
+	/*
 	 * a minor optimization: If the old font in the hash table has
 	 * not been loaded yet, replace it by this one, so we can use
 	 * CopyFont later.
@@ -296,7 +296,7 @@ static int t1_really_load_font(DviParams *params, DviFont *font, T1Info *info)
 		DEBUG((DBG_TYPE1, "(t1) font `%s' exchanged in hash table\n",
 			info->fontname));
 		mdvi_hash_remove(&t1hash, (unsigned char *)old->fontname);
-		mdvi_hash_add(&t1hash, (unsigned char *)info->fontname, 
+		mdvi_hash_add(&t1hash, (unsigned char *)info->fontname,
 			info, MDVI_HASH_UNCHECKED);
 	}
 
@@ -323,7 +323,7 @@ static int t1_really_load_font(DviParams *params, DviFont *font, T1Info *info)
 	/* get the scaled characters metrics */
 	get_tfm_chars(params, font, info->tfminfo, 0);
 	info->hasmetrics = 1;
-	
+
 	DEBUG((DBG_TYPE1, "(t1) font `%s' really-loaded\n", info->fontname));
 	return 0;
 
@@ -331,7 +331,7 @@ t1_error:
 	/* some error does not allows us to use this font. We need to reset
 	 * the font structure, so the font system can try to read this
 	 * font in a different class */
-	
+
 	/* first destroy the private data */
 	t1_font_remove(info);
 	/* now reset all chars -- this is the important part */
@@ -365,7 +365,7 @@ static int init_t1lib(DviParams *params)
 	mdvi_hash_init(&t1hash);
 	DEBUG((DBG_TYPE1, "(t1) t1lib %s initialized -- resolution is (%d, %d), pad is %d bits\n",
 		T1_GetLibIdent(), params->dpi, params->vdpi, T1_GetBitmapPad()));
-	t1lib_initialized = 1;	
+	t1lib_initialized = 1;
 	t1lib_xdpi = params->dpi;
 	t1lib_ydpi = params->vdpi;
 	return 0;
@@ -375,7 +375,7 @@ static int t1_load_font(DviParams *params, DviFont *font)
 {
 	T1Info	*info;
 	int	i;
-				
+
 	if(t1lib_initialized < 0)
 		return -1;
 	else if(t1lib_initialized == 0 && init_t1lib(params) < 0)
@@ -389,7 +389,7 @@ static int t1_load_font(DviParams *params, DviFont *font)
 
 	info = xalloc(T1Info);
 
-	/* 
+	/*
 	 * mark the font as `unregistered' with T1lib. It will
 	 * be added when we actually use it
 	 */
@@ -405,15 +405,15 @@ static int t1_load_font(DviParams *params, DviFont *font)
 	info->mapinfo.extend = 0;
 	info->mapinfo.slant = 0;
 	info->encoding = NULL;
-	
+
 	/* create the hash table if we have not done so yet */
 	if(t1hash.nbucks == 0)
 		mdvi_hash_create(&t1hash, T1_HASH_SIZE);
-	mdvi_hash_add(&t1hash, (unsigned char *) info->fontname, info, MDVI_HASH_UNIQUE);		
+	mdvi_hash_add(&t1hash, (unsigned char *) info->fontname, info, MDVI_HASH_UNIQUE);
 	listh_append(&t1fonts, LIST(info));
 
 	font->private = info;
-		
+
 	/* reset everything */
 	font->chars = xnalloc(DviFontChar, 256);
 	font->loc = 0;
@@ -426,7 +426,7 @@ static int t1_load_font(DviParams *params, DviFont *font)
 		font->chars[i].shrunk.data = NULL;
 		font->chars[i].grey.data = NULL;
 	}
-	
+
 	return 0;
 }
 
@@ -438,7 +438,7 @@ static int t1_load_font(DviParams *params, DviFont *font)
 static inline BITMAP *t1_glyph_bitmap(GLYPH *glyph)
 {
 	int	w, h, pad;
-	
+
 	w = GLYPH_WIDTH(glyph);
 	h = GLYPH_HEIGHT(glyph);
 
@@ -455,12 +455,12 @@ static void t1_font_shrink_glyph(DviContext *dvi, DviFont *font, DviFontChar *ch
 	GLYPH	*glyph;
 	T1Info	*info;
 	T1_TMATRIX matrix;
-	
+
 	info = (T1Info *)font->private;
 	ASSERT(info != NULL);
 
 	DEBUG((DBG_TYPE1, "(t1) shrinking glyph for character %d in `%s' (%d,%d)\n",
-		ch->code, font->fontname, ch->width, ch->height));	
+		ch->code, font->fontname, ch->width, ch->height));
 	size = (double)font->scale / (dvi->params.tfm_conv * 0x100000);
 	size = 72.0 * size / 72.27;
 	matrix.cxx = 1.0/(double)dvi->params.hshrink;
@@ -477,7 +477,7 @@ static void t1_font_shrink_glyph(DviContext *dvi, DviFont *font, DviFontChar *ch
 
 #ifndef NODEBUG
 	if(DEBUGGING(BITMAP_DATA)) {
-		DEBUG((DBG_BITMAP_DATA, 
+		DEBUG((DBG_BITMAP_DATA,
 			"(t1) %s: t1_shrink_glyph(%d): (%dw,%dh,%dx,%dy) -> (%dw,%dh,%dx,%dy)\n",
 			ch->glyph.w, ch->glyph.h, ch->glyph.x, ch->glyph.y,
 			dest->w, dest->h, dest->x, dest->y));
@@ -497,11 +497,11 @@ static int t1_font_get_glyph(DviParams *params, DviFont *font, int code)
 	double	size;
 	T1_TMATRIX matrix;
 	int	dpi;
-	
+
 	ASSERT(info != NULL);
 	if(!info->hasmetrics && t1_really_load_font(params, font, info) < 0)
 		return -1;
-	ch = FONTCHAR(font, code);	
+	ch = FONTCHAR(font, code);
 	if(!ch || !glyph_present(ch))
 		return -1;
 	ch->loaded = 1;
@@ -522,7 +522,7 @@ static int t1_font_get_glyph(DviParams *params, DviFont *font, int code)
 	size = 72.0 * size / 72.27;
 
 	dpi = Max(font->hdpi, font->vdpi);
-	/* we don't want the glyph to be cached twice (once by us, another by 
+	/* we don't want the glyph to be cached twice (once by us, another by
 	 * T1lib), so we use an identity matrix to tell T1lib not to keep the
 	 * glyph around */
 	matrix.cxx = (double)font->hdpi / dpi;
@@ -545,21 +545,21 @@ static int t1_font_get_glyph(DviParams *params, DviFont *font, int code)
 	ch->glyph.w = GLYPH_WIDTH(glyph);
 	ch->glyph.h = GLYPH_HEIGHT(glyph);
 
-	/* let's also fix the glyph's origin 
+	/* let's also fix the glyph's origin
 	 * (which is not contained in the TFM) */
 	ch->x = ch->glyph.x;
 	ch->y = ch->glyph.y;
 	/* let's fix these too */
 	ch->width = ch->glyph.w;
 	ch->height = ch->glyph.h;
-		
+
 	return 0;
 }
 
 static void t1_font_remove(T1Info *info)
 {
 	T1Info	*old;
-	
+
 	/* first remove it from our list */
 	listh_remove(&t1fonts, LIST(info));
 
@@ -567,13 +567,13 @@ static void t1_font_remove(T1Info *info)
 	old = (T1Info *)mdvi_hash_lookup(&t1hash, (unsigned char *)info->fontname);
 	if(old == info) {
 		mdvi_hash_remove(&t1hash, (unsigned char *) info->fontname);
-		/* go through the list and see if there is another 
+		/* go through the list and see if there is another
 		 * font with this name */
 		for(old = (T1Info *)t1fonts.head; old; old = old->next)
 			if(STREQ(old->fontname, info->fontname))
 				break;
 		if(old != NULL)
-			mdvi_hash_add(&t1hash, (unsigned char *) old->fontname, old, 
+			mdvi_hash_add(&t1hash, (unsigned char *) old->fontname, old,
 				MDVI_HASH_UNCHECKED);
 	}
 	/* release our encoding vector */
@@ -603,17 +603,17 @@ static void t1_free_data(DviFont *font)
 	/* called after all the glyphs are destroyed */
 
 	if(font->private == NULL) {
-		/* this is perfectly normal, it just means the font has 
+		/* this is perfectly normal, it just means the font has
 		 * not been requested by MDVI yet */
 		return;
 	}
-	
+
 	/* destroy this data */
 
 	t1_font_remove((T1Info *)font->private);
 	font->private = NULL;
 
-	/* 
+	/*
 	 * if this is the last T1 font, reset the T1 library
 	 * It is important that we do this, because this is will be called
 	 * when the resolution or the magnification changes.
diff --git a/backend/dvi/mdvi-lib/tfm.c b/backend/dvi/mdvi-lib/tfm.c
index f37de0be..f87140d2 100644
--- a/backend/dvi/mdvi-lib/tfm.c
+++ b/backend/dvi/mdvi-lib/tfm.c
@@ -74,7 +74,7 @@ DviFontInfo afm_font_info = {
 #define TYPENAME(font)	\
 	((font)->search.info ? (font)->search.info : "none")
 
-/* 
+/*
  * Although it does not seem that way, this conversion is independent of the
  * shrinking factors, within roundoff (that's because `conv' and `vconv'
  * have already been scaled by hshrink and vshrink, repsectively). We
@@ -91,14 +91,14 @@ int	get_tfm_chars(DviParams *params, DviFont *font, TFMInfo *info, int loaded)
 	int	n;
 	DviFontChar *ch;
 	TFMChar	*ptr;
-	
+
 	n = info->hic - info->loc + 1;
 	if(n != FONT_GLYPH_COUNT(font)) {
 		font->chars = mdvi_realloc(font->chars,
 			n * sizeof(DviFontChar));
 	}
 	font->loc = info->loc;
-	font->hic = info->hic;	
+	font->hic = info->hic;
 	ch = font->chars;
 	ptr = info->chars;
 
@@ -120,14 +120,14 @@ int	get_tfm_chars(DviParams *params, DviFont *font, TFMInfo *info, int loaded)
 		c = TFMSCALE(z, ptr->height, alpha, beta);
 		d = TFMSCALE(z, ptr->depth, alpha, beta);
 
-		/* now convert to unscaled pixels */		
+		/* now convert to unscaled pixels */
 		ch->width = XCONV(b - a);
 		ch->height = YCONV(c - d);
 		if(ch->height < 0) ch->height = -ch->height;
 		ch->x = XCONV(a);
 		ch->y = YCONV(c);
 		/*
-		 * the offset is not used, but we might as well set it to 
+		 * the offset is not used, but we might as well set it to
 		 * something meaningful (and it MUST be non-zero)
 		 */
 		ch->flags       = 0;
@@ -173,10 +173,10 @@ static int tfm_load_font(DviParams *params, DviFont *font)
 	tfm = get_font_metrics(font->fontname, type, font->filename);
 	if(tfm == NULL)
 		return -1;
-			
+
 	if(tfm->checksum && font->checksum && tfm->checksum != font->checksum) {
 		mdvi_warning(_("%s: Checksum mismatch (got %u, expected %u)\n"),
-			     font->fontname, (unsigned)tfm->checksum, 
+			     font->fontname, (unsigned)tfm->checksum,
 			     (unsigned)font->checksum);
 	}
 	font->checksum = tfm->checksum;
@@ -185,17 +185,17 @@ static int tfm_load_font(DviParams *params, DviFont *font)
 	font->hic = 0;
 	font->chars = NULL;
 	get_tfm_chars(params, font, tfm, 1);
-	
+
 	/* free everything */
 	free_font_metrics(tfm);
-	
+
 	return 0;
 }
 
 static int tfm_font_get_glyph(DviParams *params, DviFont *font, int code)
 {
 	DviFontChar *ch;
-	
+
 	ch = FONTCHAR(font, code);
 	if(!glyph_present(ch))
 		return -1;
@@ -203,9 +203,9 @@ static int tfm_font_get_glyph(DviParams *params, DviFont *font, int code)
 	ch->glyph.y = ch->y;
 	ch->glyph.w = ch->width;
 	ch->glyph.h = ch->height;
-	/* 
+	/*
 	 * This has two purposes: (1) avoid unnecessary calls to this function,
-	 * and (2) detect when the glyph data for a TFM font is actually used 
+	 * and (2) detect when the glyph data for a TFM font is actually used
 	 * (we'll get a SEGV). Any occurrence of that is a bug.
 	 */
 	ch->glyph.data = MDVI_GLYPH_EMPTY;
diff --git a/backend/dvi/mdvi-lib/tfmfile.c b/backend/dvi/mdvi-lib/tfmfile.c
index c23d9fe0..f7ba251f 100644
--- a/backend/dvi/mdvi-lib/tfmfile.c
+++ b/backend/dvi/mdvi-lib/tfmfile.c
@@ -51,7 +51,7 @@ static DviHashTable tfmhash;
 static inline void swap_array(Uint32 *ptr, int n)
 {
 	Uint32 i;
-	
+
 	while(n-- > 0) {
 		i = *ptr;
 		*ptr++ = ((i & 0xff000000) >> 24)
@@ -80,7 +80,7 @@ int	afm_load_file(const char *filename, TFMInfo *info)
 	int	status;
 	CharMetricInfo *cm;
 	FILE	*in;
-	
+
 	in = fopen(filename, "rb");
 	if(in == NULL)
 		return -1;
@@ -91,7 +91,7 @@ int	afm_load_file(const char *filename, TFMInfo *info)
 		mdvi_error(_("%s: Error reading AFM data\n"), filename);
 		return -1;
 	}
-	
+
 	/* aim high */
 	info->chars = xnalloc(TFMChar, 256);
 	info->loc = 256;
@@ -106,7 +106,7 @@ int	afm_load_file(const char *filename, TFMInfo *info)
 	for(cm = fi->cmi; cm < fi->cmi + fi->numOfChars; cm++) {
 		int	code;
 		TFMChar	*ch;
-		
+
 		code = cm->code;
 		if(code < 0 || code > 255)
 			continue; /* ignore it */
@@ -179,7 +179,7 @@ int	tfm_load_file(const char *filename, TFMInfo *info)
 	/* allocate a word-aligned buffer to hold the file */
 	size = 4 * ROUND(st.st_size, 4);
 	if(size != st.st_size)
-		mdvi_warning(_("Warning: TFM file `%s' has suspicious size\n"), 
+		mdvi_warning(_("Warning: TFM file `%s' has suspicious size\n"),
 			     filename);
 	tfm = (Uchar *)mdvi_malloc(size);
 	if(fread(tfm, st.st_size, 1, in) != 1)
@@ -190,12 +190,12 @@ int	tfm_load_file(const char *filename, TFMInfo *info)
 
 	/* not a checksum, but serves a similar purpose */
 	checksum = 0;
-	
+
 	ptr = tfm;
 	/* get the counters */
 	lf = muget2(ptr);
 	lh = muget2(ptr); checksum += 6 + lh;
-	bc = muget2(ptr); 
+	bc = muget2(ptr);
 	ec = muget2(ptr); checksum += ec - bc + 1;
 	nw = muget2(ptr); checksum += nw;
 	nh = muget2(ptr); checksum += nh;
@@ -213,7 +213,7 @@ int	tfm_load_file(const char *filename, TFMInfo *info)
 	heights     = cb;  cb += nh;
 	depths      = cb;
 
-	if(widths[0] || heights[0] || depths[0] || 
+	if(widths[0] || heights[0] || depths[0] ||
 	   checksum != lf || bc - 1 > ec || ec > 255 || ne > 256)
 		goto bad_tfm;
 
@@ -250,7 +250,7 @@ int	tfm_load_file(const char *filename, TFMInfo *info)
 		ptr += n;
 	}
 	/* now we don't read from `ptr' anymore */
-	
+
 	info->loc = bc;
 	info->hic = ec;
 	info->type = DviFontTFM;
@@ -285,7 +285,7 @@ int	tfm_load_file(const char *filename, TFMInfo *info)
 
 	/* free everything */
 	mdvi_free(tfm);
-	
+
 	return 0;
 
 bad_tfm:
@@ -293,7 +293,7 @@ bad_tfm:
 error:
 	if(tfm) mdvi_free(tfm);
 	if(in)  fclose(in);
-	return -1;	
+	return -1;
 }
 
 static int ofm1_load_file(FILE *in, TFMInfo *info)
@@ -309,7 +309,7 @@ static int ofm1_load_file(FILE *in, TFMInfo *info)
 	Int32	*depths;
 	TFMChar	*tch;
 	TFMChar	*end;
-	
+
 	lh = fuget4(in);
 	bc = fuget4(in);
 	ec = fuget4(in);
@@ -355,16 +355,16 @@ static int ofm1_load_file(FILE *in, TFMInfo *info)
 	/* jump to the beginning of the char-info table */
 	fseek(in, 4L*nco, SEEK_SET);
 
-	size = ec - bc + 1;	
+	size = ec - bc + 1;
 	info->loc = bc;
 	info->hic = ec;
 	info->chars = xnalloc(TFMChar, size);
 	end = info->chars + size;
-	
+
 	for(tch = info->chars, i = 0; i < ncw; i++) {
 		TFMChar	ch;
 		int	nr;
-		
+
 		/* in the characters we store the actual indices */
 		ch.advance = fuget2(in);
 		ch.height  = fuget1(in);
@@ -383,7 +383,7 @@ static int ofm1_load_file(FILE *in, TFMInfo *info)
 			memcpy(tch++, &ch, sizeof(TFMChar));
 		if(tch == end)
 			goto bad_tfm;
-	}	
+	}
 
 	/* I wish we were done, but we aren't */
 
@@ -406,7 +406,7 @@ static int ofm1_load_file(FILE *in, TFMInfo *info)
 
 	if(widths[0] || heights[0] || depths[0])
 		goto bad_tfm;
-	
+
 	/* now fix the characters */
 	size = ec - bc + 1;
 	for(tch = info->chars; tch < end; tch++) {
@@ -451,7 +451,7 @@ static int	ofm_load_file(const char *filename, TFMInfo *info)
 
 	/* not a checksum, but serves a similar purpose */
 	checksum = 0;
-	
+
 	/* get the counters */
 	/* get file level */
 	olevel = fsget2(in);
@@ -459,7 +459,7 @@ static int	ofm_load_file(const char *filename, TFMInfo *info)
 		goto bad_tfm;
 	olevel = fsget2(in);
 	if(olevel != 0) {
-		DEBUG((DBG_FONTS, "(mt) reading Level-1 OFM file `%s'\n", 
+		DEBUG((DBG_FONTS, "(mt) reading Level-1 OFM file `%s'\n",
 			filename));
 		/* we handle level-1 files separately */
 		if(ofm1_load_file(in, info) < 0)
@@ -471,7 +471,7 @@ static int	ofm_load_file(const char *filename, TFMInfo *info)
 	nwords = 14;
 	lf = fuget4(in); checksum  = nwords;
 	lh = fuget4(in); checksum += lh;
-	bc = fuget4(in); 
+	bc = fuget4(in);
 	ec = fuget4(in); checksum += 2 * (ec - bc + 1);
 	nw = fuget4(in); checksum += nw;
 	nh = fuget4(in); checksum += nh;
@@ -482,7 +482,7 @@ static int	ofm_load_file(const char *filename, TFMInfo *info)
 	checksum += 2*fuget4(in); /* skip extensible recipe count */
 	checksum +=   fuget4(in); /* skip # of font parameters */
 
-	/* I have found several .ofm files that seem to have the 
+	/* I have found several .ofm files that seem to have the
 	 * font-direction word missing, so we try to detect that here */
 	if(checksum == lf + 1) {
 		DEBUG((DBG_FONTS, "(mt) font direction missing in `%s'\n",
@@ -553,12 +553,12 @@ static int	ofm_load_file(const char *filename, TFMInfo *info)
 	}
 
 	/* from this point on, no error checking is done */
-	
+
 	/* we don't need this anymore */
 	fclose(in);
 
 	/* now we don't read from `ptr' anymore */
-	
+
 	info->loc = bc;
 	info->hic = ec;
 	info->type = DviFontTFM;
@@ -589,13 +589,13 @@ static int	ofm_load_file(const char *filename, TFMInfo *info)
 bad_tfm:
 	mdvi_error(_("%s: File corrupted, or not a TFM file\n"), filename);
 	fclose(in);
-	return -1;	
+	return -1;
 }
 
 char	*lookup_font_metrics(const char *name, int *type)
 {
 	char	*file;
-	
+
 	switch(*type) {
 #ifndef WITH_AFM_FILES
 		case DviFontAny:
@@ -617,7 +617,7 @@ char	*lookup_font_metrics(const char *name, int *type)
 #ifdef WITH_AFM_FILES
 		case DviFontAFM:
 			file = kpse_find_file(name, kpse_afm_format, 0);
-			break;	
+			break;
 		case DviFontAny:
 			file = kpse_find_file(name, kpse_afm_format, 0);
 			*type = DviFontAFM;
@@ -634,8 +634,8 @@ char	*lookup_font_metrics(const char *name, int *type)
 	return file;
 }
 
-/* 
- * The next two functions are just wrappers for the font metric loaders, 
+/*
+ * The next two functions are just wrappers for the font metric loaders,
  * and use the pool of TFM data
  */
 
@@ -652,9 +652,9 @@ TFMInfo	*get_font_metrics(const char *short_name, int type, const char *filename
 	TFMPool *tfm = NULL;
 	int	status;
 	char	*file;
-	
+
 	if(tfmpool.count) {
-		tfm = (TFMPool *)mdvi_hash_lookup(&tfmhash, 
+		tfm = (TFMPool *)mdvi_hash_lookup(&tfmhash,
 			MDVI_KEY(short_name));
 		if(tfm != NULL) {
 			DEBUG((DBG_FONTS, "(mt) reusing metric file `%s' (%d links)\n",
@@ -693,11 +693,11 @@ TFMInfo	*get_font_metrics(const char *short_name, int type, const char *filename
 		return NULL;
 	}
 	tfm->short_name = mdvi_strdup(short_name);
-	
+
 	/* add it to the pool */
 	if(tfmpool.count == 0)
 		mdvi_hash_create(&tfmhash, TFM_HASH_SIZE);
-	mdvi_hash_add(&tfmhash, MDVI_KEY(tfm->short_name), 
+	mdvi_hash_add(&tfmhash, MDVI_KEY(tfm->short_name),
 		tfm, MDVI_HASH_UNCHECKED);
 	listh_prepend(&tfmpool, LIST(tfm));
 	tfm->links = 1;
@@ -719,7 +719,7 @@ void	free_font_metrics(TFMInfo *info)
 	if(tfm == NULL)
 		return;
 	if(--tfm->links > 0) {
-		DEBUG((DBG_FONTS, "(mt) %s not removed, still in use\n",	
+		DEBUG((DBG_FONTS, "(mt) %s not removed, still in use\n",
 			tfm->short_name));
 		return;
 	}
@@ -729,16 +729,16 @@ void	free_font_metrics(TFMInfo *info)
 	listh_remove(&tfmpool, LIST(tfm));
 	mdvi_free(tfm->short_name);
 	mdvi_free(tfm->tfminfo.chars);
-	mdvi_free(tfm);	
+	mdvi_free(tfm);
 }
 
 void	flush_font_metrics(void)
 {
 	TFMPool	*ptr;
-	
+
 	for(; (ptr = (TFMPool *)tfmpool.head); ) {
 		tfmpool.head = LIST(ptr->next);
-		
+
 		mdvi_free(ptr->short_name);
 		mdvi_free(ptr->tfminfo.chars);
 		mdvi_free(ptr);
diff --git a/backend/dvi/mdvi-lib/tt.c b/backend/dvi/mdvi-lib/tt.c
index e85d8e70..28ce3204 100644
--- a/backend/dvi/mdvi-lib/tt.c
+++ b/backend/dvi/mdvi-lib/tt.c
@@ -51,7 +51,7 @@ static int tt_load_font __PROTO((DviParams *, DviFont *));
 static int tt_font_get_glyph __PROTO((DviParams *, DviFont *, int));
 static void tt_free_data __PROTO((DviFont *));
 static void tt_reset_font __PROTO((DviFont *));
-static void tt_shrink_glyph 
+static void tt_shrink_glyph
 	__PROTO((DviContext *, DviFont *, DviFontChar *, DviGlyph *));
 static void tt_font_remove __PROTO((FTInfo *));
 
@@ -97,14 +97,14 @@ static void tt_encode_font(DviFont *font, FTInfo *info)
 {
 	TT_Face_Properties prop;
 	int	i;
-	
+
 	if(TT_Get_Face_Properties(info->face, &prop))
 		return;
-	
+
 	for(i = 0; i < prop.num_Glyphs; i++) {
 		char	*string;
 		int	ndx;
-		
+
 		if(TT_Get_PS_Name(info->face, i, &string))
 			continue;
 		ndx = mdvi_encode_glyph(info->encoding, string);
@@ -127,9 +127,9 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 	TT_CharMap cmap;
 	TT_Face_Properties props;
 	int	map_found;
-			
+
 	DEBUG((DBG_TT, "(tt) really_load_font(%s)\n", info->fontname));
-	
+
 	/* get the point size */
 	point_size = (double)font->scale / (params->tfm_conv * 0x100000);
 	point_size = 72.0 * point_size / 72.27;
@@ -142,7 +142,7 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 		info->hasmetrics = 1;
 		return 0;
 	}
-	
+
 	/* load the face */
 	DEBUG((DBG_TT, "(tt) loading new face `%s'\n",
 		info->fontname));
@@ -152,11 +152,11 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 			info->fontname, TT_ErrToString18(status));
 		return -1;
 	}
-	
+
 	/* create a new instance of this face */
 	status = TT_New_Instance(info->face, &info->instance);
 	if(status) {
-		mdvi_warning(_("(tt) %s: could not create face: %s\n"), 
+		mdvi_warning(_("(tt) %s: could not create face: %s\n"),
 			info->fontname, TT_ErrToString18(status));
 		TT_Close_Face(info->face);
 		return -1;
@@ -165,12 +165,12 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 	/* create a glyph */
 	status = TT_New_Glyph(info->face, &info->glyph);
 	if(status) {
-		mdvi_warning(_("(tt) %s: could not create glyph: %s\n"), 
+		mdvi_warning(_("(tt) %s: could not create glyph: %s\n"),
 			info->fontname, TT_ErrToString18(status));
 		goto tt_error;
 	}
 
-	/* 
+	/*
 	 * We'll try to find a Unicode charmap. It's not that important that we
 	 * actually find one, especially if the fontmap files are installed
 	 * properly, but it's good to have some predefined behaviour
@@ -180,14 +180,14 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 	map_found = -1;
 	for(i = 0; map_found < 0 && i < props.num_CharMaps; i++) {
 		TT_UShort	pid, eid;
-		
+
 		TT_Get_CharMap_ID(info->face, i, &pid, &eid);
 		switch(pid) {
 		case TT_PLATFORM_APPLE_UNICODE:
 			map_found = i;
 			break;
 		case TT_PLATFORM_ISO:
-			if(eid == TT_ISO_ID_7BIT_ASCII || 
+			if(eid == TT_ISO_ID_7BIT_ASCII ||
 			   eid == TT_ISO_ID_8859_1)
 			   	map_found = 1;
 			break;
@@ -205,7 +205,7 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 	DEBUG((DBG_TT, "(tt) %s: using charmap #%d\n",
 		info->fontname, map_found));
 	TT_Get_CharMap(info->face, map_found, &cmap);
-		
+
 	DEBUG((DBG_TT, "(tt) %s: Set_Char_Size(%.2f, %d, %d)\n",
 		font->fontname, point_size, font->hdpi, font->vdpi));
 	status = TT_Set_Instance_Resolutions(info->instance,
@@ -215,7 +215,7 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 			info->fontname, TT_ErrToString18(status));
 		goto tt_error;
 	}
-	status = TT_Set_Instance_CharSize(info->instance, 
+	status = TT_Set_Instance_CharSize(info->instance,
 			FROUND(point_size * 64));
 	if(status) {
 		error(_("(tt) %s: could not set point size: %s\n"),
@@ -234,7 +234,7 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 
 	if(info->encoding != NULL) {
 		TT_Post	post;
-		
+
 		status = TT_Load_PS_Names(info->face, &post);
 		if(status) {
 			mdvi_warning(_("(tt) %s: could not load PS name table\n"),
@@ -245,7 +245,7 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 	}
 
 	/* get the metrics. If this fails, it's not fatal, but certainly bad */
-	info->tfminfo = get_font_metrics(info->fontname, 
+	info->tfminfo = get_font_metrics(info->fontname,
 		info->fmftype, info->fmfname);
 
 	if(info->tfminfo == NULL) {
@@ -269,7 +269,7 @@ static int tt_really_load_font(DviParams *params, DviFont *font, FTInfo *info)
 			font->chars[i - font->loc].code = TT_Char_Index(cmap, i);
 	}
 
-	info->loaded = 1;	
+	info->loaded = 1;
 	info->hasmetrics = 1;
 	return 0;
 
@@ -285,10 +285,10 @@ static int tt_load_font(DviParams *params, DviFont *font)
 {
 	int	i;
 	FTInfo	*info;
-	
+
 	if(!initialized && init_freetype() < 0)
 		return -1;
-	
+
 	if(font->in != NULL) {
 		fclose(font->in);
 		font->in = NULL;
@@ -297,7 +297,7 @@ static int tt_load_font(DviParams *params, DviFont *font)
 	info = xalloc(FTInfo);
 
 	memzero(info, sizeof(FTInfo));
-	info->fmftype    = DviFontAny; /* any metrics type will do */	
+	info->fmftype    = DviFontAny; /* any metrics type will do */
 	info->fmfname    = lookup_font_metrics(font->fontname, &info->fmftype);
 	info->fontname   = font->fontname;
 	info->hasmetrics = 0;
@@ -320,17 +320,17 @@ static int tt_load_font(DviParams *params, DviFont *font)
 		font->chars[i].shrunk.data = NULL;
 		font->chars[i].grey.data = NULL;
 	}
-	
+
 	if(info->fmfname == NULL)
 		mdvi_warning(_("(tt) %s: no font metric data\n"), font->fontname);
-	
+
 	listh_append(&ttfonts, LIST(info));
 	font->private = info;
 
 	return 0;
 }
 
-static int tt_get_bitmap(DviParams *params, DviFont *font, 
+static int tt_get_bitmap(DviParams *params, DviFont *font,
 	int code, double xscale, double yscale, DviGlyph *glyph)
 {
 	TT_Outline	outline;
@@ -379,18 +379,18 @@ static int tt_get_bitmap(DviParams *params, DviFont *font,
 	raster.size = h * raster.cols;
 	raster.flow = TT_Flow_Down;
 	raster.bitmap = mdvi_calloc(h, raster.cols);
-	
+
 	TT_Translate_Outline(&outline, -bbox.xMin, -bbox.yMin);
 	TT_Get_Outline_Bitmap(tt_handle, &outline, &raster);
 	glyph->data = bitmap_convert_msb8(raster.bitmap, w, h, ROUND(w, 8));
 	TT_Done_Outline(&outline);
 	mdvi_free(raster.bitmap);
-	
+
 	return 0;
 tt_error:
 	if(have_outline)
 		TT_Done_Outline(&outline);
-	return -1;	
+	return -1;
 }
 
 static int tt_font_get_glyph(DviParams *params, DviFont *font, int code)
@@ -400,7 +400,7 @@ static int tt_font_get_glyph(DviParams *params, DviFont *font, int code)
 	int	error;
 	double	xs, ys;
 	int	dpi;
-			
+
 	ASSERT(info != NULL);
 	if(!info->hasmetrics && tt_really_load_font(params, font, info) < 0)
 		return -1;
@@ -420,11 +420,11 @@ static int tt_font_get_glyph(DviParams *params, DviFont *font, int code)
 		(double)font->hdpi / dpi,
 		(double)font->vdpi / dpi,
 		&ch->glyph);
-	if(error)	
+	if(error)
 		goto missing;
 	ch->x = ch->glyph.x;
 	ch->y = ch->glyph.y;
-		
+
 	return 0;
 
 missing:
@@ -452,10 +452,10 @@ static void tt_shrink_glyph(DviContext *dvi, DviFont *font, DviFontChar *ch, Dvi
 static void tt_reset_font(DviFont *font)
 {
 	FTInfo	*info = (FTInfo *)font->private;
-	
+
 	if(info == NULL)
 		return;
-	info->hasmetrics = 0;	
+	info->hasmetrics = 0;
 }
 
 static void tt_font_remove(FTInfo *info)
@@ -483,7 +483,7 @@ static void tt_free_data(DviFont *font)
 {
 	if(font->private == NULL)
 		return;
-	
+
 	tt_font_remove((FTInfo *)font->private);
 	if(initialized && ttfonts.count == 0) {
 		DEBUG((DBG_TT, "(tt) last font removed -- closing FreeType\n"));
diff --git a/backend/dvi/mdvi-lib/util.c b/backend/dvi/mdvi-lib/util.c
index 349d273a..15b53f13 100644
--- a/backend/dvi/mdvi-lib/util.c
+++ b/backend/dvi/mdvi-lib/util.c
@@ -85,7 +85,7 @@ int mdvi_set_logstream(FILE *file)
 int mdvi_set_loglevel(int level)
 {
 	int	old = _mdvi_log_level;
-	
+
 	_mdvi_log_level = level;
 	return old;
 }
@@ -96,7 +96,7 @@ Uint32 _mdvi_debug_mask = 0;
 void	__debug(int mask, const char *format, ...)
 {
 	va_list	ap;
-	
+
 	va_start(ap, format);
 	if(_mdvi_debug_mask & mask) {
 		if(!DEBUGGING(SILENT)) {
@@ -118,7 +118,7 @@ void	__debug(int mask, const char *format, ...)
 void	mdvi_message(const char *format, ...)
 {
 	va_list	ap;
-	
+
 	va_start(ap, format);
 	if(_mdvi_log_level >= LOG_INFO) {
 		fprintf(stderr, "%s: ", program_name);
@@ -135,10 +135,10 @@ void	mdvi_message(const char *format, ...)
 void	mdvi_crash(const char *format, ...)
 {
 	va_list ap;
-	
+
 	va_start(ap, format);
-	fprintf(stderr, "%s: %s: ", 
-		program_name, 
+	fprintf(stderr, "%s: %s: ",
+		program_name,
 		gettext(messages[(int)time(NULL) % NMSGS]));
 	vfprintf(stderr, format, ap);
 #ifndef __GNUC__
@@ -154,7 +154,7 @@ void	mdvi_crash(const char *format, ...)
 void	mdvi_error(const char *format, ...)
 {
 	va_list	ap;
-	
+
 	va_start(ap, format);
 	fprintf(stderr, _("%s: Error: "), program_name);
 	vfprintf(stderr, format, ap);
@@ -170,7 +170,7 @@ void	mdvi_error(const char *format, ...)
 void	mdvi_warning(const char *format, ...)
 {
 	va_list	ap;
-	
+
 	va_start(ap, format);
 	fprintf(stderr, _("%s: Warning: "), program_name);
 	vfprintf(stderr, format, ap);
@@ -186,7 +186,7 @@ void	mdvi_warning(const char *format, ...)
 void	mdvi_fatal(const char *format, ...)
 {
 	va_list	ap;
-	
+
 	va_start(ap, format);
 	fprintf(stderr, _("%s: Fatal: "), program_name);
 	vfprintf(stderr, format, ap);
@@ -207,7 +207,7 @@ void	mdvi_fatal(const char *format, ...)
 void	*mdvi_malloc(size_t nelems)
 {
 	void	*ptr = malloc(nelems);
-	
+
 	if(ptr == NULL)
 		mdvi_fatal(_("out of memory allocating %u bytes\n"),
 			   (unsigned)nelems);
@@ -217,19 +217,19 @@ void	*mdvi_malloc(size_t nelems)
 void	*mdvi_realloc(void *data, size_t newsize)
 {
 	void	*ptr;
-	
+
 	if(newsize == 0)
 		mdvi_crash(_("attempted to reallocate with zero size\n"));
 	ptr = realloc(data, newsize);
 	if(ptr == NULL)
 		mdvi_fatal(_("failed to reallocate %u bytes\n"), (unsigned)newsize);
-	return ptr;	
+	return ptr;
 }
 
 void	*mdvi_calloc(size_t nmemb, size_t size)
 {
 	void	*ptr;
-	
+
 	if(nmemb == 0)
 		mdvi_crash(_("attempted to callocate 0 members\n"));
 	if(size == 0)
@@ -253,7 +253,7 @@ char	*mdvi_strdup(const char *string)
 {
 	int	length;
 	char	*ptr;
-	
+
 	length = strlen(string) + 1;
 	ptr = (char *)mdvi_malloc(length);
 	memcpy(ptr, string, length);
@@ -272,7 +272,7 @@ char	*mdvi_strndup(const char *string, size_t length)
 {
 	int	n;
 	char	*ptr;
-	
+
 	n = strlen(string);
 	if(n > length)
 		n = length;
@@ -284,7 +284,7 @@ char	*mdvi_strndup(const char *string, size_t length)
 void	*mdvi_memdup(const void *data, size_t length)
 {
 	void	*ptr = mdvi_malloc(length);
-	
+
 	memcpy(ptr, data, length);
 	return ptr;
 }
@@ -339,7 +339,7 @@ char   *mdvi_build_path_from_cwd (const char *path)
 	buf = mdvi_realloc (buf, strlen (buf) + strlen (path) + 2);
 	strcat (buf, "/");
 	strncat (buf, path, strlen (path));
-	
+
 	return buf;
 }
 
@@ -349,9 +349,9 @@ double	unit2pix_factor(const char *spec)
 	double	factor;
 	const char *p, *q;
 	static const char *units = "incmmmmtptpcddccspbpftydcs";
-	
+
 	val = 0.0;
-	
+
 	for(p = spec; *p >= '0' && *p <= '9'; p++)
 		val = 10.0 * val + (double)(*p - '0');
 	if(*p == '.') {
@@ -389,14 +389,14 @@ double	unit2pix_factor(const char *spec)
 int	unit2pix(int dpi, const char *spec)
 {
 	double	factor = unit2pix_factor(spec);
-	
+
 	return (int)(factor * dpi + 0.5);
 }
 
 Ulong	get_mtime(int fd)
 {
 	struct stat st;
-	
+
 	if(fstat(fd, &st) == 0)
 		return (Ulong)st.st_mtime;
 	return 0;
@@ -419,7 +419,7 @@ char	*getword(char *string, const char *delim, char **end)
 {
 	char *ptr;
 	char *word;
-	
+
 	/* skip leading delimiters */
 	for(ptr = string; *ptr && strchr(delim, *ptr); ptr++);
 
@@ -438,10 +438,10 @@ char	*getstring(char *string, const char *delim, char **end)
 	char *ptr;
 	char *word;
 	int	quoted = 0;
-	
+
 	/* skip leading delimiters */
 	for(ptr = string; *ptr && strchr(delim, *ptr); ptr++);
-	
+
 	if(ptr == NULL)
 		return NULL;
 	quoted = (*ptr == '"');
@@ -456,7 +456,7 @@ char	*getstring(char *string, const char *delim, char **end)
 static long pow2(size_t n)
 {
 	long	x = 8; /* don't bother allocating less than this */
-	
+
 	while(x < n)
 		x <<= 1L;
 	return x;
@@ -487,7 +487,7 @@ int	dstring_append(Dstring *dstr, const char *string, int len)
 		dstr->data = mdvi_malloc(8);
 		dstr->data[0] = 0;
 	}
-		
+
 	return dstr->length;
 }
 
diff --git a/backend/dvi/mdvi-lib/vf.c b/backend/dvi/mdvi-lib/vf.c
index a5ae3bbe..5fa5e451 100644
--- a/backend/dvi/mdvi-lib/vf.c
+++ b/backend/dvi/mdvi-lib/vf.c
@@ -68,11 +68,11 @@ static int vf_load_font(DviParams *params, DviFont *font)
 	int	nchars;
 	int	loc, hic;
 	DviFontRef *last;
-	
+
 	macros = NULL;
 	msize = mlen = 0;
 	p = font->in;
-	
+
 	if(fuget1(p) != 247 || fuget1(p) != 202)
 		goto badvf;
 	mlen = fuget1(p);
@@ -84,14 +84,14 @@ static int vf_load_font(DviParams *params, DviFont *font)
 	} else if(!font->checksum)
 		font->checksum = checksum;
 	font->design = fuget4(p);
-	
+
 	/* read all the fonts in the preamble */
 	last = NULL;
 
 	/* initialize alpha, beta and z for TFM width computation */
 	TFMPREPARE(font->scale, z, alpha, beta);
 
-	op = fuget1(p);	
+	op = fuget1(p);
 	while(op >= DVI_FNT_DEF1 && op <= DVI_FNT_DEF4) {
 		DviFontRef *ref;
 		Int32	scale, design;
@@ -101,9 +101,9 @@ static int vf_load_font(DviParams *params, DviFont *font)
 		int	hdpi;
 		int	vdpi;
 		char	*name;
-		
+
 		/* process fnt_def commands */
-		
+
 		id = fugetn(p, op - DVI_FNT_DEF1 + 1);
 		checksum = fuget4(p);
 		scale = fuget4(p);
@@ -121,13 +121,13 @@ static int vf_load_font(DviParams *params, DviFont *font)
 		fread(name, 1, n, p);
 		name[n] = 0;
 		DEBUG((DBG_FONTS, "(vf) %s: defined font `%s' at %.1fpt (%dx%d dpi)\n",
-			font->fontname, name, 
+			font->fontname, name,
 			(double)scale / (params->tfm_conv * 0x100000), hdpi, vdpi));
 
 		/* get the font */
 		ref = font_reference(params, id, name, checksum, hdpi, vdpi, scale);
 		if(ref == NULL) {
-			mdvi_error(_("(vf) %s: could not load font `%s'\n"), 
+			mdvi_error(_("(vf) %s: could not load font `%s'\n"),
 				   font->fontname, name);
 			goto error;
 		}
@@ -139,12 +139,12 @@ static int vf_load_font(DviParams *params, DviFont *font)
 		ref->next = NULL;
 		op = fuget1(p);
 	}
-	
+
 	if(op >= DVI_FNT_DEF1 && op <= DVI_FNT_DEF4)
 		goto error;
 
 	/* This function correctly reads both .vf and .ovf files */
-	
+
 	font->chars = xnalloc(DviFontChar, 256);
 	for(i = 0; i < 256; i++)
 		font->chars[i].offset = 0;
@@ -155,7 +155,7 @@ static int vf_load_font(DviParams *params, DviFont *font)
 		int	pl;
 		Int32	cc;
 		Int32	tfm;
-		
+
 		if(op == 242) {
 			pl = fuget4(p);
 			cc = fuget4(p);
@@ -176,7 +176,7 @@ static int vf_load_font(DviParams *params, DviFont *font)
 		if(hic < 0 || cc > hic)
 			hic = cc;
 		if(cc >= nchars) {
-			font->chars = xresize(font->chars, 
+			font->chars = xresize(font->chars,
 				DviFontChar, cc + 16);
 			for(i = nchars; i < cc + 16; i++)
 				font->chars[i].offset = 0;
@@ -187,7 +187,7 @@ static int vf_load_font(DviParams *params, DviFont *font)
 				   font->fontname, cc);
 			goto error;
 		}
-				
+
 		DEBUG((DBG_GLYPHS, "(vf) %s: defined character %d (macro length %d)\n",
 			font->fontname, cc, pl));
 		font->chars[cc].width = pl + 1;
@@ -215,8 +215,8 @@ static int vf_load_font(DviParams *params, DviFont *font)
 		macros = xresize(macros, Uchar, mlen);
 		msize = mlen;
 	}
-	
-	DEBUG((DBG_FONTS|DBG_GLYPHS, 
+
+	DEBUG((DBG_FONTS|DBG_GLYPHS,
 		"(vf) %s: macros use %d bytes\n", font->fontname, msize));
 
 	if(loc > 0 || hic < nchars-1) {
@@ -230,7 +230,7 @@ static int vf_load_font(DviParams *params, DviFont *font)
 	font->private = macros;
 
 	return 0;
-	
+
 badvf:
 	mdvi_error(_("%s: File corrupted, or not a VF file.\n"), font->fontname);
 error:
@@ -243,5 +243,5 @@ error:
 
 static void vf_free_macros(DviFont *font)
 {
-	mdvi_free(font->private);	
+	mdvi_free(font->private);
 }