XFA: merge patch from CL 817753002
[pdfium.git] / core / include / thirdparties / freetype / 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-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 "ftobjs.h"
26 #include "t1types.h"
27 #include "services/svpscmap.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 */