PageRenderTime 29ms CodeModel.GetById 20ms app.highlight 5ms RepoModel.GetById 1ms app.codeStats 0ms

/src/compiler/android-ndk/jni/freetype/include/freetype/internal/ftserv.h

http://ftk.googlecode.com/
C++ Header | 620 lines | 398 code | 55 blank | 167 comment | 26 complexity | 6145acdb74fb0c8cd2f59379d89bd738 MD5 | raw file
  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
 35FT_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
615FT_END_HEADER
616
617#endif /* __FTSERV_H__ */
618
619
620/* END */