include/freetype/internal/psaux.h

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  psaux.h                                                                */
   4 /*                                                                         */
   5 /*    Auxiliary functions and data structures related to PostScript fonts  */
   6 /*    (specification).                                                     */
   7 /*                                                                         */
   8 /*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2008, 2009 by             */
   9 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  10 /*                                                                         */
  11 /*  This file is part of the FreeType project, and may only be used,       */
  12 /*  modified, and distributed under the terms of the FreeType project      */
  13 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  14 /*  this file you indicate that you have read the license and              */
  15 /*  understand and accept it fully.                                        */
  16 /*                                                                         */
  17 /***************************************************************************/
  18
  19
  20 #ifndef __PSAUX_H__
  21 #define __PSAUX_H__
  22
  23
  24 #include <ft2build.h>
  25 #include FT_INTERNAL_OBJECTS_H
  26 #include FT_INTERNAL_TYPE1_TYPES_H
  27 #include FT_SERVICE_POSTSCRIPT_CMAPS_H
  28
  29
  30 FT_BEGIN_HEADER
  31
  32
  33   /*************************************************************************/
  34   /*************************************************************************/
  35   /*****                                                               *****/
  36   /*****                             T1_TABLE                          *****/
  37   /*****                                                               *****/
  38   /*************************************************************************/
  39   /*************************************************************************/
  40
  41
  42   typedef struct PS_TableRec_*              PS_Table;
  43   typedef const struct PS_Table_FuncsRec_*  PS_Table_Funcs;
  44
  45
  46   /*************************************************************************/
  47   /*                                                                       */
  48   /* <Struct>                                                              */
  49   /*    PS_Table_FuncsRec                                                  */
  50   /*                                                                       */
  51   /* <Description>                                                         */
  52   /*    A set of function pointers to manage PS_Table objects.             */
  53   /*                                                                       */
  54   /* <Fields>                                                              */
  55   /*    table_init    :: Used to initialize a table.                       */
  56   /*                                                                       */
  57   /*    table_done    :: Finalizes resp. destroy a given table.            */
  58   /*                                                                       */
  59   /*    table_add     :: Adds a new object to a table.                     */
  60   /*                                                                       */
  61   /*    table_release :: Releases table data, then finalizes it.           */
  62   /*                                                                       */
  63   typedef struct  PS_Table_FuncsRec_
  64   {
  65     FT_Error
  66     (*init)( PS_Table   table,
  67              FT_Int     count,
  68              FT_Memory  memory );
  69
  70     void
  71     (*done)( PS_Table  table );
  72
  73     FT_Error
  74     (*add)( PS_Table    table,
  75             FT_Int      idx,
  76             void*       object,
  77             FT_PtrDist  length );
  78
  79     void
  80     (*release)( PS_Table  table );
  81
  82   } PS_Table_FuncsRec;
  83
  84
  85   /*************************************************************************/
  86   /*                                                                       */
  87   /* <Struct>                                                              */
  88   /*    PS_TableRec                                                        */
  89   /*                                                                       */
  90   /* <Description>                                                         */
  91   /*    A PS_Table is a simple object used to store an array of objects in */
  92   /*    a single memory block.                                             */
  93   /*                                                                       */
  94   /* <Fields>                                                              */
  95   /*    block     :: The address in memory of the growheap's block.  This  */
  96   /*                 can change between two object adds, due to            */
  97   /*                 reallocation.                                         */
  98   /*                                                                       */
  99   /*    cursor    :: The current top of the grow heap within its block.    */
 100   /*                                                                       */
 101   /*    capacity  :: The current size of the heap block.  Increments by    */
 102   /*                 1kByte chunks.                                        */
 103   /*                                                                       */
 104   /*    max_elems :: The maximum number of elements in table.              */
 105   /*                                                                       */
 106   /*    num_elems :: The current number of elements in table.              */
 107   /*                                                                       */
 108   /*    elements  :: A table of element addresses within the block.        */
 109   /*                                                                       */
 110   /*    lengths   :: A table of element sizes within the block.            */
 111   /*                                                                       */
 112   /*    memory    :: The object used for memory operations                 */
 113   /*                 (alloc/realloc).                                      */
 114   /*                                                                       */
 115   /*    funcs     :: A table of method pointers for this object.           */
 116   /*                                                                       */
 117   typedef struct  PS_TableRec_
 118   {
 119     FT_Byte*           block;          /* current memory block           */
 120     FT_Offset          cursor;         /* current cursor in memory block */
 121     FT_Offset          capacity;       /* current size of memory block   */
 122     FT_Long            init;
 123
 124     FT_Int             max_elems;
 125     FT_Int             num_elems;
 126     FT_Byte**          elements;       /* addresses of table elements */
 127     FT_PtrDist*        lengths;        /* lengths of table elements   */
 128
 129     FT_Memory          memory;
 130     PS_Table_FuncsRec  funcs;
 131
 132   } PS_TableRec;
 133
 134
 135   /*************************************************************************/
 136   /*************************************************************************/
 137   /*****                                                               *****/
 138   /*****                       T1 FIELDS & TOKENS                      *****/
 139   /*****                                                               *****/
 140   /*************************************************************************/
 141   /*************************************************************************/
 142
 143   typedef struct PS_ParserRec_*  PS_Parser;
 144
 145   typedef struct T1_TokenRec_*   T1_Token;
 146
 147   typedef struct T1_FieldRec_*   T1_Field;
 148
 149
 150   /* simple enumeration type used to identify token types */
 151   typedef enum  T1_TokenType_
 152   {
 153     T1_TOKEN_TYPE_NONE = 0,
 154     T1_TOKEN_TYPE_ANY,
 155     T1_TOKEN_TYPE_STRING,
 156     T1_TOKEN_TYPE_ARRAY,
 157     T1_TOKEN_TYPE_KEY, /* aka `name' */
 158
 159     /* do not remove */
 160     T1_TOKEN_TYPE_MAX
 161
 162   } T1_TokenType;
 163
 164
 165   /* a simple structure used to identify tokens */
 166   typedef struct  T1_TokenRec_
 167   {
 168     FT_Byte*      start;   /* first character of token in input stream */
 169     FT_Byte*      limit;   /* first character after the token          */
 170     T1_TokenType  type;    /* type of token                            */
 171
 172   } T1_TokenRec;
 173
 174
 175   /* enumeration type used to identify object fields */
 176   typedef enum  T1_FieldType_
 177   {
 178     T1_FIELD_TYPE_NONE = 0,
 179     T1_FIELD_TYPE_BOOL,
 180     T1_FIELD_TYPE_INTEGER,
 181     T1_FIELD_TYPE_FIXED,
 182     T1_FIELD_TYPE_FIXED_1000,
 183     T1_FIELD_TYPE_STRING,
 184     T1_FIELD_TYPE_KEY,
 185     T1_FIELD_TYPE_BBOX,
 186     T1_FIELD_TYPE_INTEGER_ARRAY,
 187     T1_FIELD_TYPE_FIXED_ARRAY,
 188     T1_FIELD_TYPE_CALLBACK,
 189
 190     /* do not remove */
 191     T1_FIELD_TYPE_MAX
 192
 193   } T1_FieldType;
 194
 195
 196   typedef enum  T1_FieldLocation_
 197   {
 198     T1_FIELD_LOCATION_CID_INFO,
 199     T1_FIELD_LOCATION_FONT_DICT,
 200     T1_FIELD_LOCATION_FONT_EXTRA,
 201     T1_FIELD_LOCATION_FONT_INFO,
 202     T1_FIELD_LOCATION_PRIVATE,
 203     T1_FIELD_LOCATION_BBOX,
 204     T1_FIELD_LOCATION_LOADER,
 205     T1_FIELD_LOCATION_FACE,
 206     T1_FIELD_LOCATION_BLEND,
 207
 208     /* do not remove */
 209     T1_FIELD_LOCATION_MAX
 210
 211   } T1_FieldLocation;
 212
 213
 214   typedef void
 215   (*T1_Field_ParseFunc)( FT_Face     face,
 216                          FT_Pointer  parser );
 217
 218
 219   /* structure type used to model object fields */
 220   typedef struct  T1_FieldRec_
 221   {
 222     const char*         ident;        /* field identifier               */
 223     T1_FieldLocation    location;
 224     T1_FieldType        type;         /* type of field                  */
 225     T1_Field_ParseFunc  reader;
 226     FT_UInt             offset;       /* offset of field in object      */
 227     FT_Byte             size;         /* size of field in bytes         */
 228     FT_UInt             array_max;    /* maximal number of elements for */
 229                                       /* array                          */
 230     FT_UInt             count_offset; /* offset of element count for    */
 231                                       /* arrays; must not be zero if in */
 232                                       /* use -- in other words, a       */
 233                                       /* `num_FOO' element must not     */
 234                                       /* start the used structure if we */
 235                                       /* parse a `FOO' array            */
 236     FT_UInt             dict;         /* where we expect it             */
 237   } T1_FieldRec;
 238
 239 #define T1_FIELD_DICT_FONTDICT ( 1 << 0 ) /* also FontInfo and FDArray */
 240 #define T1_FIELD_DICT_PRIVATE  ( 1 << 1 )
 241
 242
 243
 244 #define T1_NEW_SIMPLE_FIELD( _ident, _type, _fname, _dict ) \
 245           {                                                 \
 246             _ident, T1CODE, _type,                          \
 247             0,                                              \
 248             FT_FIELD_OFFSET( _fname ),                      \
 249             FT_FIELD_SIZE( _fname ),                        \
 250             0, 0,                                           \
 251             _dict                                           \
 252           },
 253
 254 #define T1_NEW_CALLBACK_FIELD( _ident, _reader, _dict ) \
 255           {                                             \
 256             _ident, T1CODE, T1_FIELD_TYPE_CALLBACK,     \
 257             (T1_Field_ParseFunc)_reader,                \
 258             0, 0,                                       \
 259             0, 0,                                       \
 260             _dict                                       \
 261           },
 262
 263 #define T1_NEW_TABLE_FIELD( _ident, _type, _fname, _max, _dict ) \
 264           {                                                      \
 265             _ident, T1CODE, _type,                               \
 266             0,                                                   \
 267             FT_FIELD_OFFSET( _fname ),                           \
 268             FT_FIELD_SIZE_DELTA( _fname ),                       \
 269             _max,                                                \
 270             FT_FIELD_OFFSET( num_ ## _fname ),                   \
 271             _dict                                                \
 272           },
 273
 274 #define T1_NEW_TABLE_FIELD2( _ident, _type, _fname, _max, _dict ) \
 275           {                                                       \
 276             _ident, T1CODE, _type,                                \
 277             0,                                                    \
 278             FT_FIELD_OFFSET( _fname ),                            \
 279             FT_FIELD_SIZE_DELTA( _fname ),                        \
 280             _max, 0,                                              \
 281             _dict                                                 \
 282           },
 283
 284
 285 #define T1_FIELD_BOOL( _ident, _fname, _dict )                             \
 286           T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_BOOL, _fname, _dict )
 287
 288 #define T1_FIELD_NUM( _ident, _fname, _dict )                                 \
 289           T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER, _fname, _dict )
 290
 291 #define T1_FIELD_FIXED( _ident, _fname, _dict )                             \
 292           T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_FIXED, _fname, _dict )
 293
 294 #define T1_FIELD_FIXED_1000( _ident, _fname, _dict )                     \
 295           T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_FIXED_1000, _fname, \
 296                                _dict )
 297
 298 #define T1_FIELD_STRING( _ident, _fname, _dict )                             \
 299           T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_STRING, _fname, _dict )
 300
 301 #define T1_FIELD_KEY( _ident, _fname, _dict )                             \
 302           T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_KEY, _fname, _dict )
 303
 304 #define T1_FIELD_BBOX( _ident, _fname, _dict )                             \
 305           T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_BBOX, _fname, _dict )
 306
 307
 308 #define T1_FIELD_NUM_TABLE( _ident, _fname, _fmax, _dict )         \
 309           T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \
 310                               _fname, _fmax, _dict )
 311
 312 #define T1_FIELD_FIXED_TABLE( _ident, _fname, _fmax, _dict )     \
 313           T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \
 314                               _fname, _fmax, _dict )
 315
 316 #define T1_FIELD_NUM_TABLE2( _ident, _fname, _fmax, _dict )         \
 317           T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \
 318                                _fname, _fmax, _dict )
 319
 320 #define T1_FIELD_FIXED_TABLE2( _ident, _fname, _fmax, _dict )     \
 321           T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \
 322                                _fname, _fmax, _dict )
 323
 324 #define T1_FIELD_CALLBACK( _ident, _name, _dict )       \
 325           T1_NEW_CALLBACK_FIELD( _ident, _name, _dict )
 326
 327
 328   /*************************************************************************/
 329   /*************************************************************************/
 330   /*****                                                               *****/
 331   /*****                            T1 PARSER                          *****/
 332   /*****                                                               *****/
 333   /*************************************************************************/
 334   /*************************************************************************/
 335
 336   typedef const struct PS_Parser_FuncsRec_*  PS_Parser_Funcs;
 337
 338   typedef struct  PS_Parser_FuncsRec_
 339   {
 340     void
 341     (*init)( PS_Parser  parser,
 342              FT_Byte*   base,
 343              FT_Byte*   limit,
 344              FT_Memory  memory );
 345
 346     void
 347     (*done)( PS_Parser  parser );
 348
 349     void
 350     (*skip_spaces)( PS_Parser  parser );
 351     void
 352     (*skip_PS_token)( PS_Parser  parser );
 353
 354     FT_Long
 355     (*to_int)( PS_Parser  parser );
 356     FT_Fixed
 357     (*to_fixed)( PS_Parser  parser,
 358                  FT_Int     power_ten );
 359
 360     FT_Error
 361     (*to_bytes)( PS_Parser  parser,
 362                  FT_Byte*   bytes,
 363                  FT_Offset  max_bytes,
 364                  FT_Long*   pnum_bytes,
 365                  FT_Bool    delimiters );
 366
 367     FT_Int
 368     (*to_coord_array)( PS_Parser  parser,
 369                        FT_Int     max_coords,
 370                        FT_Short*  coords );
 371     FT_Int
 372     (*to_fixed_array)( PS_Parser  parser,
 373                        FT_Int     max_values,
 374                        FT_Fixed*  values,
 375                        FT_Int     power_ten );
 376
 377     void
 378     (*to_token)( PS_Parser  parser,
 379                  T1_Token   token );
 380     void
 381     (*to_token_array)( PS_Parser  parser,
 382                        T1_Token   tokens,
 383                        FT_UInt    max_tokens,
 384                        FT_Int*    pnum_tokens );
 385
 386     FT_Error
 387     (*load_field)( PS_Parser       parser,
 388                    const T1_Field  field,
 389                    void**          objects,
 390                    FT_UInt         max_objects,
 391                    FT_ULong*       pflags );
 392
 393     FT_Error
 394     (*load_field_table)( PS_Parser       parser,
 395                          const T1_Field  field,
 396                          void**          objects,
 397                          FT_UInt         max_objects,
 398                          FT_ULong*       pflags );
 399
 400   } PS_Parser_FuncsRec;
 401
 402
 403   /*************************************************************************/
 404   /*                                                                       */
 405   /* <Struct>                                                              */
 406   /*    PS_ParserRec                                                       */
 407   /*                                                                       */
 408   /* <Description>                                                         */
 409   /*    A PS_Parser is an object used to parse a Type 1 font very quickly. */
 410   /*                                                                       */
 411   /* <Fields>                                                              */
 412   /*    cursor :: The current position in the text.                        */
 413   /*                                                                       */
 414   /*    base   :: Start of the processed text.                             */
 415   /*                                                                       */
 416   /*    limit  :: End of the processed text.                               */
 417   /*                                                                       */
 418   /*    error  :: The last error returned.                                 */
 419   /*                                                                       */
 420   /*    memory :: The object used for memory operations (alloc/realloc).   */
 421   /*                                                                       */
 422   /*    funcs  :: A table of functions for the parser.                     */
 423   /*                                                                       */
 424   typedef struct  PS_ParserRec_
 425   {
 426     FT_Byte*   cursor;
 427     FT_Byte*   base;
 428     FT_Byte*   limit;
 429     FT_Error   error;
 430     FT_Memory  memory;
 431
 432     PS_Parser_FuncsRec  funcs;
 433
 434   } PS_ParserRec;
 435
 436
 437   /*************************************************************************/
 438   /*************************************************************************/
 439   /*****                                                               *****/
 440   /*****                         T1 BUILDER                            *****/
 441   /*****                                                               *****/
 442   /*************************************************************************/
 443   /*************************************************************************/
 444
 445
 446   typedef struct T1_BuilderRec_*  T1_Builder;
 447
 448
 449   typedef FT_Error
 450   (*T1_Builder_Check_Points_Func)( T1_Builder  builder,
 451                                    FT_Int      count );
 452
 453   typedef void
 454   (*T1_Builder_Add_Point_Func)( T1_Builder  builder,
 455                                 FT_Pos      x,
 456                                 FT_Pos      y,
 457                                 FT_Byte     flag );
 458
 459   typedef FT_Error
 460   (*T1_Builder_Add_Point1_Func)( T1_Builder  builder,
 461                                  FT_Pos      x,
 462                                  FT_Pos      y );
 463
 464   typedef FT_Error
 465   (*T1_Builder_Add_Contour_Func)( T1_Builder  builder );
 466
 467   typedef FT_Error
 468   (*T1_Builder_Start_Point_Func)( T1_Builder  builder,
 469                                   FT_Pos      x,
 470                                   FT_Pos      y );
 471
 472   typedef void
 473   (*T1_Builder_Close_Contour_Func)( T1_Builder  builder );
 474
 475
 476   typedef const struct T1_Builder_FuncsRec_*  T1_Builder_Funcs;
 477
 478   typedef struct  T1_Builder_FuncsRec_
 479   {
 480     void
 481     (*init)( T1_Builder    builder,
 482              FT_Face       face,
 483              FT_Size       size,
 484              FT_GlyphSlot  slot,
 485              FT_Bool       hinting );
 486
 487     void
 488     (*done)( T1_Builder   builder );
 489
 490     T1_Builder_Check_Points_Func   check_points;
 491     T1_Builder_Add_Point_Func      add_point;
 492     T1_Builder_Add_Point1_Func     add_point1;
 493     T1_Builder_Add_Contour_Func    add_contour;
 494     T1_Builder_Start_Point_Func    start_point;
 495     T1_Builder_Close_Contour_Func  close_contour;
 496
 497   } T1_Builder_FuncsRec;
 498
 499
 500   /* an enumeration type to handle charstring parsing states */
 501   typedef enum  T1_ParseState_
 502   {
 503     T1_Parse_Start,
 504     T1_Parse_Have_Width,
 505     T1_Parse_Have_Moveto,
 506     T1_Parse_Have_Path
 507
 508   } T1_ParseState;
 509
 510
 511   /*************************************************************************/
 512   /*                                                                       */
 513   /* <Structure>                                                           */
 514   /*    T1_BuilderRec                                                      */
 515   /*                                                                       */
 516   /* <Description>                                                         */
 517   /*     A structure used during glyph loading to store its outline.       */
 518   /*                                                                       */
 519   /* <Fields>                                                              */
 520   /*    memory       :: The current memory object.                         */
 521   /*                                                                       */
 522   /*    face         :: The current face object.                           */
 523   /*                                                                       */
 524   /*    glyph        :: The current glyph slot.                            */
 525   /*                                                                       */
 526   /*    loader       :: XXX                                                */
 527   /*                                                                       */
 528   /*    base         :: The base glyph outline.                            */
 529   /*                                                                       */
 530   /*    current      :: The current glyph outline.                         */
 531   /*                                                                       */
 532   /*    max_points   :: maximum points in builder outline                  */
 533   /*                                                                       */
 534   /*    max_contours :: Maximal number of contours in builder outline.     */
 535   /*                                                                       */
 536   /*    pos_x        :: The horizontal translation (if composite glyph).   */
 537   /*                                                                       */
 538   /*    pos_y        :: The vertical translation (if composite glyph).     */
 539   /*                                                                       */
 540   /*    left_bearing :: The left side bearing point.                       */
 541   /*                                                                       */
 542   /*    advance      :: The horizontal advance vector.                     */
 543   /*                                                                       */
 544   /*    bbox         :: Unused.                                            */
 545   /*                                                                       */
 546   /*    parse_state  :: An enumeration which controls the charstring       */
 547   /*                    parsing state.                                     */
 548   /*                                                                       */
 549   /*    load_points  :: If this flag is not set, no points are loaded.     */
 550   /*                                                                       */
 551   /*    no_recurse   :: Set but not used.                                  */
 552   /*                                                                       */
 553   /*    metrics_only :: A boolean indicating that we only want to compute  */
 554   /*                    the metrics of a given glyph, not load all of its  */
 555   /*                    points.                                            */
 556   /*                                                                       */
 557   /*    funcs        :: An array of function pointers for the builder.     */
 558   /*                                                                       */
 559   typedef struct  T1_BuilderRec_
 560   {
 561     FT_Memory       memory;
 562     FT_Face         face;
 563     FT_GlyphSlot    glyph;
 564     FT_GlyphLoader  loader;
 565     FT_Outline*     base;
 566     FT_Outline*     current;
 567
 568     FT_Pos          pos_x;
 569     FT_Pos          pos_y;
 570
 571     FT_Vector       left_bearing;
 572     FT_Vector       advance;
 573
 574     FT_BBox         bbox;          /* bounding box */
 575     T1_ParseState   parse_state;
 576     FT_Bool         load_points;
 577     FT_Bool         no_recurse;
 578
 579     FT_Bool         metrics_only;
 580
 581     void*           hints_funcs;    /* hinter-specific */
 582     void*           hints_globals;  /* hinter-specific */
 583
 584     T1_Builder_FuncsRec  funcs;
 585
 586   } T1_BuilderRec;
 587
 588
 589   /*************************************************************************/
 590   /*************************************************************************/
 591   /*****                                                               *****/
 592   /*****                         T1 DECODER                            *****/
 593   /*****                                                               *****/
 594   /*************************************************************************/
 595   /*************************************************************************/
 596
 597 #if 0
 598
 599   /*************************************************************************/
 600   /*                                                                       */
 601   /* T1_MAX_SUBRS_CALLS details the maximum number of nested sub-routine   */
 602   /* calls during glyph loading.                                           */
 603   /*                                                                       */
 604 #define T1_MAX_SUBRS_CALLS  8
 605
 606
 607   /*************************************************************************/
 608   /*                                                                       */
 609   /* T1_MAX_CHARSTRING_OPERANDS is the charstring stack's capacity.  A     */
 610   /* minimum of 16 is required.                                            */
 611   /*                                                                       */
 612 #define T1_MAX_CHARSTRINGS_OPERANDS  32
 613
 614 #endif /* 0 */
 615
 616
 617   typedef struct  T1_Decoder_ZoneRec_
 618   {
 619     FT_Byte*  cursor;
 620     FT_Byte*  base;
 621     FT_Byte*  limit;
 622
 623   } T1_Decoder_ZoneRec, *T1_Decoder_Zone;
 624
 625
 626   typedef struct T1_DecoderRec_*              T1_Decoder;
 627   typedef const struct T1_Decoder_FuncsRec_*  T1_Decoder_Funcs;
 628
 629
 630   typedef FT_Error
 631   (*T1_Decoder_Callback)( T1_Decoder  decoder,
 632                           FT_UInt     glyph_index );
 633
 634
 635   typedef struct  T1_Decoder_FuncsRec_
 636   {
 637     FT_Error
 638     (*init)( T1_Decoder           decoder,
 639              FT_Face              face,
 640              FT_Size              size,
 641              FT_GlyphSlot         slot,
 642              FT_Byte**            glyph_names,
 643              PS_Blend             blend,
 644              FT_Bool              hinting,
 645              FT_Render_Mode       hint_mode,
 646              T1_Decoder_Callback  callback );
 647
 648     void
 649     (*done)( T1_Decoder  decoder );
 650
 651     FT_Error
 652     (*parse_charstrings)( T1_Decoder  decoder,
 653                           FT_Byte*    base,
 654                           FT_UInt     len );
 655
 656   } T1_Decoder_FuncsRec;
 657
 658
 659   typedef struct  T1_DecoderRec_
 660   {
 661     T1_BuilderRec        builder;
 662
 663     FT_Long              stack[T1_MAX_CHARSTRINGS_OPERANDS];
 664     FT_Long*             top;
 665
 666     T1_Decoder_ZoneRec   zones[T1_MAX_SUBRS_CALLS + 1];
 667     T1_Decoder_Zone      zone;
 668
 669     FT_Service_PsCMaps   psnames;      /* for seac */
 670     FT_UInt              num_glyphs;
 671     FT_Byte**            glyph_names;
 672
 673     FT_Int               lenIV;        /* internal for sub routine calls */
 674     FT_UInt              num_subrs;
 675     FT_Byte**            subrs;
 676     FT_PtrDist*          subrs_len;    /* array of subrs length (optional) */
 677
 678     FT_Matrix            font_matrix;
 679     FT_Vector            font_offset;
 680
 681     FT_Int               flex_state;
 682     FT_Int               num_flex_vectors;
 683     FT_Vector            flex_vectors[7];
 684
 685     PS_Blend             blend;       /* for multiple master support */
 686
 687     FT_Render_Mode       hint_mode;
 688
 689     T1_Decoder_Callback  parse_callback;
 690     T1_Decoder_FuncsRec  funcs;
 691
 692     FT_Long*             buildchar;
 693     FT_UInt              len_buildchar;
 694
 695     FT_Bool              seac;
 696
 697   } T1_DecoderRec;
 698
 699
 700   /*************************************************************************/
 701   /*************************************************************************/
 702   /*****                                                               *****/
 703   /*****                            AFM PARSER                         *****/
 704   /*****                                                               *****/
 705   /*************************************************************************/
 706   /*************************************************************************/
 707
 708   typedef struct AFM_ParserRec_*  AFM_Parser;
 709
 710   typedef struct  AFM_Parser_FuncsRec_
 711   {
 712     FT_Error
 713     (*init)( AFM_Parser  parser,
 714              FT_Memory   memory,
 715              FT_Byte*    base,
 716              FT_Byte*    limit );
 717
 718     void
 719     (*done)( AFM_Parser  parser );
 720
 721     FT_Error
 722     (*parse)( AFM_Parser  parser );
 723
 724   } AFM_Parser_FuncsRec;
 725
 726
 727   typedef struct AFM_StreamRec_*  AFM_Stream;
 728
 729
 730   /*************************************************************************/
 731   /*                                                                       */
 732   /* <Struct>                                                              */
 733   /*    AFM_ParserRec                                                      */
 734   /*                                                                       */
 735   /* <Description>                                                         */
 736   /*    An AFM_Parser is a parser for the AFM files.                       */
 737   /*                                                                       */
 738   /* <Fields>                                                              */
 739   /*    memory    :: The object used for memory operations (alloc and      */
 740   /*                 realloc).                                             */
 741   /*                                                                       */
 742   /*    stream    :: This is an opaque object.                             */
 743   /*                                                                       */
 744   /*    FontInfo  :: The result will be stored here.                       */
 745   /*                                                                       */
 746   /*    get_index :: A user provided function to get a glyph index by its  */
 747   /*                 name.                                                 */
 748   /*                                                                       */
 749   typedef struct  AFM_ParserRec_
 750   {
 751     FT_Memory     memory;
 752     AFM_Stream    stream;
 753
 754     AFM_FontInfo  FontInfo;
 755
 756     FT_Int
 757     (*get_index)( const char*  name,
 758                   FT_Offset    len,
 759                   void*        user_data );
 760
 761     void*         user_data;
 762
 763   } AFM_ParserRec;
 764
 765
 766   /*************************************************************************/
 767   /*************************************************************************/
 768   /*****                                                               *****/
 769   /*****                     TYPE1 CHARMAPS                            *****/
 770   /*****                                                               *****/
 771   /*************************************************************************/
 772   /*************************************************************************/
 773
 774   typedef const struct T1_CMap_ClassesRec_*  T1_CMap_Classes;
 775
 776   typedef struct T1_CMap_ClassesRec_
 777   {
 778     FT_CMap_Class  standard;
 779     FT_CMap_Class  expert;
 780     FT_CMap_Class  custom;
 781     FT_CMap_Class  unicode;
 782
 783   } T1_CMap_ClassesRec;
 784
 785
 786   /*************************************************************************/
 787   /*************************************************************************/
 788   /*****                                                               *****/
 789   /*****                        PSAux Module Interface                 *****/
 790   /*****                                                               *****/
 791   /*************************************************************************/
 792   /*************************************************************************/
 793
 794   typedef struct  PSAux_ServiceRec_
 795   {
 796     /* don't use `PS_Table_Funcs' and friends to avoid compiler warnings */
 797     const PS_Table_FuncsRec*    ps_table_funcs;
 798     const PS_Parser_FuncsRec*   ps_parser_funcs;
 799     const T1_Builder_FuncsRec*  t1_builder_funcs;
 800     const T1_Decoder_FuncsRec*  t1_decoder_funcs;
 801
 802     void
 803     (*t1_decrypt)( FT_Byte*   buffer,
 804                    FT_Offset  length,
 805                    FT_UShort  seed );
 806
 807     T1_CMap_Classes  t1_cmap_classes;
 808
 809     /* fields after this comment line were added after version 2.1.10 */
 810     const AFM_Parser_FuncsRec*  afm_parser_funcs;
 811
 812   } PSAux_ServiceRec, *PSAux_Service;
 813
 814   /* backwards-compatible type definition */
 815   typedef PSAux_ServiceRec   PSAux_Interface;
 816
 817
 818   /*************************************************************************/
 819   /*************************************************************************/
 820   /*****                                                               *****/
 821   /*****                 Some convenience functions                    *****/
 822   /*****                                                               *****/
 823   /*************************************************************************/
 824   /*************************************************************************/
 825
 826 #define IS_PS_NEWLINE( ch ) \
 827   ( (ch) == '\r' ||         \
 828     (ch) == '\n' )
 829
 830 #define IS_PS_SPACE( ch )  \
 831   ( (ch) == ' '         || \
 832     IS_PS_NEWLINE( ch ) || \
 833     (ch) == '\t'        || \
 834     (ch) == '\f'        || \
 835     (ch) == '\0' )
 836
 837 #define IS_PS_SPECIAL( ch )       \
 838   ( (ch) == '/'                || \
 839     (ch) == '(' || (ch) == ')' || \
 840     (ch) == '<' || (ch) == '>' || \
 841     (ch) == '[' || (ch) == ']' || \
 842     (ch) == '{' || (ch) == '}' || \
 843     (ch) == '%'                )
 844
 845 #define IS_PS_DELIM( ch )  \
 846   ( IS_PS_SPACE( ch )   || \
 847     IS_PS_SPECIAL( ch ) )
 848
 849 #define IS_PS_DIGIT( ch )        \
 850   ( (ch) >= '0' && (ch) <= '9' )
 851
 852 #define IS_PS_XDIGIT( ch )            \
 853   ( IS_PS_DIGIT( ch )              || \
 854     ( (ch) >= 'A' && (ch) <= 'F' ) || \
 855     ( (ch) >= 'a' && (ch) <= 'f' ) )
 856
 857 #define IS_PS_BASE85( ch )       \
 858   ( (ch) >= '!' && (ch) <= 'u' )
 859
 860 #define IS_PS_TOKEN( cur, limit, token )                                \
 861   ( (char)(cur)[0] == (token)[0]                                     && \
 862     ( (cur) + sizeof ( (token) ) == (limit) ||                          \
 863       ( (cur) + sizeof( (token) ) < (limit)          &&                 \
 864         IS_PS_DELIM( (cur)[sizeof ( (token) ) - 1] ) ) )             && \
 865     ft_strncmp( (char*)(cur), (token), sizeof ( (token) ) - 1 ) == 0 )
 866
 867
 868 FT_END_HEADER
 869
 870 #endif /* __PSAUX_H__ */
 871
 872
 873 /* END */