flower/include/parse-afm.hh

   1 /* Modified 1999 Morten Welinder:
   2  * 1. ANSI prototype.
   3  * 2. parseFileFree function.
   4  */
   5 // 2000 HWN: AFM_ prefixes.
   6 /*
   7  * (C) 1988, 1989 by Adobe Systems Incorporated. All rights reserved.
   8  *
   9  * This file may be freely copied and redistributed as long as:
  10  *   1) This entire notice continues to be included in the file,
  11  *   2) If the file has been modified in any way, a notice of such
  12  *      modification is conspicuously indicated.
  13  *
  14  * PostScript, Display PostScript, and Adobe are registered trademarks of
  15  * Adobe Systems Incorporated.
  16  *
  17  * ************************************************************************
  18  * THE INFORMATION BELOW IS FURNISHED AS IS, IS SUBJECT TO CHANGE WITHOUT
  19  * NOTICE, AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY ADOBE SYSTEMS
  20  * INCORPORATED. ADOBE SYSTEMS INCORPORATED ASSUMES NO RESPONSIBILITY OR
  21  * LIABILITY FOR ANY ERRORS OR INACCURACIES, MAKES NO WARRANTY OF ANY
  22  * KIND (EXPRESS, IMPLIED OR STATUTORY) WITH RESPECT TO THIS INFORMATION,
  23  * AND EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR PARTICULAR PURPOSES AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  25  * ************************************************************************
  26  */
  27
  28 /* ParseAFM.h
  29  *
  30  * This header file is used in conjuction with the parseAFM.c file.
  31  * Together these files provide the functionality to parse Adobe Font
  32  * Metrics files and store the information in predefined data structures.
  33  * It is intended to work with an application program that needs font metric
  34  * information. The program can be used as is by making a procedure call to
  35  * parse an AFM file and have the data stored, or an application developer
  36  * may wish to customize the code.
  37  *
  38  * This header file defines the data structures used as well as the key
  39  * strings that are currently recognized by this version of the AFM parser.
  40  * This program is based on the document "Adobe Font Metrics Files,
  41  * Specification Version 2.0".
  42  *
  43  * AFM files are separated into distinct sections of different data. Because
  44  * of this, the parseAFM program can parse a specified file to only save
  45  * certain sections of information based on the application's needs. A record
  46  * containing the requested information will be returned to the application.
  47  *
  48  * AFM files are divided into five sections of data:
  49  *      1) The Global Font Information
  50  *      2) The Character Metrics Information
  51  *      3) The Track Kerning Data
  52  *      4) The Pair-Wise Kerning Data
  53  *      5) The Composite Character Data
  54  *
  55  * Basically, the application can request any of these sections independent
  56  * of what other sections are requested. In addition, in recognizing that
  57  * many applications will want ONLY the x-width of characters and not all
  58  * of the other character metrics information, there is a way to receive
  59  * only the width information so as not to pay the storage cost for the
  60  * unwanted data. An application should never request both the
  61  * "quick and dirty" char metrics (widths only) and the Character Metrics
  62  * Information since the Character Metrics Information will contain all
  63  * of the character widths as well.
  64  *
  65  * There is a procedure in parseAFM.c, called parseFile, that can be
  66  * called from any application wishing to get information from the AFM File.
  67  * This procedure expects 3 parameters: a vaild file descriptor, a pointer
  68  * to a (FontInfo *) variable (for which space will be allocated and then
  69  * will be filled in with the data requested), and a mask specifying
  70  * which data from the AFM File should be saved in the FontInfo structure.
  71  *
  72  * The flags that can be used to set the appropriate mask are defined below.
  73  * In addition, several commonly used masks have already been defined.
  74  *
  75  * History:
  76  *      original: DSM  Thu Oct 20 17:39:59 PDT 1988
  77  *  modified: DSM  Mon Jul  3 14:17:50 PDT 1989
  78  *    - added 'storageProblem' return code
  79  *        - fixed typos
  80  */
  81
  82 #include <cstdio>
  83
  84 #define BOOL int
  85 #define FLAGS int
  86
  87
  88
  89 /* Possible return codes from the parseFile procedure.
  90  *
  91  * ok means there were no problems parsing the file.
  92  *
  93  * parseError means that there was some kind of parsing error, but the
  94  * parser went on. This could include problems like the count for any given
  95  * section does not add up to how many entries there actually were, or
  96  * there was a key that was not recognized. The return record may contain
  97  * vaild data or it may not.
  98  *
  99  * earlyEOF means that an End of File was encountered before expected. This
 100  * may mean that the AFM file had been truncated, or improperly formed.
 101  *
 102  * storageProblem means that there were problems allocating storage for
 103  * the data structures that would have contained the AFM data.
 104  */
 105 #define AFM_ok 0
 106 #define AFM_parseError -1
 107 #define AFM_earlyEOF -2
 108 #define AFM_storageProblem -3
 109
 110
 111
 112 /************************* TYPES *********************************/
 113 /* Below are all of the data structure definitions. These structures
 114  * try to map as closely as possible to grouping and naming of data
 115  * in the AFM Files.
 116  */
 117
 118
 119 /* Bounding box definition. Used for the Font AFM_BBox as well as the
 120  * Character AFM_BBox.
 121  */
 122 typedef struct
 123 {
 124    int llx;     /* lower left x-position  */
 125    int lly;     /* lower left y-position  */
 126    int urx;     /* upper right x-position */
 127    int ury;     /* upper right y-position */
 128 } AFM_BBox;
 129
 130
 131 /* Global Font information.
 132  * The key that each field is associated with is in comments. For an
 133  * explanation about each key and its value please refer to the AFM
 134  * documentation (full title & version given above).
 135  */
 136 typedef struct
 137 {
 138    char *afmVersion;            /* key: StartFontMetrics */
 139    char *fontName;              /* key: FontName */
 140    char *fullName;              /* key: FullName */
 141    char *familyName;            /* key: FamilyName */
 142    char *weight;                /* key: Weight */
 143    float italicAngle;           /* key: ItalicAngle */
 144    BOOL isFixedPitch;           /* key: IsFixedPitch */
 145    AFM_BBox fontBBox;           /* key: FontBBox */
 146    int underlinePosition;       /* key: UnderlinePosition */
 147    int underlineThickness;      /* key: UnderlineThickness */
 148    char *version;               /* key: Version */
 149    char *notice;                /* key: Notice */
 150    char *encodingScheme;        /* key: EncodingScheme */
 151    int capHeight;               /* key: CapHeight */
 152    int xHeight;                 /* key: XHeight */
 153    int ascender;                /* key: Ascender */
 154    int descender;               /* key: Descender */
 155 } AFM_GlobalFontInfo;
 156
 157
 158 /* Ligature definition is a linked list since any character can have
 159  * any number of ligatures.
 160  */
 161 typedef struct _t_ligature
 162 {
 163     char *succ, *lig;
 164     struct _t_ligature *next;
 165 } AFM_Ligature;
 166
 167
 168 /* Character Metric Information. This structure is used only if ALL
 169  * character metric information is requested. If only the character
 170  * widths is requested, then only an array of the character x-widths
 171  * is returned.
 172  *
 173  * The key that each field is associated with is in comments. For an
 174  * explanation about each key and its value please refer to the
 175  * Character Metrics section of the AFM documentation (full title
 176  * & version given above).
 177  */
 178 typedef struct
 179 {
 180     int code,           /* key: C */
 181         wx,             /* key: WX */
 182         wy;             /* together wx and wy are associated with key: W */
 183     char *name;         /* key: N */
 184     AFM_BBox charBBox;  /* key: B */
 185     AFM_Ligature *ligs; /* key: L (linked list; not a fixed number of Ls */
 186 } AFM_CharMetricInfo;
 187
 188
 189 /* Track kerning data structure.
 190  * The fields of this record are the five values associated with every
 191  * TrackKern entry.
 192  *
 193  * For an explanation about each value please refer to the
 194  * Track Kerning section of the AFM documentation (full title
 195  * & version given above).
 196  */
 197 typedef struct
 198 {
 199     int degree;
 200     float minPtSize,
 201           minKernAmt,
 202           maxPtSize,
 203           maxKernAmt;
 204 } AFM_TrackKernData;
 205
 206
 207 /* Pair Kerning data structure.
 208  * The fields of this record are the four values associated with every
 209  * KP entry. For KPX entries, the yamt will be zero.
 210  *
 211  * For an explanation about each value please refer to the
 212  * Pair Kerning section of the AFM documentation (full title
 213  * & version given above).
 214  */
 215 typedef struct
 216 {
 217     char *name1;
 218     char *name2;
 219     int xamt,
 220         yamt;
 221 } AFM_PairKernData;
 222
 223
 224 /* AFM_Pcc is a piece of a composite character. This is a sub structure of a
 225  * AFM_CompCharData described below.
 226  * These fields will be filled in with the values from the key AFM_Pcc.
 227  *
 228  * For an explanation about each key and its value please refer to the
 229  * Composite Character section of the AFM documentation (full title
 230  * & version given above).
 231  */
 232 typedef struct
 233 {
 234     char *AFM_PccName;
 235     int deltax,
 236         deltay;
 237 } AFM_Pcc;
 238
 239
 240 /* Composite Character Information data structure.
 241  * The fields ccName and numOfPieces are filled with the values associated
 242  * with the key CC. The field pieces points to an array (size = numOfPieces)
 243  * of information about each of the parts of the composite character. That
 244  * array is filled in with the values from the key AFM_Pcc.
 245  *
 246  * For an explanation about each key and its value please refer to the
 247  * Composite Character section of the AFM documentation (full title
 248  * & version given above).
 249  */
 250 typedef struct
 251 {
 252     char *ccName;
 253     int numOfPieces;
 254     AFM_Pcc *pieces;
 255 } AFM_CompCharData;
 256
 257
 258 /*  FontInfo
 259  *  Record type containing pointers to all of the other data
 260  *  structures containing information about a font.
 261  *  A a record of this type is filled with data by the
 262  *  parseFile function.
 263  */
 264 typedef struct
 265 {
 266     AFM_GlobalFontInfo *gfi;    /* ptr to a AFM_GlobalFontInfo record */
 267     int *cwi;                   /* ptr to 256 element array of just char widths */
 268     int numOfChars;             /* number of entries in char metrics array */
 269     AFM_CharMetricInfo *cmi;    /* ptr to char metrics array */
 270     int numOfTracks;            /* number to entries in track kerning array */
 271     AFM_TrackKernData *tkd;             /* ptr to track kerning array */
 272     int numOfPairs;             /* number to entries in pair kerning array */
 273     AFM_PairKernData *pkd;              /* ptr to pair kerning array */
 274     int numOfComps;             /* number to entries in comp char array */
 275     AFM_CompCharData *ccd;              /* ptr to comp char array */
 276 } AFM_Font_info;
 277
 278
 279
 280 /************************* PROCEDURES ****************************/
 281
 282 /*  Call this procedure to do the grunt work of parsing an AFM file.
 283  *
 284  *  "fp" should be a valid file pointer to an AFM file.
 285  *
 286  *  "fi" is a pointer to a pointer to a FontInfo record sturcture
 287  * (defined above). Storage for the FontInfo structure will be
 288  *  allocated in parseFile and the structure will be filled in
 289  *  with the requested data from the AFM File.
 290  *
 291  *  "flags" is a mask with bits set representing what data should
 292  *  be saved. Defined above are valid flags that can be used to set
 293  *  the mask, as well as a few commonly used masks.
 294  *
 295  *  The possible return codes from parseFile are defined above.
 296  */
 297
 298 int AFM_parseFile (FILE *fp, AFM_Font_info **fi, FLAGS flags);
 299 void AFM_free (AFM_Font_info *fi);