ReceiveTempSMS
/
Al-Qurtas-Islamic-bank-The-Best-Bank-in-Iraq
forked from minhngoc25a/freetype2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Finishing first formatting/documenting etc. of the `base' dir. Some modules 

are still badly documented, though...
This commit is contained in:
Werner Lemberg 2000-06-02 14:30:38 +00:00
parent 08edde5805
commit 91e52d416a
4 changed files with 453 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/base/ftobjs.c
View File

@ -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,

467
src/base/ftstream.c
View File

@ -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 <freetype/internal/ftstream.h>
#include <freetype/internal/ftdebug.h>
@ -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 */

305
src/base/ftsystem.c
View File

@ -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 <freetype/config/ftconfig.h>
#include <freetype/ftsystem.h>
#include <freetype/fterrors.h>
#include <freetype/fttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*********************************************************************/
/* */
/* MEMORY MANAGEMENT INTERFACE */
/* */
/************************************************************************
*
* <FuncType>
* FT_Alloc_Func
*
* <Description>
* The memory allocator function type
*
* <Input>
* system :: pointer to the system object
* size :: requested size in bytes
*
* <Output>
* block :: address of newly allocated block
*
* <Return>
* Error code. 0 means success.
*
* <Note>
* 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(). */
/* */
/*************************************************************************/
/*************************************************************************/
/* */
/* <Function> */
/* ft_alloc */
/* */
/* <Description> */
/* The memory allocation function. */
/* */
/* <Input> */
/* memory :: A pointer to the memory object. */
/* size :: The requested size in bytes. */
/* */
/* <Return> */
/* 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 );
}
/************************************************************************
*
* <FuncType>
* FT_Realloc_Func
*
* <Description>
* The memory reallocator function type
*
* <Input>
* system :: pointer to the system object
* new_size :: new requested size in bytes
*
* <InOut>
* block :: address of block in memory
*
* <Return>
* Error code. 0 means success.
*
* <Note>
* 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.
*
************************************************************************/
/*************************************************************************/
/* */
/* <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. */
/* */
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 );
}
/************************************************************************
*
* <FuncType>
* FT_Free_Func
*
* <Description>
* The memory release function type
*
* <Input>
* system :: pointer to the system object
* block :: address of block in memory
*
* <Note>
* 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.
*
************************************************************************/
/*************************************************************************/
/* */
/* <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. */
/* */
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 )
/*************************************************************************/
/* */
/* <Function> */
/* ft_close_stream */
/* */
/* <Description> */
/* The function to close a stream. */
/* */
/* <Input> */
/* stream :: A pointer to the stream object. */
/* */
static
void ft_close_stream( FT_Stream stream )
{
fclose( STREAM_FILE(stream) );
fclose( STREAM_FILE( stream ) );
}
/*************************************************************************/
/* */
/* <Function> */
/* ft_io_stream */
/* */
/* <Description> */
/* The function to open a stream. */
/* */
/* <Input> */
/* 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. */
/* */
/* <Return> */
/* 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 )
/*************************************************************************/
/* */
/* <Function> */
/* FT_New_Stream */
/* */
/* <Description> */
/* Creates a new stream object. */
/* */
/* <Input> */
/* filepathname :: The name of the stream (usually a file) to be */
/* opened. */
/* */
/* stream :: A pointer to the stream object. */
/* */
/* <Return> */
/* 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 )
/*************************************************************************/
/* */
/* <Function> */
/* FT_New_Memory */
/* */
/* <Description> */
/* Creates a new memory object. */
/* */
/* <Return> */
/* 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 */

13
src/base/rules.mk
View File

@ -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)