diff options
Diffstat (limited to 'backend/dvi/mdvi-lib/afmparse.c')
| -rw-r--r-- | backend/dvi/mdvi-lib/afmparse.c | 494 |
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 */ |