Visualization Library 2.0.0-b5

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
ftsystem.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* ftsystem.c */
4 /* */
5 /* VMS-specific FreeType low-level system interface (body). */
6 /* */
7 /* Copyright 1996-2001, 2002, 2005, 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 #include <ft2build.h>
20  /* we use our special ftconfig.h file, not the standard one */
21 #include <ftconfig.h>
22 #include FT_INTERNAL_DEBUG_H
23 #include FT_SYSTEM_H
24 #include FT_ERRORS_H
25 #include FT_TYPES_H
26 #include FT_INTERNAL_OBJECTS_H
27 
28  /* memory-mapping includes and definitions */
29 #ifdef HAVE_UNISTD_H
30 #include <unistd.h>
31 #endif
32 
33 #include <sys/mman.h>
34 #ifndef MAP_FILE
35 #define MAP_FILE 0x00
36 #endif
37 
38 #ifdef MUNMAP_USES_VOIDP
39 #define MUNMAP_ARG_CAST void *
40 #else
41 #define MUNMAP_ARG_CAST char *
42 #endif
43 
44 #ifdef NEED_MUNMAP_DECL
45 
46 #ifdef __cplusplus
47  extern "C"
48 #else
49  extern
50 #endif
51  int
52  munmap( char* addr,
53  int len );
54 
55 #define MUNMAP_ARG_CAST char *
56 
57 #endif /* NEED_DECLARATION_MUNMAP */
58 
59 
60 #include <sys/types.h>
61 #include <sys/stat.h>
62 
63 #ifdef HAVE_FCNTL_H
64 #include <fcntl.h>
65 #endif
66 
67 #include <stdio.h>
68 #include <stdlib.h>
69 #include <string.h>
70 
71 
72  /*************************************************************************/
73  /* */
74  /* MEMORY MANAGEMENT INTERFACE */
75  /* */
76  /*************************************************************************/
77 
78 
79  /*************************************************************************/
80  /* */
81  /* <Function> */
82  /* ft_alloc */
83  /* */
84  /* <Description> */
85  /* The memory allocation function. */
86  /* */
87  /* <Input> */
88  /* memory :: A pointer to the memory object. */
89  /* */
90  /* size :: The requested size in bytes. */
91  /* */
92  /* <Return> */
93  /* The address of newly allocated block. */
94  /* */
95  FT_CALLBACK_DEF( void* )
97  long size )
98  {
99  FT_UNUSED( memory );
100 
101  return malloc( size );
102  }
103 
104 
105  /*************************************************************************/
106  /* */
107  /* <Function> */
108  /* ft_realloc */
109  /* */
110  /* <Description> */
111  /* The memory reallocation function. */
112  /* */
113  /* <Input> */
114  /* memory :: A pointer to the memory object. */
115  /* */
116  /* cur_size :: The current size of the allocated memory block. */
117  /* */
118  /* new_size :: The newly requested size in bytes. */
119  /* */
120  /* block :: The current address of the block in memory. */
121  /* */
122  /* <Return> */
123  /* The address of the reallocated memory block. */
124  /* */
125  FT_CALLBACK_DEF( void* )
127  long cur_size,
128  long new_size,
129  void* block )
130  {
131  FT_UNUSED( memory );
132  FT_UNUSED( cur_size );
133 
134  return realloc( block, new_size );
135  }
136 
137 
138  /*************************************************************************/
139  /* */
140  /* <Function> */
141  /* ft_free */
142  /* */
143  /* <Description> */
144  /* The memory release function. */
145  /* */
146  /* <Input> */
147  /* memory :: A pointer to the memory object. */
148  /* */
149  /* block :: The address of block in memory to be freed. */
150  /* */
151  FT_CALLBACK_DEF( void )
153  void* block )
154  {
155  FT_UNUSED( memory );
156 
157  free( block );
158  }
159 
160 
161  /*************************************************************************/
162  /* */
163  /* RESOURCE MANAGEMENT INTERFACE */
164  /* */
165  /*************************************************************************/
166 
167 
168  /*************************************************************************/
169  /* */
170  /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
171  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
172  /* messages during execution. */
173  /* */
174 #undef FT_COMPONENT
175 #define FT_COMPONENT trace_io
176 
177  /* We use the macro STREAM_FILE for convenience to extract the */
178  /* system-specific stream handle from a given FreeType stream object */
179 #define STREAM_FILE( stream ) ( (FILE*)stream->descriptor.pointer )
180 
181 
182  /*************************************************************************/
183  /* */
184  /* <Function> */
185  /* ft_close_stream */
186  /* */
187  /* <Description> */
188  /* The function to close a stream. */
189  /* */
190  /* <Input> */
191  /* stream :: A pointer to the stream object. */
192  /* */
193  FT_CALLBACK_DEF( void )
195  {
196  munmap( (MUNMAP_ARG_CAST)stream->descriptor.pointer, stream->size );
197 
198  stream->descriptor.pointer = NULL;
199  stream->size = 0;
200  stream->base = 0;
201  }
202 
203 
204  /* documentation is in ftobjs.h */
205 
208  const char* filepathname )
209  {
210  int file;
211  struct stat stat_buf;
212 
213 
214  if ( !stream )
215  return FT_Err_Invalid_Stream_Handle;
216 
217  /* open the file */
218  file = open( filepathname, O_RDONLY );
219  if ( file < 0 )
220  {
221  FT_ERROR(( "FT_Stream_Open:" ));
222  FT_ERROR(( " could not open `%s'\n", filepathname ));
223  return FT_Err_Cannot_Open_Resource;
224  }
225 
226  if ( fstat( file, &stat_buf ) < 0 )
227  {
228  FT_ERROR(( "FT_Stream_Open:" ));
229  FT_ERROR(( " could not `fstat' file `%s'\n", filepathname ));
230  goto Fail_Map;
231  }
232 
233  stream->size = stat_buf.st_size;
234  if ( !stream->size )
235  {
236  FT_ERROR(( "FT_Stream_Open:" ));
237  FT_ERROR(( " opened `%s' but zero-sized\n", filepathname ));
238  goto Fail_Map;
239  }
240 
241  stream->pos = 0;
242  stream->base = (unsigned char *)mmap( NULL,
243  stream->size,
244  PROT_READ,
245  MAP_FILE | MAP_PRIVATE,
246  file,
247  0 );
248 
249  if ( (long)stream->base == -1 )
250  {
251  FT_ERROR(( "FT_Stream_Open:" ));
252  FT_ERROR(( " could not `mmap' file `%s'\n", filepathname ));
253  goto Fail_Map;
254  }
255 
256  close( file );
257 
258  stream->descriptor.pointer = stream->base;
259  stream->pathname.pointer = (char*)filepathname;
260 
261  stream->close = ft_close_stream;
262  stream->read = 0;
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  Fail_Map:
271  close( file );
272 
273  stream->base = NULL;
274  stream->size = 0;
275  stream->pos = 0;
276 
277  return FT_Err_Cannot_Open_Stream;
278  }
279 
280 
281 #ifdef FT_DEBUG_MEMORY
282 
283  extern FT_Int
284  ft_mem_debug_init( FT_Memory memory );
285 
286  extern void
287  ft_mem_debug_done( FT_Memory memory );
288 
289 #endif
290 
291 
292  /* documentation is in ftobjs.h */
293 
296  {
297  FT_Memory memory;
298 
299 
300  memory = (FT_Memory)malloc( sizeof ( *memory ) );
301  if ( memory )
302  {
303  memory->user = 0;
304  memory->alloc = ft_alloc;
305  memory->realloc = ft_realloc;
306  memory->free = ft_free;
307 #ifdef FT_DEBUG_MEMORY
308  ft_mem_debug_init( memory );
309 #endif
310  }
311 
312  return memory;
313  }
314 
315 
316  /* documentation is in ftobjs.h */
317 
318  FT_BASE_DEF( void )
320  {
321 #ifdef FT_DEBUG_MEMORY
322  ft_mem_debug_done( memory );
323 #endif
324  memory->free( memory, memory );
325  }
326 
327 
328 /* END */
int FT_Error
Definition: fttypes.h:296
FT_New_Memory(void)
Definition: ftsystem.c:475
GLuint GLuint stream
ft_close_stream(FT_Stream stream)
Definition: ftsystem.c:194
#define NULL
Definition: ftobjs.h:61
signed int FT_Int
Definition: fttypes.h:216
#define FT_UNUSED(arg)
Definition: ftconfig.h:76
char * malloc()
return FT_Err_Ok
Definition: ftbbox.c:645
#define FT_TRACE1(varformat)
Definition: ftdebug.h:158
#define const
Definition: zconf.h:91
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
#define FT_BASE_DEF(x)
Definition: ftconfig.h:258
FT_Stream_Open(FT_Stream stream, const char *filepathname)
Definition: ftsystem.c:381
GLenum const GLvoid * addr
GLenum GLsizei len
int close(int fd)
Definition: tif_acorn.c:320
int free()
#define FT_CALLBACK_DEF(x)
Definition: ftconfig.h:323
#define MAP_FILE
Definition: ftsystem.c:35
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
#define MUNMAP_ARG_CAST
Definition: ftsystem.c:41
ft_free(FT_Memory memory, void *block)
Definition: ftsystem.c:213
int open(const char *name, int flags, int mode)
Definition: tif_acorn.c:285
ft_alloc(FT_Memory memory, long size)
Definition: ftsystem.c:141
FT_Done_Memory(FT_Memory memory)
Definition: ftsystem.c:515
GLsizeiptr size
ft_realloc(FT_Memory memory, long cur_size, long new_size, void *block)
Definition: ftsystem.c:173