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

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

PDF plugin: freetype library updated to version 2.3.5

File size: 35.8 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 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_INFO,
201    T1_FIELD_LOCATION_PRIVATE,
202    T1_FIELD_LOCATION_BBOX,
203    T1_FIELD_LOCATION_LOADER,
204    T1_FIELD_LOCATION_FACE,
205    T1_FIELD_LOCATION_BLEND,
206
207    /* do not remove */
208    T1_FIELD_LOCATION_MAX
209
210  } T1_FieldLocation;
211
212
213  typedef void
214  (*T1_Field_ParseFunc)( FT_Face     face,
215                         FT_Pointer  parser );
216
217
218  /* structure type used to model object fields */
219  typedef struct  T1_FieldRec_
220  {
221    const char*         ident;        /* field identifier               */
222    T1_FieldLocation    location;
223    T1_FieldType        type;         /* type of field                  */
224    T1_Field_ParseFunc  reader;
225    FT_UInt             offset;       /* offset of field in object      */
226    FT_Byte             size;         /* size of field in bytes         */
227    FT_UInt             array_max;    /* maximal number of elements for */
228                                      /* array                          */
229    FT_UInt             count_offset; /* offset of element count for    */
230                                      /* arrays                         */
231    FT_UInt             dict;         /* where we expect it             */
232  } T1_FieldRec;
233
234#define T1_FIELD_DICT_FONTDICT ( 1 << 0 ) /* also FontInfo and FDArray */
235#define T1_FIELD_DICT_PRIVATE  ( 1 << 1 )
236
237
238
239#define T1_NEW_SIMPLE_FIELD( _ident, _type, _fname, _dict ) \
240          {                                                 \
241            _ident, T1CODE, _type,                          \
242            0,                                              \
243            FT_FIELD_OFFSET( _fname ),                      \
244            FT_FIELD_SIZE( _fname ),                        \
245            0, 0,                                           \
246            _dict                                           \
247          },
248
249#define T1_NEW_CALLBACK_FIELD( _ident, _reader, _dict ) \
250          {                                             \
251            _ident, T1CODE, T1_FIELD_TYPE_CALLBACK,     \
252            (T1_Field_ParseFunc)_reader,                \
253            0, 0,                                       \
254            0, 0,                                       \
255            _dict                                       \
256          },
257
258#define T1_NEW_TABLE_FIELD( _ident, _type, _fname, _max, _dict ) \
259          {                                                      \
260            _ident, T1CODE, _type,                               \
261            0,                                                   \
262            FT_FIELD_OFFSET( _fname ),                           \
263            FT_FIELD_SIZE_DELTA( _fname ),                       \
264            _max,                                                \
265            FT_FIELD_OFFSET( num_ ## _fname ),                   \
266            _dict                                                \
267          },
268
269#define T1_NEW_TABLE_FIELD2( _ident, _type, _fname, _max, _dict ) \
270          {                                                       \
271            _ident, T1CODE, _type,                                \
272            0,                                                    \
273            FT_FIELD_OFFSET( _fname ),                            \
274            FT_FIELD_SIZE_DELTA( _fname ),                        \
275            _max, 0,                                              \
276            _dict                                                 \
277          },
278
279
280#define T1_FIELD_BOOL( _ident, _fname, _dict )                             \
281          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_BOOL, _fname, _dict )
282
283#define T1_FIELD_NUM( _ident, _fname, _dict )                                 \
284          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER, _fname, _dict )
285
286#define T1_FIELD_FIXED( _ident, _fname, _dict )                             \
287          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_FIXED, _fname, _dict )
288
289#define T1_FIELD_FIXED_1000( _ident, _fname, _dict )                     \
290          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_FIXED_1000, _fname, \
291                               _dict )
292
293#define T1_FIELD_STRING( _ident, _fname, _dict )                             \
294          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_STRING, _fname, _dict )
295
296#define T1_FIELD_KEY( _ident, _fname, _dict )                             \
297          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_KEY, _fname, _dict )
298
299#define T1_FIELD_BBOX( _ident, _fname, _dict )                             \
300          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_BBOX, _fname, _dict )
301
302
303#define T1_FIELD_NUM_TABLE( _ident, _fname, _fmax, _dict )         \
304          T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \
305                              _fname, _fmax, _dict )
306
307#define T1_FIELD_FIXED_TABLE( _ident, _fname, _fmax, _dict )     \
308          T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \
309                              _fname, _fmax, _dict )
310
311#define T1_FIELD_NUM_TABLE2( _ident, _fname, _fmax, _dict )         \
312          T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \
313                               _fname, _fmax, _dict )
314
315#define T1_FIELD_FIXED_TABLE2( _ident, _fname, _fmax, _dict )     \
316          T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \
317                               _fname, _fmax, _dict )
318
319#define T1_FIELD_CALLBACK( _ident, _name, _dict )       \
320          T1_NEW_CALLBACK_FIELD( _ident, _name, _dict )
321
322
323  /*************************************************************************/
324  /*************************************************************************/
325  /*****                                                               *****/
326  /*****                            T1 PARSER                          *****/
327  /*****                                                               *****/
328  /*************************************************************************/
329  /*************************************************************************/
330
331  typedef const struct PS_Parser_FuncsRec_*  PS_Parser_Funcs;
332
333  typedef struct  PS_Parser_FuncsRec_
334  {
335    void
336    (*init)( PS_Parser  parser,
337             FT_Byte*   base,
338             FT_Byte*   limit,
339             FT_Memory  memory );
340
341    void
342    (*done)( PS_Parser  parser );
343
344    void
345    (*skip_spaces)( PS_Parser  parser );
346    void
347    (*skip_PS_token)( PS_Parser  parser );
348
349    FT_Long
350    (*to_int)( PS_Parser  parser );
351    FT_Fixed
352    (*to_fixed)( PS_Parser  parser,
353                 FT_Int     power_ten );
354
355    FT_Error
356    (*to_bytes)( PS_Parser  parser,
357                 FT_Byte*   bytes,
358                 FT_Long    max_bytes,
359                 FT_Long*   pnum_bytes,
360                 FT_Bool    delimiters );
361
362    FT_Int
363    (*to_coord_array)( PS_Parser  parser,
364                       FT_Int     max_coords,
365                       FT_Short*  coords );
366    FT_Int
367    (*to_fixed_array)( PS_Parser  parser,
368                       FT_Int     max_values,
369                       FT_Fixed*  values,
370                       FT_Int     power_ten );
371
372    void
373    (*to_token)( PS_Parser  parser,
374                 T1_Token   token );
375    void
376    (*to_token_array)( PS_Parser  parser,
377                       T1_Token   tokens,
378                       FT_UInt    max_tokens,
379                       FT_Int*    pnum_tokens );
380
381    FT_Error
382    (*load_field)( PS_Parser       parser,
383                   const T1_Field  field,
384                   void**          objects,
385                   FT_UInt         max_objects,
386                   FT_ULong*       pflags );
387
388    FT_Error
389    (*load_field_table)( PS_Parser       parser,
390                         const T1_Field  field,
391                         void**          objects,
392                         FT_UInt         max_objects,
393                         FT_ULong*       pflags );
394
395  } PS_Parser_FuncsRec;
396
397
398  /*************************************************************************/
399  /*                                                                       */
400  /* <Struct>                                                              */
401  /*    PS_ParserRec                                                       */
402  /*                                                                       */
403  /* <Description>                                                         */
404  /*    A PS_Parser is an object used to parse a Type 1 font very quickly. */
405  /*                                                                       */
406  /* <Fields>                                                              */
407  /*    cursor :: The current position in the text.                        */
408  /*                                                                       */
409  /*    base   :: Start of the processed text.                             */
410  /*                                                                       */
411  /*    limit  :: End of the processed text.                               */
412  /*                                                                       */
413  /*    error  :: The last error returned.                                 */
414  /*                                                                       */
415  /*    memory :: The object used for memory operations (alloc/realloc).   */
416  /*                                                                       */
417  /*    funcs  :: A table of functions for the parser.                     */
418  /*                                                                       */
419  typedef struct  PS_ParserRec_
420  {
421    FT_Byte*   cursor;
422    FT_Byte*   base;
423    FT_Byte*   limit;
424    FT_Error   error;
425    FT_Memory  memory;
426
427    PS_Parser_FuncsRec  funcs;
428
429  } PS_ParserRec;
430
431
432  /*************************************************************************/
433  /*************************************************************************/
434  /*****                                                               *****/
435  /*****                         T1 BUILDER                            *****/
436  /*****                                                               *****/
437  /*************************************************************************/
438  /*************************************************************************/
439
440
441  typedef struct T1_BuilderRec_*  T1_Builder;
442
443
444  typedef FT_Error
445  (*T1_Builder_Check_Points_Func)( T1_Builder  builder,
446                                   FT_Int      count );
447
448  typedef void
449  (*T1_Builder_Add_Point_Func)( T1_Builder  builder,
450                                FT_Pos      x,
451                                FT_Pos      y,
452                                FT_Byte     flag );
453
454  typedef FT_Error
455  (*T1_Builder_Add_Point1_Func)( T1_Builder  builder,
456                                 FT_Pos      x,
457                                 FT_Pos      y );
458
459  typedef FT_Error
460  (*T1_Builder_Add_Contour_Func)( T1_Builder  builder );
461
462  typedef FT_Error
463  (*T1_Builder_Start_Point_Func)( T1_Builder  builder,
464                                  FT_Pos      x,
465                                  FT_Pos      y );
466
467  typedef void
468  (*T1_Builder_Close_Contour_Func)( T1_Builder  builder );
469
470
471  typedef const struct T1_Builder_FuncsRec_*  T1_Builder_Funcs;
472
473  typedef struct  T1_Builder_FuncsRec_
474  {
475    void
476    (*init)( T1_Builder    builder,
477             FT_Face       face,
478             FT_Size       size,
479             FT_GlyphSlot  slot,
480             FT_Bool       hinting );
481
482    void
483    (*done)( T1_Builder   builder );
484
485    T1_Builder_Check_Points_Func   check_points;
486    T1_Builder_Add_Point_Func      add_point;
487    T1_Builder_Add_Point1_Func     add_point1;
488    T1_Builder_Add_Contour_Func    add_contour;
489    T1_Builder_Start_Point_Func    start_point;
490    T1_Builder_Close_Contour_Func  close_contour;
491
492  } T1_Builder_FuncsRec;
493
494
495  /* an enumeration type to handle charstring parsing states */
496  typedef enum  T1_ParseState_
497  {
498    T1_Parse_Start,
499    T1_Parse_Have_Width,
500    T1_Parse_Have_Moveto,
501    T1_Parse_Have_Path
502
503  } T1_ParseState;
504
505
506  /*************************************************************************/
507  /*                                                                       */
508  /* <Structure>                                                           */
509  /*    T1_BuilderRec                                                      */
510  /*                                                                       */
511  /* <Description>                                                         */
512  /*     A structure used during glyph loading to store its outline.       */
513  /*                                                                       */
514  /* <Fields>                                                              */
515  /*    memory       :: The current memory object.                         */
516  /*                                                                       */
517  /*    face         :: The current face object.                           */
518  /*                                                                       */
519  /*    glyph        :: The current glyph slot.                            */
520  /*                                                                       */
521  /*    loader       :: XXX                                                */
522  /*                                                                       */
523  /*    base         :: The base glyph outline.                            */
524  /*                                                                       */
525  /*    current      :: The current glyph outline.                         */
526  /*                                                                       */
527  /*    max_points   :: maximum points in builder outline                  */
528  /*                                                                       */
529  /*    max_contours :: Maximal number of contours in builder outline.     */
530  /*                                                                       */
531  /*    last         :: The last point position.                           */
532  /*                                                                       */
533  /*    pos_x        :: The horizontal translation (if composite glyph).   */
534  /*                                                                       */
535  /*    pos_y        :: The vertical translation (if composite glyph).     */
536  /*                                                                       */
537  /*    left_bearing :: The left side bearing point.                       */
538  /*                                                                       */
539  /*    advance      :: The horizontal advance vector.                     */
540  /*                                                                       */
541  /*    bbox         :: Unused.                                            */
542  /*                                                                       */
543  /*    parse_state  :: An enumeration which controls the charstring       */
544  /*                    parsing state.                                     */
545  /*                                                                       */
546  /*    load_points  :: If this flag is not set, no points are loaded.     */
547  /*                                                                       */
548  /*    no_recurse   :: Set but not used.                                  */
549  /*                                                                       */
550  /*    metrics_only :: A boolean indicating that we only want to compute  */
551  /*                    the metrics of a given glyph, not load all of its  */
552  /*                    points.                                            */
553  /*                                                                       */
554  /*    funcs        :: An array of function pointers for the builder.     */
555  /*                                                                       */
556  typedef struct  T1_BuilderRec_
557  {
558    FT_Memory       memory;
559    FT_Face         face;
560    FT_GlyphSlot    glyph;
561    FT_GlyphLoader  loader;
562    FT_Outline*     base;
563    FT_Outline*     current;
564
565    FT_Vector       last;
566
567    FT_Pos          pos_x;
568    FT_Pos          pos_y;
569
570    FT_Vector       left_bearing;
571    FT_Vector       advance;
572
573    FT_BBox         bbox;          /* bounding box */
574    T1_ParseState   parse_state;
575    FT_Bool         load_points;
576    FT_Bool         no_recurse;
577    FT_Bool         shift;
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_Int*              buildchar;
693    FT_UInt              len_buildchar;
694
695  } T1_DecoderRec;
696
697
698  /*************************************************************************/
699  /*************************************************************************/
700  /*****                                                               *****/
701  /*****                            AFM PARSER                         *****/
702  /*****                                                               *****/
703  /*************************************************************************/
704  /*************************************************************************/
705
706  typedef struct AFM_ParserRec_*  AFM_Parser;
707
708  typedef struct  AFM_Parser_FuncsRec_
709  {
710    FT_Error
711    (*init)( AFM_Parser  parser,
712             FT_Memory   memory,
713             FT_Byte*    base,
714             FT_Byte*    limit );
715
716    void
717    (*done)( AFM_Parser  parser );
718
719    FT_Error
720    (*parse)( AFM_Parser  parser );
721
722  } AFM_Parser_FuncsRec;
723
724
725  typedef struct AFM_StreamRec_*  AFM_Stream;
726
727
728  /*************************************************************************/
729  /*                                                                       */
730  /* <Struct>                                                              */
731  /*    AFM_ParserRec                                                      */
732  /*                                                                       */
733  /* <Description>                                                         */
734  /*    An AFM_Parser is a parser for the AFM files.                       */
735  /*                                                                       */
736  /* <Fields>                                                              */
737  /*    memory    :: The object used for memory operations (alloc and      */
738  /*                 realloc).                                             */
739  /*                                                                       */
740  /*    stream    :: This is an opaque object.                             */
741  /*                                                                       */
742  /*    FontInfo  :: The result will be stored here.                       */
743  /*                                                                       */
744  /*    get_index :: A user provided function to get a glyph index by its  */
745  /*                 name.                                                 */
746  /*                                                                       */
747  typedef struct  AFM_ParserRec_
748  {
749    FT_Memory     memory;
750    AFM_Stream    stream;
751
752    AFM_FontInfo  FontInfo;
753
754    FT_Int
755    (*get_index)( const char*  name,
756                  FT_UInt      len,
757                  void*        user_data );
758
759    void*         user_data;
760
761  } AFM_ParserRec;
762
763
764  /*************************************************************************/
765  /*************************************************************************/
766  /*****                                                               *****/
767  /*****                     TYPE1 CHARMAPS                            *****/
768  /*****                                                               *****/
769  /*************************************************************************/
770  /*************************************************************************/
771
772  typedef const struct T1_CMap_ClassesRec_*  T1_CMap_Classes;
773
774  typedef struct T1_CMap_ClassesRec_
775  {
776    FT_CMap_Class  standard;
777    FT_CMap_Class  expert;
778    FT_CMap_Class  custom;
779    FT_CMap_Class  unicode;
780
781  } T1_CMap_ClassesRec;
782
783
784  /*************************************************************************/
785  /*************************************************************************/
786  /*****                                                               *****/
787  /*****                        PSAux Module Interface                 *****/
788  /*****                                                               *****/
789  /*************************************************************************/
790  /*************************************************************************/
791
792  typedef struct  PSAux_ServiceRec_
793  {
794    /* don't use `PS_Table_Funcs' and friends to avoid compiler warnings */
795    const PS_Table_FuncsRec*    ps_table_funcs;
796    const PS_Parser_FuncsRec*   ps_parser_funcs;
797    const T1_Builder_FuncsRec*  t1_builder_funcs;
798    const T1_Decoder_FuncsRec*  t1_decoder_funcs;
799
800    void
801    (*t1_decrypt)( FT_Byte*   buffer,
802                   FT_Offset  length,
803                   FT_UShort  seed );
804
805    T1_CMap_Classes  t1_cmap_classes;
806
807    /* fields after this comment line were added after version 2.1.10 */
808    const AFM_Parser_FuncsRec*  afm_parser_funcs;
809
810  } PSAux_ServiceRec, *PSAux_Service;
811
812  /* backwards-compatible type definition */
813  typedef PSAux_ServiceRec   PSAux_Interface;
814
815
816  /*************************************************************************/
817  /*************************************************************************/
818  /*****                                                               *****/
819  /*****                 Some convenience functions                    *****/
820  /*****                                                               *****/
821  /*************************************************************************/
822  /*************************************************************************/
823
824#define IS_PS_NEWLINE( ch ) \
825  ( (ch) == '\r' ||         \
826    (ch) == '\n' )
827
828#define IS_PS_SPACE( ch )  \
829  ( (ch) == ' '         || \
830    IS_PS_NEWLINE( ch ) || \
831    (ch) == '\t'        || \
832    (ch) == '\f'        || \
833    (ch) == '\0' )
834
835#define IS_PS_SPECIAL( ch )       \
836  ( (ch) == '/'                || \
837    (ch) == '(' || (ch) == ')' || \
838    (ch) == '<' || (ch) == '>' || \
839    (ch) == '[' || (ch) == ']' || \
840    (ch) == '{' || (ch) == '}' || \
841    (ch) == '%'                )
842
843#define IS_PS_DELIM( ch )  \
844  ( IS_PS_SPACE( ch )   || \
845    IS_PS_SPECIAL( ch ) )
846
847#define IS_PS_DIGIT( ch )        \
848  ( (ch) >= '0' && (ch) <= '9' )
849
850#define IS_PS_XDIGIT( ch )            \
851  ( IS_PS_DIGIT( ch )              || \
852    ( (ch) >= 'A' && (ch) <= 'F' ) || \
853    ( (ch) >= 'a' && (ch) <= 'f' ) )
854
855#define IS_PS_BASE85( ch )       \
856  ( (ch) >= '!' && (ch) <= 'u' )
857
858#define IS_PS_TOKEN( cur, limit, token )                                \
859  ( (char)(cur)[0] == (token)[0]                                     && \
860    ( (cur) + sizeof ( (token) ) == (limit) ||                          \
861      ( (cur) + sizeof( (token) ) < (limit)          &&                 \
862        IS_PS_DELIM( (cur)[sizeof ( (token) ) - 1] ) ) )             && \
863    ft_strncmp( (char*)(cur), (token), sizeof ( (token) ) - 1 ) == 0 )
864
865
866FT_END_HEADER
867
868#endif /* __PSAUX_H__ */
869
870
871/* END */
Note: See TracBrowser for help on using the repository browser.