开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
ftsystem.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：13k
源码类别：

其他游戏

开发平台：

Visual C++

ftsystem.c：源码内容
  2. /***************************************************************************/
  3. /*                                                                         */
  4. /*  ftsystem.c                                                             */
  5. /*                                                                         */
  6. /*    ANSI-specific FreeType low-level system interface (body).            */
  7. /*                                                                         */
  8. /*  Copyright 1996-2001, 2002, 2006 by                                     */
  9. /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  10. /*                                                                         */
  11. /*  This file is part of the FreeType project, and may only be used,       */
  12. /*  modified, and distributed under the terms of the FreeType project      */
  13. /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  14. /*  this file you indicate that you have read the license and              */
  15. /*  understand and accept it fully.                                        */
  16. /*                                                                         */
  17. /***************************************************************************/
  19.   /*************************************************************************/
  20.   /*                                                                       */
  21.   /* This file contains the default interface used by FreeType to access   */
  22.   /* low-level, i.e. memory management, i/o access as well as thread       */
  23.   /* synchronisation.  It can be replaced by user-specific routines if     */
  24.   /* necessary.                                                            */
  25.   /*                                                                       */
  26.   /*************************************************************************/
  29. #include <ft2build.h>
  30. #include FT_CONFIG_CONFIG_H
  31. #include FT_INTERNAL_DEBUG_H
  32. #include FT_INTERNAL_STREAM_H
  33. #include FT_SYSTEM_H
  34. #include FT_ERRORS_H
  35. #include FT_TYPES_H
  38.   /*************************************************************************/
  39.   /*                                                                       */
  40.   /*                       MEMORY MANAGEMENT INTERFACE                     */
  41.   /*                                                                       */
  42.   /*************************************************************************/
  44.   /*************************************************************************/
  45.   /*                                                                       */
  46.   /* It is not necessary to do any error checking for the                  */
  47.   /* allocation-related functions.  This will be done by the higher level  */
  48.   /* routines like ft_mem_alloc() or ft_mem_realloc().                     */
  49.   /*                                                                       */
  50.   /*************************************************************************/
  53.   /*************************************************************************/
  54.   /*                                                                       */
  55.   /* <Function>                                                            */
  56.   /*    ft_alloc                                                           */
  57.   /*                                                                       */
  58.   /* <Description>                                                         */
  59.   /*    The memory allocation function.                                    */
  60.   /*                                                                       */
  61.   /* <Input>                                                               */
  62.   /*    memory :: A pointer to the memory object.                          */
  63.   /*                                                                       */
  64.   /*    size   :: The requested size in bytes.                             */
  65.   /*                                                                       */
  66.   /* <Return>                                                              */
  67.   /*    The address of newly allocated block.                              */
  68.   /*                                                                       */
  69.   FT_CALLBACK_DEF( void* )
  70.   ft_alloc( FT_Memory  memory,
  71.             long       size )
  72.   {
  73.     FT_UNUSED( memory );
  75.     return ft_smalloc( size );
  76.   }
  79.   /*************************************************************************/
  80.   /*                                                                       */
  81.   /* <Function>                                                            */
  82.   /*    ft_realloc                                                         */
  83.   /*                                                                       */
  84.   /* <Description>                                                         */
  85.   /*    The memory reallocation function.                                  */
  86.   /*                                                                       */
  87.   /* <Input>                                                               */
  88.   /*    memory   :: A pointer to the memory object.                        */
  89.   /*                                                                       */
  90.   /*    cur_size :: The current size of the allocated memory block.        */
  91.   /*                                                                       */
  92.   /*    new_size :: The newly requested size in bytes.                     */
  93.   /*                                                                       */
  94.   /*    block    :: The current address of the block in memory.            */
  95.   /*                                                                       */
  96.   /* <Return>                                                              */
  97.   /*    The address of the reallocated memory block.                       */
  98.   /*                                                                       */
  99.   FT_CALLBACK_DEF( void* )
  100.   ft_realloc( FT_Memory  memory,
  101.               long       cur_size,
  102.               long       new_size,
  103.               void*      block )
  104.   {
  105.     FT_UNUSED( memory );
  106.     FT_UNUSED( cur_size );
  108.     return ft_srealloc( block, new_size );
  109.   }
  112.   /*************************************************************************/
  113.   /*                                                                       */
  114.   /* <Function>                                                            */
  115.   /*    ft_free                                                            */
  116.   /*                                                                       */
  117.   /* <Description>                                                         */
  118.   /*    The memory release function.                                       */
  119.   /*                                                                       */
  120.   /* <Input>                                                               */
  121.   /*    memory  :: A pointer to the memory object.                         */
  122.   /*                                                                       */
  123.   /*    block   :: The address of block in memory to be freed.             */
  124.   /*                                                                       */
  125.   FT_CALLBACK_DEF( void )
  126.   ft_free( FT_Memory  memory,
  127.            void*      block )
  128.   {
  129.     FT_UNUSED( memory );
  131.     ft_sfree( block );
  132.   }
  135.   /*************************************************************************/
  136.   /*                                                                       */
  137.   /*                     RESOURCE MANAGEMENT INTERFACE                     */
  138.   /*                                                                       */
  139.   /*************************************************************************/
  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
  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 )
  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 )
  168.   ft_ansi_stream_close( FT_Stream  stream )
  169.   {
  170.     ft_fclose( STREAM_FILE( stream ) );
  172.     stream->descriptor.pointer = NULL;
  173.     stream->size               = 0;
  174.     stream->base               = 0;
  175.   }
  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.                                 */
  197.   /*                                                                       */
  198.   FT_CALLBACK_DEF( unsigned long )
  199.   ft_ansi_stream_io( FT_Stream       stream,
  200.                      unsigned long   offset,
  201.                      unsigned char*  buffer,
  202.                      unsigned long   count )
  203.   {
  204.     FT_FILE*  file;
  207.     file = STREAM_FILE( stream );
  209.     ft_fseek( file, offset, SEEK_SET );
  211.     return (unsigned long)ft_fread( buffer, 1, count, file );
  212.   }
  215.   /* documentation is in ftstream.h */
  217.   FT_BASE_DEF( FT_Error )
  218.   FT_Stream_Open( FT_Stream    stream,
  219.                   const char*  filepathname )
  220.   {
  221.     FT_FILE*  file;
  224.     if ( !stream )
  225.       return FT_Err_Invalid_Stream_Handle;
  227.     file = ft_fopen( filepathname, "rb" );
  228.     if ( !file )
  229.     {
  230.       FT_ERROR(( "FT_Stream_Open:" ));
  231.       FT_ERROR(( " could not open `%s'n", filepathname ));
  233.       return FT_Err_Cannot_Open_Resource;
  234.     }
  236.     ft_fseek( file, 0, SEEK_END );
  237.     stream->size = ft_ftell( file );
  238.     ft_fseek( file, 0, SEEK_SET );
  240.     stream->descriptor.pointer = file;
  241.     stream->pathname.pointer   = (char*)filepathname;
  242.     stream->pos                = 0;
  244.     stream->read  = ft_ansi_stream_io;
  245.     stream->close = ft_ansi_stream_close;
  247.     FT_TRACE1(( "FT_Stream_Open:" ));
  248.     FT_TRACE1(( " opened `%s' (%d bytes) successfullyn",
  249.                 filepathname, stream->size ));
  251.     return FT_Err_Ok;
  252.   }
  255. #ifdef FT_DEBUG_MEMORY
  257.   extern FT_Int
  258.   ft_mem_debug_init( FT_Memory  memory );
  260.   extern void
  261.   ft_mem_debug_done( FT_Memory  memory );
  263. #endif
  266.   /* documentation is in ftobjs.h */
  268.   FT_BASE_DEF( FT_Memory )
  269.   FT_New_Memory( void )
  270.   {
  271.     FT_Memory  memory;
  274.     memory = (FT_Memory)ft_smalloc( sizeof ( *memory ) );
  275.     if ( memory )
  276.     {
  277.       memory->user    = 0;
  278.       memory->alloc   = ft_alloc;
  279.       memory->realloc = ft_realloc;
  280.       memory->free    = ft_free;
  281. #ifdef FT_DEBUG_MEMORY
  282.       ft_mem_debug_init( memory );
  283. #endif
  284.     }
  286.     return memory;
  287.   }
  290.   /* documentation is in ftobjs.h */
  292.   FT_BASE_DEF( void )
  293.   FT_Done_Memory( FT_Memory  memory )
  294.   {
  295. #ifdef FT_DEBUG_MEMORY
  296.     ft_mem_debug_done( memory );
  297. #endif
  298.     memory->free( memory, memory );
  299.   }
  302. /* END */