kc3-lang/freetype/src/base/ftstream.h

• Show log

  Commit

• Hash : 818336fd
  Author :
  Date : 2000-02-13T13:36:53
  

  Added the function FT_Read_Fields, it acts as a finite-state automata to load large TrueType tables in object structures. This is experimental, don't mess too much with it, thanks :-)

Download

• src/base/ftstream.h

• #ifndef FTSTREAM_H
  #define FTSTREAM_H
  
  #include <ftobjs.h>
  
  /* format of an 8-bit frame_op value = [ xxxxx | e | s ] */
  /* where s is set to 1 when the value is signed..        */
  /* where e is set to 1 when the value is little-endian   */
  /* xxxxx is a command                                    */
  
  #define FT_FRAME_OP_SHIFT   2
  #define FT_FRAME_OP_SIGNED  1
  #define FT_FRAME_OP_LITTLE  2
  #define FT_FRAME_OP_COMMAND(x) (x >> FT_FRAME_OP_SHIFT)
  
  #define FT_MAKE_FRAME_OP( command, little, sign )  \
            ((command << FT_FRAME_OP_SHIFT) | (little << 1) | sign)
  
  #define FT_FRAME_OP_END   0
  #define FT_FRAME_OP_START 1  /* start a new frame */
  #define FT_FRAME_OP_BYTE  2  /* read 1-byte value */
  #define FT_FRAME_OP_SHORT 3  /* read 2-byte value */
  #define FT_FRAME_OP_LONG  4  /* read 4-byte value */
  #define FT_FRAME_OP_OFF3  5  /* read 3-byte value */
  
  typedef enum FT_Frame_Op_
  {
    ft_frame_end       = 0,
    ft_frame_start     = FT_MAKE_FRAME_OP( FT_FRAME_OP_START, 0, 0 ),
    
    ft_frame_byte      = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE,  0, 0 ),
    ft_frame_schar     = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE,  0, 1 ),
    
    ft_frame_ushort_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 0 ),
    ft_frame_short_be  = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 1 ),
    ft_frame_ushort_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 0 ),
    ft_frame_short_le  = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 1 ),
    
    ft_frame_ulong_be  = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 0 ),
    ft_frame_ulong_le  = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 1 ),
    ft_frame_long_be   = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 0 ),
    ft_frame_long_le   = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 1 ),
  
    ft_frame_uoff3_be  = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 0 ),
    ft_frame_uoff3_le  = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 1 ),
    ft_frame_off3_be   = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 0 ),
    ft_frame_off3_le   = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 1 ),
  
  } FT_Frame_Op;
  
  
  typedef struct FT_Frame_Field_
  {
    FT_Frame_Op   value;
    char          size;
    FT_UShort     offset;
    
  } FT_Frame_Field;
  
  /* make-up a FT_Frame_Field out of a structure type and a field name */
  #define FT_FIELD_REF(s,f)  (((s*)0)->f)
  
  #define FT_FRAME_FIELD( frame_op, struct_type, field )                 \
            {                                                            \
              frame_op,                                                  \
              sizeof(FT_FIELD_REF(struct_type,field)),                   \
              (FT_UShort)(char*)&FT_FIELD_REF(struct_type,field) }
  
  #define FT_MAKE_EMPTY_FIELD( frame_op )  { frame_op, 0, 0 }
  
  #define FT_FRAME_LONG(s,f)   FT_FRAME_FIELD( ft_frame_long_be, s, f )
  #define FT_FRAME_ULONG(s,f)  FT_FRAME_FIELD( ft_frame_ulong_be, s, f )
  #define FT_FRAME_SHORT(s,f)  FT_FRAME_FIELD( ft_frame_short_be, s, f )
  #define FT_FRAME_USHORT(s,f) FT_FRAME_FIELD( ft_frame_ushort_be, s, f )
  #define FT_FRAME_BYTE(s,f)   FT_FRAME_FIELD( ft_frame_byte, s, f )
  #define FT_FRAME_CHAR(s,f)   FT_FRAME_FIELD( ft_frame_schar, s, f )
  
    /*************************************************************************/
    /*                                                                       */
    /* integer extraction macros - the `buffer' parameter must ALWAYS be of  */
    /* type `char*' or equivalent (1-byte elements).                         */
    /*                                                                       */
  #define NEXT_Char(buffer)    ((signed char)*buffer++)
  #define NEXT_Byte(buffer)    ((unsigned char)*buffer++)
  
  #define NEXT_Short(buffer)   ( buffer += 2,                                \
                                 ( (short)((signed   char)buffer[-2] << 8) | \
                                           (unsigned char)buffer[-1]       ) )
  
  #define NEXT_UShort(buffer)  ((unsigned short)NEXT_Short(buffer))
  
  #define NEXT_Offset(buffer)  ( buffer += 3,                                \
                                 ( ((long)(signed   char)buffer[-3] << 16) | \
                                   ((long)(unsigned char)buffer[-2] <<  8) | \
                                    (long)(unsigned char)buffer[-1]        ) )
  
  #define NEXT_UOffset(buffer) ((unsigned long)NEXT_Offset(buffer))
  
  #define NEXT_Long(buffer)    ( buffer += 4,                                \
                                 ( ((long)(signed   char)buffer[-4] << 24) | \
                                   ((long)(unsigned char)buffer[-3] << 16) | \
                                   ((long)(unsigned char)buffer[-2] <<  8) | \
                                    (long)(unsigned char)buffer[-1]        ) )
  
  #define NEXT_ULong(buffer)   ((unsigned long)NEXT_Long(buffer))
  
  
    /*************************************************************************/
    /*                                                                       */
    /* Each GET_xxxx() macro uses an implicit `stream' variable.             */
    /*                                                                       */
  #define FT_GET_MACRO( func, type )        ( (type)func(stream) )
  
  #define GET_Char()     FT_GET_MACRO( FT_Get_Char, FT_Char )
  #define GET_Byte()     FT_GET_MACRO( FT_Get_Char, FT_Byte )
  #define GET_Short()    FT_GET_MACRO( FT_Get_Short, FT_Short )
  #define GET_UShort()   FT_GET_MACRO( FT_Get_Short, FT_UShort )
  #define GET_Offset()   FT_GET_MACRO( FT_Get_Offset, FT_Long )
  #define GET_UOffset()  FT_GET_MACRO( FT_Get_Offset, FT_ULong )
  #define GET_Long()     FT_GET_MACRO( FT_Get_Long, FT_Long )
  #define GET_ULong()    FT_GET_MACRO( FT_Get_Long, FT_ULong )
  #define GET_Tag4()     FT_GET_MACRO( FT_Get_Long, FT_ULong )
  
  
  #define FT_READ_MACRO( func, type, var )        \
            ( var = (type)func( stream, &error ), \
              error != FT_Err_Ok )
  
  #define READ_Byte( var )     FT_READ_MACRO( FT_Read_Char, FT_Byte, var )
  #define READ_Char( var )     FT_READ_MACRO( FT_Read_Char, FT_Char, var )
  #define READ_Short( var )    FT_READ_MACRO( FT_Read_Short, FT_Short, var )
  #define READ_UShort( var )   FT_READ_MACRO( FT_Read_Short, FT_UShort, var )
  #define READ_Offset( var )   FT_READ_MACRO( FT_Read_Offset, FT_Long, var )
  #define READ_UOffset( var )  FT_READ_MACRO( FT_Read_Offset, FT_ULong, var )
  #define READ_Long( var )     FT_READ_MACRO( FT_Read_Long, FT_Long, var )
  #define READ_ULong( var )    FT_READ_MACRO( FT_Read_Long, FT_ULong, var )
  
  
  
    BASE_DEF
    void  FT_New_Memory_Stream( FT_Library     library,
                                void*          base,
       			      unsigned long  size,
                                FT_Stream      stream );
   
    BASE_DEF
    FT_Error  FT_Seek_Stream( FT_Stream  stream,
                              FT_ULong   pos );
  
    BASE_DEF
    FT_Error  FT_Skip_Stream( FT_Stream  stream,
                              FT_Long    distance );
                              
    BASE_DEF
    FT_Long   FT_Stream_Pos( FT_Stream  stream );
  
  
    BASE_DEF
    FT_Error  FT_Read_Stream( FT_Stream  stream,
                              void*      buffer,
                              FT_ULong   count );
                              
    BASE_DEF
    FT_Error  FT_Read_Stream_At( FT_Stream  stream,
                                 FT_ULong   pos,
                                 void*      buffer,
                                 FT_ULong   count );
                                 
    BASE_DEF
    FT_Error  FT_Access_Frame( FT_Stream  stream,
                               FT_ULong   count );
                               
    BASE_DEF
    void      FT_Forget_Frame( FT_Stream  stream );
  
  
  
    BASE_DEF
    FT_Char   FT_Get_Char( FT_Stream  stream );
    
    BASE_DEF
    FT_Short  FT_Get_Short( FT_Stream  stream );
    
    BASE_DEF
    FT_Long   FT_Get_Offset( FT_Stream  stream );
    
    BASE_DEF
    FT_Long   FT_Get_Long( FT_Stream  stream );
  
  
  
    BASE_DEF
    FT_Char  FT_Read_Char( FT_Stream  stream,
                           FT_Error*  error ); 
  
    BASE_DEF
    FT_Short  FT_Read_Short( FT_Stream  stream,
                             FT_Error*  error ); 
  
    BASE_DEF
    FT_Long  FT_Read_Offset( FT_Stream  stream,
                             FT_Error*  error ); 
  
    BASE_DEF
    FT_Long  FT_Read_Long( FT_Stream  stream,
                           FT_Error*  error ); 
  
    BASE_DEF
    FT_Error FT_Read_Fields( FT_Stream             stream,
                             const FT_Frame_Field* fields,
                             void*                 structure );
  
  
  #define USE_Stream( resource, stream )  \
            FT_SET_ERROR( FT_Open_Stream( resource, stream ) )
  
  #define DONE_Stream( stream )  \
            FT_Done_Stream( stream )
  
  
  #define ACCESS_Frame( size )  \
            FT_SET_ERROR( FT_Access_Frame( stream, size ) )
  
  #define ACCESS_Compressed_Frame( size )  \
            FT_SET_ERROR( FT_Access_Compressed_Frame( stream, size ) )
  
  
  #define FORGET_Frame() \
            FT_Forget_Frame( stream )
  
  
  #define FILE_Seek( position )  \
            FT_SET_ERROR( FT_Seek_Stream( stream, position ) )
  
  #define FILE_Skip( distance )  \
            FT_SET_ERROR( FT_Skip_Stream( stream, distance ) )
  
  #define FILE_Pos() \
            FT_Stream_Pos( stream )
  
  #define FILE_Read( buffer, count )                         \
            FT_SET_ERROR( FT_Read_Stream( stream,            \
                                          (FT_Char*)buffer,  \
                                          count ) )
  
  #define FILE_Read_At( position, buffer, count )              \
            FT_SET_ERROR( FT_Read_Stream_At( stream,           \
                                             position,         \
                                             (FT_Char*)buffer, \
                                             count ) )
  
  #define READ_Fields( fields, object )  \
            ((error = FT_Read_Fields( stream, fields, object )) != FT_Err_Ok)
  
  #endif /* FTIO_H */
  

Download