← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/freetype/src/base/ftsystem.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/ftsystem.c
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  ftsystem.c                                                             */
 
4
/*                                                                         */
 
5
/*    ANSI-specific FreeType low-level system interface (body).            */
 
6
/*                                                                         */
 
7
/*  Copyright 1996-2001, 2002, 2006, 2008, 2009, 2010 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
  /* This file contains the default interface used by FreeType to access   */
 
21
  /* low-level, i.e. memory management, i/o access as well as thread       */
 
22
  /* synchronisation.  It can be replaced by user-specific routines if     */
 
23
  /* necessary.                                                            */
 
24
  /*                                                                       */
 
25
  /*************************************************************************/
 
26
 
 
27
 
 
28
#include <ft2build.h>
 
29
#include FT_CONFIG_CONFIG_H
 
30
#include FT_INTERNAL_DEBUG_H
 
31
#include FT_INTERNAL_STREAM_H
 
32
#include FT_SYSTEM_H
 
33
#include FT_ERRORS_H
 
34
#include FT_TYPES_H
 
35
 
 
36
 
 
37
  /*************************************************************************/
 
38
  /*                                                                       */
 
39
  /*                       MEMORY MANAGEMENT INTERFACE                     */
 
40
  /*                                                                       */
 
41
  /*************************************************************************/
 
42
 
 
43
  /*************************************************************************/
 
44
  /*                                                                       */
 
45
  /* It is not necessary to do any error checking for the                  */
 
46
  /* allocation-related functions.  This will be done by the higher level  */
 
47
  /* routines like ft_mem_alloc() or ft_mem_realloc().                     */
 
48
  /*                                                                       */
 
49
  /*************************************************************************/
 
50
 
 
51
 
 
52
  /*************************************************************************/
 
53
  /*                                                                       */
 
54
  /* <Function>                                                            */
 
55
  /*    ft_alloc                                                           */
 
56
  /*                                                                       */
 
57
  /* <Description>                                                         */
 
58
  /*    The memory allocation function.                                    */
 
59
  /*                                                                       */
 
60
  /* <Input>                                                               */
 
61
  /*    memory :: A pointer to the memory object.                          */
 
62
  /*                                                                       */
 
63
  /*    size   :: The requested size in bytes.                             */
 
64
  /*                                                                       */
 
65
  /* <Return>                                                              */
 
66
  /*    The address of newly allocated block.                              */
 
67
  /*                                                                       */
 
68
  FT_CALLBACK_DEF( void* )
 
69
  ft_alloc( FT_Memory  memory,
 
70
            long       size )
 
71
  {
 
72
    FT_UNUSED( memory );
 
73
 
 
74
    return ft_smalloc( size );
 
75
  }
 
76
 
 
77
 
 
78
  /*************************************************************************/
 
79
  /*                                                                       */
 
80
  /* <Function>                                                            */
 
81
  /*    ft_realloc                                                         */
 
82
  /*                                                                       */
 
83
  /* <Description>                                                         */
 
84
  /*    The memory reallocation function.                                  */
 
85
  /*                                                                       */
 
86
  /* <Input>                                                               */
 
87
  /*    memory   :: A pointer to the memory object.                        */
 
88
  /*                                                                       */
 
89
  /*    cur_size :: The current size of the allocated memory block.        */
 
90
  /*                                                                       */
 
91
  /*    new_size :: The newly requested size in bytes.                     */
 
92
  /*                                                                       */
 
93
  /*    block    :: The current address of the block in memory.            */
 
94
  /*                                                                       */
 
95
  /* <Return>                                                              */
 
96
  /*    The address of the reallocated memory block.                       */
 
97
  /*                                                                       */
 
98
  FT_CALLBACK_DEF( void* )
 
99
  ft_realloc( FT_Memory  memory,
 
100
              long       cur_size,
 
101
              long       new_size,
 
102
              void*      block )
 
103
  {
 
104
    FT_UNUSED( memory );
 
105
    FT_UNUSED( cur_size );
 
106
 
 
107
    return ft_srealloc( block, new_size );
 
108
  }
 
109
 
 
110
 
 
111
  /*************************************************************************/
 
112
  /*                                                                       */
 
113
  /* <Function>                                                            */
 
114
  /*    ft_free                                                            */
 
115
  /*                                                                       */
 
116
  /* <Description>                                                         */
 
117
  /*    The memory release function.                                       */
 
118
  /*                                                                       */
 
119
  /* <Input>                                                               */
 
120
  /*    memory  :: A pointer to the memory object.                         */
 
121
  /*                                                                       */
 
122
  /*    block   :: The address of block in memory to be freed.             */
 
123
  /*                                                                       */
 
124
  FT_CALLBACK_DEF( void )
 
125
  ft_free( FT_Memory  memory,
 
126
           void*      block )
 
127
  {
 
128
    FT_UNUSED( memory );
 
129
 
 
130
    ft_sfree( block );
 
131
  }
 
132
 
 
133
 
 
134
  /*************************************************************************/
 
135
  /*                                                                       */
 
136
  /*                     RESOURCE MANAGEMENT INTERFACE                     */
 
137
  /*                                                                       */
 
138
  /*************************************************************************/
 
139
 
 
140
 
 
141
  /*************************************************************************/
 
142
  /*                                                                       */
 
143
  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
 
144
  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
 
145
  /* messages during execution.                                            */
 
146
  /*                                                                       */
 
147
#undef  FT_COMPONENT
 
148
#define FT_COMPONENT  trace_io
 
149
 
 
150
  /* We use the macro STREAM_FILE for convenience to extract the       */
 
151
  /* system-specific stream handle from a given FreeType stream object */
 
152
#define STREAM_FILE( stream )  ( (FT_FILE*)stream->descriptor.pointer )
 
153
 
 
154
 
 
155
  /*************************************************************************/
 
156
  /*                                                                       */
 
157
  /* <Function>                                                            */
 
158
  /*    ft_ansi_stream_close                                               */
 
159
  /*                                                                       */
 
160
  /* <Description>                                                         */
 
161
  /*    The function to close a stream.                                    */
 
162
  /*                                                                       */
 
163
  /* <Input>                                                               */
 
164
  /*    stream :: A pointer to the stream object.                          */
 
165
  /*                                                                       */
 
166
  FT_CALLBACK_DEF( void )
 
167
  ft_ansi_stream_close( FT_Stream  stream )
 
168
  {
 
169
    ft_fclose( STREAM_FILE( stream ) );
 
170
 
 
171
    stream->descriptor.pointer = NULL;
 
172
    stream->size               = 0;
 
173
    stream->base               = 0;
 
174
  }
 
175
 
 
176
 
 
177
  /*************************************************************************/
 
178
  /*                                                                       */
 
179
  /* <Function>                                                            */
 
180
  /*    ft_ansi_stream_io                                                  */
 
181
  /*                                                                       */
 
182
  /* <Description>                                                         */
 
183
  /*    The function to open a stream.                                     */
 
184
  /*                                                                       */
 
185
  /* <Input>                                                               */
 
186
  /*    stream :: A pointer to the stream object.                          */
 
187
  /*                                                                       */
 
188
  /*    offset :: The position in the data stream to start reading.        */
 
189
  /*                                                                       */
 
190
  /*    buffer :: The address of buffer to store the read data.            */
 
191
  /*                                                                       */
 
192
  /*    count  :: The number of bytes to read from the stream.             */
 
193
  /*                                                                       */
 
194
  /* <Return>                                                              */
 
195
  /*    The number of bytes actually read.  If `count' is zero (this is,   */
 
196
  /*    the function is used for seeking), a non-zero return value         */
 
197
  /*    indicates an error.                                                */
 
198
  /*                                                                       */
 
199
  FT_CALLBACK_DEF( unsigned long )
 
200
  ft_ansi_stream_io( FT_Stream       stream,
 
201
                     unsigned long   offset,
 
202
                     unsigned char*  buffer,
 
203
                     unsigned long   count )
 
204
  {
 
205
    FT_FILE*  file;
 
206
 
 
207
 
 
208
    if ( !count && offset > stream->size )
 
209
      return 1;
 
210
 
 
211
    file = STREAM_FILE( stream );
 
212
 
 
213
    if ( stream->pos != offset )
 
214
      ft_fseek( file, offset, SEEK_SET );
 
215
 
 
216
    return (unsigned long)ft_fread( buffer, 1, count, file );
 
217
  }
 
218
 
 
219
 
 
220
  /* documentation is in ftstream.h */
 
221
 
 
222
  FT_BASE_DEF( FT_Error )
 
223
  FT_Stream_Open( FT_Stream    stream,
 
224
                  const char*  filepathname )
 
225
  {
 
226
    FT_FILE*  file;
 
227
 
 
228
 
 
229
    if ( !stream )
 
230
      return FT_Err_Invalid_Stream_Handle;
 
231
 
 
232
    stream->descriptor.pointer = NULL;
 
233
    stream->pathname.pointer   = (char*)filepathname;
 
234
    stream->base               = 0;
 
235
    stream->pos                = 0;
 
236
    stream->read               = NULL;
 
237
    stream->close              = NULL;
 
238
 
 
239
    file = ft_fopen( filepathname, "rb" );
 
240
    if ( !file )
 
241
    {
 
242
      FT_ERROR(( "FT_Stream_Open:"
 
243
                 " could not open `%s'\n", filepathname ));
 
244
 
 
245
      return FT_Err_Cannot_Open_Resource;
 
246
    }
 
247
 
 
248
    ft_fseek( file, 0, SEEK_END );
 
249
    stream->size = ft_ftell( file );
 
250
    if ( !stream->size )
 
251
    {
 
252
      FT_ERROR(( "FT_Stream_Open:" ));
 
253
      FT_ERROR(( " opened `%s' but zero-sized\n", filepathname ));
 
254
      ft_fclose( file );
 
255
      return FT_Err_Cannot_Open_Stream;
 
256
    }
 
257
    ft_fseek( file, 0, SEEK_SET );
 
258
 
 
259
    stream->descriptor.pointer = file;
 
260
    stream->read  = ft_ansi_stream_io;
 
261
    stream->close = ft_ansi_stream_close;
 
262
 
 
263
    FT_TRACE1(( "FT_Stream_Open:" ));
 
264
    FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
 
265
                filepathname, stream->size ));
 
266
 
 
267
    return FT_Err_Ok;
 
268
  }
 
269
 
 
270
 
 
271
#ifdef FT_DEBUG_MEMORY
 
272
 
 
273
  extern FT_Int
 
274
  ft_mem_debug_init( FT_Memory  memory );
 
275
 
 
276
  extern void
 
277
  ft_mem_debug_done( FT_Memory  memory );
 
278
 
 
279
#endif
 
280
 
 
281
 
 
282
  /* documentation is in ftobjs.h */
 
283
 
 
284
  FT_BASE_DEF( FT_Memory )
 
285
  FT_New_Memory( void )
 
286
  {
 
287
    FT_Memory  memory;
 
288
 
 
289
 
 
290
    memory = (FT_Memory)ft_smalloc( sizeof ( *memory ) );
 
291
    if ( memory )
 
292
    {
 
293
      memory->user    = 0;
 
294
      memory->alloc   = ft_alloc;
 
295
      memory->realloc = ft_realloc;
 
296
      memory->free    = ft_free;
 
297
#ifdef FT_DEBUG_MEMORY
 
298
      ft_mem_debug_init( memory );
 
299
#endif
 
300
    }
 
301
 
 
302
    return memory;
 
303
  }
 
304
 
 
305
 
 
306
  /* documentation is in ftobjs.h */
 
307
 
 
308
  FT_BASE_DEF( void )
 
309
  FT_Done_Memory( FT_Memory  memory )
 
310
  {
 
311
#ifdef FT_DEBUG_MEMORY
 
312
    ft_mem_debug_done( memory );
 
313
#endif
 
314
    ft_sfree( memory );
 
315
  }
 
316
 
 
317
 
 
318
/* END */