fixed a bug in ftsystem that prevented the library from reading files
This commit is contained in:
David Turner
parent
c6cda4a74e
commit
b4a98378e1
@ -168,7 +168,7 @@
|
||||
file = STREAM_FILE(stream);
|
||||
|
||||
fseek( file, offset, SEEK_SET );
|
||||
return (unsigned long)fread( buffer, count, 1, file );
|
||||
return (unsigned long)fread( buffer, 1, count, file );
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -168,7 +168,7 @@
|
||||
file = STREAM_FILE(stream);
|
||||
|
||||
fseek( file, offset, SEEK_SET );
|
||||
return (unsigned long)fread( buffer, count, 1, file );
|
||||
return (unsigned long)fread( buffer, 1, count, file );
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -1,866 +0,0 @@
|
||||
/*******************************************************************
|
||||
*
|
||||
* ftsys.c
|
||||
*
|
||||
* ANSI-specific system operations.
|
||||
*
|
||||
* Copyright 1996-1998 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.
|
||||
*
|
||||
*
|
||||
* This implementation of the 'ftsys' component uses the standard
|
||||
* ANSI C library.
|
||||
*
|
||||
* IMPORTANT NOTE :
|
||||
*
|
||||
* Porters, read carefully the comments in ftsys.h before trying
|
||||
* to port this file to your system. It contains many essential
|
||||
* remarks, and will ease your work greatly..
|
||||
*
|
||||
******************************************************************/
|
||||
|
||||
#include "ftsys.h"
|
||||
#include "ftstream.h"
|
||||
#include "ftdebug.h"
|
||||
|
||||
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the PTRACE and PERROR macros, used to print/log */
|
||||
/* messages during execution.. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_io
|
||||
|
||||
|
||||
#undef CUR_SYSTEM /* just in case */
|
||||
|
||||
|
||||
/* To ease porting, we use the macro SYS_STREAM to name the system-specific */
|
||||
/* stream type. For example, it is a "FILE*" with the ANSI libc, it will be */
|
||||
/* a file descriptor, i.e. an integer, when using the Unix system api, etc. */
|
||||
|
||||
#define SYS_STREAM FILE*
|
||||
|
||||
|
||||
/* This implementation of ftsys uses the ANSI C library. Memory */
|
||||
/* management is performed through malloc/free, i/o access through */
|
||||
/* fopen/fread/fseek, and no synchronisation primitive is implemented */
|
||||
/* (they contain dummy code) */
|
||||
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
/* */
|
||||
/* I/O ACCESS AND MANAGEMENT */
|
||||
/* */
|
||||
/* We only define the "ANSI" resource class in this class. It is */
|
||||
/* disk-based, and provides a MRU cache, in order to only keep the file */
|
||||
/* descriptors of the 10 most recently used resource files. */
|
||||
/* */
|
||||
/* it simply contains two lists. One contains the "cached" resources */
|
||||
/* with a valid FILE* pointer, the second contains all other "flushed" */
|
||||
/* resource objects. */
|
||||
/* */
|
||||
|
||||
/* The FT_ANSI_File class derives from FT_ResourceRec - description : */
|
||||
/* */
|
||||
/* <Struct> FT_AnsiFileRec */
|
||||
/* */
|
||||
/* <Fields> */
|
||||
/* */
|
||||
/* root :: */
|
||||
/* the root resource class fields. */
|
||||
/* */
|
||||
/* pathname :: */
|
||||
/* this is a copy of the ANSI file pathname used to open streams */
|
||||
/* for the resource. A different implementation is free to use */
|
||||
/* unicode chars, or file i-node numbers, etc.. */
|
||||
/* */
|
||||
/* file_size :: */
|
||||
/* the size in bytes of the resource. This field should be set to */
|
||||
/* -1 until the resource is first opened.. */
|
||||
/* */
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
typedef struct FT_AnsiFileRec_
|
||||
{
|
||||
FT_ResourceRec root;
|
||||
char* pathname; /* the font file's pathname */
|
||||
FT_Long file_size; /* file size in bytes */
|
||||
|
||||
} FT_AnsiFileRec, *FT_AnsiFile;
|
||||
|
||||
|
||||
/* We use the macro STREAM_Name as a convenience to return a given */
|
||||
/* ANSI resource's pathname. Its "stream" argument is a FT_Resource */
|
||||
/* which is typecasted to the FT_AnsiFile class */
|
||||
#define STREAM_Name(stream) ((FT_AnsiFile)stream->resource)->pathname
|
||||
|
||||
/* We use the macro STREAM_File as a convenience to extract the */
|
||||
/* system-specific stream handle from a given FreeType stream object */
|
||||
#define STREAM_File(stream) ((FILE*)stream->stream_id.pointer)
|
||||
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* <Function> AnsiFile_Open */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* This function is used to open a system-stream for a given resource. */
|
||||
/* */
|
||||
/* Note that it must update the target FreeType stream object with the */
|
||||
/* system-stream handle and the resource's size. */
|
||||
/* */
|
||||
/* Also, the 'stream->base' field must be set to NULL for disk-based */
|
||||
/* resource, and to the address in memory of the resource's first byte */
|
||||
/* for a memory-based one. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* resource :: the source resource */
|
||||
/* stream :: the target stream object */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* Error code */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* This function simply calls fopen in the resource's file pathname */
|
||||
/* */
|
||||
/* The stream object IS NOT CREATED by this function, but by its caller. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
static
|
||||
FT_Error AnsiFile_Open( FT_AnsiFile resource,
|
||||
FT_Stream stream )
|
||||
{
|
||||
FILE* file;
|
||||
|
||||
/* open the file */
|
||||
file = fopen( resource->pathname, "rb" );
|
||||
if (!file)
|
||||
{
|
||||
PERROR(( "AnsiFile_Open: could not open file '%s'\n",
|
||||
resource->pathname ));
|
||||
return FT_Err_Cannot_Open_Stream;
|
||||
}
|
||||
|
||||
/* compute file size if necessary */
|
||||
if ( resource->file_size < 0 )
|
||||
{
|
||||
fseek( file, 0, SEEK_END );
|
||||
resource->file_size = ftell(file);
|
||||
fseek( file, 0, SEEK_SET );
|
||||
}
|
||||
|
||||
stream->resource = (FT_Resource)resource;
|
||||
stream->stream_id.pointer = file;
|
||||
stream->size = resource->file_size;
|
||||
|
||||
/* it's a disk-based resource, we don't need to use the "base" and */
|
||||
/* "cursor" fields of the stream objects */
|
||||
stream->base = NULL;
|
||||
stream->cursor = NULL;
|
||||
|
||||
PTRACE1(( "AnsiFile_Open: opened '%s' (%d bytes) succesfully\n",
|
||||
resource->pathname, resource->file_size ));
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* <Function> AnsiFile_Close */
|
||||
/* */
|
||||
/* <Description> Closes a given stream */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* stream :: the target stream object */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* Error code */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* This function simply calls fclose on the stream's ANSI FILE object */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
static
|
||||
FT_Error AnsiFile_Close( FT_Stream stream )
|
||||
{
|
||||
PTRACE1(( "Closing file '%s'\n", STREAM_Name(stream) ));
|
||||
|
||||
fclose( STREAM_File(stream) );
|
||||
|
||||
stream->resource = NULL;
|
||||
stream->stream_id.pointer = NULL;
|
||||
stream->size = 0;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* <Function> AnsiFile_Seek */
|
||||
/* */
|
||||
/* <Description> Seek a stream to a given position */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* stream :: the target stream object */
|
||||
/* position :: offset in bytes from start of resource/stream */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* Error code */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* This function simply calls fseek on the stream. */
|
||||
/* */
|
||||
/* The "seek" method is never called by the stream manager in the case */
|
||||
/* of a memory-based resource (i.e. when 'stream->base' isn't NULL). */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
static
|
||||
FT_Error AnsiFile_Seek( FT_Stream stream,
|
||||
FT_Long position )
|
||||
{
|
||||
if ( fseek( STREAM_File(stream), position, SEEK_SET ) )
|
||||
{
|
||||
PERROR(( "AnsiFile_Seek : FAILED !! pos. %ld of '%s'\n",
|
||||
position, STREAM_Name(stream) ));
|
||||
|
||||
return FT_Err_Invalid_Stream_Seek;
|
||||
}
|
||||
|
||||
PTRACE2(( "AnsiFile_Seek : pos. %ld of '%s'\n",
|
||||
position, STREAM_Name(stream) ));
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* <Function> AnsiFile_Skip */
|
||||
/* */
|
||||
/* <Description> Skip a given number of bytes in an ANSI stream. */
|
||||
/* Useful to skip pad bytes, for example. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* stream :: the target stream object */
|
||||
/* count :: number of bytes to skip in the stream */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* Error code */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* This function simply calls fseek on the stream. */
|
||||
/* */
|
||||
/* The "skip" method is never called by the stream manager in the case */
|
||||
/* of a memory-based resource (i.e. when 'stream->base' isn't NULL). */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
static
|
||||
FT_Error AnsiFile_Skip( FT_Stream stream,
|
||||
FT_Long count )
|
||||
{
|
||||
if ( fseek( STREAM_File(stream), count, SEEK_CUR ) )
|
||||
{
|
||||
PERROR(( "AnsiFile_Skip : FAILED !! %ld bytes in '%s'\n",
|
||||
count, STREAM_Name(stream) ));
|
||||
|
||||
return FT_Err_Invalid_Stream_Seek;
|
||||
}
|
||||
|
||||
PTRACE2(( "AnsiFile_Skip : %ld bytes in '%s'\n",count,
|
||||
STREAM_Name(stream) ));
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* <Function> AnsiFile_Pos */
|
||||
/* */
|
||||
/* <Description> Returns the current offset within an ANSI stream's */
|
||||
/* resource. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* stream :: the target stream object */
|
||||
/* */
|
||||
/* <Output> */
|
||||
/* position :: current offset. -1 in case of error */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* Error code. */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* This function simply calls ftell on the stream. */
|
||||
/* */
|
||||
/* The "pos" method is never called by the stream manager in the case */
|
||||
/* of a memory-based resource (i.e. when 'stream->base' isn't NULL). */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
static
|
||||
FT_Error AnsiFile_Pos( FT_Stream stream,
|
||||
FT_Long* position )
|
||||
{
|
||||
*position = ftell( STREAM_File(stream) );
|
||||
if ( *position == -1 )
|
||||
{
|
||||
PTRACE2(( "AnsiFile_Pos : FAILED !! in '%s'\n", STREAM_Name(stream) ));
|
||||
return FT_Err_Invalid_Stream_Seek;
|
||||
}
|
||||
|
||||
PTRACE2(( "AnsiFile_Pos : for '%s'\n", STREAM_Name(stream) ));
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* <Function> AnsiFile_Read */
|
||||
/* */
|
||||
/* <Description> Read a given number of bytes from an ANSI stream into */
|
||||
/* memory. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* stream :: the target stream object */
|
||||
/* buffer :: the target read buffer where data is copied */
|
||||
/* size :: number of bytes to read from the stream */
|
||||
/* */
|
||||
/* <Output> */
|
||||
/* read_bytes :: the number of bytes effectively read from the stream */
|
||||
/* used in case of error (i.e. FT_Err_Invalid_Stream_Read) */
|
||||
/* by some parts of the library.. */
|
||||
/* <Return> */
|
||||
/* Error code */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* This function simply calls fread on the stream. */
|
||||
/* */
|
||||
/* It MUST return the error FT_Err_Invalid_Stream_Read in case of */
|
||||
/* an over-read (i.e. reading more bytes from the stream that what */
|
||||
/* is left int), as the stream component checks for this specific */
|
||||
/* value.. */
|
||||
/* */
|
||||
/* The "read" method is never called by the stream manager in the case */
|
||||
/* of a memory-based resource (i.e. when 'stream->base' isn't NULL). */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
static
|
||||
FT_Error AnsiFile_Read( FT_Stream stream,
|
||||
FT_Char* buffer,
|
||||
FT_Long size,
|
||||
FT_Long* read_bytes )
|
||||
{
|
||||
*read_bytes = fread( buffer, 1, size, STREAM_File(stream) );
|
||||
if ( *read_bytes != size )
|
||||
{
|
||||
/* Note : we can have an over-read here when called by the */
|
||||
/* function FT_Access_Compressed_Frame. This means */
|
||||
/* that the following message should be a trace, */
|
||||
/* rather than an error for disk-based resources.. */
|
||||
/* */
|
||||
/* the function must set the value of 'read_bytes' */
|
||||
/* even if it returns an error code.. */
|
||||
PTRACE2(( "AnsiFile_Read : FAILED !! read %ld bytes from '%s'\n",
|
||||
size, STREAM_Name(stream) ));
|
||||
|
||||
return FT_Err_Invalid_Stream_Read;
|
||||
}
|
||||
|
||||
PTRACE2(( "AnsiFile_Read : read %ld bytes to buffer 0x%08lx from '%s'\n",
|
||||
size, (long)buffer, STREAM_Name(stream) ));
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
/* The following table is the "virtual method table" for the 'ANSI */
|
||||
/* resource class', which methods are defined above. Its address is */
|
||||
/* set in the 'interface' field of all resource objects created by */
|
||||
/* the function FT_Create_AnsiFile (see below) */
|
||||
|
||||
static
|
||||
FTRes_InterfaceRec FT_AnsiFile_Interface =
|
||||
{
|
||||
(FTRes_Open_Func) AnsiFile_Open,
|
||||
(FTRes_Close_Func) AnsiFile_Close,
|
||||
(FTRes_Seek_Func) AnsiFile_Seek,
|
||||
(FTRes_Skip_Func) AnsiFile_Skip,
|
||||
(FTRes_Pos_Func) AnsiFile_Pos,
|
||||
(FTRes_Read_Func) AnsiFile_Read,
|
||||
};
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* <Function> FT_Create_Resource */
|
||||
/* */
|
||||
/* <Description> Creates a new resource object, of class "AnsiFile". */
|
||||
/* This function is never called directly by the font */
|
||||
/* drivers. Only by the higher-level part of FreeType */
|
||||
/* (called the HLib), or client applications */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* pathname :: the file's pathname, in ASCII */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* Handle/pointer to the new resource object. NULL in case of error */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* This functions does not open a stream. It simply copies the */
|
||||
/* pathname within a fresh new resource object. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
EXPORT_FUNC
|
||||
FT_Error FT_Create_Resource( FT_Library library,
|
||||
const char* pathname,
|
||||
FT_Resource* aresource )
|
||||
{
|
||||
FT_Int len;
|
||||
FT_AnsiFile resource;
|
||||
FT_Error error;
|
||||
FT_System system = library->system;
|
||||
|
||||
if ( !pathname )
|
||||
goto Fail_Null;
|
||||
|
||||
len = strlen(pathname);
|
||||
if (len == 0)
|
||||
goto Fail_Null;
|
||||
|
||||
resource = NULL;
|
||||
|
||||
if ( ALLOC( resource, sizeof(*resource) ) ||
|
||||
ALLOC( resource->pathname, len+1 ) )
|
||||
goto Fail_Memory;
|
||||
|
||||
resource->root.library = library;
|
||||
resource->root.interface = &FT_AnsiFile_Interface;
|
||||
resource->root.flags = FT_RESOURCE_TYPE_DISK_BASED;
|
||||
resource->file_size = -1;
|
||||
strcpy( resource->pathname, pathname );
|
||||
|
||||
PTRACE1(( "Create_AnsiFile : Ansi resource created for '%s'\n",
|
||||
pathname ));
|
||||
|
||||
*aresource = (FT_Resource)resource;
|
||||
return FT_Err_Ok;
|
||||
|
||||
Fail_Null:
|
||||
PERROR(( "Create_AnsiFile : null pathname !!\n" ));
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
Fail_Memory:
|
||||
if (resource)
|
||||
FREE( resource->pathname );
|
||||
FREE( resource );
|
||||
PERROR(( "Create_AnsiFile : not enough memory to create resource !\n" ));
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* <Function> FT_Destroy_Resource */
|
||||
/* */
|
||||
/* <Description> Destroys an ANSI resource object. */
|
||||
/* This function is never called directly by the font */
|
||||
/* drivers. Only by the higher-level part of FreeType */
|
||||
/* (called the HLib), or client applications */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* resource :: the Ansi resource object */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* This functions does not check that runs or streams are opened for */
|
||||
/* the resource (for now, we assume developer intelligence. We'll most */
|
||||
/* probably lower our standard later to ease debugging ;-) */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
EXPORT_FUNC
|
||||
FT_Error FT_Destroy_Resource( FT_Resource resource )
|
||||
{
|
||||
FT_System system = resource->library->system;
|
||||
FT_AnsiFile ansi = (FT_AnsiFile)resource;
|
||||
|
||||
if ( !ansi || ansi->root.interface != &FT_AnsiFile_Interface )
|
||||
{
|
||||
PERROR((
|
||||
"Destroy_AnsiFile : Trying to destroy an invalid resource !!\n" ));
|
||||
return FT_Err_Invalid_Resource_Handle;
|
||||
}
|
||||
|
||||
PTRACE1(( "Destroy_AnsiFile : destroying resource for '%s'\n",
|
||||
ansi->pathname ));
|
||||
|
||||
FREE( ansi->pathname );
|
||||
FREE( ansi );
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
/* */
|
||||
/* MEMORY MANAGEMENT */
|
||||
/* */
|
||||
/* */
|
||||
/* This part copies the old FreeType 1.0 and 1.1 memory management */
|
||||
/* scheme that was defined in the file "ttmemory.h". One can see that */
|
||||
/* */
|
||||
/* - a set of macros is defined for the memory operations used */
|
||||
/* by the engine ( MEM_Copy, MEM_Move, MEM_Set ). This comes from */
|
||||
/* the fact that many compilers are able to inline these ops directly */
|
||||
/* within the compiled code, rather than generating a call to the */
|
||||
/* C library. However, this obliges us to include the <string.h> */
|
||||
/* header file. */
|
||||
/* */
|
||||
/* If you provide your own memory operations routine, you can get */
|
||||
/* rid of the #include <string.h> below. */
|
||||
/* */
|
||||
/* */
|
||||
/* - the FT_Alloc function has several essential properties that */
|
||||
/* MUST be retained by each port : */
|
||||
/* */
|
||||
/* - it returns an error code, NOT the allocated block's base */
|
||||
/* address */
|
||||
/* */
|
||||
/* - it takes the address of a target pointer, where the block's */
|
||||
/* base address will be set. if the size is zero, its value */
|
||||
/* will be NULL and the function returns successfully */
|
||||
/* */
|
||||
/* - in case of error, the pointer's value is set to NULL and */
|
||||
/* an error code is returned.. */
|
||||
/* */
|
||||
/* - the new allocated block MUST be zero-filled. This is a strong */
|
||||
/* convetion the rest of the engine relies on */
|
||||
/* */
|
||||
/* */
|
||||
/* */
|
||||
/* - the FT_Free function has also its essentials : */
|
||||
/* */
|
||||
/* - it takes the address of a pointer which value is the block's */
|
||||
/* base address. This is UNLIKE a standard "free" which takes the */
|
||||
/* the block's base directly. */
|
||||
/* */
|
||||
/* - it accepts succesfully the address of a pointer which value */
|
||||
/* is NULL, in which case it simply returns. */
|
||||
/* */
|
||||
/* - the pointer is always set to NULL by the function */
|
||||
/* */
|
||||
/* */
|
||||
/* - the MEM_Alloc, ALLOC and ALLOC_ARRAY macros are used by the */
|
||||
/* library, and should NOT be modified by porters !! */
|
||||
/* */
|
||||
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the PTRACE and PERROR macros, used to print/log */
|
||||
/* messages during execution.. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_memory
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
/**************************************************************************/
|
||||
/* */
|
||||
/* <Function> FT_Alloc */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* Allocates a new bloc of memory. The returned area is always */
|
||||
/* zero-filled, this is a strong convention in many FreeType parts */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* system :: handle to a given 'system object' where allocation */
|
||||
/* occurs.. */
|
||||
/* */
|
||||
/* size :: size in bytes of the block to allocate */
|
||||
/* */
|
||||
/* <Output> */
|
||||
/* P :: pointer to the fresh new block. It should be set */
|
||||
/* to NULL if 'size' is 0, of in case of error.. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* FreeType error code. 0 means success. */
|
||||
/* */
|
||||
/**************************************************************************/
|
||||
|
||||
BASE_FUNC
|
||||
FT_Error FT_Alloc( FT_System system,
|
||||
long size,
|
||||
void* *P )
|
||||
{
|
||||
|
||||
if (!P)
|
||||
{
|
||||
PERROR(( "FT_Alloc : invalid pointer address !!\n" ));
|
||||
return FT_Err_Invalid_Argument;
|
||||
}
|
||||
|
||||
if ( size > 0 )
|
||||
{
|
||||
*P = malloc( size );
|
||||
if ( !*P )
|
||||
{
|
||||
PERROR(( "FT_Alloc : out of memory (%ld bytes requested) !!\n",
|
||||
size ));
|
||||
|
||||
return FT_Err_Out_Of_Memory;
|
||||
}
|
||||
|
||||
system->total_alloc += size;
|
||||
|
||||
/* ALWAYS ZERO-FILL THE BLOCK !!!!! */
|
||||
MEM_Set( *P, 0, size );
|
||||
}
|
||||
else
|
||||
*P = NULL;
|
||||
|
||||
PTRACE2(( "FT_Alloc : size = %ld, pointer = 0x%08lx, block = 0x%08lx\n",
|
||||
size, (long)P, (long)*P ));
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
/* */
|
||||
/* <Function> FT_Realloc */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* Reallocates a block of memory pointed to by '*P' to 'Size' */
|
||||
/* bytes from the hea^, possibly changing '*P'. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* system :: handle to a given 'system object' where allocation */
|
||||
/* occurs.. */
|
||||
/* */
|
||||
/* size :: size in bytes of the block to allocate */
|
||||
/* */
|
||||
/* <InOut> */
|
||||
/* P :: pointer to the fresh new block. It should be set */
|
||||
/* to NULL if 'size' is 0, of in case of error.. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* FreeType error code. 0 means success. */
|
||||
/* */
|
||||
|
||||
BASE_FUNC
|
||||
int FT_Realloc( FT_System system,
|
||||
long size,
|
||||
void* *P )
|
||||
{
|
||||
void* Q;
|
||||
|
||||
if (!P)
|
||||
{
|
||||
PERROR(( "FT_Realloc : invalid pointer address !!\n" ));
|
||||
return FT_Err_Invalid_Argument;
|
||||
}
|
||||
|
||||
/* if the original pointer is NULL, call FT_Alloc */
|
||||
if (!*P)
|
||||
return FT_Alloc( system, size, P );
|
||||
|
||||
/* if the new block if zero-sized, clear the current one */
|
||||
if (size <= 0)
|
||||
return FT_Free( system, P );
|
||||
|
||||
Q = (void*)realloc( *P, size );
|
||||
if (!Q)
|
||||
{
|
||||
PERROR(( "FT_Realloc : reallocation failed\n" ));
|
||||
return FT_Err_Out_Of_Memory;
|
||||
}
|
||||
|
||||
*P = Q;
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
/* */
|
||||
/* <Function> FT_Free */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* Releases a given block of memory allocated through FT_Alloc */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* system :: handle to a given 'system object' where allocation */
|
||||
/* occured.. */
|
||||
/* */
|
||||
/* P :: This is the _address_ of a _pointer_ which points to */
|
||||
/* the allocated block. It is always set to NULL on exit */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* FreeType error code. 0 means success. */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* If P or *P are NULL, this function should return successfuly. This */
|
||||
/* is a strong convention within all of FreeType and its drivers.. */
|
||||
/* */
|
||||
|
||||
BASE_FUNC
|
||||
FT_Error FT_Free( FT_System system,
|
||||
void* *P )
|
||||
{
|
||||
(void)system; /* unused parameter. Gets rid of warnings */
|
||||
|
||||
PTRACE2(( "FT_Free : freeing pointer 0x%08lx (block 0x%08lx)\n",
|
||||
(long)P, (P ? (long)*P : -1) ));
|
||||
|
||||
if ( !P || !*P )
|
||||
return FT_Err_Ok;
|
||||
|
||||
free( *P );
|
||||
*P = NULL;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
/**************************************************************************/
|
||||
/* */
|
||||
/* SYNCHRONIZATION MANAGEMENT */
|
||||
/* */
|
||||
/* */
|
||||
/* This section deals with mutexes. The library can be compiled to */
|
||||
/* three distinct thread-support levels ( namely single-threaded, */
|
||||
/* thread-safe and re-entrant modes ). */
|
||||
/* */
|
||||
/* It protects its variables through the MUTEX_Lock and MUTEX_Release */
|
||||
/* macros which are void in single-threaded mode. */
|
||||
/* */
|
||||
/* */
|
||||
/* It defines a type-less mutex reference type, "TMutex", that you're */
|
||||
/* free to redefine for your system's needs.. */
|
||||
/* */
|
||||
/* The default implementation of ftsys.c contains only dummy functions */
|
||||
/* which always return succesfully. you NEED to specialize them in */
|
||||
/* order to port ftsys.c in any multi-threaded environment... */
|
||||
/* */
|
||||
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the PTRACE and PERROR macros, used to print/log */
|
||||
/* messages during execution.. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_sync
|
||||
|
||||
#ifdef FT_CONFIG_THREADS
|
||||
|
||||
|
||||
BASE_FUNC
|
||||
FT_Error FT_Mutex_Create ( FT_System system,
|
||||
TMutex* mutex )
|
||||
{
|
||||
(void)system; /* unused parameter. Gets rid of warnings */
|
||||
|
||||
mutex = (void*)-1;
|
||||
system->num_mutexes++;
|
||||
return FT_Err_Ok;
|
||||
/* Replace this line with your own mutex creation code */
|
||||
}
|
||||
|
||||
|
||||
BASE_FUNC
|
||||
void FT_Mutex_Delete ( FT_System system,
|
||||
TMutex* mutex )
|
||||
{
|
||||
(void)system; /* unused parameter. Gets rid of warnings */
|
||||
|
||||
mutex = (void*)0;
|
||||
system->num_mutexes--;
|
||||
/* Replace this line with your own mutex destruction code */
|
||||
}
|
||||
|
||||
BASE_FUNC
|
||||
void FT_Mutex_Lock ( FT_System system,
|
||||
TMutex* mutex )
|
||||
{
|
||||
/* NOTE: It is legal to call this function with a NULL argument */
|
||||
/* in which case an immediate return is appropriate. */
|
||||
(void)system; /* unused parameter. Gets rid of warnings */
|
||||
|
||||
if ( !mutex )
|
||||
return;
|
||||
|
||||
; /* Insert your own mutex locking code here */
|
||||
}
|
||||
|
||||
|
||||
void FT_Mutex_Release( FT_System system,
|
||||
TMutex* mutex )
|
||||
{
|
||||
/* NOTE: It is legal to call this function with a NULL argument */
|
||||
/* in which case an immediate return is appropriate */
|
||||
(void)system; /* unused parameter. Gets rid of warnings */
|
||||
|
||||
if ( !mutex )
|
||||
return;
|
||||
; /* Insert your own mutex release code here */
|
||||
}
|
||||
|
||||
#endif /* FT_CONFIG_THREADS */
|
||||
|
||||
|
||||
|
||||
|
||||
EXPORT_FUNC
|
||||
FT_Error FT_New_System( FT_System* system )
|
||||
{
|
||||
*system = (FT_System)malloc( sizeof(**system) );
|
||||
if ( !*system )
|
||||
return FT_Err_Out_Of_Memory;
|
||||
|
||||
/* the ANSI function 'free' is unable to return the number */
|
||||
/* of released bytes. Hence, the 'current_alloc' field of the */
|
||||
/* system object cannot be used */
|
||||
|
||||
(*system)->system_flags = FT_SYSTEM_FLAG_TOTAL_ALLOC |
|
||||
FT_SYSTEM_FLAG_MUTEXES;
|
||||
(*system)->total_alloc = 0;
|
||||
(*system)->num_mutexes = 0;
|
||||
|
||||
/* initialise i/o management (nothing) */
|
||||
|
||||
/* initialise synchronisation (nothing) */
|
||||
|
||||
/* initialise streams */
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
|
||||
EXPORT_FUNC
|
||||
FT_Error FT_Done_System( FT_System system )
|
||||
{
|
||||
/* finalise syncrhonisation (nothing) */
|
||||
|
||||
/* finalise i/o management (nothing) */
|
||||
|
||||
/* finalise memory management */
|
||||
free( system );
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@ -168,7 +168,7 @@
|
||||
file = STREAM_FILE(stream);
|
||||
|
||||
fseek( file, offset, SEEK_SET );
|
||||
return (unsigned long)fread( buffer, count, 1, file );
|
||||
return (unsigned long)fread( buffer, 1, count, file );
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -168,7 +168,7 @@
|
||||
file = STREAM_FILE(stream);
|
||||
|
||||
fseek( file, offset, SEEK_SET );
|
||||
return (unsigned long)fread( buffer, count, 1, file );
|
||||
return (unsigned long)fread( buffer, 1, count, file );
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user