• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /****************************************************************************
2  *
3  * ftsystem.c
4  *
5  *   ANSI-specific FreeType low-level system interface (body).
6  *
7  * Copyright (C) 1996-2020 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 <freetype/internal/ftdebug.h>
31 #include <freetype/internal/ftstream.h>
32 #include <freetype/ftsystem.h>
33 #include <freetype/fterrors.h>
34 #include <freetype/fttypes.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 ::
62    *     A pointer to the memory object.
63    *
64    *   size ::
65    *     The requested size in bytes.
66    *
67    * @Return:
68    *   The address of newly allocated block.
69    */
70   FT_CALLBACK_DEF( void* )
ft_alloc(FT_Memory memory,long size)71   ft_alloc( FT_Memory  memory,
72             long       size )
73   {
74     FT_UNUSED( memory );
75 
76     return ft_smalloc( (size_t)size );
77   }
78 
79 
80   /**************************************************************************
81    *
82    * @Function:
83    *   ft_realloc
84    *
85    * @Description:
86    *   The memory reallocation function.
87    *
88    * @Input:
89    *   memory ::
90    *     A pointer to the memory object.
91    *
92    *   cur_size ::
93    *     The current size of the allocated memory block.
94    *
95    *   new_size ::
96    *     The newly requested size in bytes.
97    *
98    *   block ::
99    *     The current address of the block in memory.
100    *
101    * @Return:
102    *   The address of the reallocated memory block.
103    */
104   FT_CALLBACK_DEF( void* )
ft_realloc(FT_Memory memory,long cur_size,long new_size,void * block)105   ft_realloc( FT_Memory  memory,
106               long       cur_size,
107               long       new_size,
108               void*      block )
109   {
110     FT_UNUSED( memory );
111     FT_UNUSED( cur_size );
112 
113     return ft_srealloc( block, (size_t)new_size );
114   }
115 
116 
117   /**************************************************************************
118    *
119    * @Function:
120    *   ft_free
121    *
122    * @Description:
123    *   The memory release function.
124    *
125    * @Input:
126    *   memory ::
127    *     A pointer to the memory object.
128    *
129    *   block ::
130    *     The address of block in memory to be freed.
131    */
132   FT_CALLBACK_DEF( void )
ft_free(FT_Memory memory,void * block)133   ft_free( FT_Memory  memory,
134            void*      block )
135   {
136     FT_UNUSED( memory );
137 
138     ft_sfree( block );
139   }
140 
141 
142   /**************************************************************************
143    *
144    *                    RESOURCE MANAGEMENT INTERFACE
145    *
146    */
147 
148 #ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT
149 
150   /**************************************************************************
151    *
152    * The macro FT_COMPONENT is used in trace mode.  It is an implicit
153    * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
154    * messages during execution.
155    */
156 #undef  FT_COMPONENT
157 #define FT_COMPONENT  io
158 
159   /* We use the macro STREAM_FILE for convenience to extract the       */
160   /* system-specific stream handle from a given FreeType stream object */
161 #define STREAM_FILE( stream )  ( (FT_FILE*)stream->descriptor.pointer )
162 
163 
164   /**************************************************************************
165    *
166    * @Function:
167    *   ft_ansi_stream_close
168    *
169    * @Description:
170    *   The function to close a stream.
171    *
172    * @Input:
173    *   stream ::
174    *     A pointer to the stream object.
175    */
176   FT_CALLBACK_DEF( void )
ft_ansi_stream_close(FT_Stream stream)177   ft_ansi_stream_close( FT_Stream  stream )
178   {
179     ft_fclose( STREAM_FILE( stream ) );
180 
181     stream->descriptor.pointer = NULL;
182     stream->size               = 0;
183     stream->base               = NULL;
184   }
185 
186 
187   /**************************************************************************
188    *
189    * @Function:
190    *   ft_ansi_stream_io
191    *
192    * @Description:
193    *   The function to open a stream.
194    *
195    * @Input:
196    *   stream ::
197    *     A pointer to the stream object.
198    *
199    *   offset ::
200    *     The position in the data stream to start reading.
201    *
202    *   buffer ::
203    *     The address of buffer to store the read data.
204    *
205    *   count ::
206    *     The number of bytes to read from the stream.
207    *
208    * @Return:
209    *   The number of bytes actually read.  If `count' is zero (this is,
210    *   the function is used for seeking), a non-zero return value
211    *   indicates an error.
212    */
213   FT_CALLBACK_DEF( unsigned long )
ft_ansi_stream_io(FT_Stream stream,unsigned long offset,unsigned char * buffer,unsigned long count)214   ft_ansi_stream_io( FT_Stream       stream,
215                      unsigned long   offset,
216                      unsigned char*  buffer,
217                      unsigned long   count )
218   {
219     FT_FILE*  file;
220 
221 
222     if ( !count && offset > stream->size )
223       return 1;
224 
225     file = STREAM_FILE( stream );
226 
227     if ( stream->pos != offset )
228       ft_fseek( file, (long)offset, SEEK_SET );
229 
230     return (unsigned long)ft_fread( buffer, 1, count, file );
231   }
232 
233 
234   /* documentation is in ftstream.h */
235 
236   FT_BASE_DEF( FT_Error )
FT_Stream_Open(FT_Stream stream,const char * filepathname)237   FT_Stream_Open( FT_Stream    stream,
238                   const char*  filepathname )
239   {
240     FT_FILE*  file;
241 
242 
243     if ( !stream )
244       return FT_THROW( Invalid_Stream_Handle );
245 
246     stream->descriptor.pointer = NULL;
247     stream->pathname.pointer   = (char*)filepathname;
248     stream->base               = NULL;
249     stream->pos                = 0;
250     stream->read               = NULL;
251     stream->close              = NULL;
252 
253     file = ft_fopen( filepathname, "rb" );
254     if ( !file )
255     {
256       FT_ERROR(( "FT_Stream_Open:"
257                  " could not open `%s'\n", filepathname ));
258 
259       return FT_THROW( Cannot_Open_Resource );
260     }
261 
262     ft_fseek( file, 0, SEEK_END );
263     stream->size = (unsigned long)ft_ftell( file );
264     if ( !stream->size )
265     {
266       FT_ERROR(( "FT_Stream_Open:" ));
267       FT_ERROR(( " opened `%s' but zero-sized\n", filepathname ));
268       ft_fclose( file );
269       return FT_THROW( Cannot_Open_Stream );
270     }
271     ft_fseek( file, 0, SEEK_SET );
272 
273     stream->descriptor.pointer = file;
274     stream->read  = ft_ansi_stream_io;
275     stream->close = ft_ansi_stream_close;
276 
277     FT_TRACE1(( "FT_Stream_Open:" ));
278     FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
279                 filepathname, stream->size ));
280 
281     return FT_Err_Ok;
282   }
283 
284 #endif /* !FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT */
285 
286 #ifdef FT_DEBUG_MEMORY
287 
288   extern FT_Int
289   ft_mem_debug_init( FT_Memory  memory );
290 
291   extern void
292   ft_mem_debug_done( FT_Memory  memory );
293 
294 #endif
295 
296 
297   /* documentation is in ftobjs.h */
298 
299   FT_BASE_DEF( FT_Memory )
FT_New_Memory(void)300   FT_New_Memory( void )
301   {
302     FT_Memory  memory;
303 
304 
305     memory = (FT_Memory)ft_smalloc( sizeof ( *memory ) );
306     if ( memory )
307     {
308       memory->user    = NULL;
309       memory->alloc   = ft_alloc;
310       memory->realloc = ft_realloc;
311       memory->free    = ft_free;
312 #ifdef FT_DEBUG_MEMORY
313       ft_mem_debug_init( memory );
314 #endif
315     }
316 
317     return memory;
318   }
319 
320 
321   /* documentation is in ftobjs.h */
322 
323   FT_BASE_DEF( void )
FT_Done_Memory(FT_Memory memory)324   FT_Done_Memory( FT_Memory  memory )
325   {
326 #ifdef FT_DEBUG_MEMORY
327     ft_mem_debug_done( memory );
328 #endif
329     ft_sfree( memory );
330   }
331 
332 
333 /* END */
334