← Back to branch summary

~ubuntu-branches/ubuntu/wily/hedgewars/wily

« back to all changes in this revision

Viewing changes to misc/libfreetype/builds/vms/ftsystem.c

  • Committer: Package Import Robot
  • Author(s): Dmitry E. Oboukhov
  • Date: 2011-09-23 10:16:55 UTC
  • mfrom: (1.2.11 upstream)
  • Revision ID: package-import@ubuntu.com-20110923101655-3977th2gc5n0a3pv
Tags: 0.9.16-1
* New upstream version.
 + Downloadable content! Simply click to install any content.
   New voices, hats, maps, themes, translations, music, scripts...
   Hedgewars is now more customisable than ever before! As time goes
   by we will be soliciting community content to feature on this page,
   so remember to check it from time to time. If you decide you want
   to go back to standard Hedgewars, just remove the Data directory
   from your Hedgewars config directory.
 + 3-D rendering! Diorama-like rendering of the game in a variety
   of 3D modes. Let us know which ones work best for you, we didn't
   really have the equipment to test them all.
 + Resizable game window.
 + New utilities! The Time Box will remove one of your hedgehogs
   from the game for a while, protecting from attack until it returns,
   somewhere else on the map. Land spray will allow you to build bridges,
   seal up holes, or just make life unpleasant for your enemies.
 + New single player: Bamboo Thicket, That Sinking Feeling, Newton and
   the Tree and multi-player: The Specialists, Space Invaders,
   Racer - scripts! And a ton more script hooks for scripters
 + New twists on old weapons. Drill strike, seduction and fire have
   been adjusted. Defective mines have been added, rope can attach to
   hogs/crates/barrels again, grenades now have variable bounce (use
   precise key + 1-5). Portal gun is now more usable in flight and
   all game actions are a lot faster.
 + New theme - Golf, dozens of new community hats and a new
   localised Default voice, Ukranian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
misc/libfreetype/builds/vms/ftsystem.c
 
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* )
 
96
  ft_alloc( FT_Memory  memory,
 
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* )
 
126
  ft_realloc( FT_Memory  memory,
 
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 )
 
152
  ft_free( FT_Memory  memory,
 
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 )
 
194
  ft_close_stream( FT_Stream  stream )
 
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
 
 
206
  FT_BASE_DEF( FT_Error )
 
207
  FT_Stream_Open( FT_Stream    stream,
 
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
 
 
294
  FT_BASE_DEF( FT_Memory )
 
295
  FT_New_Memory( void )
 
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 )
 
319
  FT_Done_Memory( FT_Memory  memory )
 
320
  {
 
321
#ifdef FT_DEBUG_MEMORY
 
322
    ft_mem_debug_done( memory );
 
323
#endif
 
324
    memory->free( memory, memory );
 
325
  }
 
326
 
 
327
 
 
328
/* END */