← Back to branch summary

~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

« back to all changes in this revision

Viewing changes to src/3rdparty/freetype/include/freetype/fttypes.h

  • Committer: Package Import Robot
  • Author(s): Timo Jyrinki
  • Date: 2013-02-05 12:46:17 UTC
  • Revision ID: package-import@ubuntu.com-20130205124617-c8jouts182j002fx
Tags: upstream-5.0.1+dfsg
Import upstream version 5.0.1+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/freetype/include/freetype/fttypes.h
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  fttypes.h                                                              */
 
4
/*                                                                         */
 
5
/*    FreeType simple types definitions (specification only).              */
 
6
/*                                                                         */
 
7
/*  Copyright 1996-2001, 2002, 2004, 2006, 2007, 2008 by                   */
 
8
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 
9
/*                                                                         */
 
10
/*  This file is part of the FreeType project, and may only be used,       */
 
11
/*  modified, and distributed under the terms of the FreeType project      */
 
12
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 
13
/*  this file you indicate that you have read the license and              */
 
14
/*  understand and accept it fully.                                        */
 
15
/*                                                                         */
 
16
/***************************************************************************/
 
17
 
 
18
 
 
19
#ifndef __FTTYPES_H__
 
20
#define __FTTYPES_H__
 
21
 
 
22
 
 
23
#include <ft2build.h>
 
24
#include FT_CONFIG_CONFIG_H
 
25
#include FT_SYSTEM_H
 
26
#include FT_IMAGE_H
 
27
 
 
28
#include <stddef.h>
 
29
 
 
30
 
 
31
FT_BEGIN_HEADER
 
32
 
 
33
 
 
34
  /*************************************************************************/
 
35
  /*                                                                       */
 
36
  /* <Section>                                                             */
 
37
  /*    basic_types                                                        */
 
38
  /*                                                                       */
 
39
  /* <Title>                                                               */
 
40
  /*    Basic Data Types                                                   */
 
41
  /*                                                                       */
 
42
  /* <Abstract>                                                            */
 
43
  /*    The basic data types defined by the library.                       */
 
44
  /*                                                                       */
 
45
  /* <Description>                                                         */
 
46
  /*    This section contains the basic data types defined by FreeType~2,  */
 
47
  /*    ranging from simple scalar types to bitmap descriptors.  More      */
 
48
  /*    font-specific structures are defined in a different section.       */
 
49
  /*                                                                       */
 
50
  /* <Order>                                                               */
 
51
  /*    FT_Byte                                                            */
 
52
  /*    FT_Bytes                                                           */
 
53
  /*    FT_Char                                                            */
 
54
  /*    FT_Int                                                             */
 
55
  /*    FT_UInt                                                            */
 
56
  /*    FT_Int16                                                           */
 
57
  /*    FT_UInt16                                                          */
 
58
  /*    FT_Int32                                                           */
 
59
  /*    FT_UInt32                                                          */
 
60
  /*    FT_Short                                                           */
 
61
  /*    FT_UShort                                                          */
 
62
  /*    FT_Long                                                            */
 
63
  /*    FT_ULong                                                           */
 
64
  /*    FT_Bool                                                            */
 
65
  /*    FT_Offset                                                          */
 
66
  /*    FT_PtrDist                                                         */
 
67
  /*    FT_String                                                          */
 
68
  /*    FT_Tag                                                             */
 
69
  /*    FT_Error                                                           */
 
70
  /*    FT_Fixed                                                           */
 
71
  /*    FT_Pointer                                                         */
 
72
  /*    FT_Pos                                                             */
 
73
  /*    FT_Vector                                                          */
 
74
  /*    FT_BBox                                                            */
 
75
  /*    FT_Matrix                                                          */
 
76
  /*    FT_FWord                                                           */
 
77
  /*    FT_UFWord                                                          */
 
78
  /*    FT_F2Dot14                                                         */
 
79
  /*    FT_UnitVector                                                      */
 
80
  /*    FT_F26Dot6                                                         */
 
81
  /*                                                                       */
 
82
  /*                                                                       */
 
83
  /*    FT_Generic                                                         */
 
84
  /*    FT_Generic_Finalizer                                               */
 
85
  /*                                                                       */
 
86
  /*    FT_Bitmap                                                          */
 
87
  /*    FT_Pixel_Mode                                                      */
 
88
  /*    FT_Palette_Mode                                                    */
 
89
  /*    FT_Glyph_Format                                                    */
 
90
  /*    FT_IMAGE_TAG                                                       */
 
91
  /*                                                                       */
 
92
  /*************************************************************************/
 
93
 
 
94
 
 
95
  /*************************************************************************/
 
96
  /*                                                                       */
 
97
  /* <Type>                                                                */
 
98
  /*    FT_Bool                                                            */
 
99
  /*                                                                       */
 
100
  /* <Description>                                                         */
 
101
  /*    A typedef of unsigned char, used for simple booleans.  As usual,   */
 
102
  /*    values 1 and~0 represent true and false, respectively.             */
 
103
  /*                                                                       */
 
104
  typedef unsigned char  FT_Bool;
 
105
 
 
106
 
 
107
  /*************************************************************************/
 
108
  /*                                                                       */
 
109
  /* <Type>                                                                */
 
110
  /*    FT_FWord                                                           */
 
111
  /*                                                                       */
 
112
  /* <Description>                                                         */
 
113
  /*    A signed 16-bit integer used to store a distance in original font  */
 
114
  /*    units.                                                             */
 
115
  /*                                                                       */
 
116
  typedef signed short  FT_FWord;   /* distance in FUnits */
 
117
 
 
118
 
 
119
  /*************************************************************************/
 
120
  /*                                                                       */
 
121
  /* <Type>                                                                */
 
122
  /*    FT_UFWord                                                          */
 
123
  /*                                                                       */
 
124
  /* <Description>                                                         */
 
125
  /*    An unsigned 16-bit integer used to store a distance in original    */
 
126
  /*    font units.                                                        */
 
127
  /*                                                                       */
 
128
  typedef unsigned short  FT_UFWord;  /* unsigned distance */
 
129
 
 
130
 
 
131
  /*************************************************************************/
 
132
  /*                                                                       */
 
133
  /* <Type>                                                                */
 
134
  /*    FT_Char                                                            */
 
135
  /*                                                                       */
 
136
  /* <Description>                                                         */
 
137
  /*    A simple typedef for the _signed_ char type.                       */
 
138
  /*                                                                       */
 
139
  typedef signed char  FT_Char;
 
140
 
 
141
 
 
142
  /*************************************************************************/
 
143
  /*                                                                       */
 
144
  /* <Type>                                                                */
 
145
  /*    FT_Byte                                                            */
 
146
  /*                                                                       */
 
147
  /* <Description>                                                         */
 
148
  /*    A simple typedef for the _unsigned_ char type.                     */
 
149
  /*                                                                       */
 
150
  typedef unsigned char  FT_Byte;
 
151
 
 
152
 
 
153
  /*************************************************************************/
 
154
  /*                                                                       */
 
155
  /* <Type>                                                                */
 
156
  /*    FT_Bytes                                                           */
 
157
  /*                                                                       */
 
158
  /* <Description>                                                         */
 
159
  /*    A typedef for constant memory areas.                               */
 
160
  /*                                                                       */
 
161
  typedef const FT_Byte*  FT_Bytes;
 
162
 
 
163
 
 
164
  /*************************************************************************/
 
165
  /*                                                                       */
 
166
  /* <Type>                                                                */
 
167
  /*    FT_Tag                                                             */
 
168
  /*                                                                       */
 
169
  /* <Description>                                                         */
 
170
  /*    A typedef for 32-bit tags (as used in the SFNT format).             */
 
171
  /*                                                                       */
 
172
  typedef FT_UInt32  FT_Tag;
 
173
 
 
174
 
 
175
  /*************************************************************************/
 
176
  /*                                                                       */
 
177
  /* <Type>                                                                */
 
178
  /*    FT_String                                                          */
 
179
  /*                                                                       */
 
180
  /* <Description>                                                         */
 
181
  /*    A simple typedef for the char type, usually used for strings.      */
 
182
  /*                                                                       */
 
183
  typedef char  FT_String;
 
184
 
 
185
 
 
186
  /*************************************************************************/
 
187
  /*                                                                       */
 
188
  /* <Type>                                                                */
 
189
  /*    FT_Short                                                           */
 
190
  /*                                                                       */
 
191
  /* <Description>                                                         */
 
192
  /*    A typedef for signed short.                                        */
 
193
  /*                                                                       */
 
194
  typedef signed short  FT_Short;
 
195
 
 
196
 
 
197
  /*************************************************************************/
 
198
  /*                                                                       */
 
199
  /* <Type>                                                                */
 
200
  /*    FT_UShort                                                          */
 
201
  /*                                                                       */
 
202
  /* <Description>                                                         */
 
203
  /*    A typedef for unsigned short.                                      */
 
204
  /*                                                                       */
 
205
  typedef unsigned short  FT_UShort;
 
206
 
 
207
 
 
208
  /*************************************************************************/
 
209
  /*                                                                       */
 
210
  /* <Type>                                                                */
 
211
  /*    FT_Int                                                             */
 
212
  /*                                                                       */
 
213
  /* <Description>                                                         */
 
214
  /*    A typedef for the int type.                                        */
 
215
  /*                                                                       */
 
216
  typedef signed int  FT_Int;
 
217
 
 
218
 
 
219
  /*************************************************************************/
 
220
  /*                                                                       */
 
221
  /* <Type>                                                                */
 
222
  /*    FT_UInt                                                            */
 
223
  /*                                                                       */
 
224
  /* <Description>                                                         */
 
225
  /*    A typedef for the unsigned int type.                               */
 
226
  /*                                                                       */
 
227
  typedef unsigned int  FT_UInt;
 
228
 
 
229
 
 
230
  /*************************************************************************/
 
231
  /*                                                                       */
 
232
  /* <Type>                                                                */
 
233
  /*    FT_Long                                                            */
 
234
  /*                                                                       */
 
235
  /* <Description>                                                         */
 
236
  /*    A typedef for signed long.                                         */
 
237
  /*                                                                       */
 
238
  typedef signed long  FT_Long;
 
239
 
 
240
 
 
241
  /*************************************************************************/
 
242
  /*                                                                       */
 
243
  /* <Type>                                                                */
 
244
  /*    FT_ULong                                                           */
 
245
  /*                                                                       */
 
246
  /* <Description>                                                         */
 
247
  /*    A typedef for unsigned long.                                       */
 
248
  /*                                                                       */
 
249
  typedef unsigned long  FT_ULong;
 
250
 
 
251
 
 
252
  /*************************************************************************/
 
253
  /*                                                                       */
 
254
  /* <Type>                                                                */
 
255
  /*    FT_F2Dot14                                                         */
 
256
  /*                                                                       */
 
257
  /* <Description>                                                         */
 
258
  /*    A signed 2.14 fixed float type used for unit vectors.              */
 
259
  /*                                                                       */
 
260
  typedef signed short  FT_F2Dot14;
 
261
 
 
262
 
 
263
  /*************************************************************************/
 
264
  /*                                                                       */
 
265
  /* <Type>                                                                */
 
266
  /*    FT_F26Dot6                                                         */
 
267
  /*                                                                       */
 
268
  /* <Description>                                                         */
 
269
  /*    A signed 26.6 fixed float type used for vectorial pixel            */
 
270
  /*    coordinates.                                                       */
 
271
  /*                                                                       */
 
272
  typedef signed long  FT_F26Dot6;
 
273
 
 
274
 
 
275
  /*************************************************************************/
 
276
  /*                                                                       */
 
277
  /* <Type>                                                                */
 
278
  /*    FT_Fixed                                                           */
 
279
  /*                                                                       */
 
280
  /* <Description>                                                         */
 
281
  /*    This type is used to store 16.16 fixed float values, like scaling  */
 
282
  /*    values or matrix coefficients.                                     */
 
283
  /*                                                                       */
 
284
  typedef signed long  FT_Fixed;
 
285
 
 
286
 
 
287
  /*************************************************************************/
 
288
  /*                                                                       */
 
289
  /* <Type>                                                                */
 
290
  /*    FT_Error                                                           */
 
291
  /*                                                                       */
 
292
  /* <Description>                                                         */
 
293
  /*    The FreeType error code type.  A value of~0 is always interpreted  */
 
294
  /*    as a successful operation.                                         */
 
295
  /*                                                                       */
 
296
  typedef int  FT_Error;
 
297
 
 
298
 
 
299
  /*************************************************************************/
 
300
  /*                                                                       */
 
301
  /* <Type>                                                                */
 
302
  /*    FT_Pointer                                                         */
 
303
  /*                                                                       */
 
304
  /* <Description>                                                         */
 
305
  /*    A simple typedef for a typeless pointer.                           */
 
306
  /*                                                                       */
 
307
  typedef void*  FT_Pointer;
 
308
 
 
309
 
 
310
  /*************************************************************************/
 
311
  /*                                                                       */
 
312
  /* <Type>                                                                */
 
313
  /*    FT_Offset                                                          */
 
314
  /*                                                                       */
 
315
  /* <Description>                                                         */
 
316
  /*    This is equivalent to the ANSI~C `size_t' type, i.e., the largest  */
 
317
  /*    _unsigned_ integer type used to express a file size or position,   */
 
318
  /*    or a memory block size.                                            */
 
319
  /*                                                                       */
 
320
  typedef size_t  FT_Offset;
 
321
 
 
322
 
 
323
  /*************************************************************************/
 
324
  /*                                                                       */
 
325
  /* <Type>                                                                */
 
326
  /*    FT_PtrDist                                                         */
 
327
  /*                                                                       */
 
328
  /* <Description>                                                         */
 
329
  /*    This is equivalent to the ANSI~C `ptrdiff_t' type, i.e., the       */
 
330
  /*    largest _signed_ integer type used to express the distance         */
 
331
  /*    between two pointers.                                              */
 
332
  /*                                                                       */
 
333
  typedef ft_ptrdiff_t  FT_PtrDist;
 
334
 
 
335
 
 
336
  /*************************************************************************/
 
337
  /*                                                                       */
 
338
  /* <Struct>                                                              */
 
339
  /*    FT_UnitVector                                                      */
 
340
  /*                                                                       */
 
341
  /* <Description>                                                         */
 
342
  /*    A simple structure used to store a 2D vector unit vector.  Uses    */
 
343
  /*    FT_F2Dot14 types.                                                  */
 
344
  /*                                                                       */
 
345
  /* <Fields>                                                              */
 
346
  /*    x :: Horizontal coordinate.                                        */
 
347
  /*                                                                       */
 
348
  /*    y :: Vertical coordinate.                                          */
 
349
  /*                                                                       */
 
350
  typedef struct  FT_UnitVector_
 
351
  {
 
352
    FT_F2Dot14  x;
 
353
    FT_F2Dot14  y;
 
354
 
 
355
  } FT_UnitVector;
 
356
 
 
357
 
 
358
  /*************************************************************************/
 
359
  /*                                                                       */
 
360
  /* <Struct>                                                              */
 
361
  /*    FT_Matrix                                                          */
 
362
  /*                                                                       */
 
363
  /* <Description>                                                         */
 
364
  /*    A simple structure used to store a 2x2 matrix.  Coefficients are   */
 
365
  /*    in 16.16 fixed float format.  The computation performed is:        */
 
366
  /*                                                                       */
 
367
  /*       {                                                               */
 
368
  /*          x' = x*xx + y*xy                                             */
 
369
  /*          y' = x*yx + y*yy                                             */
 
370
  /*       }                                                               */
 
371
  /*                                                                       */
 
372
  /* <Fields>                                                              */
 
373
  /*    xx :: Matrix coefficient.                                          */
 
374
  /*                                                                       */
 
375
  /*    xy :: Matrix coefficient.                                          */
 
376
  /*                                                                       */
 
377
  /*    yx :: Matrix coefficient.                                          */
 
378
  /*                                                                       */
 
379
  /*    yy :: Matrix coefficient.                                          */
 
380
  /*                                                                       */
 
381
  typedef struct  FT_Matrix_
 
382
  {
 
383
    FT_Fixed  xx, xy;
 
384
    FT_Fixed  yx, yy;
 
385
 
 
386
  } FT_Matrix;
 
387
 
 
388
 
 
389
  /*************************************************************************/
 
390
  /*                                                                       */
 
391
  /* <Struct>                                                              */
 
392
  /*    FT_Data                                                            */
 
393
  /*                                                                       */
 
394
  /* <Description>                                                         */
 
395
  /*    Read-only binary data represented as a pointer and a length.       */
 
396
  /*                                                                       */
 
397
  /* <Fields>                                                              */
 
398
  /*    pointer :: The data.                                               */
 
399
  /*                                                                       */
 
400
  /*    length  :: The length of the data in bytes.                        */
 
401
  /*                                                                       */
 
402
  typedef struct  FT_Data_
 
403
  {
 
404
    const FT_Byte*  pointer;
 
405
    FT_Int          length;
 
406
 
 
407
  } FT_Data;
 
408
 
 
409
 
 
410
  /*************************************************************************/
 
411
  /*                                                                       */
 
412
  /* <FuncType>                                                            */
 
413
  /*    FT_Generic_Finalizer                                               */
 
414
  /*                                                                       */
 
415
  /* <Description>                                                         */
 
416
  /*    Describe a function used to destroy the `client' data of any       */
 
417
  /*    FreeType object.  See the description of the @FT_Generic type for  */
 
418
  /*    details of usage.                                                  */
 
419
  /*                                                                       */
 
420
  /* <Input>                                                               */
 
421
  /*    The address of the FreeType object which is under finalization.    */
 
422
  /*    Its client data is accessed through its `generic' field.           */
 
423
  /*                                                                       */
 
424
  typedef void  (*FT_Generic_Finalizer)(void*  object);
 
425
 
 
426
 
 
427
  /*************************************************************************/
 
428
  /*                                                                       */
 
429
  /* <Struct>                                                              */
 
430
  /*    FT_Generic                                                         */
 
431
  /*                                                                       */
 
432
  /* <Description>                                                         */
 
433
  /*    Client applications often need to associate their own data to a    */
 
434
  /*    variety of FreeType core objects.  For example, a text layout API  */
 
435
  /*    might want to associate a glyph cache to a given size object.      */
 
436
  /*                                                                       */
 
437
  /*    Most FreeType object contains a `generic' field, of type           */
 
438
  /*    FT_Generic, which usage is left to client applications and font    */
 
439
  /*    servers.                                                           */
 
440
  /*                                                                       */
 
441
  /*    It can be used to store a pointer to client-specific data, as well */
 
442
  /*    as the address of a `finalizer' function, which will be called by  */
 
443
  /*    FreeType when the object is destroyed (for example, the previous   */
 
444
  /*    client example would put the address of the glyph cache destructor */
 
445
  /*    in the `finalizer' field).                                         */
 
446
  /*                                                                       */
 
447
  /* <Fields>                                                              */
 
448
  /*    data      :: A typeless pointer to any client-specified data. This */
 
449
  /*                 field is completely ignored by the FreeType library.  */
 
450
  /*                                                                       */
 
451
  /*    finalizer :: A pointer to a `generic finalizer' function, which    */
 
452
  /*                 will be called when the object is destroyed.  If this */
 
453
  /*                 field is set to NULL, no code will be called.         */
 
454
  /*                                                                       */
 
455
  typedef struct  FT_Generic_
 
456
  {
 
457
    void*                 data;
 
458
    FT_Generic_Finalizer  finalizer;
 
459
 
 
460
  } FT_Generic;
 
461
 
 
462
 
 
463
  /*************************************************************************/
 
464
  /*                                                                       */
 
465
  /* <Macro>                                                               */
 
466
  /*    FT_MAKE_TAG                                                        */
 
467
  /*                                                                       */
 
468
  /* <Description>                                                         */
 
469
  /*    This macro converts four-letter tags which are used to label       */
 
470
  /*    TrueType tables into an unsigned long to be used within FreeType.  */
 
471
  /*                                                                       */
 
472
  /* <Note>                                                                */
 
473
  /*    The produced values *must* be 32-bit integers.  Don't redefine     */
 
474
  /*    this macro.                                                        */
 
475
  /*                                                                       */
 
476
#define FT_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
 
477
          ( ( (FT_ULong)_x1 << 24 ) |     \
 
478
            ( (FT_ULong)_x2 << 16 ) |     \
 
479
            ( (FT_ULong)_x3 <<  8 ) |     \
 
480
              (FT_ULong)_x4         )
 
481
 
 
482
 
 
483
  /*************************************************************************/
 
484
  /*************************************************************************/
 
485
  /*                                                                       */
 
486
  /*                    L I S T   M A N A G E M E N T                      */
 
487
  /*                                                                       */
 
488
  /*************************************************************************/
 
489
  /*************************************************************************/
 
490
 
 
491
 
 
492
  /*************************************************************************/
 
493
  /*                                                                       */
 
494
  /* <Section>                                                             */
 
495
  /*    list_processing                                                    */
 
496
  /*                                                                       */
 
497
  /*************************************************************************/
 
498
 
 
499
 
 
500
  /*************************************************************************/
 
501
  /*                                                                       */
 
502
  /* <Type>                                                                */
 
503
  /*    FT_ListNode                                                        */
 
504
  /*                                                                       */
 
505
  /* <Description>                                                         */
 
506
  /*     Many elements and objects in FreeType are listed through an       */
 
507
  /*     @FT_List record (see @FT_ListRec).  As its name suggests, an      */
 
508
  /*     FT_ListNode is a handle to a single list element.                 */
 
509
  /*                                                                       */
 
510
  typedef struct FT_ListNodeRec_*  FT_ListNode;
 
511
 
 
512
 
 
513
  /*************************************************************************/
 
514
  /*                                                                       */
 
515
  /* <Type>                                                                */
 
516
  /*    FT_List                                                            */
 
517
  /*                                                                       */
 
518
  /* <Description>                                                         */
 
519
  /*    A handle to a list record (see @FT_ListRec).                       */
 
520
  /*                                                                       */
 
521
  typedef struct FT_ListRec_*  FT_List;
 
522
 
 
523
 
 
524
  /*************************************************************************/
 
525
  /*                                                                       */
 
526
  /* <Struct>                                                              */
 
527
  /*    FT_ListNodeRec                                                     */
 
528
  /*                                                                       */
 
529
  /* <Description>                                                         */
 
530
  /*    A structure used to hold a single list element.                    */
 
531
  /*                                                                       */
 
532
  /* <Fields>                                                              */
 
533
  /*    prev :: The previous element in the list.  NULL if first.          */
 
534
  /*                                                                       */
 
535
  /*    next :: The next element in the list.  NULL if last.               */
 
536
  /*                                                                       */
 
537
  /*    data :: A typeless pointer to the listed object.                   */
 
538
  /*                                                                       */
 
539
  typedef struct  FT_ListNodeRec_
 
540
  {
 
541
    FT_ListNode  prev;
 
542
    FT_ListNode  next;
 
543
    void*        data;
 
544
 
 
545
  } FT_ListNodeRec;
 
546
 
 
547
 
 
548
  /*************************************************************************/
 
549
  /*                                                                       */
 
550
  /* <Struct>                                                              */
 
551
  /*    FT_ListRec                                                         */
 
552
  /*                                                                       */
 
553
  /* <Description>                                                         */
 
554
  /*    A structure used to hold a simple doubly-linked list.  These are   */
 
555
  /*    used in many parts of FreeType.                                    */
 
556
  /*                                                                       */
 
557
  /* <Fields>                                                              */
 
558
  /*    head :: The head (first element) of doubly-linked list.            */
 
559
  /*                                                                       */
 
560
  /*    tail :: The tail (last element) of doubly-linked list.             */
 
561
  /*                                                                       */
 
562
  typedef struct  FT_ListRec_
 
563
  {
 
564
    FT_ListNode  head;
 
565
    FT_ListNode  tail;
 
566
 
 
567
  } FT_ListRec;
 
568
 
 
569
 
 
570
  /* */
 
571
 
 
572
#define FT_IS_EMPTY( list )  ( (list).head == 0 )
 
573
 
 
574
  /* return base error code (without module-specific prefix) */
 
575
#define FT_ERROR_BASE( x )    ( (x) & 0xFF )
 
576
 
 
577
  /* return module error code */
 
578
#define FT_ERROR_MODULE( x )  ( (x) & 0xFF00U )
 
579
 
 
580
#define FT_BOOL( x )  ( (FT_Bool)( x ) )
 
581
 
 
582
FT_END_HEADER
 
583
 
 
584
#endif /* __FTTYPES_H__ */
 
585
 
 
586
 
 
587
/* END */