PageRenderTime 66ms CodeModel.GetById 32ms app.highlight 26ms RepoModel.GetById 2ms app.codeStats 0ms

/src/freetype/include/freetype/internal/psaux.h

https://bitbucket.org/cabalistic/ogredeps/
C++ Header | 873 lines | 440 code | 188 blank | 245 comment | 44 complexity | 552f2a91c920ed475a51e11ffdbca213 MD5 | raw file
  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
 30FT_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
868FT_END_HEADER
869
870#endif /* __PSAUX_H__ */
871
872
873/* END */