cffparse.h File Reference

#include <ft2build.h>

Include dependency graph for cffparse.h:

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

Go to the source code of this file.

Classes
struct	CFF_ParserRec_
struct	CFF_Field_Handler_

Macros
#define	CFF_MAX_STACK_DEPTH   96
#define	CFF2_MAX_STACK   513
#define	CFF2_DEFAULT_STACK   513
#define	CFF_CODE_TOPDICT   0x1000
#define	CFF_CODE_PRIVATE   0x2000
#define	CFF2_CODE_TOPDICT   0x3000
#define	CFF2_CODE_FONTDICT   0x4000
#define	CFF2_CODE_PRIVATE   0x5000

Typedefs
typedef struct CFF_ParserRec_	CFF_ParserRec
typedef struct CFF_ParserRec_ *	CFF_Parser
typedef FT_Error(*	CFF_Field_Reader) (CFF_Parser parser)
typedef struct CFF_Field_Handler_	CFF_Field_Handler

Enumerations
enum	{   cff_kind_none = 0 , cff_kind_num , cff_kind_fixed , cff_kind_fixed_thousand ,   cff_kind_string , cff_kind_bool , cff_kind_delta , cff_kind_callback ,   cff_kind_blend , cff_kind_max }

Functions
	cff_parse_num (CFF_Parser parser, FT_Byte **d)
	cff_parser_init (CFF_Parser parser, FT_UInt code, void *object, FT_Library library, FT_UInt stackSize, FT_UShort num_designs, FT_UShort num_axes)
	cff_parser_done (CFF_Parser parser)
	cff_parser_run (CFF_Parser parser, FT_Byte *start, FT_Byte *limit)

Macro Definition Documentation

CFF2_CODE_FONTDICT

#define CFF2_CODE_FONTDICT   0x4000

Definition at line 48 of file cffparse.h.

CFF2_CODE_PRIVATE

#define CFF2_CODE_PRIVATE   0x5000

Definition at line 49 of file cffparse.h.

CFF2_CODE_TOPDICT

#define CFF2_CODE_TOPDICT   0x3000

Definition at line 47 of file cffparse.h.

CFF2_DEFAULT_STACK

#define CFF2_DEFAULT_STACK   513

Definition at line 43 of file cffparse.h.

CFF2_MAX_STACK

#define CFF2_MAX_STACK   513

Definition at line 42 of file cffparse.h.

CFF_CODE_PRIVATE

#define CFF_CODE_PRIVATE   0x2000

Definition at line 46 of file cffparse.h.

CFF_CODE_TOPDICT

#define CFF_CODE_TOPDICT   0x1000

Definition at line 45 of file cffparse.h.

CFF_MAX_STACK_DEPTH

#define CFF_MAX_STACK_DEPTH   96

Definition at line 33 of file cffparse.h.

Typedef Documentation

CFF_Field_Handler

typedef struct CFF_Field_Handler_ CFF_Field_Handler

CFF_Field_Reader

typedef FT_Error(* CFF_Field_Reader) (CFF_Parser parser)

Definition at line 111 of file cffparse.h.

CFF_Parser

typedef struct CFF_ParserRec_ * CFF_Parser

CFF_ParserRec

typedef struct CFF_ParserRec_ CFF_ParserRec

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
cff_kind_none
cff_kind_num
cff_kind_fixed
cff_kind_fixed_thousand
cff_kind_string
cff_kind_bool
cff_kind_delta
cff_kind_callback
cff_kind_blend
cff_kind_max

Definition at line 94 of file cffparse.h.

  {
    cff_kind_none = 0,
    cff_kind_num,
    cff_kind_fixed,
    cff_kind_fixed_thousand,
    cff_kind_string,
    cff_kind_bool,
    cff_kind_delta,
    cff_kind_callback,
    cff_kind_blend,
 
    cff_kind_max  /* do not remove */
  };

Function Documentation

cff_parse_num()

cff_parse_num	(	CFF_Parser	parser,
		FT_Byte **	d
	)

Definition at line 454 of file cffparse.c.

  {
    if ( **d == 30 )
    {
      /* binary-coded decimal is truncated to integer */
      return cff_parse_real( *d, parser->limit, 0, NULL ) >> 16;
    }
 
    else if ( **d == 255 )
    {
      /* 16.16 fixed point is used internally for CFF2 blend results. */
      /* Since these are trusted values, a limit check is not needed. */
 
      /* After the 255, 4 bytes give the number.                 */
      /* The blend value is converted to integer, with rounding; */
      /* due to the right-shift we don't need the lowest byte.   */
#if 0
      return (FT_Short)(
               ( ( ( (FT_UInt32)*( d[0] + 1 ) << 24 ) |
                   ( (FT_UInt32)*( d[0] + 2 ) << 16 ) |
                   ( (FT_UInt32)*( d[0] + 3 ) <<  8 ) |
                     (FT_UInt32)*( d[0] + 4 )         ) + 0x8000U ) >> 16 );
#else
      return (FT_Short)(
               ( ( ( (FT_UInt32)*( d[0] + 1 ) << 16 ) |
                   ( (FT_UInt32)*( d[0] + 2 ) <<  8 ) |
                     (FT_UInt32)*( d[0] + 3 )         ) + 0x80U ) >> 8 );
#endif
    }
 
    else
      return cff_parse_integer( *d, parser->limit );
  }

Referenced by cff_blend_doBlend(), cff_parse_blend(), cff_parse_cid_ros(), cff_parse_maxstack(), cff_parse_multiple_master(), cff_parse_private_dict(), cff_parse_vsindex(), and cff_parser_run().

cff_parser_done()

cff_parser_done

(

CFF_Parser

parser

)

Definition at line 81 of file cffparse.c.

  {
    FT_Memory  memory = parser->library->memory;    /* for FT_FREE */
 
 
    FT_FREE( parser->stack );
  }

Referenced by cff_load_private_dict(), and cff_subfont_load().

cff_parser_init()

cff_parser_init	(	CFF_Parser	parser,
		FT_UInt	code,
		void *	object,
		FT_Library	library,
		FT_UInt	stackSize,
		FT_UShort	num_designs,
		FT_UShort	num_axes
	)

Definition at line 42 of file cffparse.c.

  {
    FT_Memory  memory = library->memory;    /* for FT_NEW_ARRAY */
    FT_Error   error;                       /* for FT_NEW_ARRAY */
 
 
    FT_ZERO( parser );
 
#if 0
    parser->top         = parser->stack;
#endif
    parser->object_code = code;
    parser->object      = object;
    parser->library     = library;
    parser->num_designs = num_designs;
    parser->num_axes    = num_axes;
 
    /* allocate the stack buffer */
    if ( FT_NEW_ARRAY( parser->stack, stackSize ) )
    {
      FT_FREE( parser->stack );
      goto Exit;
    }
 
    parser->stackSize = stackSize;
    parser->top       = parser->stack;    /* empty stack */
 
  Exit:
    return error;
  }

Referenced by cff_load_private_dict(), and cff_subfont_load().

cff_parser_run()

cff_parser_run	(	CFF_Parser	parser,
		FT_Byte *	start,
		FT_Byte *	limit
	)

Definition at line 1138 of file cffparse.c.

  {
    FT_Byte*  p     = start;
    FT_Error  error = FT_Err_Ok;
 
#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
    PSAux_Service  psaux;
 
    FT_Library  library = parser->library;
    FT_Memory   memory  = library->memory;
 
    FT_ListRec  t2s;
 
 
    FT_ZERO( &t2s );
#endif
 
    parser->top    = parser->stack;
    parser->start  = start;
    parser->limit  = limit;
    parser->cursor = start;
 
    while ( p < limit )
    {
      FT_UInt  v = *p;
 
 
      /* Opcode 31 is legacy MM T2 operator, not a number.      */
      /* Opcode 255 is reserved and should not appear in fonts; */
      /* it is used internally for CFF2 blends.                 */
      if ( v >= 27 && v != 31 && v != 255 )
      {
        /* it's a number; we will push its position on the stack */
        if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
          goto Stack_Overflow;
 
        *parser->top++ = p;
 
        /* now, skip it */
        if ( v == 30 )
        {
          /* skip real number */
          p++;
          for (;;)
          {
            /* An unterminated floating point number at the */
            /* end of a dictionary is invalid but harmless. */
            if ( p >= limit )
              goto Exit;
            v = p[0] >> 4;
            if ( v == 15 )
              break;
            v = p[0] & 0xF;
            if ( v == 15 )
              break;
            p++;
          }
        }
        else if ( v == 28 )
          p += 2;
        else if ( v == 29 )
          p += 4;
        else if ( v > 246 )
          p += 1;
      }
#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
      else if ( v == 31 )
      {
        /* a Type 2 charstring */
 
        CFF_Decoder  decoder;
        CFF_FontRec  cff_rec;
        FT_Byte*     charstring_base;
        FT_ULong     charstring_len;
 
        FT_Fixed*    stack;
        FT_ListNode  node;
        FT_Byte*     q;
 
 
        charstring_base = ++p;
 
        /* search `endchar' operator */
        for (;;)
        {
          if ( p >= limit )
            goto Exit;
          if ( *p == 14 )
            break;
          p++;
        }
 
        charstring_len = (FT_ULong)( p - charstring_base ) + 1;
 
        /* construct CFF_Decoder object */
        FT_ZERO( &decoder );
        FT_ZERO( &cff_rec );
 
        cff_rec.top_font.font_dict.num_designs = parser->num_designs;
        cff_rec.top_font.font_dict.num_axes    = parser->num_axes;
        decoder.cff                            = &cff_rec;
 
        psaux = (PSAux_Service)FT_Get_Module_Interface( library, "psaux" );
        if ( !psaux )
        {
          FT_ERROR(( "cff_parser_run: cannot access `psaux' module\n" ));
          error = FT_THROW( Missing_Module );
          goto Exit;
        }
 
        error = psaux->cff_decoder_funcs->parse_charstrings_old(
                  &decoder, charstring_base, charstring_len, 1 );
        if ( error )
          goto Exit;
 
        /* Now copy the stack data in the temporary decoder object,    */
        /* converting it back to charstring number representations     */
        /* (this is ugly, I know).                                     */
 
        node = (FT_ListNode)memory->alloc( memory,
                                           sizeof ( FT_ListNodeRec ) );
        if ( !node )
          goto Out_Of_Memory_Error;
 
        /* `5' is the conservative upper bound of required bytes per stack */
        /* element.                                                        */
        q = (FT_Byte*)memory->alloc( memory,
                                     5 * ( decoder.top - decoder.stack ) );
        if ( !q )
          goto Out_Of_Memory_Error;
 
        node->data = q;
 
        FT_List_Add( &t2s, node );
 
        stack = decoder.stack;
 
        while ( stack < decoder.top )
        {
          FT_ULong  num;
          FT_Bool   neg;
 
 
          if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
            goto Stack_Overflow;
 
          *parser->top++ = q;
 
          if ( *stack < 0 )
          {
            num = (FT_ULong)NEG_LONG( *stack );
            neg = 1;
          }
          else
          {
            num = (FT_ULong)*stack;
            neg = 0;
          }
 
          if ( num & 0xFFFFU )
          {
            if ( neg )
              num = (FT_ULong)-num;
 
            *q++ = 255;
            *q++ = ( num & 0xFF000000U ) >> 24;
            *q++ = ( num & 0x00FF0000U ) >> 16;
            *q++ = ( num & 0x0000FF00U ) >>  8;
            *q++ =   num & 0x000000FFU;
          }
          else
          {
            num >>= 16;
 
            if ( neg )
            {
              if ( num <= 107 )
                *q++ = (FT_Byte)( 139 - num );
              else if ( num <= 1131 )
              {
                *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 251 );
                *q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
              }
              else
              {
                num = (FT_ULong)-num;
 
                *q++ = 28;
                *q++ = (FT_Byte)( num >> 8 );
                *q++ = (FT_Byte)( num & 0xFF );
              }
            }
            else
            {
              if ( num <= 107 )
                *q++ = (FT_Byte)( num + 139 );
              else if ( num <= 1131 )
              {
                *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 247 );
                *q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
              }
              else
              {
                *q++ = 28;
                *q++ = (FT_Byte)( num >> 8 );
                *q++ = (FT_Byte)( num & 0xFF );
              }
            }
          }
 
          stack++;
        }
      }
#endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
      else
      {
        /* This is not a number, hence it's an operator.  Compute its code */
        /* and look for it in our current list.                            */
 
        FT_UInt                   code;
        FT_UInt                   num_args;
        const CFF_Field_Handler*  field;
 
 
        if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
          goto Stack_Overflow;
 
        num_args     = (FT_UInt)( parser->top - parser->stack );
        *parser->top = p;
        code         = v;
 
        if ( v == 12 )
        {
          /* two byte operator */
          p++;
          if ( p >= limit )
            goto Syntax_Error;
 
          code = 0x100 | p[0];
        }
        code = code | parser->object_code;
 
        for ( field = cff_field_handlers; field->kind; field++ )
        {
          if ( field->code == (FT_Int)code )
          {
            /* we found our field's handler; read it */
            FT_Long   val;
            FT_Byte*  q = (FT_Byte*)parser->object + field->offset;
 
 
#ifdef FT_DEBUG_LEVEL_TRACE
            FT_TRACE4(( "  %s", field->id ));
#endif
 
            /* check that we have enough arguments -- except for */
            /* delta encoded arrays, which can be empty          */
            if ( field->kind != cff_kind_delta && num_args < 1 )
              goto Stack_Underflow;
 
            switch ( field->kind )
            {
            case cff_kind_bool:
            case cff_kind_string:
            case cff_kind_num:
              val = cff_parse_num( parser, parser->stack );
              goto Store_Number;
 
            case cff_kind_fixed:
              val = cff_parse_fixed( parser, parser->stack );
              goto Store_Number;
 
            case cff_kind_fixed_thousand:
              val = cff_parse_fixed_scaled( parser, parser->stack, 3 );
 
            Store_Number:
              switch ( field->size )
              {
              case (8 / FT_CHAR_BIT):
                *(FT_Byte*)q = (FT_Byte)val;
                break;
 
              case (16 / FT_CHAR_BIT):
                *(FT_Short*)q = (FT_Short)val;
                break;
 
              case (32 / FT_CHAR_BIT):
                *(FT_Int32*)q = (FT_Int)val;
                break;
 
              default:  /* for 64-bit systems */
                *(FT_Long*)q = val;
              }
 
#ifdef FT_DEBUG_LEVEL_TRACE
              switch ( field->kind )
              {
              case cff_kind_bool:
                FT_TRACE4(( " %s\n", val ? "true" : "false" ));
                break;
 
              case cff_kind_string:
                FT_TRACE4(( " %ld (SID)\n", val ));
                break;
 
              case cff_kind_num:
                FT_TRACE4(( " %ld\n", val ));
                break;
 
              case cff_kind_fixed:
                FT_TRACE4(( " %f\n", (double)val / 65536 ));
                break;
 
              case cff_kind_fixed_thousand:
                FT_TRACE4(( " %f\n", (double)val / 65536 / 1000 ));
 
              default:
                ; /* never reached */
              }
#endif
 
              break;
 
            case cff_kind_delta:
              {
                FT_Byte*   qcount = (FT_Byte*)parser->object +
                                      field->count_offset;
 
                FT_Byte**  data = parser->stack;
 
 
                if ( num_args > field->array_max )
                  num_args = field->array_max;
 
                FT_TRACE4(( " [" ));
 
                /* store count */
                *qcount = (FT_Byte)num_args;
 
                val = 0;
                while ( num_args > 0 )
                {
                  val = ADD_LONG( val, cff_parse_num( parser, data++ ) );
                  switch ( field->size )
                  {
                  case (8 / FT_CHAR_BIT):
                    *(FT_Byte*)q = (FT_Byte)val;
                    break;
 
                  case (16 / FT_CHAR_BIT):
                    *(FT_Short*)q = (FT_Short)val;
                    break;
 
                  case (32 / FT_CHAR_BIT):
                    *(FT_Int32*)q = (FT_Int)val;
                    break;
 
                  default:  /* for 64-bit systems */
                    *(FT_Long*)q = val;
                  }
 
                  FT_TRACE4(( " %ld", val ));
 
                  q += field->size;
                  num_args--;
                }
 
                FT_TRACE4(( "]\n" ));
              }
              break;
 
            default:  /* callback or blend */
              error = field->reader( parser );
              if ( error )
                goto Exit;
            }
            goto Found;
          }
        }
 
        /* this is an unknown operator, or it is unsupported; */
        /* we will ignore it for now.                         */
 
      Found:
        /* clear stack */
        /* TODO: could clear blend stack here,       */
        /*       but we don't have access to subFont */
        if ( field->kind != cff_kind_blend )
          parser->top = parser->stack;
      }
      p++;
    } /* while ( p < limit ) */
 
  Exit:
#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
    FT_List_Finalize( &t2s, destruct_t2s_item, memory, NULL );
#endif
    return error;
 
#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
  Out_Of_Memory_Error:
    error = FT_THROW( Out_Of_Memory );
    goto Exit;
#endif
 
  Stack_Overflow:
    error = FT_THROW( Invalid_Argument );
    goto Exit;
 
  Stack_Underflow:
    error = FT_THROW( Invalid_Argument );
    goto Exit;
 
  Syntax_Error:
    error = FT_THROW( Invalid_Argument );
    goto Exit;
  }

Referenced by cff_load_private_dict(), and cff_subfont_load().