source: trunk/poppler/freetype2/include/freetype/internal/psaux.h @ 269

Last change on this file since 269 was 269, checked in by Eugene Romanenko, 13 years ago

PDF plugin: freetype library updated to version 2.3.9

File size: 36.1 KB
Line 
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_Long    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  /*    last         :: The last point position.                           */
537  /*                                                                       */
538  /*    pos_x        :: The horizontal translation (if composite glyph).   */
539  /*                                                                       */
540  /*    pos_y        :: The vertical translation (if composite glyph).     */
541  /*                                                                       */
542  /*    left_bearing :: The left side bearing point.                       */
543  /*                                                                       */
544  /*    advance      :: The horizontal advance vector.                     */
545  /*                                                                       */
546  /*    bbox         :: Unused.                                            */
547  /*                                                                       */
548  /*    parse_state  :: An enumeration which controls the charstring       */
549  /*                    parsing state.                                     */
550  /*                                                                       */
551  /*    load_points  :: If this flag is not set, no points are loaded.     */
552  /*                                                                       */
553  /*    no_recurse   :: Set but not used.                                  */
554  /*                                                                       */
555  /*    metrics_only :: A boolean indicating that we only want to compute  */
556  /*                    the metrics of a given glyph, not load all of its  */
557  /*                    points.                                            */
558  /*                                                                       */
559  /*    funcs        :: An array of function pointers for the builder.     */
560  /*                                                                       */
561  typedef struct  T1_BuilderRec_
562  {
563    FT_Memory       memory;
564    FT_Face         face;
565    FT_GlyphSlot    glyph;
566    FT_GlyphLoader  loader;
567    FT_Outline*     base;
568    FT_Outline*     current;
569
570    FT_Vector       last;
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    FT_Bool         shift;
583
584    FT_Bool         metrics_only;
585
586    void*           hints_funcs;    /* hinter-specific */
587    void*           hints_globals;  /* hinter-specific */
588
589    T1_Builder_FuncsRec  funcs;
590
591  } T1_BuilderRec;
592
593
594  /*************************************************************************/
595  /*************************************************************************/
596  /*****                                                               *****/
597  /*****                         T1 DECODER                            *****/
598  /*****                                                               *****/
599  /*************************************************************************/
600  /*************************************************************************/
601
602#if 0
603
604  /*************************************************************************/
605  /*                                                                       */
606  /* T1_MAX_SUBRS_CALLS details the maximum number of nested sub-routine   */
607  /* calls during glyph loading.                                           */
608  /*                                                                       */
609#define T1_MAX_SUBRS_CALLS  8
610
611
612  /*************************************************************************/
613  /*                                                                       */
614  /* T1_MAX_CHARSTRING_OPERANDS is the charstring stack's capacity.  A     */
615  /* minimum of 16 is required.                                            */
616  /*                                                                       */
617#define T1_MAX_CHARSTRINGS_OPERANDS  32
618
619#endif /* 0 */
620
621
622  typedef struct  T1_Decoder_ZoneRec_
623  {
624    FT_Byte*  cursor;
625    FT_Byte*  base;
626    FT_Byte*  limit;
627
628  } T1_Decoder_ZoneRec, *T1_Decoder_Zone;
629
630
631  typedef struct T1_DecoderRec_*              T1_Decoder;
632  typedef const struct T1_Decoder_FuncsRec_*  T1_Decoder_Funcs;
633
634
635  typedef FT_Error
636  (*T1_Decoder_Callback)( T1_Decoder  decoder,
637                          FT_UInt     glyph_index );
638
639
640  typedef struct  T1_Decoder_FuncsRec_
641  {
642    FT_Error
643    (*init)( T1_Decoder           decoder,
644             FT_Face              face,
645             FT_Size              size,
646             FT_GlyphSlot         slot,
647             FT_Byte**            glyph_names,
648             PS_Blend             blend,
649             FT_Bool              hinting,
650             FT_Render_Mode       hint_mode,
651             T1_Decoder_Callback  callback );
652
653    void
654    (*done)( T1_Decoder  decoder );
655
656    FT_Error
657    (*parse_charstrings)( T1_Decoder  decoder,
658                          FT_Byte*    base,
659                          FT_UInt     len );
660
661  } T1_Decoder_FuncsRec;
662
663
664  typedef struct  T1_DecoderRec_
665  {
666    T1_BuilderRec        builder;
667
668    FT_Long              stack[T1_MAX_CHARSTRINGS_OPERANDS];
669    FT_Long*             top;
670
671    T1_Decoder_ZoneRec   zones[T1_MAX_SUBRS_CALLS + 1];
672    T1_Decoder_Zone      zone;
673
674    FT_Service_PsCMaps   psnames;      /* for seac */
675    FT_UInt              num_glyphs;
676    FT_Byte**            glyph_names;
677
678    FT_Int               lenIV;        /* internal for sub routine calls */
679    FT_UInt              num_subrs;
680    FT_Byte**            subrs;
681    FT_PtrDist*          subrs_len;    /* array of subrs length (optional) */
682
683    FT_Matrix            font_matrix;
684    FT_Vector            font_offset;
685
686    FT_Int               flex_state;
687    FT_Int               num_flex_vectors;
688    FT_Vector            flex_vectors[7];
689
690    PS_Blend             blend;       /* for multiple master support */
691
692    FT_Render_Mode       hint_mode;
693
694    T1_Decoder_Callback  parse_callback;
695    T1_Decoder_FuncsRec  funcs;
696
697    FT_Int*              buildchar;
698    FT_UInt              len_buildchar;
699
700  } T1_DecoderRec;
701
702
703  /*************************************************************************/
704  /*************************************************************************/
705  /*****                                                               *****/
706  /*****                            AFM PARSER                         *****/
707  /*****                                                               *****/
708  /*************************************************************************/
709  /*************************************************************************/
710
711  typedef struct AFM_ParserRec_*  AFM_Parser;
712
713  typedef struct  AFM_Parser_FuncsRec_
714  {
715    FT_Error
716    (*init)( AFM_Parser  parser,
717             FT_Memory   memory,
718             FT_Byte*    base,
719             FT_Byte*    limit );
720
721    void
722    (*done)( AFM_Parser  parser );
723
724    FT_Error
725    (*parse)( AFM_Parser  parser );
726
727  } AFM_Parser_FuncsRec;
728
729
730  typedef struct AFM_StreamRec_*  AFM_Stream;
731
732
733  /*************************************************************************/
734  /*                                                                       */
735  /* <Struct>                                                              */
736  /*    AFM_ParserRec                                                      */
737  /*                                                                       */
738  /* <Description>                                                         */
739  /*    An AFM_Parser is a parser for the AFM files.                       */
740  /*                                                                       */
741  /* <Fields>                                                              */
742  /*    memory    :: The object used for memory operations (alloc and      */
743  /*                 realloc).                                             */
744  /*                                                                       */
745  /*    stream    :: This is an opaque object.                             */
746  /*                                                                       */
747  /*    FontInfo  :: The result will be stored here.                       */
748  /*                                                                       */
749  /*    get_index :: A user provided function to get a glyph index by its  */
750  /*                 name.                                                 */
751  /*                                                                       */
752  typedef struct  AFM_ParserRec_
753  {
754    FT_Memory     memory;
755    AFM_Stream    stream;
756
757    AFM_FontInfo  FontInfo;
758
759    FT_Int
760    (*get_index)( const char*  name,
761                  FT_UInt      len,
762                  void*        user_data );
763
764    void*         user_data;
765
766  } AFM_ParserRec;
767
768
769  /*************************************************************************/
770  /*************************************************************************/
771  /*****                                                               *****/
772  /*****                     TYPE1 CHARMAPS                            *****/
773  /*****                                                               *****/
774  /*************************************************************************/
775  /*************************************************************************/
776
777  typedef const struct T1_CMap_ClassesRec_*  T1_CMap_Classes;
778
779  typedef struct T1_CMap_ClassesRec_
780  {
781    FT_CMap_Class  standard;
782    FT_CMap_Class  expert;
783    FT_CMap_Class  custom;
784    FT_CMap_Class  unicode;
785
786  } T1_CMap_ClassesRec;
787
788
789  /*************************************************************************/
790  /*************************************************************************/
791  /*****                                                               *****/
792  /*****                        PSAux Module Interface                 *****/
793  /*****                                                               *****/
794  /*************************************************************************/
795  /*************************************************************************/
796
797  typedef struct  PSAux_ServiceRec_
798  {
799    /* don't use `PS_Table_Funcs' and friends to avoid compiler warnings */
800    const PS_Table_FuncsRec*    ps_table_funcs;
801    const PS_Parser_FuncsRec*   ps_parser_funcs;
802    const T1_Builder_FuncsRec*  t1_builder_funcs;
803    const T1_Decoder_FuncsRec*  t1_decoder_funcs;
804
805    void
806    (*t1_decrypt)( FT_Byte*   buffer,
807                   FT_Offset  length,
808                   FT_UShort  seed );
809
810    T1_CMap_Classes  t1_cmap_classes;
811
812    /* fields after this comment line were added after version 2.1.10 */
813    const AFM_Parser_FuncsRec*  afm_parser_funcs;
814
815  } PSAux_ServiceRec, *PSAux_Service;
816
817  /* backwards-compatible type definition */
818  typedef PSAux_ServiceRec   PSAux_Interface;
819
820
821  /*************************************************************************/
822  /*************************************************************************/
823  /*****                                                               *****/
824  /*****                 Some convenience functions                    *****/
825  /*****                                                               *****/
826  /*************************************************************************/
827  /*************************************************************************/
828
829#define IS_PS_NEWLINE( ch ) \
830  ( (ch) == '\r' ||         \
831    (ch) == '\n' )
832
833#define IS_PS_SPACE( ch )  \
834  ( (ch) == ' '         || \
835    IS_PS_NEWLINE( ch ) || \
836    (ch) == '\t'        || \
837    (ch) == '\f'        || \
838    (ch) == '\0' )
839
840#define IS_PS_SPECIAL( ch )       \
841  ( (ch) == '/'                || \
842    (ch) == '(' || (ch) == ')' || \
843    (ch) == '<' || (ch) == '>' || \
844    (ch) == '[' || (ch) == ']' || \
845    (ch) == '{' || (ch) == '}' || \
846    (ch) == '%'                )
847
848#define IS_PS_DELIM( ch )  \
849  ( IS_PS_SPACE( ch )   || \
850    IS_PS_SPECIAL( ch ) )
851
852#define IS_PS_DIGIT( ch )        \
853  ( (ch) >= '0' && (ch) <= '9' )
854
855#define IS_PS_XDIGIT( ch )            \
856  ( IS_PS_DIGIT( ch )              || \
857    ( (ch) >= 'A' && (ch) <= 'F' ) || \
858    ( (ch) >= 'a' && (ch) <= 'f' ) )
859
860#define IS_PS_BASE85( ch )       \
861  ( (ch) >= '!' && (ch) <= 'u' )
862
863#define IS_PS_TOKEN( cur, limit, token )                                \
864  ( (char)(cur)[0] == (token)[0]                                     && \
865    ( (cur) + sizeof ( (token) ) == (limit) ||                          \
866      ( (cur) + sizeof( (token) ) < (limit)          &&                 \
867        IS_PS_DELIM( (cur)[sizeof ( (token) ) - 1] ) ) )             && \
868    ft_strncmp( (char*)(cur), (token), sizeof ( (token) ) - 1 ) == 0 )
869
870
871FT_END_HEADER
872
873#endif /* __PSAUX_H__ */
874
875
876/* END */
Note: See TracBrowser for help on using the repository browser.