← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/freetype/src/base/ftinit.c

  • 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/src/base/ftinit.c
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  ftinit.c                                                               */
 
4
/*                                                                         */
 
5
/*    FreeType initialization layer (body).                                */
 
6
/*                                                                         */
 
7
/*  Copyright 1996-2001, 2002, 2005, 2007, 2009 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
  /*  The purpose of this file is to implement the following two           */
 
21
  /*  functions:                                                           */
 
22
  /*                                                                       */
 
23
  /*  FT_Add_Default_Modules():                                            */
 
24
  /*     This function is used to add the set of default modules to a      */
 
25
  /*     fresh new library object.  The set is taken from the header file  */
 
26
  /*     `freetype/config/ftmodule.h'.  See the document `FreeType 2.0     */
 
27
  /*     Build System' for more information.                               */
 
28
  /*                                                                       */
 
29
  /*  FT_Init_FreeType():                                                  */
 
30
  /*     This function creates a system object for the current platform,   */
 
31
  /*     builds a library out of it, then calls FT_Default_Drivers().      */
 
32
  /*                                                                       */
 
33
  /*  Note that even if FT_Init_FreeType() uses the implementation of the  */
 
34
  /*  system object defined at build time, client applications are still   */
 
35
  /*  able to provide their own `ftsystem.c'.                              */
 
36
  /*                                                                       */
 
37
  /*************************************************************************/
 
38
 
 
39
 
 
40
#include <ft2build.h>
 
41
#include FT_CONFIG_CONFIG_H
 
42
#include FT_INTERNAL_OBJECTS_H
 
43
#include FT_INTERNAL_DEBUG_H
 
44
#include FT_MODULE_H
 
45
#include "basepic.h"
 
46
 
 
47
 
 
48
  /*************************************************************************/
 
49
  /*                                                                       */
 
50
  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
 
51
  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
 
52
  /* messages during execution.                                            */
 
53
  /*                                                                       */
 
54
#undef  FT_COMPONENT
 
55
#define FT_COMPONENT  trace_init
 
56
 
 
57
#ifndef FT_CONFIG_OPTION_PIC
 
58
 
 
59
#undef  FT_USE_MODULE
 
60
#ifdef __cplusplus
 
61
#define FT_USE_MODULE( type, x )  extern "C" const type  x;
 
62
#else
 
63
#define FT_USE_MODULE( type, x )  extern const type  x;
 
64
#endif
 
65
 
 
66
 
 
67
#include FT_CONFIG_MODULES_H
 
68
 
 
69
 
 
70
#undef  FT_USE_MODULE
 
71
#define FT_USE_MODULE( type, x )  (const FT_Module_Class*)&(x),
 
72
 
 
73
  static
 
74
  const FT_Module_Class*  const ft_default_modules[] =
 
75
  {
 
76
#include FT_CONFIG_MODULES_H
 
77
    0
 
78
  };
 
79
 
 
80
#else /* FT_CONFIG_OPTION_PIC */
 
81
 
 
82
#ifdef __cplusplus
 
83
#define FT_EXTERNC  extern "C"
 
84
#else
 
85
#define FT_EXTERNC  extern
 
86
#endif
 
87
 
 
88
  /* declare the module's class creation/destruction functions */
 
89
#undef  FT_USE_MODULE
 
90
#define FT_USE_MODULE( type, x )  \
 
91
  FT_EXTERNC FT_Error FT_Create_Class_##x( FT_Library library, FT_Module_Class** output_class ); \
 
92
  FT_EXTERNC void     FT_Destroy_Class_##x( FT_Library library, FT_Module_Class*  clazz );
 
93
 
 
94
#include FT_CONFIG_MODULES_H
 
95
 
 
96
 
 
97
  /* count all module classes */
 
98
#undef  FT_USE_MODULE
 
99
#define FT_USE_MODULE( type, x )  MODULE_CLASS_##x,
 
100
 
 
101
  enum
 
102
  {
 
103
#include FT_CONFIG_MODULES_H
 
104
    FT_NUM_MODULE_CLASSES
 
105
  };
 
106
 
 
107
  /* destroy all module classes */  
 
108
#undef  FT_USE_MODULE
 
109
#define FT_USE_MODULE( type, x )  \
 
110
  if ( classes[i] ) { FT_Destroy_Class_##x(library, classes[i]); } \
 
111
  i++;                                                             \
 
112
 
 
113
  FT_BASE_DEF( void )
 
114
  ft_destroy_default_module_classes( FT_Library  library )
 
115
  {
 
116
    FT_Module_Class** classes;
 
117
    FT_Memory         memory;
 
118
    FT_UInt           i;
 
119
    BasePIC*          pic_container = (BasePIC*)library->pic_container.base;
 
120
 
 
121
    if ( !pic_container->default_module_classes )
 
122
      return;
 
123
 
 
124
    memory = library->memory;
 
125
    classes = pic_container->default_module_classes;
 
126
    i = 0;
 
127
 
 
128
#include FT_CONFIG_MODULES_H
 
129
 
 
130
    FT_FREE( classes );
 
131
    pic_container->default_module_classes = 0;
 
132
  }
 
133
 
 
134
  /* initialize all module classes and the pointer table */
 
135
#undef  FT_USE_MODULE
 
136
#define FT_USE_MODULE( type, x )                \
 
137
  error = FT_Create_Class_##x(library, &clazz); \
 
138
  if (error) goto Exit;                         \
 
139
  classes[i++] = clazz;
 
140
 
 
141
  FT_BASE_DEF( FT_Error )
 
142
  ft_create_default_module_classes( FT_Library  library )
 
143
  {
 
144
    FT_Error          error;
 
145
    FT_Memory         memory;
 
146
    FT_Module_Class** classes;
 
147
    FT_Module_Class*  clazz;
 
148
    FT_UInt           i;
 
149
    BasePIC*          pic_container = (BasePIC*)library->pic_container.base;
 
150
 
 
151
    memory = library->memory;  
 
152
    pic_container->default_module_classes = 0;
 
153
 
 
154
    if ( FT_ALLOC(classes, sizeof(FT_Module_Class*) * (FT_NUM_MODULE_CLASSES + 1) ) )
 
155
      return error;
 
156
    /* initialize all pointers to 0, especially the last one */
 
157
    for (i = 0; i < FT_NUM_MODULE_CLASSES; i++)
 
158
      classes[i] = 0;
 
159
    classes[FT_NUM_MODULE_CLASSES] = 0;
 
160
 
 
161
    i = 0;
 
162
 
 
163
#include FT_CONFIG_MODULES_H
 
164
 
 
165
Exit:    
 
166
    if (error) ft_destroy_default_module_classes( library );
 
167
    else pic_container->default_module_classes = classes;
 
168
 
 
169
    return error;    
 
170
  }
 
171
 
 
172
 
 
173
#endif /* FT_CONFIG_OPTION_PIC */
 
174
 
 
175
  /* documentation is in ftmodapi.h */
 
176
 
 
177
  FT_EXPORT_DEF( void )
 
178
  FT_Add_Default_Modules( FT_Library  library )
 
179
  {
 
180
    FT_Error                       error;
 
181
    const FT_Module_Class* const*  cur;
 
182
 
 
183
 
 
184
    /* test for valid `library' delayed to FT_Add_Module() */
 
185
 
 
186
    cur = FT_DEFAULT_MODULES_GET;
 
187
    while ( *cur )
 
188
    {
 
189
      error = FT_Add_Module( library, *cur );
 
190
      /* notify errors, but don't stop */
 
191
      if ( error )
 
192
        FT_TRACE0(( "FT_Add_Default_Module:"
 
193
                    " Cannot install `%s', error = 0x%x\n",
 
194
                    (*cur)->module_name, error ));
 
195
      cur++;
 
196
    }
 
197
  }
 
198
 
 
199
 
 
200
  /* documentation is in freetype.h */
 
201
 
 
202
  FT_EXPORT_DEF( FT_Error )
 
203
  FT_Init_FreeType( FT_Library  *alibrary )
 
204
  {
 
205
    FT_Error   error;
 
206
    FT_Memory  memory;
 
207
 
 
208
 
 
209
    /* First of all, allocate a new system object -- this function is part */
 
210
    /* of the system-specific component, i.e. `ftsystem.c'.                */
 
211
 
 
212
    memory = FT_New_Memory();
 
213
    if ( !memory )
 
214
    {
 
215
      FT_ERROR(( "FT_Init_FreeType: cannot find memory manager\n" ));
 
216
      return FT_Err_Unimplemented_Feature;
 
217
    }
 
218
 
 
219
    /* build a library out of it, then fill it with the set of */
 
220
    /* default drivers.                                        */
 
221
 
 
222
    error = FT_New_Library( memory, alibrary );
 
223
    if ( error )
 
224
      FT_Done_Memory( memory );
 
225
    else
 
226
      FT_Add_Default_Modules( *alibrary );
 
227
 
 
228
    return error;
 
229
  }
 
230
 
 
231
 
 
232
  /* documentation is in freetype.h */
 
233
 
 
234
  FT_EXPORT_DEF( FT_Error )
 
235
  FT_Done_FreeType( FT_Library  library )
 
236
  {
 
237
    if ( library )
 
238
    {
 
239
      FT_Memory  memory = library->memory;
 
240
 
 
241
 
 
242
      /* Discard the library object */
 
243
      FT_Done_Library( library );
 
244
 
 
245
      /* discard memory manager */
 
246
      FT_Done_Memory( memory );
 
247
    }
 
248
 
 
249
    return FT_Err_Ok;
 
250
  }
 
251
 
 
252
 
 
253
/* END */