afmparse.h File Reference

#include <ft2build.h>

Include dependency graph for afmparse.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	AFM_ValueRec_

Macros
#define	AFM_MAX_ARGUMENTS   5

Typedefs
typedef struct AFM_ValueRec_	AFM_ValueRec
typedef struct AFM_ValueRec_ *	AFM_Value

Enumerations
enum	AFM_ValueType_ {   AFM_VALUE_TYPE_STRING , AFM_VALUE_TYPE_NAME , AFM_VALUE_TYPE_FIXED , AFM_VALUE_TYPE_INTEGER ,   AFM_VALUE_TYPE_BOOL , AFM_VALUE_TYPE_INDEX }

Functions
FT_BEGIN_HEADER	afm_parser_init (AFM_Parser parser, FT_Memory memory, FT_Byte *base, FT_Byte *limit)
	afm_parser_done (AFM_Parser parser)
	afm_parser_parse (AFM_Parser parser)
	afm_parser_read_vals (AFM_Parser parser, AFM_Value vals, FT_Int n)
	afm_parser_next_key (AFM_Parser parser, FT_Bool line, FT_Offset *len)

Macro Definition Documentation

AFM_MAX_ARGUMENTS

#define AFM_MAX_ARGUMENTS   5

Definition at line 71 of file afmparse.h.

Typedef Documentation

AFM_Value

typedef struct AFM_ValueRec_ * AFM_Value

AFM_ValueRec

typedef struct AFM_ValueRec_ AFM_ValueRec

Enumeration Type Documentation

AFM_ValueType_

enum AFM_ValueType_

Enumerator
AFM_VALUE_TYPE_STRING
AFM_VALUE_TYPE_NAME
AFM_VALUE_TYPE_FIXED
AFM_VALUE_TYPE_INTEGER
AFM_VALUE_TYPE_BOOL
AFM_VALUE_TYPE_INDEX

Definition at line 45 of file afmparse.h.

  {
    AFM_VALUE_TYPE_STRING,
    AFM_VALUE_TYPE_NAME,
    AFM_VALUE_TYPE_FIXED,   /* real number */
    AFM_VALUE_TYPE_INTEGER,
    AFM_VALUE_TYPE_BOOL,
    AFM_VALUE_TYPE_INDEX    /* glyph index */
  };

Function Documentation

afm_parser_done()

afm_parser_done

(

AFM_Parser

parser

)

Definition at line 558 of file afmparse.c.

  {
    FT_Memory  memory = parser->memory;
 
 
    FT_FREE( parser->stream );
  }

afm_parser_init()

FT_BEGIN_HEADER afm_parser_init	(	AFM_Parser	parser,
		FT_Memory	memory,
		FT_Byte *	base,
		FT_Byte *	limit
	)

Definition at line 530 of file afmparse.c.

  {
    AFM_Stream  stream = NULL;
    FT_Error    error;
 
 
    if ( FT_NEW( stream ) )
      return error;
 
    stream->cursor = stream->base = base;
    stream->limit  = limit;
 
    /* don't skip the first line during the first call */
    stream->status = AFM_STREAM_STATUS_EOL;
 
    parser->memory    = memory;
    parser->stream    = stream;
    parser->FontInfo  = NULL;
    parser->get_index = NULL;
 
    return FT_Err_Ok;
  }

afm_parser_next_key()

afm_parser_next_key	(	AFM_Parser	parser,
		FT_Bool	line,
		FT_Offset *	len
	)

Definition at line 446 of file afmparse.c.

  {
    AFM_Stream  stream = parser->stream;
    char*       key    = NULL;  /* make stupid compiler happy */
 
 
    if ( line )
    {
      while ( 1 )
      {
        /* skip current line */
        if ( !AFM_STATUS_EOL( stream ) )
          afm_stream_read_string( stream );
 
        stream->status = AFM_STREAM_STATUS_NORMAL;
        key = afm_stream_read_one( stream );
 
        /* skip empty line */
        if ( !key                      &&
             !AFM_STATUS_EOF( stream ) &&
             AFM_STATUS_EOL( stream )  )
          continue;
 
        break;
      }
    }
    else
    {
      while ( 1 )
      {
        /* skip current column */
        while ( !AFM_STATUS_EOC( stream ) )
          afm_stream_read_one( stream );
 
        stream->status = AFM_STREAM_STATUS_NORMAL;
        key = afm_stream_read_one( stream );
 
        /* skip empty column */
        if ( !key                      &&
             !AFM_STATUS_EOF( stream ) &&
             AFM_STATUS_EOC( stream )  )
          continue;
 
        break;
      }
    }
 
    if ( len )
      *len = ( key ) ? (FT_Offset)AFM_STREAM_KEY_LEN( stream, key )
                     : 0;
 
    return key;
  }

Referenced by afm_parse_kern_data(), afm_parse_kern_pairs(), afm_parse_track_kern(), afm_parser_parse(), and afm_parser_skip_section().

afm_parser_parse()

afm_parser_parse

(

AFM_Parser

parser

)

Definition at line 862 of file afmparse.c.

  {
    FT_Memory     memory = parser->memory;
    AFM_FontInfo  fi     = parser->FontInfo;
    FT_Error      error  = FT_ERR( Syntax_Error );
    char*         key;
    FT_Offset     len;
    FT_Int        metrics_sets = 0;
 
 
    if ( !fi )
      return FT_THROW( Invalid_Argument );
 
    key = afm_parser_next_key( parser, 1, &len );
    if ( !key || len != 16                              ||
         ft_strncmp( key, "StartFontMetrics", 16 ) != 0 )
      return FT_THROW( Unknown_File_Format );
 
    while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
    {
      AFM_ValueRec  shared_vals[4];
 
 
      switch ( afm_tokenize( key, len ) )
      {
      case AFM_TOKEN_METRICSSETS:
        if ( afm_parser_read_int( parser, &metrics_sets ) )
          goto Fail;
 
        if ( metrics_sets != 0 && metrics_sets != 2 )
        {
          error = FT_THROW( Unimplemented_Feature );
 
          goto Fail;
        }
        break;
 
      case AFM_TOKEN_ISCIDFONT:
        shared_vals[0].type = AFM_VALUE_TYPE_BOOL;
        if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 )
          goto Fail;
 
        fi->IsCIDFont = shared_vals[0].u.b;
        break;
 
      case AFM_TOKEN_FONTBBOX:
        shared_vals[0].type = AFM_VALUE_TYPE_FIXED;
        shared_vals[1].type = AFM_VALUE_TYPE_FIXED;
        shared_vals[2].type = AFM_VALUE_TYPE_FIXED;
        shared_vals[3].type = AFM_VALUE_TYPE_FIXED;
        if ( afm_parser_read_vals( parser, shared_vals, 4 ) != 4 )
          goto Fail;
 
        fi->FontBBox.xMin = shared_vals[0].u.f;
        fi->FontBBox.yMin = shared_vals[1].u.f;
        fi->FontBBox.xMax = shared_vals[2].u.f;
        fi->FontBBox.yMax = shared_vals[3].u.f;
        break;
 
      case AFM_TOKEN_ASCENDER:
        shared_vals[0].type = AFM_VALUE_TYPE_FIXED;
        if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 )
          goto Fail;
 
        fi->Ascender = shared_vals[0].u.f;
        break;
 
      case AFM_TOKEN_DESCENDER:
        shared_vals[0].type = AFM_VALUE_TYPE_FIXED;
        if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 )
          goto Fail;
 
        fi->Descender = shared_vals[0].u.f;
        break;
 
      case AFM_TOKEN_STARTCHARMETRICS:
        {
          FT_Int  n = 0;
 
 
          if ( afm_parser_read_int( parser, &n ) )
            goto Fail;
 
          error = afm_parser_skip_section( parser, n,
                                           AFM_TOKEN_ENDCHARMETRICS );
          if ( error )
            return error;
        }
        break;
 
      case AFM_TOKEN_STARTKERNDATA:
        error = afm_parse_kern_data( parser );
        if ( error )
          goto Fail;
        /* fall through since we only support kern data */
 
      case AFM_TOKEN_ENDFONTMETRICS:
        return FT_Err_Ok;
 
      default:
        break;
      }
    }
 
  Fail:
    FT_FREE( fi->TrackKerns );
    fi->NumTrackKern = 0;
 
    FT_FREE( fi->KernPairs );
    fi->NumKernPair = 0;
 
    fi->IsCIDFont = 0;
 
    return error;
  }

afm_parser_read_vals()

afm_parser_read_vals	(	AFM_Parser	parser,
		AFM_Value	vals,
		FT_Int	n
	)

Definition at line 372 of file afmparse.c.

  {
    AFM_Stream  stream = parser->stream;
    char*       str;
    FT_Int      i;
 
 
    if ( n > AFM_MAX_ARGUMENTS )
      return 0;
 
    for ( i = 0; i < n; i++ )
    {
      FT_Offset  len;
      AFM_Value  val = vals + i;
 
 
      if ( val->type == AFM_VALUE_TYPE_STRING )
        str = afm_stream_read_string( stream );
      else
        str = afm_stream_read_one( stream );
 
      if ( !str )
        break;
 
      len = AFM_STREAM_KEY_LEN( stream, str );
 
      switch ( val->type )
      {
      case AFM_VALUE_TYPE_STRING:
      case AFM_VALUE_TYPE_NAME:
        {
          FT_Memory  memory = parser->memory;
          FT_Error   error;
 
 
          if ( !FT_QALLOC( val->u.s, len + 1 ) )
          {
            ft_memcpy( val->u.s, str, len );
            val->u.s[len] = '\0';
          }
        }
        break;
 
      case AFM_VALUE_TYPE_FIXED:
        val->u.f = PS_Conv_ToFixed( (FT_Byte**)(void*)&str,
                                    (FT_Byte*)str + len, 0 );
        break;
 
      case AFM_VALUE_TYPE_INTEGER:
        val->u.i = PS_Conv_ToInt( (FT_Byte**)(void*)&str,
                                  (FT_Byte*)str + len );
        break;
 
      case AFM_VALUE_TYPE_BOOL:
        val->u.b = FT_BOOL( len == 4                      &&
                            !ft_strncmp( str, "true", 4 ) );
        break;
 
      case AFM_VALUE_TYPE_INDEX:
        if ( parser->get_index )
          val->u.i = parser->get_index( str, len, parser->user_data );
        else
          val->u.i = 0;
        break;
      }
    }
 
    return i;
  }

Referenced by afm_parse_kern_pairs(), afm_parse_track_kern(), afm_parser_parse(), and afm_parser_read_int().