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