/*
* (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,
* 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,
* FITNESS FOR PARTICULAR PURPOSES AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
* ************************************************************************
*/
/*
* Changes made for OpenOffice.org
*
* 10/24/2000 pl - changed code to compile with c++-compilers
* - added namespace to avoid symbol clashes
* - replaced BOOL by bool
* - added function to free space allocated by parseFile
* 10/26/2000 pl - added additional keys
* - added ability to parse slightly broken files
* - added charwidth member to GlobalFontInfo
* 04/26/2001 pl - added OpenOffice header
* 10/19/2005 pl - performance increase:
* - fread file in one pass
* - replace file io by buffer access
* 10/20/2005 pl - performance increase:
* - use one table lookup in token() routine
* instead of many conditions
* - return token length in toke() routine
* - use hash lookup instead of binary search
* in recognize() routine
*/
/*************************************************************************
*
* $RCSfile: parseAFM.cxx,v $
*
* $Revision: 1.11 $
*
* last change: $Author: rt $ $Date: 2008-01-29 16:08:31 $
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_psprint.hxx"
/* 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
* AFM file, or an application developer may wish to customize this
* code.
*
* There is also a file, parseAFMclient.c, that is a sample application
* showing how to call the "parseFile" procedure and how to use the data
* after "parseFile" has returned.
*
* Please read the comments in parseAFM.h and parseAFMclient.c.
*
* History:
* original: DSM Thu Oct 20 17:39:59 PDT 1988
* modified: DSM Mon Jul 3 14:17:50 PDT 1989
* - added 'storageProblem' return code
* - fixed bug of not allocating extra byte for string duplication
* - fixed typos
* modified: DSM Tue Apr 3 11:18:34 PDT 1990
* - added free(ident) at end of parseFile routine
* modified: DSM Tue Jun 19 10:16:29 PDT 1990
* - changed (width == 250) to (width = 250) in initializeArray
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <math.h>
#include <parseAFM.hxx>
#include <psprint/strhelper.hxx>
#include <rtl/alloc.h>
#define lineterm EOL /* line terminating character */
#define normalEOF 1 /* return code from parsing routines used only */
/* in this module */
#define Space "space" /* used in string comparison to look for the width */
/* of the space character to init the widths array */
#define False "false" /* used in string comparison to check the value of */
/* boolean keys (e.g. IsFixedPitch) */
#define MATCH(A,B) (strncmp((A),(B), MAX_NAME) == 0)
namespace psp {
class FileInputStream
{
char* m_pMemory;
unsigned int m_nPos;
unsigned int m_nLen;
public:
FileInputStream( const char* pFilename );
~FileInputStream();
int getChar() { return (m_nPos < m_nLen) ? int(m_pMemory[m_nPos++]) : -1; }
void ungetChar()
{
if( m_nPos > 0 )
m_nPos--;
}
unsigned int tell() const { return m_nPos; }
void seek( unsigned int nPos )
// NOTE: do not check input data since only results of tell()
// get seek()ed in this file
{ m_nPos = nPos; }
};
FileInputStream::FileInputStream( const char* pFilename ) :
m_pMemory( NULL ),
m_nPos( 0 ),
m_nLen( 0 )
{
struct stat aStat;
if( ! stat( pFilename, &aStat ) &&
S_ISREG( aStat.st_mode ) &&
aStat.st_size > 0
)
{
FILE* fp = fopen( pFilename, "r" );
if( fp )
{
m_pMemory = (char*)rtl_allocateMemory( aStat.st_size );
m_nLen = (unsigned int)fread( m_pMemory, 1, aStat.st_size, fp );
fclose( fp );
}
}
}
FileInputStream::~FileInputStream()
{
rtl_freeMemory( m_pMemory );
}
/*************************** GLOBALS ***********************/
/* "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
* 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
* "recognize" procedure to calculate how many possible keys there are.
*/
// some metrics have Ascent, Descent instead Ascender, Descender or Em
// which is not allowed per afm spcification, but let us handle
// this gently
enum parseKey {
ASCENDER, ASCENT, CHARBBOX, CODE, COMPCHAR, CODEHEX, CAPHEIGHT, CHARWIDTH, CHARACTERSET, CHARACTERS, COMMENT,
DESCENDER, DESCENT, EM, ENCODINGSCHEME, ENDCHARMETRICS, ENDCOMPOSITES, ENDDIRECTION,
ENDFONTMETRICS, ENDKERNDATA, ENDKERNPAIRS, ENDTRACKKERN,
FAMILYNAME, FONTBBOX, FONTNAME, FULLNAME, ISBASEFONT, ISFIXEDPITCH,
ITALICANGLE, KERNPAIR, KERNPAIRXAMT, LIGATURE, MAPPINGSCHEME, METRICSSETS, CHARNAME,
NOTICE, COMPCHARPIECE, STARTCHARMETRICS, STARTCOMPOSITES, STARTDIRECTION,
STARTFONTMETRICS, STARTKERNDATA, STARTKERNPAIRS,
STARTTRACKKERN, STDHW, STDVW, TRACKKERN, UNDERLINEPOSITION,
UNDERLINETHICKNESS, VVECTOR, VERSION, XYWIDTH, X0WIDTH, XWIDTH, WEIGHT, XHEIGHT,
NOPE
};
/*************************** 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
* reads all tokens until the next end-of-line.
*/
// token white space is ' ', '\n', '\r', ',', '\t', ';'
static const bool is_white_Array[ 256 ] =
{ false, false, false, false, false, false, false, false, // 0-7
false, true, true, false, false, true, false, false, // 8-15
false, false, false, false, false, false, false, false, // 16-23
false, false, false, false, false, false, false, false, // 24-31
true, false, false, false, false, false, false, false, // 32-39
false, false, false, false, true, false, false, false, // 40-47
false, false, false, false, false, false, false, false, // 48-55
false, false, false, true, false, false, false, false, // 56-63
false, false, false, false, false, false, false, false, // 64 -
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, // 127
false, false, false, false, false, false, false, false, // 128 -
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, // 191
false, false, false, false, false, false, false, false, // 192 -
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, // 255
};
// token delimiters are ' ', '\n', '\r', '\t', ':', ';'
static const bool is_delimiter_Array[ 256 ] =
{ false, false, false, false, false, false, false, false, // 0-7
false, true, true, false, false, true, false, false, // 8-15
false, false, false, false, false, false, false, false, // 16-23
false, false, false, false, false, false, false, false, // 24-31
true, false, false, false, false, false, false, false, // 32-39
false, false, false, false, false, false, false, false, // 40-47
false, false, false, false, false, false, false, false, // 48-55
false, false, true, true, false, false, false, false, // 56-63
false, false, false, false, false, false, false, false, // 64 -
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, // 127
false, false, false, false, false, false, false, false, // 128 -
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, // 191
false, false, false, false, false, false, false, false, // 192 -
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, // 255
};
static char *token( FileInputStream* stream, int& rLen )
{
static char ident[MAX_NAME]; /* storage buffer for keywords */
int ch, idx;
/* skip over white space */
// relies on EOF = -1
while( is_white_Array[ (ch = stream->getChar()) & 255 ] )
;
idx = 0;
while( ch != -1 && ! is_delimiter_Array[ ch & 255 ] && idx < MAX_NAME-1 )
{
ident[idx++] = ch;
ch = stream->getChar();
}
if (ch == -1 && idx < 1) return ((char *)NULL);
if (idx >= 1 && ch != ':' && ch != -1) stream->ungetChar();
if (idx < 1 ) ident[idx++] = ch; /* single-character token */
ident[idx] = 0;
rLen = idx;
return(ident); /* returns pointer to the token */
} /* token */
/*************************** linetoken *************************/
/* "linetoken" will get read all tokens until the EOL character from
* the given stream. This is used to get any arguments that can be
* more than one word (like Comment lines and FullName).
*/
static char *linetoken( FileInputStream* stream )
{
static char ident[MAX_NAME]; /* storage buffer for keywords */
int ch, idx;
while ((ch = stream->getChar()) == ' ' || ch == '\t' );
idx = 0;
while (ch != -1 && ch != lineterm && ch != '\r' && idx < MAX_NAME-1 )
{
ident[idx++] = ch;
ch = stream->getChar();
} /* while */
stream->ungetChar();
ident[idx] = 0;
return(ident); /* returns pointer to the token */
} /* linetoken */
/*************************** recognize *************************/
/* This function tries to match a string to a known list of
* valid AFM entries (check the keyStrings array above).
* "ident" contains everything from white space through the
* next space, tab, or ":" character.
*
* The algorithm is a standard Knuth binary search.
*/
#include "afm_hash.cpp"
static inline enum parseKey recognize( register char* ident, int len)
{
const hash_entry* pEntry = AfmKeywordHash::in_word_set( ident, len );
return pEntry ? pEntry->eKey : NOPE;
} /* recognize */
/************************* parseGlobals *****************************/
/* 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.
*
* 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
* data structure.
*
* 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
* parseFile to determine if there is more file to parse.
*/
static int parseGlobals( FileInputStream* fp, register GlobalFontInfo* gfi )
{
bool cont = true, save = (gfi != NULL);
int error = ok;
register char *keyword;
int direction = -1;
int tokenlen;
while (cont)
{
keyword = token(fp, tokenlen);
if (keyword == NULL)
/* Have reached an early and unexpected EOF. */
/* Set flag and stop parsing */
{
error = earlyEOF;
break; /* get out of loop */
}
if (!save)
/* get tokens until the end of the Global Font info section */
/* without saving any of the data */
switch (recognize(keyword, tokenlen))
{
case STARTCHARMETRICS:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
default:
break;
} /* switch */
else
/* otherwise parse entire global font info section, */
/* saving the data */
switch(recognize(keyword, tokenlen))
{
case STARTFONTMETRICS:
keyword = token(fp,tokenlen);
gfi->afmVersion = strdup( keyword );
break;
case COMMENT:
keyword = linetoken(fp);
break;
case FONTNAME:
keyword = token(fp, tokenlen);
gfi->fontName = strdup( keyword );
break;
case ENCODINGSCHEME:
keyword = token(fp, tokenlen);
gfi->encodingScheme = strdup( keyword );
break;
case FULLNAME:
keyword = linetoken(fp);
gfi->fullName = strdup( keyword );
break;
case FAMILYNAME:
keyword = linetoken(fp);
gfi->familyName = strdup( keyword );
break;
case WEIGHT:
keyword = token(fp, tokenlen);
gfi->weight = strdup( keyword );
break;
case ITALICANGLE:
keyword = token(fp,tokenlen);
gfi->italicAngle = StringToDouble( keyword );
break;
case ISFIXEDPITCH:
keyword = token(fp,tokenlen);
if (MATCH(keyword, False))
gfi->isFixedPitch = 0;
else
gfi->isFixedPitch = 1;
break;
case UNDERLINEPOSITION:
keyword = token(fp,tokenlen);
gfi->underlinePosition = atoi(keyword);
break;
case UNDERLINETHICKNESS:
keyword = token(fp,tokenlen);
gfi->underlineThickness = atoi(keyword);
break;
case VERSION:
keyword = token(fp,tokenlen);
gfi->version = strdup( keyword );
break;
case NOTICE:
keyword = linetoken(fp);
gfi->notice = strdup( keyword );
break;
case FONTBBOX:
keyword = token(fp,tokenlen);
gfi->fontBBox.llx = atoi(keyword);
keyword = token(fp,tokenlen);
gfi->fontBBox.lly = atoi(keyword);
keyword = token(fp,tokenlen);
gfi->fontBBox.urx = atoi(keyword);
keyword = token(fp,tokenlen);
gfi->fontBBox.ury = atoi(keyword);
break;
case CAPHEIGHT:
keyword = token(fp,tokenlen);
gfi->capHeight = atoi(keyword);
break;
case XHEIGHT:
keyword = token(fp,tokenlen);
gfi->xHeight = atoi(keyword);
break;
case DESCENT:
keyword = token(fp,tokenlen);
gfi->descender = -atoi(keyword);
break;
case DESCENDER:
keyword = token(fp,tokenlen);
gfi->descender = atoi(keyword);
break;
case ASCENT:
case ASCENDER:
keyword = token(fp,tokenlen);
gfi->ascender = atoi(keyword);
break;
case STARTCHARMETRICS:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
case EM:
// skip one token
keyword = token(fp,tokenlen);
break;
case STARTDIRECTION:
keyword = token(fp,tokenlen);
direction = atoi(keyword);
break; /* ignore this for now */
case ENDDIRECTION:
break; /* ignore this for now */
case MAPPINGSCHEME:
keyword = token(fp,tokenlen);
break; /* ignore this for now */
case CHARACTERS:
keyword = token(fp,tokenlen);
break; /* ignore this for now */
case ISBASEFONT:
keyword = token(fp,tokenlen);
break; /* ignore this for now */
case CHARACTERSET:
keyword=token(fp,tokenlen); //ignore
break;
case STDHW:
keyword=token(fp,tokenlen); //ignore
break;
case STDVW:
keyword=token(fp,tokenlen); //ignore
break;
case CHARWIDTH:
keyword = token(fp,tokenlen);
if (direction == 0)
gfi->charwidth = atoi(keyword);
keyword = token(fp,tokenlen);
/* ignore y-width for now */
break;
case METRICSSETS:
keyword = token(fp,tokenlen);
break; /* ignore this for now */
case NOPE:
default:
error = parseError;
break;
} /* switch */
} /* while */
return(error);
} /* parseGlobals */
#if 0
/************************* initializeArray ************************/
/* 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
* 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.
*
* Before returning, the position of the read/write pointer of the
* FileInputStream is reset to be where it was upon entering this function.
*/
static int initializeArray( FileInputStream* fp, register int* cwi)
{
bool cont = true, found = false;
unsigned int opos = fp->tell();
int code = 0, width = 0, i = 0, error = 0, tokenlen;
register char *keyword;
while (cont)
{
keyword = token(fp,tokenlen);
if (keyword == NULL)
{
error = earlyEOF;
break; /* get out of loop */
}
switch(recognize(keyword,tokenlen))
{
case COMMENT:
keyword = linetoken(fp);
break;
case CODE:
code = atoi(token(fp,tokenlen));
break;
case CODEHEX:
sscanf(token(fp,tokenlen),"<%x>", &code);
break;
case XWIDTH:
width = atoi(token(fp,tokenlen));
break;
case X0WIDTH:
(void) token(fp,tokenlen);
break;
case CHARNAME:
keyword = token(fp,tokenlen);
if (MATCH(keyword, Space))
{
cont = false;
found = true;
}
break;
case ENDCHARMETRICS:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
case NOPE:
default:
error = parseError;
break;
} /* switch */
} /* while */
if (!found)
width = 250;
for (i = 0; i < 256; ++i)
cwi[i] = width;
fp->seek(opos);
return(error);
} /* initializeArray */
#endif
/************************* parseCharWidths **************************/
/* This function is called by "parseFile". It will parse the AFM file
* 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
* 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
* parseFile to determine if there is more file to parse.
*/
static int parseCharWidths( FileInputStream* fp, register int* cwi)
{
bool cont = true, save = (cwi != NULL);
int pos = 0, error = ok, tokenlen;
register char *keyword;
while (cont)
{
keyword = token(fp,tokenlen);
/* Have reached an early and unexpected EOF. */
/* Set flag and stop parsing */
if (keyword == NULL)
{
error = earlyEOF;
break; /* get out of loop */
}
if (!save)
/* get tokens until the end of the Char Metrics section without */
/* saving any of the data*/
switch (recognize(keyword,tokenlen))
{
case ENDCHARMETRICS:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
default:
break;
} /* switch */
else
/* otherwise parse entire char metrics section, saving */
/* only the char x-width info */
switch(recognize(keyword,tokenlen))
{
case COMMENT:
keyword = linetoken(fp);
break;
case CODE:
keyword = token(fp,tokenlen);
pos = atoi(keyword);
break;
case XYWIDTH:
/* PROBLEM: Should be no Y-WIDTH when doing "quick & dirty" */
keyword = token(fp,tokenlen); keyword = token(fp,tokenlen); /* eat values */
error = parseError;
break;
case CODEHEX:
keyword = token(fp,tokenlen);
sscanf(keyword, "<%x>", &pos);
break;
case X0WIDTH:
(void) token(fp,tokenlen);
break;
case XWIDTH:
keyword = token(fp,tokenlen);
if (pos >= 0) /* ignore unmapped chars */
cwi[pos] = atoi(keyword);
break;
case ENDCHARMETRICS:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
case CHARNAME: /* eat values (so doesn't cause parseError) */
keyword = token(fp,tokenlen);
break;
case CHARBBOX:
keyword = token(fp,tokenlen); keyword = token(fp,tokenlen);
keyword = token(fp,tokenlen); keyword = token(fp,tokenlen);
break;
case LIGATURE:
keyword = token(fp,tokenlen); keyword = token(fp,tokenlen);
break;
case VVECTOR:
keyword = token(fp,tokenlen);
keyword = token(fp,tokenlen);
break;
case NOPE:
default:
error = parseError;
break;
} /* switch */
} /* while */
return(error);
} /* parseCharWidths */
/*
* number of char metrics is almost allways inaccurate, so be gentle and try to
* adapt our internal storage by adjusting the allocated list
*/
static int
reallocFontMetrics( void **pp_fontmetrics, int *p_oldcount, int n_newcount, unsigned int n_size )
{
char *p_tmpmetrics = NULL;
if ((pp_fontmetrics == NULL) || (*pp_fontmetrics == NULL))
return storageProblem;
if (*p_oldcount == n_newcount)
return ok;
p_tmpmetrics = (char*)realloc(*pp_fontmetrics, n_newcount * n_size);
if (p_tmpmetrics == NULL)
return storageProblem;
if ( n_newcount > *p_oldcount )
{
char *p_inimetrics = p_tmpmetrics + n_size * *p_oldcount;
int n_inimetrics = n_size * (n_newcount - *p_oldcount);
memset( p_inimetrics, 0, n_inimetrics );
}
*pp_fontmetrics = p_tmpmetrics;
*p_oldcount = n_newcount;
return ok;
}
static unsigned int
enlargeCount( unsigned int n_oldcount )
{
unsigned int n_newcount = n_oldcount + n_oldcount / 5;
if (n_oldcount == n_newcount )
n_newcount = n_oldcount + 5;
return n_newcount;
}
/************************* parseCharMetrics ************************/
/* This function is called by parseFile if the caller of parseFile
* requested that all character metric information be saved
* (as opposed to only the character width information).
*
* 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)
* 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
* parseFile to determine if there is more file to parse.
*/
static int parseCharMetrics( FileInputStream* fp, register FontInfo* fi)
{
bool cont = true, firstTime = true;
int error = ok, count = 0, tokenlen;
register CharMetricInfo *temp = fi->cmi;
register char *keyword;
while (cont)
{
keyword = token(fp,tokenlen);
if (keyword == NULL)
{
error = earlyEOF;
break; /* get out of loop */
}
switch(recognize(keyword,tokenlen))
{
case COMMENT:
keyword = linetoken(fp);
break;
case CODE:
if (!(count < fi->numOfChars))
{
reallocFontMetrics( (void**)&(fi->cmi),
&(fi->numOfChars), enlargeCount(fi->numOfChars),
sizeof(CharMetricInfo) );
temp = &(fi->cmi[ count - 1 ]);
}
if (count < fi->numOfChars)
{
if (firstTime) firstTime = false;
else temp++;
temp->code = atoi(token(fp,tokenlen));
if (fi->gfi && fi->gfi->charwidth)
temp->wx = fi->gfi->charwidth;
count++;
}
else
{
error = parseError;
cont = false;
}
break;
case CODEHEX:
if (!(count < fi->numOfChars ))
{
reallocFontMetrics( (void**)&(fi->cmi),
&(fi->numOfChars), enlargeCount(fi->numOfChars),
sizeof(CharMetricInfo) );
temp = &(fi->cmi[ count - 1 ]);
}
if (count < fi->numOfChars) {
if (firstTime)
firstTime = false;
else
temp++;
sscanf(token(fp,tokenlen),"<%x>", &temp->code);
if (fi->gfi && fi->gfi->charwidth)
temp->wx = fi->gfi->charwidth;
count++;
}
else {
error = parseError;
cont = false;
}
break;
case XYWIDTH:
temp->wx = atoi(token(fp,tokenlen));
temp->wy = atoi(token(fp,tokenlen));
break;
case X0WIDTH:
temp->wx = atoi(token(fp,tokenlen));
break;
case XWIDTH:
temp->wx = atoi(token(fp,tokenlen));
break;
case CHARNAME:
keyword = token(fp,tokenlen);
temp->name = (char *)strdup(keyword);
break;
case CHARBBOX:
temp->charBBox.llx = atoi(token(fp,tokenlen));
temp->charBBox.lly = atoi(token(fp,tokenlen));
temp->charBBox.urx = atoi(token(fp,tokenlen));
temp->charBBox.ury = atoi(token(fp,tokenlen));
break;
case LIGATURE: {
Ligature **tail = &(temp->ligs);
Ligature *node = *tail;
if (*tail != NULL)
{
while (node->next != NULL)
node = node->next;
tail = &(node->next);
}
*tail = (Ligature *) calloc(1, sizeof(Ligature));
keyword = token(fp,tokenlen);
(*tail)->succ = (char *)strdup(keyword);
keyword = token(fp,tokenlen);
(*tail)->lig = (char *)strdup(keyword);
break; }
case ENDCHARMETRICS:
cont = false;;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
case VVECTOR:
keyword = token(fp,tokenlen);
keyword = token(fp,tokenlen);
break;
case NOPE:
default:
error = parseError;
break;
} /* switch */
} /* while */
if ((error == ok) && (count != fi->numOfChars))
error = reallocFontMetrics( (void**)&(fi->cmi), &(fi->numOfChars),
count, sizeof(CharMetricInfo) );
if ((error == ok) && (count != fi->numOfChars))
error = parseError;
return(error);
} /* parseCharMetrics */
/************************* parseTrackKernData ***********************/
/* 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
* 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
* parseFile to determine if there is more file to parse.
*/
static int parseTrackKernData( FileInputStream* fp, register FontInfo* fi)
{
bool cont = true, save = (fi->tkd != NULL);
int pos = 0, error = ok, tcount = 0, tokenlen;
register char *keyword;
while (cont)
{
keyword = token(fp,tokenlen);
if (keyword == NULL)
{
error = earlyEOF;
break; /* get out of loop */
}
if (!save)
/* get tokens until the end of the Track Kerning Data */
/* section without saving any of the data */
switch(recognize(keyword,tokenlen))
{
case ENDTRACKKERN:
case ENDKERNDATA:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
default:
break;
} /* switch */
else
/* otherwise parse entire Track Kerning Data section, */
/* saving the data */
switch(recognize(keyword,tokenlen))
{
case COMMENT:
keyword = linetoken(fp);
break;
case TRACKKERN:
if (!(tcount < fi->numOfTracks))
{
reallocFontMetrics( (void**)&(fi->tkd), &(fi->numOfTracks),
enlargeCount(fi->numOfTracks), sizeof(TrackKernData) );
}
if (tcount < fi->numOfTracks)
{
keyword = token(fp,tokenlen);
fi->tkd[pos].degree = atoi(keyword);
keyword = token(fp,tokenlen);
fi->tkd[pos].minPtSize = StringToDouble(keyword);
keyword = token(fp,tokenlen);
fi->tkd[pos].minKernAmt = StringToDouble(keyword);
keyword = token(fp,tokenlen);
fi->tkd[pos].maxPtSize = StringToDouble(keyword);
keyword = token(fp,tokenlen);
fi->tkd[pos++].maxKernAmt = StringToDouble(keyword);
tcount++;
}
else
{
error = parseError;
cont = false;
}
break;
case ENDTRACKKERN:
case ENDKERNDATA:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
case NOPE:
default:
error = parseError;
break;
} /* switch */
} /* while */
if (error == ok && tcount != fi->numOfTracks)
error = reallocFontMetrics( (void**)&(fi->tkd), &(fi->numOfTracks),
tcount, sizeof(TrackKernData) );
if (error == ok && tcount != fi->numOfTracks)
error = parseError;
return(error);
} /* parseTrackKernData */
/************************* parsePairKernData ************************/
/* 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
* 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
* parseFile to determine if there is more file to parse.
*/
static int parsePairKernData( FileInputStream* fp, register FontInfo* fi)
{
bool cont = true, save = (fi->pkd != NULL);
int pos = 0, error = ok, pcount = 0, tokenlen;
register char *keyword;
while (cont)
{
keyword = token(fp,tokenlen);
if (keyword == NULL)
{
error = earlyEOF;
break; /* get out of loop */
}
if (!save)
/* get tokens until the end of the Pair Kerning Data */
/* section without saving any of the data */
switch(recognize(keyword,tokenlen))
{
case ENDKERNPAIRS:
case ENDKERNDATA:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
default:
break;
} /* switch */
else
/* otherwise parse entire Pair Kerning Data section, */
/* saving the data */
switch(recognize(keyword,tokenlen))
{
case COMMENT:
keyword = linetoken(fp);
break;
case KERNPAIR:
if (!(pcount < fi->numOfPairs))
{
reallocFontMetrics( (void**)&(fi->pkd), &(fi->numOfPairs),
enlargeCount(fi->numOfPairs), sizeof(PairKernData) );
}
if (pcount < fi->numOfPairs)
{
keyword = token(fp,tokenlen);
fi->pkd[pos].name1 = strdup( keyword );
keyword = token(fp,tokenlen);
fi->pkd[pos].name2 = strdup( keyword );
keyword = token(fp,tokenlen);
fi->pkd[pos].xamt = atoi(keyword);
keyword = token(fp,tokenlen);
fi->pkd[pos++].yamt = atoi(keyword);
pcount++;
}
else
{
error = parseError;
cont = false;
}
break;
case KERNPAIRXAMT:
if (!(pcount < fi->numOfPairs))
{
reallocFontMetrics( (void**)&(fi->pkd), &(fi->numOfPairs),
enlargeCount(fi->numOfPairs), sizeof(PairKernData) );
}
if (pcount < fi->numOfPairs)
{
keyword = token(fp,tokenlen);
fi->pkd[pos].name1 = strdup( keyword );
keyword = token(fp,tokenlen);
fi->pkd[pos].name2 = strdup( keyword );
keyword = token(fp,tokenlen);
fi->pkd[pos++].xamt = atoi(keyword);
pcount++;
}
else
{
error = parseError;
cont = false;
}
break;
case ENDKERNPAIRS:
case ENDKERNDATA:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
case NOPE:
default:
error = parseError;
break;
} /* switch */
} /* while */
if ((error == ok) && (pcount != fi->numOfPairs))
error = reallocFontMetrics( (void**)&(fi->pkd), &(fi->numOfPairs),
pcount, sizeof(PairKernData) );
if (error == ok && pcount != fi->numOfPairs)
error = parseError;
return(error);
} /* parsePairKernData */
/************************* parseCompCharData **************************/
/* 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
* 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
* parseFile to determine if there is more file to parse.
*/
static int parseCompCharData( FileInputStream* fp, register FontInfo* fi)
{
bool cont = true, firstTime = true, save = (fi->ccd != NULL);
int pos = 0, j = 0, error = ok, ccount = 0, pcount = 0, tokenlen;
register char *keyword;
while (cont)
{
keyword = token(fp,tokenlen);
if (keyword == NULL)
/* Have reached an early and unexpected EOF. */
/* Set flag and stop parsing */
{
error = earlyEOF;
break; /* get out of loop */
}
if (ccount > fi->numOfComps)
{
reallocFontMetrics( (void**)&(fi->ccd), &(fi->numOfComps),
enlargeCount(fi->numOfComps), sizeof(CompCharData) );
}
if (ccount > fi->numOfComps)
{
error = parseError;
break; /* get out of loop */
}
if (!save)
/* get tokens until the end of the Composite Character info */
/* section without saving any of the data */
switch(recognize(keyword,tokenlen))
{
case ENDCOMPOSITES:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
case COMMENT:
case COMPCHAR:
keyword = linetoken(fp);
break;
default:
break;
} /* switch */
else
/* otherwise parse entire Composite Character info section, */
/* saving the data */
switch(recognize(keyword,tokenlen))
{
case COMMENT:
keyword = linetoken(fp);
break;
case COMPCHAR:
if (!(ccount < fi->numOfComps))
{
reallocFontMetrics( (void**)&(fi->ccd), &(fi->numOfComps),
enlargeCount(fi->numOfComps), sizeof(CompCharData) );
}
if (ccount < fi->numOfComps)
{
keyword = token(fp,tokenlen);
if (pcount != fi->ccd[pos].numOfPieces)
error = parseError;
pcount = 0;
if (firstTime) firstTime = false;
else pos++;
fi->ccd[pos].ccName = strdup( keyword );
keyword = token(fp,tokenlen);
fi->ccd[pos].numOfPieces = atoi(keyword);
fi->ccd[pos].pieces = (Pcc *)
calloc(fi->ccd[pos].numOfPieces, sizeof(Pcc));
j = 0;
ccount++;
}
else
{
error = parseError;
cont = false;
}
break;
case COMPCHARPIECE:
if (pcount < fi->ccd[pos].numOfPieces)
{
keyword = token(fp,tokenlen);
fi->ccd[pos].pieces[j].pccName = strdup( keyword );
keyword = token(fp,tokenlen);
fi->ccd[pos].pieces[j].deltax = atoi(keyword);
keyword = token(fp,tokenlen);
fi->ccd[pos].pieces[j++].deltay = atoi(keyword);
pcount++;
}
else
error = parseError;
break;
case ENDCOMPOSITES:
cont = false;
break;
case ENDFONTMETRICS:
cont = false;
error = normalEOF;
break;
case NOPE:
default:
error = parseError;
break;
} /* switch */
} /* while */
if (error == ok && ccount != fi->numOfComps)
reallocFontMetrics( (void**)&(fi->ccd), &(fi->numOfComps),
ccount, sizeof(CompCharData) );
if (error == ok && ccount != fi->numOfComps)
error = parseError;
return(error);
} /* parseCompCharData */
/*************************** 'PUBLIC' FUNCTION ********************/
/*************************** parseFile *****************************/
/* 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.
*
* parseFile expects 3 parameters: a filename pointer, a pointer
* to a (FontInfo *) variable (for which storage will be allocated and
* 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
* a record of type FontInfo (refer to ParseAFM.h).
*
* parseFile returns an error code as defined in parseAFM.h.
*
* The position of the read/write pointer associated with the file
* pointer upon return of this function is undefined.
*/
int parseFile( const char* pFilename, FontInfo** fi, FLAGS flags)
{
FileInputStream aFile( pFilename );
int code = ok; /* return code from each of the parsing routines */
int error = ok; /* used as the return code from this function */
int tokenlen;
register char *keyword; /* used to store a token */
(*fi) = (FontInfo *) calloc(1, sizeof(FontInfo));
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);}
}
/* The AFM file begins with Global Font Information. This section */
/* will be parsed whether or not information should be saved. */
code = parseGlobals(&aFile, (*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 */
/* is wanted, parseCharMetrics is called. If only the character widths */
/* 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(&aFile,tokenlen));
if (flags & (P_M ^ P_W))
{
(*fi)->cmi = (CharMetricInfo *)
calloc((*fi)->numOfChars, sizeof(CharMetricInfo));
if ((*fi)->cmi == NULL) {error = storageProblem; return(error);}
code = parseCharMetrics(&aFile, *fi);
}
else
{
if (flags & P_W)
{
(*fi)->cwi = (int *) calloc(256, sizeof(int));
if ((*fi)->cwi == NULL)
{
error = storageProblem;
return(error);
}
}
/* parse section regardless */
code = parseCharWidths(&aFile, (*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(&aFile,tokenlen);
if (keyword == NULL)
/* Have reached an early and unexpected EOF. */
/* Set flag and stop parsing */
{
code = earlyEOF;
break; /* get out of loop */
}
switch(recognize(keyword,tokenlen))
{
case STARTKERNDATA:
break;
case ENDKERNDATA:
break;
case STARTTRACKKERN:
keyword = token(&aFile,tokenlen);
if (flags & P_T)
{
(*fi)->numOfTracks = atoi(keyword);
(*fi)->tkd = (TrackKernData *)
calloc((*fi)->numOfTracks, sizeof(TrackKernData));
if ((*fi)->tkd == NULL)
{
error = storageProblem;
return(error);
}
} /* if */
code = parseTrackKernData(&aFile, *fi);
break;
case STARTKERNPAIRS:
keyword = token(&aFile,tokenlen);
if (flags & P_P)
{
(*fi)->numOfPairs = atoi(keyword);
(*fi)->pkd = (PairKernData *)
calloc((*fi)->numOfPairs, sizeof(PairKernData));
if ((*fi)->pkd == NULL)
{
error = storageProblem;
return(error);
}
} /* if */
code = parsePairKernData(&aFile, *fi);
break;
case STARTCOMPOSITES:
keyword = token(&aFile,tokenlen);
if (flags & P_C)
{
(*fi)->numOfComps = atoi(keyword);
(*fi)->ccd = (CompCharData *)
calloc((*fi)->numOfComps, sizeof(CompCharData));
if ((*fi)->ccd == NULL)
{
error = storageProblem;
return(error);
}
} /* if */
code = parseCompCharData(&aFile, *fi);
break;
case ENDFONTMETRICS:
code = normalEOF;
break;
case COMMENT:
linetoken(&aFile);
break;
case NOPE:
default:
code = parseError;
break;
} /* switch */
if ((error != earlyEOF) && (code < 0)) error = code;
} /* while */
if ((error != earlyEOF) && (code < 0)) error = code;
return(error);
} /* parseFile */
void
freeFontInfo (FontInfo *fi)
{
int i, j;
if (fi->gfi)
{
free (fi->gfi->afmVersion);
free (fi->gfi->fontName);
free (fi->gfi->fullName);
free (fi->gfi->familyName);
free (fi->gfi->weight);
free (fi->gfi->version);
free (fi->gfi->notice);
free (fi->gfi->encodingScheme);
free (fi->gfi);
}
free (fi->cwi);
if (fi->cmi)
{
for (i = 0; i < fi->numOfChars; i++)
{
Ligature *ligs;
free (fi->cmi[i].name);
ligs = fi->cmi[i].ligs;
while (ligs)
{
Ligature *tmp;
tmp = ligs;
ligs = ligs->next;
free (tmp->succ);
free (tmp->lig);
free (tmp);
}
}
free (fi->cmi);
}
free (fi->tkd);
if (fi->pkd)
{
for ( i = 0; i < fi->numOfPairs; i++)
{
free (fi->pkd[i].name1);
free (fi->pkd[i].name2);
}
free (fi->pkd);
}
if (fi->ccd)
{
for (i = 0; i < fi->numOfComps; i++)
{
free (fi->ccd[i].ccName);
for (j = 0; j < fi->ccd[i].numOfPieces; j++)
free (fi->ccd[i].pieces[j].pccName);
free (fi->ccd[i].pieces);
}
free (fi->ccd);
}
free (fi);
}
} // namspace