ReactOS  0.4.14-dev-52-g6116262
ftsystem.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* ftsystem.c */
4 /* */
5 /* ANSI-specific FreeType low-level system interface (body). */
6 /* */
7 /* Copyright 1996-2018 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* )
70  long size )
71  {
72  FT_UNUSED( memory );
73 
74  return ft_smalloc( (size_t)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* )
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, (size_t)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 )
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 #ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT
141 
142  /*************************************************************************/
143  /* */
144  /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
145  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
146  /* messages during execution. */
147  /* */
148 #undef FT_COMPONENT
149 #define FT_COMPONENT trace_io
150 
151  /* We use the macro STREAM_FILE for convenience to extract the */
152  /* system-specific stream handle from a given FreeType stream object */
153 #define STREAM_FILE( stream ) ( (FT_FILE*)stream->descriptor.pointer )
154 
155 
156  /*************************************************************************/
157  /* */
158  /* <Function> */
159  /* ft_ansi_stream_close */
160  /* */
161  /* <Description> */
162  /* The function to close a stream. */
163  /* */
164  /* <Input> */
165  /* stream :: A pointer to the stream object. */
166  /* */
167  FT_CALLBACK_DEF( void )
169  {
171 
172  stream->descriptor.pointer = NULL;
173  stream->size = 0;
174  stream->base = NULL;
175  }
176 
177 
178  /*************************************************************************/
179  /* */
180  /* <Function> */
181  /* ft_ansi_stream_io */
182  /* */
183  /* <Description> */
184  /* The function to open a stream. */
185  /* */
186  /* <Input> */
187  /* stream :: A pointer to the stream object. */
188  /* */
189  /* offset :: The position in the data stream to start reading. */
190  /* */
191  /* buffer :: The address of buffer to store the read data. */
192  /* */
193  /* count :: The number of bytes to read from the stream. */
194  /* */
195  /* <Return> */
196  /* The number of bytes actually read. If `count' is zero (this is, */
197  /* the function is used for seeking), a non-zero return value */
198  /* indicates an error. */
199  /* */
200  FT_CALLBACK_DEF( unsigned long )
202  unsigned long offset,
203  unsigned char* buffer,
204  unsigned long count )
205  {
206  FT_FILE* file;
207 
208 
209  if ( !count && offset > stream->size )
210  return 1;
211 
212  file = STREAM_FILE( stream );
213 
214  if ( stream->pos != offset )
215  ft_fseek( file, (long)offset, SEEK_SET );
216 
217  return (unsigned long)ft_fread( buffer, 1, count, file );
218  }
219 
220 
221  /* documentation is in ftstream.h */
222 
225  const char* filepathname )
226  {
227  FT_FILE* file;
228 
229 
230  if ( !stream )
231  return FT_THROW( Invalid_Stream_Handle );
232 
233  stream->descriptor.pointer = NULL;
234  stream->pathname.pointer = (char*)filepathname;
235  stream->base = NULL;
236  stream->pos = 0;
237  stream->read = NULL;
238  stream->close = NULL;
239 
240  file = ft_fopen( filepathname, "rb" );
241  if ( !file )
242  {
243  FT_ERROR(( "FT_Stream_Open:"
244  " could not open `%s'\n", filepathname ));
245 
246  return FT_THROW( Cannot_Open_Resource );
247  }
248 
249  ft_fseek( file, 0, SEEK_END );
250  stream->size = (unsigned long)ft_ftell( file );
251  if ( !stream->size )
252  {
253  FT_ERROR(( "FT_Stream_Open:" ));
254  FT_ERROR(( " opened `%s' but zero-sized\n", filepathname ));
255  ft_fclose( file );
256  return FT_THROW( Cannot_Open_Stream );
257  }
258  ft_fseek( file, 0, SEEK_SET );
259 
260  stream->descriptor.pointer = file;
261  stream->read = ft_ansi_stream_io;
262  stream->close = ft_ansi_stream_close;
263 
264  FT_TRACE1(( "FT_Stream_Open:" ));
265  FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
266  filepathname, stream->size ));
267 
268  return FT_Err_Ok;
269  }
270 
271 #endif /* !FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT */
272 
273 #ifdef FT_DEBUG_MEMORY
274 
275  extern FT_Int
276  ft_mem_debug_init( FT_Memory memory );
277 
278  extern void
279  ft_mem_debug_done( FT_Memory memory );
280 
281 #endif
282 
283 
284  /* documentation is in ftobjs.h */
285 
288  {
290 
291 
292  memory = (FT_Memory)ft_smalloc( sizeof ( *memory ) );
293  if ( memory )
294  {
295  memory->user = NULL;
296  memory->alloc = ft_alloc;
297  memory->realloc = ft_realloc;
298  memory->free = ft_free;
299 #ifdef FT_DEBUG_MEMORY
300  ft_mem_debug_init( memory );
301 #endif
302  }
303 
304  return memory;
305  }
306 
307 
308  /* documentation is in ftobjs.h */
309 
310  FT_BASE_DEF( void )
312  {
313 #ifdef FT_DEBUG_MEMORY
314  ft_mem_debug_done( memory );
315 #endif
316  ft_sfree( memory );
317  }
318 
319 
320 /* END */
static unsigned int block
Definition: xmlmemory.c:118
int FT_Error
Definition: fttypes.h:300
signed int FT_Int
Definition: fttypes.h:220
GLuint GLuint GLsizei count
Definition: gl.h:1545
ft_free(FT_Memory memory, void *block)
Definition: ftsystem.c:125
GLintptr offset
Definition: glext.h:5920
#define ft_fread
Definition: ftstdlib.h:107
GLuint buffer
Definition: glext.h:5915
return FT_Err_Ok
Definition: ftbbox.c:511
static char memory[1024 *256]
Definition: process.c:116
#define FT_TRACE1(varformat)
Definition: ftdebug.h:158
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
#define FT_THROW(e)
Definition: ftdebug.h:213
ft_ansi_stream_io(FT_Stream stream, unsigned long offset, unsigned char *buffer, unsigned long count)
Definition: ftsystem.c:201
smooth NULL
Definition: ftsmooth.c:416
#define ft_sfree
Definition: ftstdlib.h:133
#define FT_FILE
Definition: ftstdlib.h:104
#define ft_fopen
Definition: ftstdlib.h:106
ft_alloc(FT_Memory memory, long size)
Definition: ftsystem.c:69
#define SEEK_SET
Definition: jmemansi.c:26
GLsizeiptr size
Definition: glext.h:5919
ft_realloc(FT_Memory memory, long cur_size, long new_size, void *block)
Definition: ftsystem.c:99
const char file[]
Definition: icontest.c:11
#define FT_CALLBACK_DEF(x)
Definition: ftconfig.h:533
TCHAR filepathname[1000]
Definition: main.cpp:52
unsigned int size
Definition: parse.h:27
Definition: parse.h:22
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
FT_Stream_Open(FT_Stream stream, const char *filepathname)
Definition: ftsystem.c:224
#define ft_smalloc
Definition: ftstdlib.h:134
ULARGE_INTEGER pos
Definition: request.c:4080
ft_ansi_stream_close(FT_Stream stream)
Definition: ftsystem.c:168
#define ft_ftell
Definition: ftstdlib.h:109
#define STREAM_FILE(stream)
Definition: ftsystem.c:153
#define ft_fclose
Definition: ftstdlib.h:105
FT_Done_Memory(FT_Memory memory)
Definition: ftsystem.c:311
#define long
Definition: qsort.c:33
#define FT_BASE_DEF(x)
Definition: ftconfig.h:419
#define ft_srealloc
Definition: ftstdlib.h:135
#define const
Definition: zconf.h:230
#define SEEK_END
Definition: cabinet.c:27
FT_New_Memory(void)
Definition: ftsystem.c:287
#define ft_fseek
Definition: ftstdlib.h:108
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
Definition: fci.c:126