← 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/ftserv.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/ftserv.h
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  ftserv.h                                                               */
 
4
/*                                                                         */
 
5
/*    The FreeType services (specification only).                          */
 
6
/*                                                                         */
 
7
/*  Copyright 2003, 2004, 2005, 2006, 2007 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
  /*                                                                       */
 
20
  /*  Each module can export one or more `services'.  Each service is      */
 
21
  /*  identified by a constant string and modeled by a pointer; the latter */
 
22
  /*  generally corresponds to a structure containing function pointers.   */
 
23
  /*                                                                       */
 
24
  /*  Note that a service's data cannot be a mere function pointer because */
 
25
  /*  in C it is possible that function pointers might be implemented      */
 
26
  /*  differently than data pointers (e.g. 48 bits instead of 32).         */
 
27
  /*                                                                       */
 
28
  /*************************************************************************/
 
29
 
 
30
 
 
31
#ifndef __FTSERV_H__
 
32
#define __FTSERV_H__
 
33
 
 
34
 
 
35
FT_BEGIN_HEADER
 
36
 
 
37
#if defined( _MSC_VER )      /* Visual C++ (and Intel C++) */
 
38
 
 
39
  /* we disable the warning `conditional expression is constant' here */
 
40
  /* in order to compile cleanly with the maximum level of warnings   */
 
41
#pragma warning( disable : 4127 )
 
42
 
 
43
#endif /* _MSC_VER */
 
44
 
 
45
  /*
 
46
   * @macro:
 
47
   *   FT_FACE_FIND_SERVICE
 
48
   *
 
49
   * @description:
 
50
   *   This macro is used to look up a service from a face's driver module.
 
51
   *
 
52
   * @input:
 
53
   *   face ::
 
54
   *     The source face handle.
 
55
   *
 
56
   *   id ::
 
57
   *     A string describing the service as defined in the service's
 
58
   *     header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
 
59
   *     `multi-masters').  It is automatically prefixed with
 
60
   *     `FT_SERVICE_ID_'.
 
61
   *
 
62
   * @output:
 
63
   *   ptr ::
 
64
   *     A variable that receives the service pointer.  Will be NULL
 
65
   *     if not found.
 
66
   */
 
67
#ifdef __cplusplus
 
68
 
 
69
#define FT_FACE_FIND_SERVICE( face, ptr, id )                               \
 
70
  FT_BEGIN_STMNT                                                            \
 
71
    FT_Module    module = FT_MODULE( FT_FACE( face )->driver );             \
 
72
    FT_Pointer   _tmp_  = NULL;                                             \
 
73
    FT_Pointer*  _pptr_ = (FT_Pointer*)&(ptr);                              \
 
74
                                                                            \
 
75
                                                                            \
 
76
    if ( module->clazz->get_interface )                                     \
 
77
      _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
 
78
    *_pptr_ = _tmp_;                                                        \
 
79
  FT_END_STMNT
 
80
 
 
81
#else /* !C++ */
 
82
 
 
83
#define FT_FACE_FIND_SERVICE( face, ptr, id )                               \
 
84
  FT_BEGIN_STMNT                                                            \
 
85
    FT_Module   module = FT_MODULE( FT_FACE( face )->driver );              \
 
86
    FT_Pointer  _tmp_  = NULL;                                              \
 
87
                                                                            \
 
88
    if ( module->clazz->get_interface )                                     \
 
89
      _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
 
90
    ptr = _tmp_;                                                            \
 
91
  FT_END_STMNT
 
92
 
 
93
#endif /* !C++ */
 
94
 
 
95
  /*
 
96
   * @macro:
 
97
   *   FT_FACE_FIND_GLOBAL_SERVICE
 
98
   *
 
99
   * @description:
 
100
   *   This macro is used to look up a service from all modules.
 
101
   *
 
102
   * @input:
 
103
   *   face ::
 
104
   *     The source face handle.
 
105
   *
 
106
   *   id ::
 
107
   *     A string describing the service as defined in the service's
 
108
   *     header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
 
109
   *     `multi-masters').  It is automatically prefixed with
 
110
   *     `FT_SERVICE_ID_'.
 
111
   *
 
112
   * @output:
 
113
   *   ptr ::
 
114
   *     A variable that receives the service pointer.  Will be NULL
 
115
   *     if not found.
 
116
   */
 
117
#ifdef __cplusplus
 
118
 
 
119
#define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id )               \
 
120
  FT_BEGIN_STMNT                                                   \
 
121
    FT_Module    module = FT_MODULE( FT_FACE( face )->driver );    \
 
122
    FT_Pointer   _tmp_;                                            \
 
123
    FT_Pointer*  _pptr_ = (FT_Pointer*)&(ptr);                     \
 
124
                                                                   \
 
125
                                                                   \
 
126
    _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
 
127
    *_pptr_ = _tmp_;                                               \
 
128
  FT_END_STMNT
 
129
 
 
130
#else /* !C++ */
 
131
 
 
132
#define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id )               \
 
133
  FT_BEGIN_STMNT                                                   \
 
134
    FT_Module   module = FT_MODULE( FT_FACE( face )->driver );     \
 
135
    FT_Pointer  _tmp_;                                             \
 
136
                                                                   \
 
137
                                                                   \
 
138
    _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
 
139
    ptr   = _tmp_;                                                 \
 
140
  FT_END_STMNT
 
141
 
 
142
#endif /* !C++ */
 
143
 
 
144
 
 
145
  /*************************************************************************/
 
146
  /*************************************************************************/
 
147
  /*****                                                               *****/
 
148
  /*****         S E R V I C E   D E S C R I P T O R S                 *****/
 
149
  /*****                                                               *****/
 
150
  /*************************************************************************/
 
151
  /*************************************************************************/
 
152
 
 
153
  /*
 
154
   *  The following structure is used to _describe_ a given service
 
155
   *  to the library.  This is useful to build simple static service lists.
 
156
   */
 
157
  typedef struct  FT_ServiceDescRec_
 
158
  {
 
159
    const char*  serv_id;     /* service name         */
 
160
    const void*  serv_data;   /* service pointer/data */
 
161
 
 
162
  } FT_ServiceDescRec;
 
163
 
 
164
  typedef const FT_ServiceDescRec*  FT_ServiceDesc;
 
165
 
 
166
  /*************************************************************************/
 
167
  /*                                                                       */
 
168
  /* <Macro>                                                               */
 
169
  /*    FT_DEFINE_SERVICEDESCREC1 .. FT_DEFINE_SERVICEDESCREC6             */
 
170
  /*                                                                       */
 
171
  /* <Description>                                                         */
 
172
  /*    Used to initialize an array of FT_ServiceDescRec structs.          */
 
173
  /*                                                                       */
 
174
  /*    When FT_CONFIG_OPTION_PIC is defined a Create funtion will need    */
 
175
  /*    to called with a pointer where the allocated array is returned.    */
 
176
  /*    And when it is no longer needed a Destroy function needs           */
 
177
  /*    to be called to release that allocation.                           */
 
178
  /*                                                                       */
 
179
  /*    These functions should be manyally called from the pic_init and    */
 
180
  /*    pic_free functions of your module (see FT_DEFINE_MODULE)           */
 
181
  /*                                                                       */
 
182
  /*    When FT_CONFIG_OPTION_PIC is not defined the array will be         */
 
183
  /*    allocated in the global scope (or the scope where the macro        */
 
184
  /*    is used).                                                          */
 
185
  /*                                                                       */
 
186
#ifndef FT_CONFIG_OPTION_PIC
 
187
 
 
188
#define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
 
189
  static const FT_ServiceDescRec class_[] =                                  \
 
190
  {                                                                          \
 
191
  {serv_id_1, serv_data_1},                                                  \
 
192
  {NULL, NULL}                                                               \
 
193
  };
 
194
#define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
 
195
        serv_id_2, serv_data_2)                                              \
 
196
  static const FT_ServiceDescRec class_[] =                                  \
 
197
  {                                                                          \
 
198
  {serv_id_1, serv_data_1},                                                  \
 
199
  {serv_id_2, serv_data_2},                                                  \
 
200
  {NULL, NULL}                                                               \
 
201
  };
 
202
#define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
 
203
        serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
 
204
  static const FT_ServiceDescRec class_[] =                                  \
 
205
  {                                                                          \
 
206
  {serv_id_1, serv_data_1},                                                  \
 
207
  {serv_id_2, serv_data_2},                                                  \
 
208
  {serv_id_3, serv_data_3},                                                  \
 
209
  {NULL, NULL}                                                               \
 
210
  };
 
211
#define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
 
212
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
213
        serv_id_4, serv_data_4)                                              \
 
214
  static const FT_ServiceDescRec class_[] =                                  \
 
215
  {                                                                          \
 
216
  {serv_id_1, serv_data_1},                                                  \
 
217
  {serv_id_2, serv_data_2},                                                  \
 
218
  {serv_id_3, serv_data_3},                                                  \
 
219
  {serv_id_4, serv_data_4},                                                  \
 
220
  {NULL, NULL}                                                               \
 
221
  };
 
222
#define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
 
223
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
224
        serv_id_4, serv_data_4, serv_id_5, serv_data_5)                      \
 
225
  static const FT_ServiceDescRec class_[] =                                  \
 
226
  {                                                                          \
 
227
  {serv_id_1, serv_data_1},                                                  \
 
228
  {serv_id_2, serv_data_2},                                                  \
 
229
  {serv_id_3, serv_data_3},                                                  \
 
230
  {serv_id_4, serv_data_4},                                                  \
 
231
  {serv_id_5, serv_data_5},                                                  \
 
232
  {NULL, NULL}                                                               \
 
233
  };
 
234
#define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
 
235
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
236
        serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
 
237
        serv_id_6, serv_data_6)                                              \
 
238
  static const FT_ServiceDescRec class_[] =                                  \
 
239
  {                                                                          \
 
240
  {serv_id_1, serv_data_1},                                                  \
 
241
  {serv_id_2, serv_data_2},                                                  \
 
242
  {serv_id_3, serv_data_3},                                                  \
 
243
  {serv_id_4, serv_data_4},                                                  \
 
244
  {serv_id_5, serv_data_5},                                                  \
 
245
  {serv_id_6, serv_data_6},                                                  \
 
246
  {NULL, NULL}                                                               \
 
247
  };
 
248
 
 
249
#else /* FT_CONFIG_OPTION_PIC */ 
 
250
 
 
251
#define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
 
252
  void                                                                       \
 
253
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
254
                             FT_ServiceDescRec* clazz )                      \
 
255
  {                                                                          \
 
256
    FT_Memory memory = library->memory;                                      \
 
257
    if ( clazz )                                                             \
 
258
      FT_FREE( clazz );                                                      \
 
259
  }                                                                          \
 
260
                                                                             \
 
261
  FT_Error                                                                   \
 
262
  FT_Create_Class_##class_( FT_Library library,                              \
 
263
                            FT_ServiceDescRec** output_class)                \
 
264
  {                                                                          \
 
265
    FT_ServiceDescRec*  clazz;                                               \
 
266
    FT_Error          error;                                                 \
 
267
    FT_Memory memory = library->memory;                                      \
 
268
                                                                             \
 
269
    if ( FT_ALLOC( clazz, sizeof(*clazz)*2 ) )                               \
 
270
      return error;                                                          \
 
271
    clazz[0].serv_id = serv_id_1;                                            \
 
272
    clazz[0].serv_data = serv_data_1;                                        \
 
273
    clazz[1].serv_id = NULL;                                                 \
 
274
    clazz[1].serv_data = NULL;                                               \
 
275
    *output_class = clazz;                                                   \
 
276
    return FT_Err_Ok;                                                        \
 
277
  } 
 
278
 
 
279
#define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
 
280
        serv_id_2, serv_data_2)                                              \
 
281
  void                                                                       \
 
282
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
283
                             FT_ServiceDescRec* clazz )                      \
 
284
  {                                                                          \
 
285
    FT_Memory memory = library->memory;                                      \
 
286
    if ( clazz )                                                             \
 
287
      FT_FREE( clazz );                                                      \
 
288
  }                                                                          \
 
289
                                                                             \
 
290
  FT_Error                                                                   \
 
291
  FT_Create_Class_##class_( FT_Library library,                              \
 
292
                            FT_ServiceDescRec** output_class)                \
 
293
  {                                                                          \
 
294
    FT_ServiceDescRec*  clazz;                                               \
 
295
    FT_Error          error;                                                 \
 
296
    FT_Memory memory = library->memory;                                      \
 
297
                                                                             \
 
298
    if ( FT_ALLOC( clazz, sizeof(*clazz)*3 ) )                               \
 
299
      return error;                                                          \
 
300
    clazz[0].serv_id = serv_id_1;                                            \
 
301
    clazz[0].serv_data = serv_data_1;                                        \
 
302
    clazz[1].serv_id = serv_id_2;                                            \
 
303
    clazz[1].serv_data = serv_data_2;                                        \
 
304
    clazz[2].serv_id = NULL;                                                 \
 
305
    clazz[2].serv_data = NULL;                                               \
 
306
    *output_class = clazz;                                                   \
 
307
    return FT_Err_Ok;                                                        \
 
308
  } 
 
309
 
 
310
#define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
 
311
        serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
 
312
  void                                                                       \
 
313
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
314
                             FT_ServiceDescRec* clazz )                      \
 
315
  {                                                                          \
 
316
    FT_Memory memory = library->memory;                                      \
 
317
    if ( clazz )                                                             \
 
318
      FT_FREE( clazz );                                                      \
 
319
  }                                                                          \
 
320
                                                                             \
 
321
  FT_Error                                                                   \
 
322
  FT_Create_Class_##class_( FT_Library library,                              \
 
323
                            FT_ServiceDescRec** output_class)                \
 
324
  {                                                                          \
 
325
    FT_ServiceDescRec*  clazz;                                               \
 
326
    FT_Error          error;                                                 \
 
327
    FT_Memory memory = library->memory;                                      \
 
328
                                                                             \
 
329
    if ( FT_ALLOC( clazz, sizeof(*clazz)*4 ) )                               \
 
330
      return error;                                                          \
 
331
    clazz[0].serv_id = serv_id_1;                                            \
 
332
    clazz[0].serv_data = serv_data_1;                                        \
 
333
    clazz[1].serv_id = serv_id_2;                                            \
 
334
    clazz[1].serv_data = serv_data_2;                                        \
 
335
    clazz[2].serv_id = serv_id_3;                                            \
 
336
    clazz[2].serv_data = serv_data_3;                                        \
 
337
    clazz[3].serv_id = NULL;                                                 \
 
338
    clazz[3].serv_data = NULL;                                               \
 
339
    *output_class = clazz;                                                   \
 
340
    return FT_Err_Ok;                                                        \
 
341
  } 
 
342
 
 
343
#define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
 
344
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
345
        serv_id_4, serv_data_4)                                              \
 
346
  void                                                                       \
 
347
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
348
                             FT_ServiceDescRec* clazz )                      \
 
349
  {                                                                          \
 
350
    FT_Memory memory = library->memory;                                      \
 
351
    if ( clazz )                                                             \
 
352
      FT_FREE( clazz );                                                      \
 
353
  }                                                                          \
 
354
                                                                             \
 
355
  FT_Error                                                                   \
 
356
  FT_Create_Class_##class_( FT_Library library,                              \
 
357
                            FT_ServiceDescRec** output_class)                \
 
358
  {                                                                          \
 
359
    FT_ServiceDescRec*  clazz;                                               \
 
360
    FT_Error          error;                                                 \
 
361
    FT_Memory memory = library->memory;                                      \
 
362
                                                                             \
 
363
    if ( FT_ALLOC( clazz, sizeof(*clazz)*5 ) )                               \
 
364
      return error;                                                          \
 
365
    clazz[0].serv_id = serv_id_1;                                            \
 
366
    clazz[0].serv_data = serv_data_1;                                        \
 
367
    clazz[1].serv_id = serv_id_2;                                            \
 
368
    clazz[1].serv_data = serv_data_2;                                        \
 
369
    clazz[2].serv_id = serv_id_3;                                            \
 
370
    clazz[2].serv_data = serv_data_3;                                        \
 
371
    clazz[3].serv_id = serv_id_4;                                            \
 
372
    clazz[3].serv_data = serv_data_4;                                        \
 
373
    clazz[4].serv_id = NULL;                                                 \
 
374
    clazz[4].serv_data = NULL;                                               \
 
375
    *output_class = clazz;                                                   \
 
376
    return FT_Err_Ok;                                                        \
 
377
  } 
 
378
 
 
379
#define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
 
380
        serv_id_2, serv_data_2, serv_id_3, serv_data_3, serv_id_4,           \
 
381
        serv_data_4, serv_id_5, serv_data_5)                                 \
 
382
  void                                                                       \
 
383
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
384
                             FT_ServiceDescRec* clazz )                      \
 
385
  {                                                                          \
 
386
    FT_Memory memory = library->memory;                                      \
 
387
    if ( clazz )                                                             \
 
388
      FT_FREE( clazz );                                                      \
 
389
  }                                                                          \
 
390
                                                                             \
 
391
  FT_Error                                                                   \
 
392
  FT_Create_Class_##class_( FT_Library library,                              \
 
393
                            FT_ServiceDescRec** output_class)                \
 
394
  {                                                                          \
 
395
    FT_ServiceDescRec*  clazz;                                               \
 
396
    FT_Error          error;                                                 \
 
397
    FT_Memory memory = library->memory;                                      \
 
398
                                                                             \
 
399
    if ( FT_ALLOC( clazz, sizeof(*clazz)*6 ) )                               \
 
400
      return error;                                                          \
 
401
    clazz[0].serv_id = serv_id_1;                                            \
 
402
    clazz[0].serv_data = serv_data_1;                                        \
 
403
    clazz[1].serv_id = serv_id_2;                                            \
 
404
    clazz[1].serv_data = serv_data_2;                                        \
 
405
    clazz[2].serv_id = serv_id_3;                                            \
 
406
    clazz[2].serv_data = serv_data_3;                                        \
 
407
    clazz[3].serv_id = serv_id_4;                                            \
 
408
    clazz[3].serv_data = serv_data_4;                                        \
 
409
    clazz[4].serv_id = serv_id_5;                                            \
 
410
    clazz[4].serv_data = serv_data_5;                                        \
 
411
    clazz[5].serv_id = NULL;                                                 \
 
412
    clazz[5].serv_data = NULL;                                               \
 
413
    *output_class = clazz;                                                   \
 
414
    return FT_Err_Ok;                                                        \
 
415
  } 
 
416
 
 
417
#define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
 
418
        serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
 
419
        serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
 
420
        serv_id_6, serv_data_6)                                              \
 
421
  void                                                                       \
 
422
  FT_Destroy_Class_##class_( FT_Library library,                             \
 
423
                             FT_ServiceDescRec* clazz )                      \
 
424
  {                                                                          \
 
425
    FT_Memory memory = library->memory;                                      \
 
426
    if ( clazz )                                                             \
 
427
      FT_FREE( clazz );                                                      \
 
428
  }                                                                          \
 
429
                                                                             \
 
430
  FT_Error                                                                   \
 
431
  FT_Create_Class_##class_( FT_Library library,                              \
 
432
                            FT_ServiceDescRec** output_class)                \
 
433
  {                                                                          \
 
434
    FT_ServiceDescRec*  clazz;                                               \
 
435
    FT_Error          error;                                                 \
 
436
    FT_Memory memory = library->memory;                                      \
 
437
                                                                             \
 
438
    if ( FT_ALLOC( clazz, sizeof(*clazz)*7 ) )                               \
 
439
      return error;                                                          \
 
440
    clazz[0].serv_id = serv_id_1;                                            \
 
441
    clazz[0].serv_data = serv_data_1;                                        \
 
442
    clazz[1].serv_id = serv_id_2;                                            \
 
443
    clazz[1].serv_data = serv_data_2;                                        \
 
444
    clazz[2].serv_id = serv_id_3;                                            \
 
445
    clazz[2].serv_data = serv_data_3;                                        \
 
446
    clazz[3].serv_id = serv_id_4;                                            \
 
447
    clazz[3].serv_data = serv_data_4;                                        \
 
448
    clazz[4].serv_id = serv_id_5;                                            \
 
449
    clazz[4].serv_data = serv_data_5;                                        \
 
450
    clazz[5].serv_id = serv_id_6;                                            \
 
451
    clazz[5].serv_data = serv_data_6;                                        \
 
452
    clazz[6].serv_id = NULL;                                                 \
 
453
    clazz[6].serv_data = NULL;                                               \
 
454
    *output_class = clazz;                                                   \
 
455
    return FT_Err_Ok;                                                        \
 
456
  } 
 
457
#endif /* FT_CONFIG_OPTION_PIC */ 
 
458
 
 
459
  /*
 
460
   *  Parse a list of FT_ServiceDescRec descriptors and look for
 
461
   *  a specific service by ID.  Note that the last element in the
 
462
   *  array must be { NULL, NULL }, and that the function should
 
463
   *  return NULL if the service isn't available.
 
464
   *
 
465
   *  This function can be used by modules to implement their
 
466
   *  `get_service' method.
 
467
   */
 
468
  FT_BASE( FT_Pointer )
 
469
  ft_service_list_lookup( FT_ServiceDesc  service_descriptors,
 
470
                          const char*     service_id );
 
471
 
 
472
 
 
473
  /*************************************************************************/
 
474
  /*************************************************************************/
 
475
  /*****                                                               *****/
 
476
  /*****             S E R V I C E S   C A C H E                       *****/
 
477
  /*****                                                               *****/
 
478
  /*************************************************************************/
 
479
  /*************************************************************************/
 
480
 
 
481
  /*
 
482
   *  This structure is used to store a cache for several frequently used
 
483
   *  services.  It is the type of `face->internal->services'.  You
 
484
   *  should only use FT_FACE_LOOKUP_SERVICE to access it.
 
485
   *
 
486
   *  All fields should have the type FT_Pointer to relax compilation
 
487
   *  dependencies.  We assume the developer isn't completely stupid.
 
488
   *
 
489
   *  Each field must be named `service_XXXX' where `XXX' corresponds to
 
490
   *  the correct FT_SERVICE_ID_XXXX macro.  See the definition of
 
491
   *  FT_FACE_LOOKUP_SERVICE below how this is implemented.
 
492
   *
 
493
   */
 
494
  typedef struct  FT_ServiceCacheRec_
 
495
  {
 
496
    FT_Pointer  service_POSTSCRIPT_FONT_NAME;
 
497
    FT_Pointer  service_MULTI_MASTERS;
 
498
    FT_Pointer  service_GLYPH_DICT;
 
499
    FT_Pointer  service_PFR_METRICS;
 
500
    FT_Pointer  service_WINFNT;
 
501
 
 
502
  } FT_ServiceCacheRec, *FT_ServiceCache;
 
503
 
 
504
 
 
505
  /*
 
506
   *  A magic number used within the services cache.
 
507
   */
 
508
#define FT_SERVICE_UNAVAILABLE  ((FT_Pointer)-2)  /* magic number */
 
509
 
 
510
 
 
511
  /*
 
512
   * @macro:
 
513
   *   FT_FACE_LOOKUP_SERVICE
 
514
   *
 
515
   * @description:
 
516
   *   This macro is used to lookup a service from a face's driver module
 
517
   *   using its cache.
 
518
   *
 
519
   * @input:
 
520
   *   face::
 
521
   *     The source face handle containing the cache.
 
522
   *
 
523
   *   field ::
 
524
   *     The field name in the cache.
 
525
   *
 
526
   *   id ::
 
527
   *     The service ID.
 
528
   *
 
529
   * @output:
 
530
   *   ptr ::
 
531
   *     A variable receiving the service data.  NULL if not available.
 
532
   */
 
533
#ifdef __cplusplus
 
534
 
 
535
#define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
 
536
  FT_BEGIN_STMNT                                               \
 
537
    FT_Pointer   svc;                                          \
 
538
    FT_Pointer*  Pptr = (FT_Pointer*)&(ptr);                   \
 
539
                                                               \
 
540
                                                               \
 
541
    svc = FT_FACE( face )->internal->services. service_ ## id; \
 
542
    if ( svc == FT_SERVICE_UNAVAILABLE )                       \
 
543
      svc = NULL;                                              \
 
544
    else if ( svc == NULL )                                    \
 
545
    {                                                          \
 
546
      FT_FACE_FIND_SERVICE( face, svc, id );                   \
 
547
                                                               \
 
548
      FT_FACE( face )->internal->services. service_ ## id =    \
 
549
        (FT_Pointer)( svc != NULL ? svc                        \
 
550
                                  : FT_SERVICE_UNAVAILABLE );  \
 
551
    }                                                          \
 
552
    *Pptr = svc;                                               \
 
553
  FT_END_STMNT
 
554
 
 
555
#else /* !C++ */
 
556
 
 
557
#define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
 
558
  FT_BEGIN_STMNT                                               \
 
559
    FT_Pointer  svc;                                           \
 
560
                                                               \
 
561
                                                               \
 
562
    svc = FT_FACE( face )->internal->services. service_ ## id; \
 
563
    if ( svc == FT_SERVICE_UNAVAILABLE )                       \
 
564
      svc = NULL;                                              \
 
565
    else if ( svc == NULL )                                    \
 
566
    {                                                          \
 
567
      FT_FACE_FIND_SERVICE( face, svc, id );                   \
 
568
                                                               \
 
569
      FT_FACE( face )->internal->services. service_ ## id =    \
 
570
        (FT_Pointer)( svc != NULL ? svc                        \
 
571
                                  : FT_SERVICE_UNAVAILABLE );  \
 
572
    }                                                          \
 
573
    ptr = svc;                                                 \
 
574
  FT_END_STMNT
 
575
 
 
576
#endif /* !C++ */
 
577
 
 
578
  /*
 
579
   *  A macro used to define new service structure types.
 
580
   */
 
581
 
 
582
#define FT_DEFINE_SERVICE( name )            \
 
583
  typedef struct FT_Service_ ## name ## Rec_ \
 
584
    FT_Service_ ## name ## Rec ;             \
 
585
  typedef struct FT_Service_ ## name ## Rec_ \
 
586
    const * FT_Service_ ## name ;            \
 
587
  struct FT_Service_ ## name ## Rec_
 
588
 
 
589
  /* */
 
590
 
 
591
  /*
 
592
   *  The header files containing the services.
 
593
   */
 
594
 
 
595
#define FT_SERVICE_BDF_H                <freetype/internal/services/svbdf.h>
 
596
#define FT_SERVICE_CID_H                <freetype/internal/services/svcid.h>
 
597
#define FT_SERVICE_GLYPH_DICT_H         <freetype/internal/services/svgldict.h>
 
598
#define FT_SERVICE_GX_VALIDATE_H        <freetype/internal/services/svgxval.h>
 
599
#define FT_SERVICE_KERNING_H            <freetype/internal/services/svkern.h>
 
600
#define FT_SERVICE_MULTIPLE_MASTERS_H   <freetype/internal/services/svmm.h>
 
601
#define FT_SERVICE_OPENTYPE_VALIDATE_H  <freetype/internal/services/svotval.h>
 
602
#define FT_SERVICE_PFR_H                <freetype/internal/services/svpfr.h>
 
603
#define FT_SERVICE_POSTSCRIPT_CMAPS_H   <freetype/internal/services/svpscmap.h>
 
604
#define FT_SERVICE_POSTSCRIPT_INFO_H    <freetype/internal/services/svpsinfo.h>
 
605
#define FT_SERVICE_POSTSCRIPT_NAME_H    <freetype/internal/services/svpostnm.h>
 
606
#define FT_SERVICE_SFNT_H               <freetype/internal/services/svsfnt.h>
 
607
#define FT_SERVICE_TRUETYPE_ENGINE_H    <freetype/internal/services/svtteng.h>
 
608
#define FT_SERVICE_TT_CMAP_H            <freetype/internal/services/svttcmap.h>
 
609
#define FT_SERVICE_WINFNT_H             <freetype/internal/services/svwinfnt.h>
 
610
#define FT_SERVICE_XFREE86_NAME_H       <freetype/internal/services/svxf86nm.h>
 
611
#define FT_SERVICE_TRUETYPE_GLYF_H      <freetype/internal/services/svttglyf.h>
 
612
 
 
613
 /* */
 
614
 
 
615
FT_END_HEADER
 
616
 
 
617
#endif /* __FTSERV_H__ */
 
618
 
 
619
 
 
620
/* END */