diff --git a/src/base/ftobjs.c b/src/base/ftobjs.c index e3f2ef3a1..beaa845f3 100644 --- a/src/base/ftobjs.c +++ b/src/base/ftobjs.c @@ -126,13 +126,6 @@ /* All callers of FT_Realloc() _must_ provide the current block size */ /* as well as the new one. */ /* */ - /* If the memory object's flag FT_SYSTEM_FLAG_NO_REALLOC is set, this */ - /* function will try to emulate a reallocation using FT_Alloc() and */ - /* FT_Free(). Otherwise, it will call the system-specific `realloc' */ - /* implementation. */ - /* */ - /* (Some embedded systems do not have a working realloc function). */ - /* */ BASE_FUNC( FT_Error ) FT_Realloc( FT_Memory memory, FT_Long current, FT_Long size, diff --git a/src/base/ftstream.c b/src/base/ftstream.c index 6c3cc6d89..e8d5b0621 100644 --- a/src/base/ftstream.c +++ b/src/base/ftstream.c @@ -1,3 +1,21 @@ +/***************************************************************************/ +/* */ +/* ftstream.c */ +/* */ +/* I/O stream support (body). */ +/* */ +/* Copyright 2000 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 #include @@ -5,10 +23,10 @@ #define FT_COMPONENT trace_stream - BASE_FUNC(void) FT_New_Memory_Stream( FT_Library library, - void* base, - unsigned long size, - FT_Stream stream ) + BASE_FUNC( void ) FT_New_Memory_Stream( FT_Library library, + void* base, + unsigned long size, + FT_Stream stream ) { stream->memory = library->memory; stream->base = (char*)base; @@ -20,34 +38,35 @@ } - BASE_FUNC(FT_Error) FT_Seek_Stream( FT_Stream stream, - FT_ULong pos ) + BASE_FUNC( FT_Error ) FT_Seek_Stream( FT_Stream stream, + FT_ULong pos ) { FT_Error error; + stream->pos = pos; - if (stream->read) + if ( stream->read ) { - if (stream->read( stream, pos, 0, 0 )) + if ( stream->read( stream, pos, 0, 0 ) ) { - error = FT_Err_Invalid_Stream_Operation; - FT_ERROR(( "FT_Seek_Stream:" )); - FT_ERROR(( " invalid i/o, pos = 0x%lx, size = 0x%lx\n", + FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n", pos, stream->size )); + + error = FT_Err_Invalid_Stream_Operation; } else error = FT_Err_Ok; } /* note that seeking to the first position after the file is valid */ - else if (pos > stream->size) + else if ( pos > stream->size ) { - error = FT_Err_Invalid_Stream_Operation; - FT_ERROR(( "FT_Seek_Stream:" )); - FT_ERROR(( " invalid i/o, pos = 0x%lx, size = 0x%lx\n", + FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n", pos, stream->size )); + + error = FT_Err_Invalid_Stream_Operation; } else @@ -57,51 +76,51 @@ } - BASE_FUNC(FT_Error) FT_Skip_Stream( FT_Stream stream, - FT_Long distance ) + BASE_FUNC( FT_Error ) FT_Skip_Stream( FT_Stream stream, + FT_Long distance ) { - return FT_Seek_Stream( stream, (FT_ULong)(stream->pos + distance) ); + return FT_Seek_Stream( stream, (FT_ULong)( stream->pos + distance ) ); } - - BASE_FUNC(FT_Long) FT_Stream_Pos( FT_Stream stream ) + BASE_FUNC( FT_Long ) FT_Stream_Pos( FT_Stream stream ) { return stream->pos; } - BASE_FUNC(FT_Error) FT_Read_Stream( FT_Stream stream, - void* buffer, - FT_ULong count ) + BASE_FUNC( FT_Error ) FT_Read_Stream( FT_Stream stream, + void* buffer, + FT_ULong count ) { return FT_Read_Stream_At( stream, stream->pos, buffer, count ); } - BASE_FUNC(FT_Error) FT_Read_Stream_At( FT_Stream stream, - FT_ULong pos, - void* buffer, - FT_ULong count ) + BASE_FUNC( FT_Error ) FT_Read_Stream_At( FT_Stream stream, + FT_ULong pos, + void* buffer, + FT_ULong count ) { FT_Error error = FT_Err_Ok; FT_ULong read_bytes; - if (pos >= stream->size) + + if ( pos >= stream->size ) { FT_ERROR(( "FT_Read_Stream_At:" )); - FT_ERROR(( " invalid i/o, pos = 0x%lx, size = 0x%lx\n", + FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n", pos, stream->size )); return FT_Err_Invalid_Stream_Operation; } - if (stream->read) + if ( stream->read ) read_bytes = stream->read( stream, pos, buffer, count ); else { read_bytes = stream->size - pos; - if (read_bytes > count) + if ( read_bytes > count ) read_bytes = count; MEM_Copy( buffer, stream->base + pos, read_bytes ); @@ -109,11 +128,12 @@ stream->pos = pos + read_bytes; - if (read_bytes < count) + if ( read_bytes < count ) { FT_ERROR(( "FT_Read_Stream_At:" )); - FT_ERROR(( " invalid read, expected %lu bytes, got %lu", + FT_ERROR(( " invalid read; expected %lu bytes, got %lu", count, read_bytes )); + error = FT_Err_Invalid_Stream_Operation; } @@ -121,62 +141,67 @@ } - BASE_FUNC(FT_Error) FT_Extract_Frame( FT_Stream stream, - FT_ULong count, - FT_Byte* *pbytes ) + BASE_FUNC( FT_Error ) FT_Extract_Frame( FT_Stream stream, + FT_ULong count, + FT_Byte** pbytes ) { FT_Error error; + error = FT_Access_Frame( stream, count ); - if (!error) + if ( !error ) { *pbytes = (FT_Byte*)stream->cursor; - /* equivalent to FT_Forget_Frame, with no memory block release */ + /* equivalent to FT_Forget_Frame(), with no memory block release */ stream->cursor = 0; stream->limit = 0; } + return error; } - BASE_FUNC(void) FT_Release_Frame( FT_Stream stream, - FT_Byte* *pbytes ) + BASE_FUNC( void ) FT_Release_Frame( FT_Stream stream, + FT_Byte** pbytes ) { - if (stream->read) + if ( stream->read ) { FT_Memory memory = stream->memory; + + FREE( *pbytes ); } *pbytes = 0; } - - BASE_FUNC(FT_Error) FT_Access_Frame( FT_Stream stream, - FT_ULong count ) + BASE_FUNC( FT_Error ) FT_Access_Frame( FT_Stream stream, + FT_ULong count ) { FT_Error error = FT_Err_Ok; FT_ULong read_bytes; + /* check for nested frame access */ FT_Assert( stream && stream->cursor == 0 ); - if (stream->read) + if ( stream->read ) { /* allocate the frame in memory */ FT_Memory memory = stream->memory; + if ( ALLOC( stream->base, count ) ) goto Exit; /* read it */ read_bytes = stream->read( stream, stream->pos, stream->base, count ); - if (read_bytes < count) + if ( read_bytes < count ) { FT_ERROR(( "FT_Access_Frame:" )); - FT_ERROR(( " invalid read, expected %lu bytes, got %lu", + FT_ERROR(( " invalid read; expected %lu bytes, got %lu", count, read_bytes )); FREE( stream->base ); @@ -189,10 +214,11 @@ else { /* check current and new position */ - if (stream->pos >= stream->size || stream->pos + count > stream->size) + if ( stream->pos >= stream->size || + stream->pos + count > stream->size ) { FT_ERROR(( "FT_Access_Frame:" )); - FT_ERROR(( " invalid i/o, pos = 0x%lx, count = %lu, size = 0x%lx", + FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx", stream->pos, count, stream->size )); error = FT_Err_Invalid_Stream_Operation; @@ -204,27 +230,30 @@ stream->limit = stream->cursor + count; stream->pos += count; } + Exit: return error; } - BASE_FUNC(void) FT_Forget_Frame( FT_Stream stream ) + BASE_FUNC( void ) FT_Forget_Frame( FT_Stream stream ) { /* IMPORTANT: The assertion stream->cursor != 0 was removed, given */ /* that it is possible to access a frame of length 0 in */ /* some weird fonts (usually, when accessing an array of */ - /* 0 records, like in some strange kern tables).. */ + /* 0 records, like in some strange kern tables). */ /* */ /* In this case, the loader code handles the 0-length table */ - /* gracefully, however, stream.cursor is really set to 0 by the */ - /* FT_Access_Frame call, and this is not an error.. */ + /* gracefully; however, stream.cursor is really set to 0 by the */ + /* FT_Access_Frame() call, and this is not an error. */ /* */ FT_Assert( stream ); - if (stream->read) + if ( stream->read ) { FT_Memory memory = stream->memory; + + FREE( stream->base ); } stream->cursor = 0; @@ -232,117 +261,126 @@ } - BASE_FUNC(FT_Char) FT_Get_Char( FT_Stream stream ) + BASE_FUNC( FT_Char ) FT_Get_Char( FT_Stream stream ) { FT_Char result; + FT_Assert( stream && stream->cursor ); result = 0; - if (stream->cursor < stream->limit) + if ( stream->cursor < stream->limit ) result = *stream->cursor++; return result; } - BASE_FUNC(FT_Short) FT_Get_Short( FT_Stream stream ) + BASE_FUNC( FT_Short ) FT_Get_Short( FT_Stream stream ) { char* p; FT_Short result; + FT_Assert( stream && stream->cursor ); result = 0; p = stream->cursor; - if (p+1 < stream->limit) - result = NEXT_Short(p); + if ( p + 1 < stream->limit ) + result = NEXT_Short( p ); stream->cursor = p; + return result; } - BASE_FUNC(FT_Long) FT_Get_Offset( FT_Stream stream ) + BASE_FUNC( FT_Long ) FT_Get_Offset( FT_Stream stream ) { char* p; FT_Long result; + FT_Assert( stream && stream->cursor ); result = 0; p = stream->cursor; - if (p+2 < stream->limit) - result = NEXT_Offset(p); + if ( p + 2 < stream->limit ) + result = NEXT_Offset( p ); stream->cursor = p; return result; } - BASE_FUNC(FT_Long) FT_Get_Long( FT_Stream stream ) + BASE_FUNC( FT_Long ) FT_Get_Long( FT_Stream stream ) { char* p; FT_Long result; + FT_Assert( stream && stream->cursor ); result = 0; p = stream->cursor; - if (p+3 < stream->limit) - result = NEXT_Long(p); + if ( p + 3 < stream->limit ) + result = NEXT_Long( p ); stream->cursor = p; return result; } - BASE_FUNC(FT_Char) FT_Read_Char( FT_Stream stream, - FT_Error* error ) + BASE_FUNC( FT_Char ) FT_Read_Char( FT_Stream stream, + FT_Error* error ) { char result = 0; + FT_Assert( stream ); *error = FT_Err_Ok; - if (stream->read) + if ( stream->read ) { if ( stream->read( stream, stream->pos, &result, 1L ) != 1L ) goto Fail; } else { - if (stream->pos < stream->size) + if ( stream->pos < stream->size ) result = stream->base[stream->pos]; else goto Fail; } stream->pos++; + return result; Fail: *error = FT_Err_Invalid_Stream_Operation; FT_ERROR(( "FT_Read_Char:" )); - FT_ERROR(( " invalid i/o, pos = 0x%lx, size = 0x%lx", + FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx", stream->pos, stream->size )); + return 0; } - BASE_FUNC(FT_Short) FT_Read_Short( FT_Stream stream, - FT_Error* error ) + BASE_FUNC( FT_Short ) FT_Read_Short( FT_Stream stream, + FT_Error* error ) { char reads[2]; char* p = 0; FT_Short result = 0; + FT_Assert( stream ); *error = FT_Err_Ok; - if (stream->pos+1 < stream->size) + if ( stream->pos + 1 < stream->size ) { - if (stream->read) + if ( stream->read ) { - if (stream->read( stream, stream->pos, reads, 2L ) != 2L ) + if ( stream->read( stream, stream->pos, reads, 2L ) != 2L ) goto Fail; p = reads; @@ -352,37 +390,41 @@ p = stream->base + stream->pos; } - if (p) - result = NEXT_Short(p); + if ( p ) + result = NEXT_Short( p ); } - else goto Fail; + else + goto Fail; stream->pos += 2; + return result; Fail: *error = FT_Err_Invalid_Stream_Operation; FT_ERROR(( "FT_Read_Short:" )); - FT_ERROR(( " invalid i/o, pos = 0x%lx, size = 0x%lx", + FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx", stream->pos, stream->size )); + return 0; } - BASE_FUNC(FT_Long) FT_Read_Offset( FT_Stream stream, - FT_Error* error ) + BASE_FUNC( FT_Long ) FT_Read_Offset( FT_Stream stream, + FT_Error* error ) { char reads[3]; char* p = 0; FT_Long result = 0; + FT_Assert( stream ); *error = FT_Err_Ok; - if (stream->pos+2 < stream->size) + if ( stream->pos + 2 < stream->size ) { - if (stream->read) + if ( stream->read ) { if (stream->read( stream, stream->pos, reads, 3L ) != 3L ) goto Fail; @@ -394,39 +436,43 @@ p = stream->base + stream->pos; } - if (p) - result = NEXT_Offset(p); + if ( p ) + result = NEXT_Offset( p ); } - else goto Fail; + else + goto Fail; stream->pos += 3; + return result; Fail: *error = FT_Err_Invalid_Stream_Operation; FT_ERROR(( "FT_Read_Offset:" )); - FT_ERROR(( " invalid i/o, pos = 0x%lx, size = 0x%lx", + FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx", stream->pos, stream->size )); + return 0; } - BASE_FUNC(FT_Long) FT_Read_Long( FT_Stream stream, - FT_Error* error ) + BASE_FUNC( FT_Long ) FT_Read_Long( FT_Stream stream, + FT_Error* error ) { char reads[4]; char* p = 0; FT_Long result = 0; + FT_Assert( stream ); *error = FT_Err_Ok; - if (stream->pos+3 < stream->size) + if ( stream->pos + 3 < stream->size ) { - if (stream->read) + if ( stream->read ) { - if (stream->read( stream, stream->pos, reads, 4L ) != 4L ) + if ( stream->read( stream, stream->pos, reads, 4L ) != 4L ) goto Fail; p = reads; @@ -436,30 +482,35 @@ p = stream->base + stream->pos; } - if (p) - result = NEXT_Long(p); + if ( p ) + result = NEXT_Long( p ); } - else goto Fail; + else + goto Fail; stream->pos += 4; + return result; Fail: - *error = FT_Err_Invalid_Stream_Operation; FT_ERROR(( "FT_Read_Long:" )); - FT_ERROR(( " invalid i/o, pos = 0x%lx, size = 0x%lx", + FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx", stream->pos, stream->size )); + *error = FT_Err_Invalid_Stream_Operation; + return 0; } - BASE_FUNC(FT_Error) FT_Read_Fields( FT_Stream stream, - const FT_Frame_Field* fields, - void* structure ) + + BASE_FUNC( FT_Error ) FT_Read_Fields( FT_Stream stream, + const FT_Frame_Field* fields, + void* structure ) { FT_Error error; FT_Bool frame_accessed = 0; - if (!fields || !stream) + + if ( !fields || !stream ) return FT_Err_Invalid_Argument; error = FT_Err_Ok; @@ -469,131 +520,149 @@ FT_Int sign_shift; FT_Byte* p; - switch (fields->value) + + switch ( fields->value ) { - case ft_frame_start: /* access a new frame */ + case ft_frame_start: /* access a new frame */ + { + error = FT_Access_Frame( stream, fields->offset ); + if ( error ) + goto Exit; + + frame_accessed = 1; + fields++; + continue; /* loop! */ + } + + case ft_frame_byte: + case ft_frame_schar: /* read a single byte */ + { + value = GET_Byte(); + sign_shift = 24; + break; + } + + case ft_frame_short_be: + case ft_frame_ushort_be: /* read a 2-byte big-endian short */ + { + value = GET_UShort(); + sign_shift = 16; + break; + } + + case ft_frame_short_le: + case ft_frame_ushort_le: /* read a 2-byte little-endian short */ + { + char* p; + value = 0; + p = stream->cursor; + if ( p + 1 < stream->limit ) { - error = FT_Access_Frame( stream, fields->offset ); - if (error) goto Exit; - - frame_accessed = 1; - fields++; - continue; /* loop ! */ + value = ( FT_UShort)p[0] | ((FT_UShort)p[1] << 8 ); + stream->cursor += 2; } + sign_shift = 16; + break; + } - case ft_frame_byte: - case ft_frame_schar: /* read a single byte */ + case ft_frame_long_be: + case ft_frame_ulong_be: /* read a 4-byte big-endian long */ + { + value = GET_ULong(); + sign_shift = 0; + break; + } + + case ft_frame_long_le: + case ft_frame_ulong_le: /* read a 4-byte little-endian long */ + { + char* p; + + + value = 0; + p = stream->cursor; + if ( p + 3 < stream->limit ) { - value = GET_Byte(); - sign_shift = 24; - break; + value = (FT_ULong)p[0] | + ( (FT_ULong)p[1] << 8 ) | + ( (FT_ULong)p[2] << 16 ) | + ( (FT_ULong)p[3] << 24 ); + stream->cursor += 4; } + sign_shift = 0; + break; + } - case ft_frame_short_be: - case ft_frame_ushort_be: /* read a 2-byte big-endian short */ + case ft_frame_off3_be: + case ft_frame_uoff3_be: /* read a 3-byte big-endian long */ + { + value = GET_UOffset(); + sign_shift = 8; + break; + } + + case ft_frame_off3_le: + case ft_frame_uoff3_le: /* read a 3-byte little-endian long */ + { + char* p; + + + value = 0; + p = stream->cursor; + if ( p + 3 < stream->limit ) { - value = GET_UShort(); - sign_shift = 16; - break; + value = (FT_ULong)p[0] | + ( (FT_ULong)p[1] << 8 ) | + ( (FT_ULong)p[2] << 16 ) | + ( (FT_ULong)p[3] << 24 ); + stream->cursor += 4; } + sign_shift = 8; + break; + } - case ft_frame_short_le: - case ft_frame_ushort_le: /* read a 2-byte little-endian short */ - { - char* p; - value = 0; - p = stream->cursor; - if (p+1 < stream->limit) - { - value = (FT_UShort)p[0] | ((FT_UShort)p[1] << 8); - stream->cursor += 2; - } - sign_shift = 16; - break; - } - - case ft_frame_long_be: - case ft_frame_ulong_be: /* read a 4-byte big-endian long */ - { - value = GET_ULong(); - sign_shift = 0; - break; - } - - case ft_frame_long_le: - case ft_frame_ulong_le: /* read a 4-byte little-endian long */ - { - char* p; - value = 0; - p = stream->cursor; - if (p+3 < stream->limit) - { - value = (FT_ULong)p[0] | - ((FT_ULong)p[1] << 8) | - ((FT_ULong)p[2] << 16) | - ((FT_ULong)p[3] << 24); - stream->cursor += 4; - } - sign_shift = 0; - break; - } - - case ft_frame_off3_be: - case ft_frame_uoff3_be: /* read a 3-byte big-endian long */ - { - value = GET_UOffset(); - sign_shift = 8; - break; - } - - case ft_frame_off3_le: - case ft_frame_uoff3_le: /* read a 3-byte little-endian long */ - { - char* p; - value = 0; - p = stream->cursor; - if (p+3 < stream->limit) - { - value = (FT_ULong)p[0] | - ((FT_ULong)p[1] << 8) | - ((FT_ULong)p[2] << 16) | - ((FT_ULong)p[3] << 24); - stream->cursor += 4; - } - sign_shift = 8; - break; - } - - default: - /* otherwise, exit the loop */ - goto Exit; + default: + /* otherwise, exit the loop */ + goto Exit; } /* now, compute the signed value is necessary */ - if (fields->value & FT_FRAME_OP_SIGNED) - value = (FT_ULong)((FT_Long)(value << sign_shift) >> sign_shift); + if ( fields->value & FT_FRAME_OP_SIGNED ) + value = (FT_ULong)( (FT_Long)( value << sign_shift ) >> sign_shift ); /* finally, store the value in the object */ p = (FT_Byte*)structure + fields->offset; - switch (fields->size) + switch ( fields->size ) { - case 1: *(FT_Byte*)p = (FT_Byte) value; break; - case 2: *(FT_UShort*)p = (FT_UShort)value; break; - case 4: *(FT_ULong*)p = (FT_ULong) value; break; - default: ; /* ignore !! */ + case 1: + *(FT_Byte*)p = (FT_Byte)value; + break; + + case 2: + *(FT_UShort*)p = (FT_UShort)value; + break; + + case 4: + *(FT_ULong*)p = (FT_ULong)value; + break; + + default: + ; /* ignore! */ } /* go to next field */ fields++; } - while (1); + while ( 1 ); Exit: /* close the frame if it was opened by this read */ - if (frame_accessed) - FT_Forget_Frame(stream); + if ( frame_accessed ) + FT_Forget_Frame( stream ); return error; } + +/* END */ diff --git a/src/base/ftsystem.c b/src/base/ftsystem.c index 25d526537..bf02b1167 100644 --- a/src/base/ftsystem.c +++ b/src/base/ftsystem.c @@ -1,163 +1,183 @@ -/************************************************************************** - * - * ftsystem.h 1.0 - * - * ANSI-specific FreeType low-level system interface - * - * This file contains the definition of interface used by FreeType - * to access low-level, i.e. memory management, i/o access as well - * as thread synchronisation. - * - * - * Copyright 1996-1999 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. - * - **************************************************************************/ +/***************************************************************************/ +/* */ +/* ftsystem.h */ +/* */ +/* ANSI-specific FreeType low-level system interface (body). */ +/* */ +/* Copyright 1996-2000 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 file contains the default interface used by FreeType to access */ + /* low-level, i.e. memory management, i/o access as well as thread */ + /* synchronisation. It can be replaced by user-specific routines if */ + /* necessary. */ + /* */ + /*************************************************************************/ + #include #include #include +#include #include #include #include - /*********************************************************************/ - /* */ - /* MEMORY MANAGEMENT INTERFACE */ - /* */ -/************************************************************************ - * - * - * FT_Alloc_Func - * - * - * The memory allocator function type - * - * - * system :: pointer to the system object - * size :: requested size in bytes - * - * - * block :: address of newly allocated block - * - * - * Error code. 0 means success. - * - * - * If your allocation routine ALWAYS zeroes the new block, you - * should set the flag FT_SYSTEM_FLAG_ALLOC_ZEROES in your system - * object 'flags' field. - * - * If you have set the flag FT_SYSTEM_FLAG_REPORT_CURRENT_ALLOC in - * your system's "system_flags" field, this function should update - * the "current_alloc" field of the system object. - * - ************************************************************************/ + /*************************************************************************/ + /* */ + /* MEMORY MANAGEMENT INTERFACE */ + /* */ + /*************************************************************************/ + /*************************************************************************/ + /* */ + /* It is not necessary to do any error checking here. This will be done */ + /* by the higher level routines like FT_Alloc() or FT_Realloc(). */ + /* */ + /*************************************************************************/ + + + /*************************************************************************/ + /* */ + /* */ + /* ft_alloc */ + /* */ + /* */ + /* The memory allocation function. */ + /* */ + /* */ + /* memory :: A pointer to the memory object. */ + /* size :: The requested size in bytes. */ + /* */ + /* */ + /* block :: The address of newly allocated block. */ + /* */ static void* ft_alloc( FT_Memory memory, long size ) { - UNUSED(memory); - return malloc(size); + UNUSED( memory ); + + return malloc( size ); } -/************************************************************************ - * - * - * FT_Realloc_Func - * - * - * The memory reallocator function type - * - * - * system :: pointer to the system object - * new_size :: new requested size in bytes - * - * - * block :: address of block in memory - * - * - * Error code. 0 means success. - * - * - * This function is _never_ called when the system flag - * FT_SYSTEM_FLAG_NO_REALLOC is set. Instead, the engine will emulate - * realloc through "alloc" and "free". - * - * Note that this is possible due to the fact that FreeType's - * "FT_Realloc" always requests the _current_ size of the reallocated - * block as a parameter, thus avoiding memory leaks. - * - * If you have set the flag FT_SYSTEM_FLAG_REPORT_CURRENT_ALLOC in - * your system's "system_flags" field, this function should update - * the "current_alloc" field of the system object. - * - ************************************************************************/ - + /*************************************************************************/ + /* */ + /* */ + /* ft_realloc */ + /* */ + /* */ + /* The memory reallocation function. */ + /* */ + /* */ + /* 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. */ + /* */ + /* */ + /* The address of the reallocated memory block. */ + /* */ static void* ft_realloc( FT_Memory memory, long cur_size, long new_size, void* block ) { - UNUSED(memory); - UNUSED(cur_size); + UNUSED( memory ); + UNUSED( cur_size ); return realloc( block, new_size ); } -/************************************************************************ - * - * - * FT_Free_Func - * - * - * The memory release function type - * - * - * system :: pointer to the system object - * block :: address of block in memory - * - * - * If you have set the flag FT_SYSTEM_FLAG_REPORT_CURRENT_ALLOC in - * your system's "system_flags" field, this function should update - * the "current_alloc" field of the system object. - * - ************************************************************************/ - + /*************************************************************************/ + /* */ + /* */ + /* ft_free */ + /* */ + /* */ + /* The memory release function. */ + /* */ + /* */ + /* memory :: A pointer to the memory object. */ + /* */ + /* block :: The address of block in memory to be freed. */ + /* */ static void ft_free( FT_Memory memory, void* block ) { - UNUSED(memory); + UNUSED( memory ); + free( block ); } - /*********************************************************************/ - /* */ - /* RESOURCE MANAGEMENT INTERFACE */ - /* */ + + /*************************************************************************/ + /* */ + /* RESOURCE MANAGEMENT INTERFACE */ + /* */ + /*************************************************************************/ -#define STREAM_FILE(stream) ((FILE*)stream->descriptor.pointer) +#define STREAM_FILE( stream ) ( (FILE*)stream->descriptor.pointer ) + + /*************************************************************************/ + /* */ + /* */ + /* ft_close_stream */ + /* */ + /* */ + /* The function to close a stream. */ + /* */ + /* */ + /* stream :: A pointer to the stream object. */ + /* */ static void ft_close_stream( FT_Stream stream ) { - fclose( STREAM_FILE(stream) ); + fclose( STREAM_FILE( stream ) ); } + + /*************************************************************************/ + /* */ + /* */ + /* ft_io_stream */ + /* */ + /* */ + /* The function to open a stream. */ + /* */ + /* */ + /* stream :: A pointer to the stream object. */ + /* */ + /* offset :: The position in the data stream to start reading. */ + /* */ + /* buffer :: The address of buffer to store the read data. */ + /* */ + /* count :: The number of bytes to read from the stream. */ + /* */ + /* */ + /* The number of bytes actually read. */ + /* */ static unsigned long ft_io_stream( FT_Stream stream, unsigned long offset, @@ -166,24 +186,44 @@ { FILE* file; - file = STREAM_FILE(stream); + + file = STREAM_FILE( stream ); fseek( file, offset, SEEK_SET ); + return (unsigned long)fread( buffer, 1, count, file ); } - FT_EXPORT_FUNC(int) FT_New_Stream( const char* filepathname, - FT_Stream stream ) + /*************************************************************************/ + /* */ + /* */ + /* FT_New_Stream */ + /* */ + /* */ + /* Creates a new stream object. */ + /* */ + /* */ + /* filepathname :: The name of the stream (usually a file) to be */ + /* opened. */ + /* */ + /* stream :: A pointer to the stream object. */ + /* */ + /* */ + /* FreeType error code. 0 means success. */ + /* */ + FT_EXPORT_FUNC( FT_Error ) FT_New_Stream( const char* filepathname, + FT_Stream stream ) { FILE* file; + file = fopen( filepathname, "rb" ); - if (!file) + if ( !file ) return FT_Err_Cannot_Open_Resource; fseek( file, 0, SEEK_END ); - stream->size = ftell(file); + stream->size = ftell( file ); fseek( file, 0, SEEK_SET ); stream->descriptor.pointer = file; @@ -192,22 +232,37 @@ stream->read = ft_io_stream; stream->close = ft_close_stream; - return 0; + return FT_Err_Ok; } - FT_EXPORT_FUNC(FT_Memory) FT_New_Memory( void ) + /*************************************************************************/ + /* */ + /* */ + /* FT_New_Memory */ + /* */ + /* */ + /* Creates a new memory object. */ + /* */ + /* */ + /* A pointer to the new memory object. 0 in case of error. */ + /* */ + FT_EXPORT_FUNC( FT_Memory ) FT_New_Memory( void ) { FT_Memory memory; - memory = (FT_Memory)malloc( sizeof(*memory) ); - if (memory) + + memory = (FT_Memory)malloc( sizeof ( *memory ) ); + if ( memory ) { memory->user = 0; memory->alloc = ft_alloc; memory->realloc = ft_realloc; memory->free = ft_free; } + return memory; } + +/* END */ diff --git a/src/base/rules.mk b/src/base/rules.mk index 367f34b2f..e2617ac1b 100644 --- a/src/base/rules.mk +++ b/src/base/rules.mk @@ -17,7 +17,7 @@ # after the call: # # BASE_H: The list of base layer header files on which the rest -# of the library (i.e., drivers) rely. +# of the library (i.e. drivers) rely. # # BASE_OBJ_S: The single-object base layer. # BASE_OBJ_M: A list of all objects for a multiple-objects build. @@ -36,7 +36,6 @@ BASE_SRC := $(BASE_)ftcalc.c \ $(BASE_)ftstream.c \ $(BASE_)ftoutln.c - # Base layer headers # BASE_H := $(INTERNAL_)ftcalc.h \ @@ -63,6 +62,10 @@ BASE_EXT_SRC := $(BASE_)ftraster.c \ # BASE_EXT_H := $(BASE_EXT_SRC:%c=%h) +# Default extensions objects +# +BASE_EXT_OBJ := $(BASE_EXT_SRC:$(BASE_)%.c=$(OBJ_)%.$O) + # Base layer object(s) # @@ -75,12 +78,6 @@ BASE_EXT_H := $(BASE_EXT_SRC:%c=%h) BASE_OBJ_M := $(BASE_SRC:$(BASE_)%.c=$(OBJ_)%.$O) BASE_OBJ_S := $(OBJ_)ftbase.$O - -# Default extensions objects -# -BASE_EXT_OBJ := $(BASE_EXT_SRC:$(BASE_)%.c=$(OBJ_)%.$O) - - # Base layer root source file(s) # BASE_SRC_M := $(BASE_SRC)