← Back to branch summary

~ubuntu-branches/ubuntu/saucy/emscripten/saucy-proposed

« back to all changes in this revision

Viewing changes to tests/freetype/include/freetype/internal/psaux.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

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