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 /* Possible return codes from the parseFile procedure.
  88  *
  89  * ok means there were no problems parsing the file.
  90  *
  91  * parseError means that there was some kind of parsing error, but the
  92  * parser went on. This could include problems like the count for any given
  93  * section does not add up to how many entries there actually were, or
  94  * there was a key that was not recognized. The return record may contain
  95  * vaild data or it may not.
  96  *
  97  * earlyEOF means that an End of File was encountered before expected. This
  98  * may mean that the AFM file had been truncated, or improperly formed.
  99  *
 100  * storageProblem means that there were problems allocating storage for
 101  * the data structures that would have contained the AFM data.
 102  */
 103 #define AFM_ok 0
 104 #define AFM_parseError -1
 105 #define AFM_earlyEOF -2
 106 #define AFM_storageProblem -3
 107
 108 /************************* TYPES *********************************/
 109 /* Below are all of the data structure definitions. These structures
 110  * try to map as closely as possible to grouping and naming of data
 111  * in the AFM Files.
 112  */
 113
 114 /* Bounding box definition. Used for the Font AFM_BBox as well as the
 115  * Character AFM_BBox.
 116  */
 117 typedef struct
 118 {
 119   int llx;      /* lower left x-position  */
 120   int lly;      /* lower left y-position  */
 121   int urx;      /* upper right x-position */
 122   int ury;      /* upper right y-position */
 123 }
 124   AFM_BBox;
 125
 126 /* Global Font information.
 127  * The key that each field is associated with is in comments. For an
 128  * explanation about each key and its value please refer to the AFM
 129  * documentation (full title & version given above).
 130  */
 131 typedef struct
 132 {
 133   char *afmVersion;             /* key: StartFontMetrics */
 134   char *fontName;               /* key: FontName */
 135   char *fullName;               /* key: FullName */
 136   char *familyName;             /* key: FamilyName */
 137   char *weight;         /* key: Weight */
 138   float italicAngle;            /* key: ItalicAngle */
 139   BOOL isFixedPitch;            /* key: IsFixedPitch */
 140   AFM_BBox fontBBox;            /* key: FontBBox */
 141   int underlinePosition;        /* key: UnderlinePosition */
 142   int underlineThickness;       /* key: UnderlineThickness */
 143   char *version;                /* key: Version */
 144   char *notice;         /* key: Notice */
 145   char *encodingScheme; /* key: EncodingScheme */
 146   int capHeight;                /* key: CapHeight */
 147   int xHeight;                  /* key: XHeight */
 148   int ascender;         /* key: Ascender */
 149   int descender;                /* key: Descender */
 150 }
 151   AFM_GlobalFontInfo;
 152
 153 /* Ligature definition is a linked list since any character can have
 154  * any number of ligatures.
 155  */
 156 typedef struct _t_ligature
 157 {
 158   char *succ, *lig;
 159   struct _t_ligature *next;
 160 }
 161   AFM_Ligature;
 162
 163 /* Character Metric Information. This structure is used only if ALL
 164  * character metric information is requested. If only the character
 165  * widths is requested, then only an array of the character x-widths
 166  * is returned.
 167  *
 168  * The key that each field is associated with is in comments. For an
 169  * explanation about each key and its value please refer to the
 170  * Character Metrics section of the AFM documentation (full title
 171  * & version given above).
 172  */
 173 typedef struct
 174 {
 175   int code,             /* key: C */
 176     wx,                 /* key: WX */
 177     wy;         /* together wx and wy are associated with key: W */
 178   char *name;   /* key: N */
 179   AFM_BBox charBBox;    /* key: B */
 180   AFM_Ligature *ligs;   /* key: L (linked list; not a fixed number of Ls */
 181 }
 182   AFM_CharMetricInfo;
 183
 184 /* Track kerning data structure.
 185  * The fields of this record are the five values associated with every
 186  * TrackKern entry.
 187  *
 188  * For an explanation about each value please refer to the
 189  * Track Kerning section of the AFM documentation (full title
 190  * & version given above).
 191  */
 192 typedef struct
 193 {
 194   int degree;
 195   float minPtSize,
 196     minKernAmt,
 197     maxPtSize,
 198     maxKernAmt;
 199 }
 200   AFM_TrackKernData;
 201
 202 /* Pair Kerning data structure.
 203  * The fields of this record are the four values associated with every
 204  * KP entry. For KPX entries, the yamt will be zero.
 205  *
 206  * For an explanation about each value please refer to the
 207  * Pair Kerning section of the AFM documentation (full title
 208  * & version given above).
 209  */
 210 typedef struct
 211 {
 212   char *name1;
 213   char *name2;
 214   int xamt,
 215     yamt;
 216 }
 217   AFM_PairKernData;
 218
 219 /* AFM_Pcc is a piece of a composite character. This is a sub structure of a
 220  * AFM_CompCharData described below.
 221  * These fields will be filled in with the values from the key AFM_Pcc.
 222  *
 223  * For an explanation about each key and its value please refer to the
 224  * Composite Character section of the AFM documentation (full title
 225  * & version given above).
 226  */
 227 typedef struct
 228 {
 229   char *AFM_PccName;
 230   int deltax,
 231     deltay;
 232 }
 233   AFM_Pcc;
 234
 235 /* Composite Character Information data structure.
 236  * The fields ccName and numOfPieces are filled with the values associated
 237  * with the key CC. The field pieces points to an array (size = numOfPieces)
 238  * of information about each of the parts of the composite character. That
 239  * array is filled in with the values from the key AFM_Pcc.
 240  *
 241  * For an explanation about each key and its value please refer to the
 242  * Composite Character section of the AFM documentation (full title
 243  * & version given above).
 244  */
 245 typedef struct
 246 {
 247   char *ccName;
 248   int numOfPieces;
 249   AFM_Pcc *pieces;
 250 }
 251   AFM_CompCharData;
 252
 253 /*  FontInfo
 254  *  Record type containing pointers to all of the other data
 255  *  structures containing information about a font.
 256  *  A a record of this type is filled with data by the
 257  *  parseFile function.
 258  */
 259 typedef struct
 260 {
 261   AFM_GlobalFontInfo *gfi;      /* ptr to a AFM_GlobalFontInfo record */
 262   int *cwi;                     /* ptr to 256 element array of just char widths */
 263   int numOfChars;               /* number of entries in char metrics array */
 264   AFM_CharMetricInfo *cmi;      /* ptr to char metrics array */
 265   int numOfTracks;              /* number to entries in track kerning array */
 266   AFM_TrackKernData *tkd;               /* ptr to track kerning array */
 267   int numOfPairs;               /* number to entries in pair kerning array */
 268   AFM_PairKernData *pkd;                /* ptr to pair kerning array */
 269   int numOfComps;               /* number to entries in comp char array */
 270   AFM_CompCharData *ccd;                /* ptr to comp char array */
 271 }
 272   AFM_Font_info;
 273
 274
 275 /************************* PROCEDURES ****************************/
 276
 277 /*  Call this procedure to do the grunt work of parsing an AFM file.
 278  *
 279  *  "fp" should be a valid file pointer to an AFM file.
 280  *
 281  *  "fi" is a pointer to a pointer to a FontInfo record sturcture
 282  * (defined above). Storage for the FontInfo structure will be
 283  *  allocated in parseFile and the structure will be filled in
 284  *  with the requested data from the AFM File.
 285  *
 286  *  "flags" is a mask with bits set representing what data should
 287  *  be saved. Defined above are valid flags that can be used to set
 288  *  the mask, as well as a few commonly used masks.
 289  *
 290  *  The possible return codes from parseFile are defined above.
 291  */
 292
 293 int AFM_parseFile (FILE *fp, AFM_Font_info **fi, FLAGS flags);
 294 void AFM_free (AFM_Font_info *fi);