Remove trailing whitespaces

1 files changed, 247 insertions, 247 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 */