include/freetype/internal/ftserv.h

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ftserv.h                                                               */
   4 /*                                                                         */
   5 /*    The FreeType services (specification only).                          */
   6 /*                                                                         */
   7 /*  Copyright 2003-2007, 2009, 2012 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   /*                                                                       */
 169   /* <Macro>                                                               */
 170   /*    FT_DEFINE_SERVICEDESCREC1 .. FT_DEFINE_SERVICEDESCREC6             */
 171   /*                                                                       */
 172   /* <Description>                                                         */
 173   /*    Used to initialize an array of FT_ServiceDescRec structures.       */
 174   /*                                                                       */
 175   /*    When FT_CONFIG_OPTION_PIC is defined a `create' function needs to  */
 176   /*    be called with a pointer to return an allocated array.  As soon as */
 177   /*    it is no longer needed, a `destroy' function needs to be called to */
 178   /*    release that allocation.                                           */
 179   /*                                                                       */
 180   /*    These functions should be manually called from the `pic_init' and  */
 181   /*    `pic_free' functions of your module (see FT_DEFINE_MODULE).        */
 182   /*                                                                       */
 183   /*    When FT_CONFIG_OPTION_PIC is not defined the array will be         */
 184   /*    allocated in the global scope (or the scope where the macro is     */
 185   /*    used).                                                             */
 186   /*                                                                       */
 187 #ifndef FT_CONFIG_OPTION_PIC
 188
 189 #define FT_DEFINE_SERVICEDESCREC1( class_,                                  \
 190                                    serv_id_1, serv_data_1 )                 \
 191   static const FT_ServiceDescRec  class_[] =                                \
 192   {                                                                         \
 193     { serv_id_1, serv_data_1 },                                             \
 194     { NULL, NULL }                                                          \
 195   };
 196
 197 #define FT_DEFINE_SERVICEDESCREC2( class_,                                  \
 198                                    serv_id_1, serv_data_1,                  \
 199                                    serv_id_2, serv_data_2 )                 \
 200   static const FT_ServiceDescRec  class_[] =                                \
 201   {                                                                         \
 202     { serv_id_1, serv_data_1 },                                             \
 203     { serv_id_2, serv_data_2 },                                             \
 204     { NULL, NULL }                                                          \
 205   };
 206
 207 #define FT_DEFINE_SERVICEDESCREC3( class_,                                  \
 208                                    serv_id_1, serv_data_1,                  \
 209                                    serv_id_2, serv_data_2,                  \
 210                                    serv_id_3, serv_data_3 )                 \
 211   static const FT_ServiceDescRec  class_[] =                                \
 212   {                                                                         \
 213     { serv_id_1, serv_data_1 },                                             \
 214     { serv_id_2, serv_data_2 },                                             \
 215     { serv_id_3, serv_data_3 },                                             \
 216     { NULL, NULL }                                                          \
 217   };
 218
 219 #define FT_DEFINE_SERVICEDESCREC4( class_,                                  \
 220                                    serv_id_1, serv_data_1,                  \
 221                                    serv_id_2, serv_data_2,                  \
 222                                    serv_id_3, serv_data_3,                  \
 223                                    serv_id_4, serv_data_4 )                 \
 224   static const FT_ServiceDescRec  class_[] =                                \
 225   {                                                                         \
 226     { serv_id_1, serv_data_1 },                                             \
 227     { serv_id_2, serv_data_2 },                                             \
 228     { serv_id_3, serv_data_3 },                                             \
 229     { serv_id_4, serv_data_4 },                                             \
 230     { NULL, NULL }                                                          \
 231   };
 232
 233 #define FT_DEFINE_SERVICEDESCREC5( class_,                                  \
 234                                    serv_id_1, serv_data_1,                  \
 235                                    serv_id_2, serv_data_2,                  \
 236                                    serv_id_3, serv_data_3,                  \
 237                                    serv_id_4, serv_data_4,                  \
 238                                    serv_id_5, serv_data_5 )                 \
 239   static const FT_ServiceDescRec  class_[] =                                \
 240   {                                                                         \
 241     { serv_id_1, serv_data_1 },                                             \
 242     { serv_id_2, serv_data_2 },                                             \
 243     { serv_id_3, serv_data_3 },                                             \
 244     { serv_id_4, serv_data_4 },                                             \
 245     { serv_id_5, serv_data_5 },                                             \
 246     { NULL, NULL }                                                          \
 247   };
 248
 249 #define FT_DEFINE_SERVICEDESCREC6( class_,                                  \
 250                                    serv_id_1, serv_data_1,                  \
 251                                    serv_id_2, serv_data_2,                  \
 252                                    serv_id_3, serv_data_3,                  \
 253                                    serv_id_4, serv_data_4,                  \
 254                                    serv_id_5, serv_data_5,                  \
 255                                    serv_id_6, serv_data_6 )                 \
 256   static const FT_ServiceDescRec  class_[] =                                \
 257   {                                                                         \
 258     { serv_id_1, serv_data_1 },                                             \
 259     { serv_id_2, serv_data_2 },                                             \
 260     { serv_id_3, serv_data_3 },                                             \
 261     { serv_id_4, serv_data_4 },                                             \
 262     { serv_id_5, serv_data_5 },                                             \
 263     { serv_id_6, serv_data_6 },                                             \
 264     { NULL, NULL }                                                          \
 265   };
 266
 267 #else /* FT_CONFIG_OPTION_PIC */
 268
 269 #define FT_DEFINE_SERVICEDESCREC1( class_,                                  \
 270                                    serv_id_1, serv_data_1 )                 \
 271   void                                                                      \
 272   FT_Destroy_Class_ ## class_( FT_Library          library,                 \
 273                                FT_ServiceDescRec*  clazz )                  \
 274   {                                                                         \
 275     FT_Memory  memory = library->memory;                                    \
 276                                                                             \
 277                                                                             \
 278     if ( clazz )                                                            \
 279       FT_FREE( clazz );                                                     \
 280   }                                                                         \
 281                                                                             \
 282   FT_Error                                                                  \
 283   FT_Create_Class_ ## class_( FT_Library           library,                 \
 284                               FT_ServiceDescRec**  output_class )           \
 285   {                                                                         \
 286     FT_ServiceDescRec*  clazz;                                              \
 287     FT_Error            error;                                              \
 288     FT_Memory           memory = library->memory;                           \
 289                                                                             \
 290                                                                             \
 291     if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 2 ) )                         \
 292       return error;                                                         \
 293                                                                             \
 294     clazz[0].serv_id   = serv_id_1;                                         \
 295     clazz[0].serv_data = serv_data_1;                                       \
 296     clazz[1].serv_id   = NULL;                                              \
 297     clazz[1].serv_data = NULL;                                              \
 298                                                                             \
 299     *output_class = clazz;                                                  \
 300                                                                             \
 301     return FT_Err_Ok;                                                       \
 302   }
 303
 304 #define FT_DEFINE_SERVICEDESCREC2( class_,                                  \
 305                                    serv_id_1, serv_data_1,                  \
 306                                    serv_id_2, serv_data_2 )                 \
 307   void                                                                      \
 308   FT_Destroy_Class_ ## class_( FT_Library          library,                 \
 309                                FT_ServiceDescRec*  clazz )                  \
 310   {                                                                         \
 311     FT_Memory  memory = library->memory;                                    \
 312                                                                             \
 313                                                                             \
 314     if ( clazz )                                                            \
 315       FT_FREE( clazz );                                                     \
 316   }                                                                         \
 317                                                                             \
 318   FT_Error                                                                  \
 319   FT_Create_Class_ ## class_( FT_Library           library,                 \
 320                               FT_ServiceDescRec**  output_class )           \
 321   {                                                                         \
 322     FT_ServiceDescRec*  clazz;                                              \
 323     FT_Error            error;                                              \
 324     FT_Memory           memory = library->memory;                           \
 325                                                                             \
 326                                                                             \
 327     if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 3 ) )                         \
 328       return error;                                                         \
 329                                                                             \
 330     clazz[0].serv_id   = serv_id_1;                                         \
 331     clazz[0].serv_data = serv_data_1;                                       \
 332     clazz[1].serv_id   = serv_id_2;                                         \
 333     clazz[1].serv_data = serv_data_2;                                       \
 334     clazz[2].serv_id   = NULL;                                              \
 335     clazz[2].serv_data = NULL;                                              \
 336                                                                             \
 337     *output_class = clazz;                                                  \
 338                                                                             \
 339     return FT_Err_Ok;                                                       \
 340   }
 341
 342 #define FT_DEFINE_SERVICEDESCREC3( class_,                                  \
 343                                    serv_id_1, serv_data_1,                  \
 344                                    serv_id_2, serv_data_2,                  \
 345                                    serv_id_3, serv_data_3 )                 \
 346   void                                                                      \
 347   FT_Destroy_Class_ ## class_( FT_Library          library,                 \
 348                                FT_ServiceDescRec*  clazz )                  \
 349   {                                                                         \
 350     FT_Memory  memory = library->memory;                                    \
 351                                                                             \
 352                                                                             \
 353     if ( clazz )                                                            \
 354       FT_FREE( clazz );                                                     \
 355   }                                                                         \
 356                                                                             \
 357   FT_Error                                                                  \
 358   FT_Create_Class_ ## class_( FT_Library           library,                 \
 359                               FT_ServiceDescRec**  output_class )           \
 360   {                                                                         \
 361     FT_ServiceDescRec*  clazz;                                              \
 362     FT_Error            error;                                              \
 363     FT_Memory           memory = library->memory;                           \
 364                                                                             \
 365                                                                             \
 366     if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 4 ) )                         \
 367       return error;                                                         \
 368                                                                             \
 369     clazz[0].serv_id   = serv_id_1;                                         \
 370     clazz[0].serv_data = serv_data_1;                                       \
 371     clazz[1].serv_id   = serv_id_2;                                         \
 372     clazz[1].serv_data = serv_data_2;                                       \
 373     clazz[2].serv_id   = serv_id_3;                                         \
 374     clazz[2].serv_data = serv_data_3;                                       \
 375     clazz[3].serv_id   = NULL;                                              \
 376     clazz[3].serv_data = NULL;                                              \
 377                                                                             \
 378     *output_class = clazz;                                                  \
 379                                                                             \
 380     return FT_Err_Ok;                                                       \
 381   }
 382
 383 #define FT_DEFINE_SERVICEDESCREC4( class_,                                  \
 384                                    serv_id_1, serv_data_1,                  \
 385                                    serv_id_2, serv_data_2,                  \
 386                                    serv_id_3, serv_data_3,                  \
 387                                    serv_id_4, serv_data_4 )                 \
 388   void                                                                      \
 389   FT_Destroy_Class_ ## class_( FT_Library          library,                 \
 390                                FT_ServiceDescRec*  clazz )                  \
 391   {                                                                         \
 392     FT_Memory  memory = library->memory;                                    \
 393                                                                             \
 394                                                                             \
 395     if ( clazz )                                                            \
 396       FT_FREE( clazz );                                                     \
 397   }                                                                         \
 398                                                                             \
 399   FT_Error                                                                  \
 400   FT_Create_Class_ ## class_( FT_Library           library,                 \
 401                               FT_ServiceDescRec**  output_class )           \
 402   {                                                                         \
 403     FT_ServiceDescRec*  clazz;                                              \
 404     FT_Error            error;                                              \
 405     FT_Memory           memory = library->memory;                           \
 406                                                                             \
 407                                                                             \
 408     if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 5 ) )                         \
 409       return error;                                                         \
 410                                                                             \
 411     clazz[0].serv_id   = serv_id_1;                                         \
 412     clazz[0].serv_data = serv_data_1;                                       \
 413     clazz[1].serv_id   = serv_id_2;                                         \
 414     clazz[1].serv_data = serv_data_2;                                       \
 415     clazz[2].serv_id   = serv_id_3;                                         \
 416     clazz[2].serv_data = serv_data_3;                                       \
 417     clazz[3].serv_id   = serv_id_4;                                         \
 418     clazz[3].serv_data = serv_data_4;                                       \
 419     clazz[4].serv_id   = NULL;                                              \
 420     clazz[4].serv_data = NULL;                                              \
 421                                                                             \
 422     *output_class = clazz;                                                  \
 423                                                                             \
 424     return FT_Err_Ok;                                                       \
 425   }
 426
 427 #define FT_DEFINE_SERVICEDESCREC5( class_,                                  \
 428                                    serv_id_1, serv_data_1,                  \
 429                                    serv_id_2, serv_data_2,                  \
 430                                    serv_id_3, serv_data_3,                  \
 431                                    serv_id_4, serv_data_4,                  \
 432                                    serv_id_5, serv_data_5 )                 \
 433   void                                                                      \
 434   FT_Destroy_Class_ ## class_( FT_Library          library,                 \
 435                                FT_ServiceDescRec*  clazz )                  \
 436   {                                                                         \
 437     FT_Memory  memory = library->memory;                                    \
 438                                                                             \
 439                                                                             \
 440     if ( clazz )                                                            \
 441       FT_FREE( clazz );                                                     \
 442   }                                                                         \
 443                                                                             \
 444   FT_Error                                                                  \
 445   FT_Create_Class_ ## class_( FT_Library           library,                 \
 446                               FT_ServiceDescRec**  output_class )           \
 447   {                                                                         \
 448     FT_ServiceDescRec*  clazz;                                              \
 449     FT_Error            error;                                              \
 450     FT_Memory           memory = library->memory;                           \
 451                                                                             \
 452                                                                             \
 453     if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 6 ) )                         \
 454       return error;                                                         \
 455                                                                             \
 456     clazz[0].serv_id   = serv_id_1;                                         \
 457     clazz[0].serv_data = serv_data_1;                                       \
 458     clazz[1].serv_id   = serv_id_2;                                         \
 459     clazz[1].serv_data = serv_data_2;                                       \
 460     clazz[2].serv_id   = serv_id_3;                                         \
 461     clazz[2].serv_data = serv_data_3;                                       \
 462     clazz[3].serv_id   = serv_id_4;                                         \
 463     clazz[3].serv_data = serv_data_4;                                       \
 464     clazz[4].serv_id   = serv_id_5;                                         \
 465     clazz[4].serv_data = serv_data_5;                                       \
 466     clazz[5].serv_id   = NULL;                                              \
 467     clazz[5].serv_data = NULL;                                              \
 468                                                                             \
 469     *output_class = clazz;                                                  \
 470                                                                             \
 471     return FT_Err_Ok;                                                       \
 472   }
 473
 474 #define FT_DEFINE_SERVICEDESCREC6( class_,                                  \
 475                                    serv_id_1, serv_data_1,                  \
 476                                    serv_id_2, serv_data_2,                  \
 477                                    serv_id_3, serv_data_3,                  \
 478                                    serv_id_4, serv_data_4,                  \
 479                                    serv_id_5, serv_data_5,                  \
 480                                    serv_id_6, serv_data_6 )                 \
 481   void                                                                      \
 482   FT_Destroy_Class_ ## class_( FT_Library          library,                 \
 483                                FT_ServiceDescRec*  clazz )                  \
 484   {                                                                         \
 485     FT_Memory  memory = library->memory;                                    \
 486                                                                             \
 487                                                                             \
 488     if ( clazz )                                                            \
 489       FT_FREE( clazz );                                                     \
 490   }                                                                         \
 491                                                                             \
 492   FT_Error                                                                  \
 493   FT_Create_Class_ ## class_( FT_Library           library,                 \
 494                               FT_ServiceDescRec**  output_class)            \
 495   {                                                                         \
 496     FT_ServiceDescRec*  clazz;                                              \
 497     FT_Error            error;                                              \
 498     FT_Memory           memory = library->memory;                           \
 499                                                                             \
 500                                                                             \
 501     if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 7 ) )                         \
 502       return error;                                                         \
 503                                                                             \
 504     clazz[0].serv_id   = serv_id_1;                                         \
 505     clazz[0].serv_data = serv_data_1;                                       \
 506     clazz[1].serv_id   = serv_id_2;                                         \
 507     clazz[1].serv_data = serv_data_2;                                       \
 508     clazz[2].serv_id   = serv_id_3;                                         \
 509     clazz[2].serv_data = serv_data_3;                                       \
 510     clazz[3].serv_id   = serv_id_4;                                         \
 511     clazz[3].serv_data = serv_data_4;                                       \
 512     clazz[4].serv_id   = serv_id_5;                                         \
 513     clazz[4].serv_data = serv_data_5;                                       \
 514     clazz[5].serv_id   = serv_id_6;                                         \
 515     clazz[5].serv_data = serv_data_6;                                       \
 516     clazz[6].serv_id   = NULL;                                              \
 517     clazz[6].serv_data = NULL;                                              \
 518                                                                             \
 519     *output_class = clazz;                                                  \
 520                                                                             \
 521     return FT_Err_Ok;                                                       \
 522   }
 523
 524 #endif /* FT_CONFIG_OPTION_PIC */
 525
 526
 527   /*
 528    *  Parse a list of FT_ServiceDescRec descriptors and look for
 529    *  a specific service by ID.  Note that the last element in the
 530    *  array must be { NULL, NULL }, and that the function should
 531    *  return NULL if the service isn't available.
 532    *
 533    *  This function can be used by modules to implement their
 534    *  `get_service' method.
 535    */
 536   FT_BASE( FT_Pointer )
 537   ft_service_list_lookup( FT_ServiceDesc  service_descriptors,
 538                           const char*     service_id );
 539
 540
 541   /*************************************************************************/
 542   /*************************************************************************/
 543   /*****                                                               *****/
 544   /*****             S E R V I C E S   C A C H E                       *****/
 545   /*****                                                               *****/
 546   /*************************************************************************/
 547   /*************************************************************************/
 548
 549   /*
 550    *  This structure is used to store a cache for several frequently used
 551    *  services.  It is the type of `face->internal->services'.  You
 552    *  should only use FT_FACE_LOOKUP_SERVICE to access it.
 553    *
 554    *  All fields should have the type FT_Pointer to relax compilation
 555    *  dependencies.  We assume the developer isn't completely stupid.
 556    *
 557    *  Each field must be named `service_XXXX' where `XXX' corresponds to
 558    *  the correct FT_SERVICE_ID_XXXX macro.  See the definition of
 559    *  FT_FACE_LOOKUP_SERVICE below how this is implemented.
 560    *
 561    */
 562   typedef struct  FT_ServiceCacheRec_
 563   {
 564     FT_Pointer  service_POSTSCRIPT_FONT_NAME;
 565     FT_Pointer  service_MULTI_MASTERS;
 566     FT_Pointer  service_GLYPH_DICT;
 567     FT_Pointer  service_PFR_METRICS;
 568     FT_Pointer  service_WINFNT;
 569
 570   } FT_ServiceCacheRec, *FT_ServiceCache;
 571
 572
 573   /*
 574    *  A magic number used within the services cache.
 575    */
 576 #define FT_SERVICE_UNAVAILABLE  ((FT_Pointer)-2)  /* magic number */
 577
 578
 579   /*
 580    * @macro:
 581    *   FT_FACE_LOOKUP_SERVICE
 582    *
 583    * @description:
 584    *   This macro is used to lookup a service from a face's driver module
 585    *   using its cache.
 586    *
 587    * @input:
 588    *   face::
 589    *     The source face handle containing the cache.
 590    *
 591    *   field ::
 592    *     The field name in the cache.
 593    *
 594    *   id ::
 595    *     The service ID.
 596    *
 597    * @output:
 598    *   ptr ::
 599    *     A variable receiving the service data.  NULL if not available.
 600    */
 601 #ifdef __cplusplus
 602
 603 #define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
 604   FT_BEGIN_STMNT                                               \
 605     FT_Pointer   svc;                                          \
 606     FT_Pointer*  Pptr = (FT_Pointer*)&(ptr);                   \
 607                                                                \
 608                                                                \
 609     svc = FT_FACE( face )->internal->services. service_ ## id; \
 610     if ( svc == FT_SERVICE_UNAVAILABLE )                       \
 611       svc = NULL;                                              \
 612     else if ( svc == NULL )                                    \
 613     {                                                          \
 614       FT_FACE_FIND_SERVICE( face, svc, id );                   \
 615                                                                \
 616       FT_FACE( face )->internal->services. service_ ## id =    \
 617         (FT_Pointer)( svc != NULL ? svc                        \
 618                                   : FT_SERVICE_UNAVAILABLE );  \
 619     }                                                          \
 620     *Pptr = svc;                                               \
 621   FT_END_STMNT
 622
 623 #else /* !C++ */
 624
 625 #define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
 626   FT_BEGIN_STMNT                                               \
 627     FT_Pointer  svc;                                           \
 628                                                                \
 629                                                                \
 630     svc = FT_FACE( face )->internal->services. service_ ## id; \
 631     if ( svc == FT_SERVICE_UNAVAILABLE )                       \
 632       svc = NULL;                                              \
 633     else if ( svc == NULL )                                    \
 634     {                                                          \
 635       FT_FACE_FIND_SERVICE( face, svc, id );                   \
 636                                                                \
 637       FT_FACE( face )->internal->services. service_ ## id =    \
 638         (FT_Pointer)( svc != NULL ? svc                        \
 639                                   : FT_SERVICE_UNAVAILABLE );  \
 640     }                                                          \
 641     ptr = svc;                                                 \
 642   FT_END_STMNT
 643
 644 #endif /* !C++ */
 645
 646   /*
 647    *  A macro used to define new service structure types.
 648    */
 649
 650 #define FT_DEFINE_SERVICE( name )            \
 651   typedef struct FT_Service_ ## name ## Rec_ \
 652     FT_Service_ ## name ## Rec ;             \
 653   typedef struct FT_Service_ ## name ## Rec_ \
 654     const * FT_Service_ ## name ;            \
 655   struct FT_Service_ ## name ## Rec_
 656
 657   /* */
 658
 659   /*
 660    *  The header files containing the services.
 661    */
 662
 663 #define FT_SERVICE_BDF_H                <freetype/internal/services/svbdf.h>
 664 #define FT_SERVICE_CID_H                <freetype/internal/services/svcid.h>
 665 #define FT_SERVICE_GLYPH_DICT_H         <freetype/internal/services/svgldict.h>
 666 #define FT_SERVICE_GX_VALIDATE_H        <freetype/internal/services/svgxval.h>
 667 #define FT_SERVICE_KERNING_H            <freetype/internal/services/svkern.h>
 668 #define FT_SERVICE_MULTIPLE_MASTERS_H   <freetype/internal/services/svmm.h>
 669 #define FT_SERVICE_OPENTYPE_VALIDATE_H  <freetype/internal/services/svotval.h>
 670 #define FT_SERVICE_PFR_H                <freetype/internal/services/svpfr.h>
 671 #define FT_SERVICE_POSTSCRIPT_CMAPS_H   <freetype/internal/services/svpscmap.h>
 672 #define FT_SERVICE_POSTSCRIPT_INFO_H    <freetype/internal/services/svpsinfo.h>
 673 #define FT_SERVICE_POSTSCRIPT_NAME_H    <freetype/internal/services/svpostnm.h>
 674 #define FT_SERVICE_SFNT_H               <freetype/internal/services/svsfnt.h>
 675 #define FT_SERVICE_TRUETYPE_ENGINE_H    <freetype/internal/services/svtteng.h>
 676 #define FT_SERVICE_TT_CMAP_H            <freetype/internal/services/svttcmap.h>
 677 #define FT_SERVICE_WINFNT_H             <freetype/internal/services/svwinfnt.h>
 678 #define FT_SERVICE_XFREE86_NAME_H       <freetype/internal/services/svxf86nm.h>
 679 #define FT_SERVICE_TRUETYPE_GLYF_H      <freetype/internal/services/svttglyf.h>
 680
 681  /* */
 682
 683 FT_END_HEADER
 684
 685 #endif /* __FTSERV_H__ */
 686
 687
 688 /* END */