ref: 91e52d416aedfdfcf5b4331c2156a3866898738e
parent: 08edde58058c882dc895e3a72d4dfcbafa95d0f2
author: Werner Lemberg <[email protected]>
date: Fri Jun 2 10:30:38 EDT 2000
Finishing first formatting/documenting etc. of the `base' dir. Some modules are still badly documented, though...
--- 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,
--- 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 <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,31 +141,35 @@
}
- 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;
@@ -152,21 +176,22 @@
}
-
- 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;
@@ -173,10 +198,10 @@
/* 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,14 +261,15 @@
}
- 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;
@@ -246,64 +276,69 @@
}
- 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;
@@ -310,39 +345,42 @@
}
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 */
- {- error = FT_Access_Frame( stream, fields->offset );
- if (error) goto Exit;
+ 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 ! */
- }
+ 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_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_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 */
+ 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 )
{- 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;
+ 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_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_long_le:
+ case ft_frame_ulong_le: /* read a 4-byte little-endian long */
+ {+ char* p;
- case ft_frame_off3_be:
- case ft_frame_uoff3_be: /* read a 3-byte big-endian long */
+
+ value = 0;
+ p = stream->cursor;
+ if ( p + 3 < stream->limit )
{- value = GET_UOffset();
- sign_shift = 8;
- 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_off3_le:
- case ft_frame_uoff3_le: /* read a 3-byte little-endian long */
+ 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 )
{- 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;
+ 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 */
--- a/src/base/ftsystem.c
+++ b/src/base/ftsystem.c
@@ -1,109 +1,99 @@
-/**************************************************************************
- *
- * 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,
@@ -110,54 +100,84 @@
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,16 +232,28 @@
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;
@@ -208,6 +260,9 @@
memory->realloc = ft_realloc;
memory->free = ft_free;
}
+
return memory;
}
+
+/* END */
--- 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_)ftstream.c \
$(BASE_)ftoutln.c
-
# Base layer headers
#
BASE_H := $(INTERNAL_)ftcalc.h \
@@ -63,7 +62,11 @@
#
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)
#
# BASE_OBJ_M is used during `multi' builds (each base source file compiles
@@ -74,12 +77,6 @@
#
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)
#