projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[FREETYPE]
[reactos.git] / reactos / lib / 3rdparty / 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 */
A free Windows-compatible Operating System