builds/windows/ftsystem.c - third_party/freetype2 - Git at Google

 /****************************************************************************
  *
  * ftsystem.c
  *
  *   Windows-specific FreeType low-level system interface (body).
  *
  * Copyright (C) 2021 by
  * David Turner, Robert Wilhelm, and Werner Lemberg.
  *
  * This file is part of the FreeType project, and may only be used,
  * modified, and distributed under the terms of the FreeType project
  * license, LICENSE.TXT.  By continuing to use, modify, or distribute
  * this file you indicate that you have read the license and
  * understand and accept it fully.
  *
  */


 #include <ft2build.h>
   /* we use our special ftconfig.h file, not the standard one */
 #include FT_CONFIG_CONFIG_H
 #include <freetype/internal/ftdebug.h>
 #include <freetype/ftsystem.h>
 #include <freetype/fterrors.h>
 #include <freetype/fttypes.h>
 #include <freetype/internal/ftstream.h>

   /* memory mapping and allocation includes and definitions */
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>


   /**************************************************************************
    *
    *                      MEMORY MANAGEMENT INTERFACE
    *
    */


   /**************************************************************************
    *
    * It is not necessary to do any error checking for the
    * allocation-related functions.  This will be done by the higher level
    * routines like ft_mem_alloc() or ft_mem_realloc().
    *
    */


   /**************************************************************************
    *
    * @Function:
    *   ft_alloc
    *
    * @Description:
    *   The memory allocation function.
    *
    * @Input:
    *   memory ::
    *     A pointer to the memory object.
    *
    *   size ::
    *     The requested size in bytes.
    *
    * @Return:
    *   The address of newly allocated block.
    */
   FT_CALLBACK_DEF( void* )
   ft_alloc( FT_Memory  memory,
             long       size )
   {
     return HeapAlloc( memory->user, 0, size );
   }


   /**************************************************************************
    *
    * @Function:
    *   ft_realloc
    *
    * @Description:
    *   The memory reallocation function.
    *
    * @Input:
    *   memory ::
    *     A pointer to the memory object.
    *
    *   cur_size ::
    *     The current size of the allocated memory block.
    *
    *   new_size ::
    *     The newly requested size in bytes.
    *
    *   block ::
    *     The current address of the block in memory.
    *
    * @Return:
    *   The address of the reallocated memory block.
    */
   FT_CALLBACK_DEF( void* )
   ft_realloc( FT_Memory  memory,
               long       cur_size,
               long       new_size,
               void*      block )
   {
     FT_UNUSED( cur_size );

     return HeapReAlloc( memory->user, 0, block, new_size );
   }


   /**************************************************************************
    *
    * @Function:
    *   ft_free
    *
    * @Description:
    *   The memory release function.
    *
    * @Input:
    *   memory ::
    *     A pointer to the memory object.
    *
    *   block ::
    *     The address of block in memory to be freed.
    */
   FT_CALLBACK_DEF( void )
   ft_free( FT_Memory  memory,
            void*      block )
   {
     HeapFree( memory->user, 0, block );
   }


   /**************************************************************************
    *
    *                    RESOURCE MANAGEMENT INTERFACE
    *
    */


   /**************************************************************************
    *
    * The macro FT_COMPONENT is used in trace mode.  It is an implicit
    * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
    * messages during execution.
    */
 #undef  FT_COMPONENT
 #define FT_COMPONENT  io

   /* We use the macro STREAM_FILE for convenience to extract the       */
   /* system-specific stream handle from a given FreeType stream object */
 #define STREAM_FILE( stream )  ( (FILE*)stream->descriptor.pointer )


   /**************************************************************************
    *
    * @Function:
    *   ft_close_stream_by_munmap
    *
    * @Description:
    *   The function to close a stream which is opened by mmap.
    *
    * @Input:
    *   stream :: A pointer to the stream object.
    */
   FT_CALLBACK_DEF( void )
   ft_close_stream_by_munmap( FT_Stream  stream )
   {
     UnmapViewOfFile( (LPCVOID)stream->descriptor.pointer );

     stream->descriptor.pointer = NULL;
     stream->size               = 0;
     stream->base               = NULL;
   }


   /**************************************************************************
    *
    * @Function:
    *   ft_close_stream_by_free
    *
    * @Description:
    *   The function to close a stream which is created by ft_alloc.
    *
    * @Input:
    *   stream :: A pointer to the stream object.
    */
   FT_CALLBACK_DEF( void )
   ft_close_stream_by_free( FT_Stream  stream )
   {
     ft_free( stream->memory, stream->descriptor.pointer );

     stream->descriptor.pointer = NULL;
     stream->size               = 0;
     stream->base               = NULL;
   }


 #ifdef _WIN32_WCE

   FT_LOCAL_DEF( HANDLE )
   CreateFileA( LPCSTR                lpFileName,
                DWORD                 dwDesiredAccess,
                DWORD                 dwShareMode,
                LPSECURITY_ATTRIBUTES lpSecurityAttributes,
                DWORD                 dwCreationDisposition,
                DWORD                 dwFlagsAndAttributes,
                HANDLE                hTemplateFile )
   {
     int            len;
     LPWSTR         lpFileNameW;


     /* allocate memory space for converted path name */
     len = MultiByteToWideChar( CP_ACP, MB_ERR_INVALID_CHARS,
                                lpFileName, -1, NULL, 0 );

     lpFileNameW = (LPWSTR)_alloca( len * sizeof ( WCHAR ) );

     if ( !len || !lpFileNameW )
     {
       FT_ERROR(( "FT_Stream_Open: cannot convert file name to LPWSTR\n" ));
       return INVALID_HANDLE_VALUE;
     }

     /* now it is safe to do the translation */
     MultiByteToWideChar( CP_ACP, MB_ERR_INVALID_CHARS,
                          lpFileName, -1, lpFileNameW, len );

     /* open the file */
     return CreateFileW( lpFileNameW, dwDesiredAccess, dwShareMode,
                         lpSecurityAttributes, dwCreationDisposition,
                         dwFlagsAndAttributes, hTemplateFile );
   }

 #endif

 #if defined( _WIN32_WCE ) || defined ( _WIN32_WINDOWS ) || \
     !defined( _WIN32_WINNT ) || _WIN32_WINNT <= 0x0400

   FT_LOCAL_DEF( BOOL )
   GetFileSizeEx( HANDLE         hFile,
                  PLARGE_INTEGER lpFileSize )
   {
     lpFileSize->u.LowPart = GetFileSize( hFile,
                                          (DWORD *)&lpFileSize->u.HighPart );

     if ( lpFileSize->u.LowPart == INVALID_FILE_SIZE &&
          GetLastError() != NO_ERROR                 )
       return FALSE;
     else
       return TRUE;
   }

 #endif


   /* documentation is in ftobjs.h */

   FT_BASE_DEF( FT_Error )
   FT_Stream_Open( FT_Stream    stream,
                   const char*  filepathname )
   {
     HANDLE         file;
     HANDLE         fm;
     LARGE_INTEGER  size;


     if ( !stream )
       return FT_THROW( Invalid_Stream_Handle );

     /* open the file */
     file = CreateFileA( (LPCSTR)filepathname, GENERIC_READ, FILE_SHARE_READ,
                         NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0 );
     if ( file == INVALID_HANDLE_VALUE )
     {
       FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not open `%s'\n", filepathname ));
       return FT_THROW( Cannot_Open_Resource );
     }

     if ( GetFileSizeEx( file, &size ) == FALSE )
     {
       FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not retrieve size of file `%s'\n", filepathname ));
       goto Fail_Open;
     }

     /* `stream->size' is typedef'd to unsigned long (in `ftsystem.h'); */
     /* So avoid overflow caused by fonts in huge files larger than     */
     /* 2GB, do a test.                                                 */
     if ( size.QuadPart > LONG_MAX )
     {
       FT_ERROR(( "FT_Stream_Open: file is too big\n" ));
       goto Fail_Open;
     }
     else if ( size.QuadPart == 0 )
     {
       FT_ERROR(( "FT_Stream_Open: zero-length file\n" ));
       goto Fail_Open;
     }

     fm = CreateFileMapping( file, NULL, PAGE_READONLY, 0, 0, NULL );
     if ( fm == NULL )
     {
       FT_ERROR(( "FT_Stream_Open: can not map file\n" ));
       goto Fail_Open;
     }

     /* Store only the low part of this 64 bits integer because long is */
     /* a 32 bits type. Anyway, a check has been done above to forbid   */
     /* a size greater than LONG_MAX                                    */
     stream->size = size.LowPart;
     stream->pos  = 0;
     stream->base = (unsigned char *)
                      MapViewOfFile( fm, FILE_MAP_READ, 0, 0, 0 );

     CloseHandle( fm );

     if ( stream->base != NULL )
       stream->close = ft_close_stream_by_munmap;
     else
     {
       DWORD  total_read_count;


       FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not `mmap' file `%s'\n", filepathname ));

       stream->base = (unsigned char*)ft_alloc( stream->memory, stream->size );

       if ( !stream->base )
       {
         FT_ERROR(( "FT_Stream_Open:" ));
         FT_ERROR(( " could not `alloc' memory\n" ));
         goto Fail_Open;
       }

       total_read_count = 0;
       do
       {
         DWORD  read_count;


         if ( ReadFile( file,
                        stream->base + total_read_count,
                        stream->size - total_read_count,
                        &read_count, NULL ) == FALSE )
         {
           FT_ERROR(( "FT_Stream_Open:" ));
           FT_ERROR(( " error while `read'ing file `%s'\n", filepathname ));
           goto Fail_Read;
         }

         total_read_count += read_count;

       } while ( total_read_count != stream->size );

       stream->close = ft_close_stream_by_free;
     }

     CloseHandle( file );

     stream->descriptor.pointer = stream->base;
     stream->pathname.pointer   = (char*)filepathname;

     stream->read = NULL;

     FT_TRACE1(( "FT_Stream_Open:" ));
     FT_TRACE1(( " opened `%s' (%ld bytes) successfully\n",
                 filepathname, stream->size ));

     return FT_Err_Ok;

   Fail_Read:
     ft_free( stream->memory, stream->base );

   Fail_Open:
     CloseHandle( file );

     stream->base = NULL;
     stream->size = 0;
     stream->pos  = 0;

     return FT_THROW( Cannot_Open_Stream );
   }


 #ifdef FT_DEBUG_MEMORY

   extern FT_Int
   ft_mem_debug_init( FT_Memory  memory );

   extern void
   ft_mem_debug_done( FT_Memory  memory );

 #endif


   /* documentation is in ftobjs.h */

   FT_BASE_DEF( FT_Memory )
   FT_New_Memory( void )
   {
     HANDLE     heap;
     FT_Memory  memory;


     heap   = GetProcessHeap();
     memory = heap ? (FT_Memory)HeapAlloc( heap, 0, sizeof ( *memory ) )
                   : NULL;

     if ( memory )
     {
       memory->user    = heap;
       memory->alloc   = ft_alloc;
       memory->realloc = ft_realloc;
       memory->free    = ft_free;
 #ifdef FT_DEBUG_MEMORY
       ft_mem_debug_init( memory );
 #endif
     }

     return memory;
   }


   /* documentation is in ftobjs.h */

   FT_BASE_DEF( void )
   FT_Done_Memory( FT_Memory  memory )
   {
 #ifdef FT_DEBUG_MEMORY
     ft_mem_debug_done( memory );
 #endif
     memory->free( memory, memory );
   }


 /* END */
	/****************************************************************************
	*
	* ftsystem.c
	*
	* Windows-specific FreeType low-level system interface (body).
	*
	* Copyright (C) 2021 by
	* David Turner, Robert Wilhelm, and Werner Lemberg.
	*
	* This file is part of the FreeType project, and may only be used,
	* modified, and distributed under the terms of the FreeType project
	* license, LICENSE.TXT. By continuing to use, modify, or distribute
	* this file you indicate that you have read the license and
	* understand and accept it fully.
	*
	*/


	#include <ft2build.h>
	/* we use our special ftconfig.h file, not the standard one */
	#include FT_CONFIG_CONFIG_H
	#include <freetype/internal/ftdebug.h>
	#include <freetype/ftsystem.h>
	#include <freetype/fterrors.h>
	#include <freetype/fttypes.h>
	#include <freetype/internal/ftstream.h>

	/* memory mapping and allocation includes and definitions */
	#define WIN32_LEAN_AND_MEAN
	#include <windows.h>


	/**************************************************************************
	*
	* MEMORY MANAGEMENT INTERFACE
	*
	*/


	/**************************************************************************
	*
	* It is not necessary to do any error checking for the
	* allocation-related functions. This will be done by the higher level
	* routines like ft_mem_alloc() or ft_mem_realloc().
	*
	*/


	/**************************************************************************
	*
	* @Function:
	* ft_alloc
	*
	* @Description:
	* The memory allocation function.
	*
	* @Input:
	* memory ::
	* A pointer to the memory object.
	*
	* size ::
	* The requested size in bytes.
	*
	* @Return:
	* The address of newly allocated block.
	*/
	FT_CALLBACK_DEF( void* )
	ft_alloc( FT_Memory memory,
	long size )
	{
	return HeapAlloc( memory->user, 0, size );
	}


	/**************************************************************************
	*
	* @Function:
	* ft_realloc
	*
	* @Description:
	* The memory reallocation function.
	*
	* @Input:
	* memory ::
	* A pointer to the memory object.
	*
	* cur_size ::
	* The current size of the allocated memory block.
	*
	* new_size ::
	* The newly requested size in bytes.
	*
	* block ::
	* The current address of the block in memory.
	*
	* @Return:
	* The address of the reallocated memory block.
	*/
	FT_CALLBACK_DEF( void* )
	ft_realloc( FT_Memory memory,
	long cur_size,
	long new_size,
	void* block )
	{
	FT_UNUSED( cur_size );

	return HeapReAlloc( memory->user, 0, block, new_size );
	}


	/**************************************************************************
	*
	* @Function:
	* ft_free
	*
	* @Description:
	* The memory release function.
	*
	* @Input:
	* memory ::
	* A pointer to the memory object.
	*
	* block ::
	* The address of block in memory to be freed.
	*/
	FT_CALLBACK_DEF( void )
	ft_free( FT_Memory memory,
	void* block )
	{
	HeapFree( memory->user, 0, block );
	}


	/**************************************************************************
	*
	* RESOURCE MANAGEMENT INTERFACE
	*
	*/


	/**************************************************************************
	*
	* The macro FT_COMPONENT is used in trace mode. It is an implicit
	* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
	* messages during execution.
	*/
	#undef FT_COMPONENT
	#define FT_COMPONENT io

	/* We use the macro STREAM_FILE for convenience to extract the */
	/* system-specific stream handle from a given FreeType stream object */
	#define STREAM_FILE( stream ) ( (FILE*)stream->descriptor.pointer )


	/**************************************************************************
	*
	* @Function:
	* ft_close_stream_by_munmap
	*
	* @Description:
	* The function to close a stream which is opened by mmap.
	*
	* @Input:
	* stream :: A pointer to the stream object.
	*/
	FT_CALLBACK_DEF( void )
	ft_close_stream_by_munmap( FT_Stream stream )
	{
	UnmapViewOfFile( (LPCVOID)stream->descriptor.pointer );

	stream->descriptor.pointer = NULL;
	stream->size = 0;
	stream->base = NULL;
	}


	/**************************************************************************
	*
	* @Function:
	* ft_close_stream_by_free
	*
	* @Description:
	* The function to close a stream which is created by ft_alloc.
	*
	* @Input:
	* stream :: A pointer to the stream object.
	*/
	FT_CALLBACK_DEF( void )
	ft_close_stream_by_free( FT_Stream stream )
	{
	ft_free( stream->memory, stream->descriptor.pointer );

	stream->descriptor.pointer = NULL;
	stream->size = 0;
	stream->base = NULL;
	}


	#ifdef _WIN32_WCE

	FT_LOCAL_DEF( HANDLE )
	CreateFileA( LPCSTR lpFileName,
	DWORD dwDesiredAccess,
	DWORD dwShareMode,
	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
	DWORD dwCreationDisposition,
	DWORD dwFlagsAndAttributes,
	HANDLE hTemplateFile )
	{
	int len;
	LPWSTR lpFileNameW;


	/* allocate memory space for converted path name */
	len = MultiByteToWideChar( CP_ACP, MB_ERR_INVALID_CHARS,
	lpFileName, -1, NULL, 0 );

	lpFileNameW = (LPWSTR)_alloca( len * sizeof ( WCHAR ) );

	if ( !len \|\| !lpFileNameW )
	{
	FT_ERROR(( "FT_Stream_Open: cannot convert file name to LPWSTR\n" ));
	return INVALID_HANDLE_VALUE;
	}

	/* now it is safe to do the translation */
	MultiByteToWideChar( CP_ACP, MB_ERR_INVALID_CHARS,
	lpFileName, -1, lpFileNameW, len );

	/* open the file */
	return CreateFileW( lpFileNameW, dwDesiredAccess, dwShareMode,
	lpSecurityAttributes, dwCreationDisposition,
	dwFlagsAndAttributes, hTemplateFile );
	}

	#endif

	#if defined( _WIN32_WCE ) \|\| defined ( _WIN32_WINDOWS ) \|\| \
	!defined( _WIN32_WINNT ) \|\| _WIN32_WINNT <= 0x0400

	FT_LOCAL_DEF( BOOL )
	GetFileSizeEx( HANDLE hFile,
	PLARGE_INTEGER lpFileSize )
	{
	lpFileSize->u.LowPart = GetFileSize( hFile,
	(DWORD *)&lpFileSize->u.HighPart );

	if ( lpFileSize->u.LowPart == INVALID_FILE_SIZE &&
	GetLastError() != NO_ERROR )
	return FALSE;
	else
	return TRUE;
	}

	#endif


	/* documentation is in ftobjs.h */

	FT_BASE_DEF( FT_Error )
	FT_Stream_Open( FT_Stream stream,
	const char* filepathname )
	{
	HANDLE file;
	HANDLE fm;
	LARGE_INTEGER size;


	if ( !stream )
	return FT_THROW( Invalid_Stream_Handle );

	/* open the file */
	file = CreateFileA( (LPCSTR)filepathname, GENERIC_READ, FILE_SHARE_READ,
	NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0 );
	if ( file == INVALID_HANDLE_VALUE )
	{
	FT_ERROR(( "FT_Stream_Open:" ));
	FT_ERROR(( " could not open `%s'\n", filepathname ));
	return FT_THROW( Cannot_Open_Resource );
	}

	if ( GetFileSizeEx( file, &size ) == FALSE )
	{
	FT_ERROR(( "FT_Stream_Open:" ));
	FT_ERROR(( " could not retrieve size of file `%s'\n", filepathname ));
	goto Fail_Open;
	}

	/* `stream->size' is typedef'd to unsigned long (in `ftsystem.h'); */
	/* So avoid overflow caused by fonts in huge files larger than */
	/* 2GB, do a test. */
	if ( size.QuadPart > LONG_MAX )
	{
	FT_ERROR(( "FT_Stream_Open: file is too big\n" ));
	goto Fail_Open;
	}
	else if ( size.QuadPart == 0 )
	{
	FT_ERROR(( "FT_Stream_Open: zero-length file\n" ));
	goto Fail_Open;
	}

	fm = CreateFileMapping( file, NULL, PAGE_READONLY, 0, 0, NULL );
	if ( fm == NULL )
	{
	FT_ERROR(( "FT_Stream_Open: can not map file\n" ));
	goto Fail_Open;
	}

	/* Store only the low part of this 64 bits integer because long is */
	/* a 32 bits type. Anyway, a check has been done above to forbid */
	/* a size greater than LONG_MAX */
	stream->size = size.LowPart;
	stream->pos = 0;
	stream->base = (unsigned char *)
	MapViewOfFile( fm, FILE_MAP_READ, 0, 0, 0 );

	CloseHandle( fm );

	if ( stream->base != NULL )
	stream->close = ft_close_stream_by_munmap;
	else
	{
	DWORD total_read_count;


	FT_ERROR(( "FT_Stream_Open:" ));
	FT_ERROR(( " could not `mmap' file `%s'\n", filepathname ));

	stream->base = (unsigned char*)ft_alloc( stream->memory, stream->size );

	if ( !stream->base )
	{
	FT_ERROR(( "FT_Stream_Open:" ));
	FT_ERROR(( " could not `alloc' memory\n" ));
	goto Fail_Open;
	}

	total_read_count = 0;
	do
	{
	DWORD read_count;


	if ( ReadFile( file,
	stream->base + total_read_count,
	stream->size - total_read_count,
	&read_count, NULL ) == FALSE )
	{
	FT_ERROR(( "FT_Stream_Open:" ));
	FT_ERROR(( " error while `read'ing file `%s'\n", filepathname ));
	goto Fail_Read;
	}

	total_read_count += read_count;

	} while ( total_read_count != stream->size );

	stream->close = ft_close_stream_by_free;
	}

	CloseHandle( file );

	stream->descriptor.pointer = stream->base;
	stream->pathname.pointer = (char*)filepathname;

	stream->read = NULL;

	FT_TRACE1(( "FT_Stream_Open:" ));
	FT_TRACE1(( " opened `%s' (%ld bytes) successfully\n",
	filepathname, stream->size ));

	return FT_Err_Ok;

	Fail_Read:
	ft_free( stream->memory, stream->base );

	Fail_Open:
	CloseHandle( file );

	stream->base = NULL;
	stream->size = 0;
	stream->pos = 0;

	return FT_THROW( Cannot_Open_Stream );
	}


	#ifdef FT_DEBUG_MEMORY

	extern FT_Int
	ft_mem_debug_init( FT_Memory memory );

	extern void
	ft_mem_debug_done( FT_Memory memory );

	#endif


	/* documentation is in ftobjs.h */

	FT_BASE_DEF( FT_Memory )
	FT_New_Memory( void )
	{
	HANDLE heap;
	FT_Memory memory;


	heap = GetProcessHeap();
	memory = heap ? (FT_Memory)HeapAlloc( heap, 0, sizeof ( *memory ) )
	: NULL;

	if ( memory )
	{
	memory->user = heap;
	memory->alloc = ft_alloc;
	memory->realloc = ft_realloc;
	memory->free = ft_free;
	#ifdef FT_DEBUG_MEMORY
	ft_mem_debug_init( memory );
	#endif
	}

	return memory;
	}


	/* documentation is in ftobjs.h */

	FT_BASE_DEF( void )
	FT_Done_Memory( FT_Memory memory )
	{
	#ifdef FT_DEBUG_MEMORY
	ft_mem_debug_done( memory );
	#endif
	memory->free( memory, memory );
	}


	/* END */