src/freetype/cff/t2parse.c

/***************************************************************************/
/*                                                                         */
/*  t2parse.c                                                              */
/*                                                                         */
/*    OpenType parser (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.                                        */
/*                                                                         */
/***************************************************************************/


#ifdef FT_FLAT_COMPILE

#include "t2parse.h"

#else

#include <cff/t2parse.h>

#endif


#include <freetype/internal/t2errors.h>


  /*************************************************************************/
  /*                                                                       */
  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  /* messages during execution.                                            */
  /*                                                                       */
#undef  FT_COMPONENT
#define FT_COMPONENT  trace_t2parse


#define T2_Err_Stack_Underflow   FT_Err_Invalid_Argument
#define T2_Err_Syntax_Error      FT_Err_Invalid_Argument


  enum
  {
    t2_kind_none = 0,
    t2_kind_num,
    t2_kind_fixed,
    t2_kind_string,
    t2_kind_bool,
    t2_kind_delta,
    t2_kind_callback,

    t2_kind_max  /* do not remove */
  };


  /* now generate handlers for the most simple fields */
  typedef FT_Error  (*T2_Field_Reader)( T2_Parser*  parser );

  typedef struct  T2_Field_Handler_
  {
    int              kind;
    int              code;
    FT_UInt          offset;
    FT_Byte          size;
    T2_Field_Reader  reader;
    FT_UInt          array_max;
    FT_UInt          count_offset;

  } T2_Field_Handler;


  LOCAL_FUNC
  void  T2_Parser_Init( T2_Parser*  parser,
                        FT_UInt     code,
                        void*       object )
  {
    MEM_Set( parser, 0, sizeof ( *parser ) );

    parser->top         = parser->stack;
    parser->object_code = code;
    parser->object      = object;
  }


  /* reads an integer */
  static
  FT_Long  parse_t2_integer( FT_Byte*  start,
                             FT_Byte*  limit )
  {
    FT_Byte*  p   = start;
    FT_Int    v   = *p++;
    FT_Long   val = 0;


    if ( v == 28 )
    {
      if ( p + 2 > limit )
        goto Bad;

      val = (FT_Short)( ( (FT_Int)p[0] << 8 ) | p[1] );
      p  += 2;
    }
    else if ( v == 29 )
    {
      if ( p + 4 > limit )
        goto Bad;

      val = ( (FT_Long)p[0] << 24 ) |
            ( (FT_Long)p[1] << 16 ) |
            ( (FT_Long)p[2] <<  8 ) |
                       p[3];
      p += 4;
    }
    else if ( v < 247 )
    {
      val = v - 139;
    }
    else if ( v < 251 )
    {
      if ( p + 1 > limit )
        goto Bad;

      val = ( v - 247 ) * 256 + p[0] + 108;
      p++;
    }
    else
    {
      if ( p + 1 > limit )
        goto Bad;

      val = -( v - 251 ) * 256 - p[0] - 108;
      p++;
    }

  Exit:
    return val;

  Bad:
    val = 0;
    goto Exit;
  }


  /* read a real */
  static
  FT_Fixed  parse_t2_real( FT_Byte*  start,
                           FT_Byte*  limit,
                           FT_Int    power_ten )
  {
    FT_Byte*  p    = start;
    FT_Long   num, divider, result, exp;
    FT_Int    sign = 0, exp_sign = 0;
    FT_Byte   nib;
    FT_Byte   phase;


    result  = 0;
    num     = 0;
    divider = 1;

    /* first of all, read the integer part */
    phase = 4;
    p--;

    for (;;)
    {
      /* read one nibble at a time */
      if ( phase && ++p >= limit )
        goto Bad;

      nib   = ( p[0] >> phase ) & 0xF;
      phase = 4 - phase;

      if ( nib == 0xE )
        sign = 1;
      else if ( nib > 9 )
        break;
      else
        result = result * 10 + nib;
    }

    /* read decimal part, if any */
    if ( nib == 0xa )
      for (;;)
      {
        /* read one nibble at a time */
        if ( !phase && ++p >= limit )
          goto Bad;

        phase = 4 - phase;
        nib   = ( p[0] >> phase ) & 0xF;

        if ( nib >= 10 )
          break;

        if (divider < 10000000L)
        {
          num      = num * 10 + nib;
          divider *= 10;
        }
      }

    /* read exponent, if any */
    if ( nib == 12 )
    {
      exp_sign = 1;
      nib      = 11;
    }

    if ( nib == 11 )
    {
      exp = 0;

      for (;;)
      {
        /* read one nibble at a time */
        if ( !phase && ++p >= limit )
          goto Bad;

        phase = 4 - phase;
        nib   = ( p[0] >> phase ) & 0xF;

        if ( nib >= 10 )
          break;

        exp = exp * 10 + nib;
      }

      if ( exp_sign )
        exp = -exp;

      power_ten += exp;
    }

    /* raise to power of ten if needed */
    while ( power_ten > 0 )
    {
      result = result * 10;
      num    = num * 10;

      power_ten--;
    }

    while ( power_ten < 0 )
    {
      result  = result / 10;
      divider = divider * 10;

      power_ten++;
    }

    if ( num )
      result += FT_DivFix( num, divider );

    if ( sign )
      result = -result;

  Exit:
    return result;

  Bad:
    result = 0;
    goto Exit;
  }


  /* read a number, either integer or real */
  static
  FT_Long  t2_parse_num( FT_Byte**  d )
  {
    return ( **d == 30 ? ( parse_t2_real( d[0], d[1], 0 ) >> 16 )
                       : parse_t2_integer( d[0], d[1] ) );
  }


  /* reads a floating point number, either integer or real */
  static
  FT_Fixed  t2_parse_fixed( FT_Byte**  d )
  {
    return ( **d == 30 ? parse_t2_real( d[0], d[1], 0 )
                       : parse_t2_integer( d[0], d[1] ) << 16 );
  }


  static
  FT_Error  parse_font_matrix( T2_Parser*  parser )
  {
    CFF_Font_Dict*  dict   = (CFF_Font_Dict*)parser->object;
    FT_Matrix*      matrix = &dict->font_matrix;
    FT_Byte**       data   = parser->stack;
    FT_Error        error;


    error = T2_Err_Stack_Underflow;

    if ( parser->top >= parser->stack + 4 )
    {
      matrix->xx = t2_parse_fixed( data++ );
      matrix->yx = t2_parse_fixed( data++ );
      matrix->xy = t2_parse_fixed( data++ );
      matrix->yy = t2_parse_fixed( data   );
      error = T2_Err_Ok;
    }

    return error;
  }


  static
  FT_Error  parse_font_bbox( T2_Parser*  parser )
  {
    CFF_Font_Dict*  dict = (CFF_Font_Dict*)parser->object;
    FT_BBox*        bbox = &dict->font_bbox;
    FT_Byte**       data = parser->stack;
    FT_Error        error;


    error = T2_Err_Stack_Underflow;

    if ( parser->top >= parser->stack + 4 )
    {
      bbox->xMin = t2_parse_num( data++ );
      bbox->yMin = t2_parse_num( data++ );
      bbox->xMax = t2_parse_num( data++ );
      bbox->yMax = t2_parse_num( data   );
      error = T2_Err_Ok;
    }

    return error;
  }


  static
  FT_Error  parse_private_dict( T2_Parser*  parser )
  {
    CFF_Font_Dict*  dict = (CFF_Font_Dict*)parser->object;
    FT_Byte**       data = parser->stack;
    FT_Error        error;


    error = T2_Err_Stack_Underflow;

    if ( parser->top >= parser->stack + 2 )
    {
      dict->private_size   = t2_parse_num( data++ );
      dict->private_offset = t2_parse_num( data   );
      error = T2_Err_Ok;
    }

    return error;
  }


  static
  FT_Error  parse_cid_ros( T2_Parser*  parser )
  {
    CFF_Font_Dict*  dict   = (CFF_Font_Dict*)parser->object;
    FT_Byte**       data   = parser->stack;
    FT_Error        error;


    error = T2_Err_Stack_Underflow;

    if ( parser->top >= parser->stack + 3 )
    {
      dict->cid_registry   = (FT_UInt)t2_parse_num( data++ );
      dict->cid_ordering   = (FT_UInt)t2_parse_num( data++ );
      dict->cid_supplement = (FT_ULong)t2_parse_num( data );
      error = T2_Err_Ok;
    }

    return error;
  }


#define T2_FIELD_NUM( code, name ) \
          T2_FIELD( code, name, t2_kind_num )
#define T2_FIELD_FIXED( code, name ) \
          T2_FIELD( code, name, t2_kind_fixed )
#define T2_FIELD_STRING( code, name ) \
          T2_FIELD( code, name, t2_kind_string )
#define T2_FIELD_BOOL( code, name ) \
          T2_FIELD( code, name, t2_kind_bool )
#define T2_FIELD_DELTA( code, name,max ) \
          T2_FIELD( code, name, t2_kind_delta )

#define T2_REF( s, f )  ( ((s*)0)->f )

#define T2_FIELD_CALLBACK( code, name ) \
          {                             \
            t2_kind_callback,           \
            code | T2CODE,              \
            0, 0,                       \
            parse_ ## name,             \
            0, 0                        \
          },

#undef  T2_FIELD
#define T2_FIELD( code, name, kind )                 \
          {                                          \
            kind,                                    \
            code | T2CODE,                           \
            (FT_UInt)(char*)&T2_REF( T2TYPE, name ), \
            sizeof( T2_REF( T2TYPE, name ) ),        \
            0, 0, 0                                  \
          },

#undef  T2_FIELD_DELTA
#define T2_FIELD_DELTA( code, name, max )                    \
        {                                                    \
          t2_kind_delta,                                     \
          code | T2CODE,                                     \
          (FT_UInt)(char*)&T2_REF( T2TYPE, name ),           \
          sizeof( T2_REF( T2TYPE, name )[0] ),               \
          0,                                                 \
          max,                                               \
          (FT_UInt)(char*)&T2_REF( T2TYPE, num_ ## name )    \
        },

#define T2CODE_TOPDICT  0x1000
#define T2CODE_PRIVATE  0x2000

  static const T2_Field_Handler  t2_field_handlers[] =
  {

#ifdef FT_FLAT_COMPILE

#include "t2tokens.h"

#else

#include <cff/t2tokens.h>

#endif

    { 0, 0, 0, 0, 0, 0, 0 }
  };


  LOCAL_FUNC
  FT_Error  T2_Parser_Run( T2_Parser*  parser,
                           FT_Byte*    start,
                           FT_Byte*    limit )
  {
    FT_Byte*  p     = start;
    FT_Error  error = T2_Err_Ok;


    parser->top    = parser->stack;
    parser->start  = start;
    parser->limit  = limit;
    parser->cursor = start;

    while ( p < limit )
    {
      FT_Byte  v = *p;


      if ( v >= 27 && v != 31 )
      {
        /* it's a number; we will push its position on the stack */
        if ( parser->top - parser->stack >= T2_MAX_STACK_DEPTH )
          goto Stack_Overflow;

        *parser->top ++ = p;

        /* now, skip it */
        if ( v == 30 )
        {
          /* skip real number */
          for (;;)
          {
            if ( p >= limit )
              goto Syntax_Error;
            v = p[0] >> 4;
            if ( v == 15 )
              break;
            v = p[0] & 0xF;
            if ( v == 15 )
              break;
            p++;
          }
          p++;
        }
        else if ( v == 28 )
          p += 2;
        else if ( v == 29 )
          p += 4;
        else if ( v > 246 )
          p += 1;
      }
      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 = (FT_UInt)
                                              ( parser->top - parser->stack );
        const T2_Field_Handler*  field;


        /* first of all, a trivial check */
        if ( num_args < 1 )
          goto Stack_Underflow;

        *parser->top = p;
        code = v;
        if ( v == 12 )
        {
          /* two byte operator */
          p++;
          code = 0x100 | p[0];
        }
        code = code | parser->object_code;

        for ( field = t2_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;


            switch ( field->kind )
            {
            case t2_kind_bool:
            case t2_kind_string:
            case t2_kind_num:
              val = t2_parse_num( parser->stack );
              goto Store_Number;

            case t2_kind_fixed:
              val = t2_parse_fixed( parser->stack );

            Store_Number:
              switch ( field->size )
              {
              case 1:
                *(FT_Byte*)q = (FT_Byte)val;
                break;

              case 2:
                *(FT_Short*)q = (FT_Short)val;
                break;

              case 4:
                *(FT_Int32*)q = (FT_Int)val;
                break;

              default:  /* for 64-bit systems where long is 8 bytes */
                *(FT_Long*)q = val;
              }
              break;

            case t2_kind_delta:
              {
                FT_Byte*   qcount = (FT_Byte*)parser->object +
                                      field->count_offset;

                FT_Long    val;
                FT_Byte**  data = parser->stack;


                if ( num_args > field->array_max )
                  num_args = field->array_max;

                /* store count */
                *qcount = (FT_Byte)num_args;

                val = 0;
                while ( num_args > 0 )
                {
                  val += t2_parse_num( data++ );
                  switch ( field->size )
                  {
                  case 1:
                    *(FT_Byte*)q = (FT_Byte)val;
                    break;

                  case 2:
                    *(FT_Short*)q = (FT_Short)val;
                    break;

                  case 4:
                    *(FT_Int32*)q = (FT_Int)val;
                    break;

                  default:  /* for 64-bit systems */
                    *(FT_Long*)q = val;
                  }

                  q += field->size;
                  num_args--;
                }
              }
              break;

            default:  /* callback */
              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 */
        parser->top = parser->stack;
      }
      p++;
    }

  Exit:
    return error;

  Stack_Overflow:
    error = T2_Err_Invalid_Argument;
    goto Exit;

  Stack_Underflow:
    error = T2_Err_Invalid_Argument;
    goto Exit;

  Syntax_Error:
    error = T2_Err_Invalid_Argument;
    goto Exit;
  }


/* END */
Commit	Line	Data
	1	/***************************************************************************/
	2	/* */
	3	/* t2parse.c */
	4	/* */
	5	/* OpenType parser (body). */
	6	/* */
	7	/* Copyright 1996-2000 by */
	8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
	9	/* */
	10	/* This file is part of the FreeType project, and may only be used, */
	11	/* modified, and distributed under the terms of the FreeType project */
	12	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
	13	/* this file you indicate that you have read the license and */
	14	/* understand and accept it fully. */
	15	/* */
	16	/***************************************************************************/
	17
	18
	19	#ifdef FT_FLAT_COMPILE
	20
	21	#include "t2parse.h"
	22
	23	#else
	24
	25	#include <cff/t2parse.h>
	26
	27	#endif
	28
	29
	30	#include <freetype/internal/t2errors.h>
	31
	32
	33	/*************************************************************************/
	34	/* */
	35	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
	36	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
	37	/* messages during execution. */
	38	/* */
	39	#undef FT_COMPONENT
	40	#define FT_COMPONENT trace_t2parse
	41
	42
	43	#define T2_Err_Stack_Underflow FT_Err_Invalid_Argument
	44	#define T2_Err_Syntax_Error FT_Err_Invalid_Argument
	45
	46
	47	enum
	48	{
	49	t2_kind_none = 0,
	50	t2_kind_num,
	51	t2_kind_fixed,
	52	t2_kind_string,
	53	t2_kind_bool,
	54	t2_kind_delta,
	55	t2_kind_callback,
	56
	57	t2_kind_max /* do not remove */
	58	};
	59
	60
	61	/* now generate handlers for the most simple fields */
	62	typedef FT_Error (T2_Field_Reader)( T2_Parser parser );
	63
	64	typedef struct T2_Field_Handler_
	65	{
	66	int kind;
	67	int code;
	68	FT_UInt offset;
	69	FT_Byte size;
	70	T2_Field_Reader reader;
	71	FT_UInt array_max;
	72	FT_UInt count_offset;
	73
	74	} T2_Field_Handler;
	75
	76
	77	LOCAL_FUNC
	78	void T2_Parser_Init( T2_Parser* parser,
	79	FT_UInt code,
	80	void* object )
	81	{
	82	MEM_Set( parser, 0, sizeof ( *parser ) );
	83
	84	parser->top = parser->stack;
	85	parser->object_code = code;
	86	parser->object = object;
	87	}
	88
	89
	90	/* reads an integer */
	91	static
	92	FT_Long parse_t2_integer( FT_Byte* start,
	93	FT_Byte* limit )
	94	{
	95	FT_Byte* p = start;
	96	FT_Int v = *p++;
	97	FT_Long val = 0;
	98
	99
	100	if ( v == 28 )
	101	{
	102	if ( p + 2 > limit )
	103	goto Bad;
	104
	105	val = (FT_Short)( ( (FT_Int)p[0] << 8 ) \| p[1] );
	106	p += 2;
	107	}
	108	else if ( v == 29 )
	109	{
	110	if ( p + 4 > limit )
	111	goto Bad;
	112
	113	val = ( (FT_Long)p[0] << 24 ) \|
	114	( (FT_Long)p[1] << 16 ) \|
	115	( (FT_Long)p[2] << 8 ) \|
	116	p[3];
	117	p += 4;
	118	}
	119	else if ( v < 247 )
	120	{
	121	val = v - 139;
	122	}
	123	else if ( v < 251 )
	124	{
	125	if ( p + 1 > limit )
	126	goto Bad;
	127
	128	val = ( v - 247 ) * 256 + p[0] + 108;
	129	p++;
	130	}
	131	else
	132	{
	133	if ( p + 1 > limit )
	134	goto Bad;
	135
	136	val = -( v - 251 ) * 256 - p[0] - 108;
	137	p++;
	138	}
	139
	140	Exit:
	141	return val;
	142
	143	Bad:
	144	val = 0;
	145	goto Exit;
	146	}
	147
	148
	149	/* read a real */
	150	static
	151	FT_Fixed parse_t2_real( FT_Byte* start,
	152	FT_Byte* limit,
	153	FT_Int power_ten )
	154	{
	155	FT_Byte* p = start;
	156	FT_Long num, divider, result, exp;
	157	FT_Int sign = 0, exp_sign = 0;
	158	FT_Byte nib;
	159	FT_Byte phase;
	160
	161
	162	result = 0;
	163	num = 0;
	164	divider = 1;
	165
	166	/* first of all, read the integer part */
	167	phase = 4;
	168	p--;
	169
	170	for (;;)
	171	{
	172	/* read one nibble at a time */
	173	if ( phase && ++p >= limit )
	174	goto Bad;
	175
	176	nib = ( p[0] >> phase ) & 0xF;
	177	phase = 4 - phase;
	178
	179	if ( nib == 0xE )
	180	sign = 1;
	181	else if ( nib > 9 )
	182	break;
	183	else
	184	result = result * 10 + nib;
	185	}
	186
	187	/* read decimal part, if any */
	188	if ( nib == 0xa )
	189	for (;;)
	190	{
	191	/* read one nibble at a time */
	192	if ( !phase && ++p >= limit )
	193	goto Bad;
	194
	195	phase = 4 - phase;
	196	nib = ( p[0] >> phase ) & 0xF;
	197
	198	if ( nib >= 10 )
	199	break;
	200
	201	if (divider < 10000000L)
	202	{
	203	num = num * 10 + nib;
	204	divider *= 10;
	205	}
	206	}
	207
	208	/* read exponent, if any */
	209	if ( nib == 12 )
	210	{
	211	exp_sign = 1;
	212	nib = 11;
	213	}
	214
	215	if ( nib == 11 )
	216	{
	217	exp = 0;
	218
	219	for (;;)
	220	{
	221	/* read one nibble at a time */
	222	if ( !phase && ++p >= limit )
	223	goto Bad;
	224
	225	phase = 4 - phase;
	226	nib = ( p[0] >> phase ) & 0xF;
	227
	228	if ( nib >= 10 )
	229	break;
	230
	231	exp = exp * 10 + nib;
	232	}
	233
	234	if ( exp_sign )
	235	exp = -exp;
	236
	237	power_ten += exp;
	238	}
	239
	240	/* raise to power of ten if needed */
	241	while ( power_ten > 0 )
	242	{
	243	result = result * 10;
	244	num = num * 10;
	245
	246	power_ten--;
	247	}
	248
	249	while ( power_ten < 0 )
	250	{
	251	result = result / 10;
	252	divider = divider * 10;
	253
	254	power_ten++;
	255	}
	256
	257	if ( num )
	258	result += FT_DivFix( num, divider );
	259
	260	if ( sign )
	261	result = -result;
	262
	263	Exit:
	264	return result;
	265
	266	Bad:
	267	result = 0;
	268	goto Exit;
	269	}
	270
	271
	272	/* read a number, either integer or real */
	273	static
	274	FT_Long t2_parse_num( FT_Byte** d )
	275	{
	276	return ( **d == 30 ? ( parse_t2_real( d[0], d[1], 0 ) >> 16 )
	277	: parse_t2_integer( d[0], d[1] ) );
	278	}
	279
	280
	281	/* reads a floating point number, either integer or real */
	282	static
	283	FT_Fixed t2_parse_fixed( FT_Byte** d )
	284	{
	285	return ( **d == 30 ? parse_t2_real( d[0], d[1], 0 )
	286	: parse_t2_integer( d[0], d[1] ) << 16 );
	287	}
	288
	289
	290	static
	291	FT_Error parse_font_matrix( T2_Parser* parser )
	292	{
	293	CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object;
	294	FT_Matrix* matrix = &dict->font_matrix;
	295	FT_Byte** data = parser->stack;
	296	FT_Error error;
	297
	298
	299	error = T2_Err_Stack_Underflow;
	300
	301	if ( parser->top >= parser->stack + 4 )
	302	{
	303	matrix->xx = t2_parse_fixed( data++ );
	304	matrix->yx = t2_parse_fixed( data++ );
	305	matrix->xy = t2_parse_fixed( data++ );
	306	matrix->yy = t2_parse_fixed( data );
	307	error = T2_Err_Ok;
	308	}
	309
	310	return error;
	311	}
	312
	313
	314	static
	315	FT_Error parse_font_bbox( T2_Parser* parser )
	316	{
	317	CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object;
	318	FT_BBox* bbox = &dict->font_bbox;
	319	FT_Byte** data = parser->stack;
	320	FT_Error error;
	321
	322
	323	error = T2_Err_Stack_Underflow;
	324
	325	if ( parser->top >= parser->stack + 4 )
	326	{
	327	bbox->xMin = t2_parse_num( data++ );
	328	bbox->yMin = t2_parse_num( data++ );
	329	bbox->xMax = t2_parse_num( data++ );
	330	bbox->yMax = t2_parse_num( data );
	331	error = T2_Err_Ok;
	332	}
	333
	334	return error;
	335	}
	336
	337
	338	static
	339	FT_Error parse_private_dict( T2_Parser* parser )
	340	{
	341	CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object;
	342	FT_Byte** data = parser->stack;
	343	FT_Error error;
	344
	345
	346	error = T2_Err_Stack_Underflow;
	347
	348	if ( parser->top >= parser->stack + 2 )
	349	{
	350	dict->private_size = t2_parse_num( data++ );
	351	dict->private_offset = t2_parse_num( data );
	352	error = T2_Err_Ok;
	353	}
	354
	355	return error;
	356	}
	357
	358
	359	static
	360	FT_Error parse_cid_ros( T2_Parser* parser )
	361	{
	362	CFF_Font_Dict* dict = (CFF_Font_Dict*)parser->object;
	363	FT_Byte** data = parser->stack;
	364	FT_Error error;
	365
	366
	367	error = T2_Err_Stack_Underflow;
	368
	369	if ( parser->top >= parser->stack + 3 )
	370	{
	371	dict->cid_registry = (FT_UInt)t2_parse_num( data++ );
	372	dict->cid_ordering = (FT_UInt)t2_parse_num( data++ );
	373	dict->cid_supplement = (FT_ULong)t2_parse_num( data );
	374	error = T2_Err_Ok;
	375	}
	376
	377	return error;
	378	}
	379
	380
	381	#define T2_FIELD_NUM( code, name ) \
	382	T2_FIELD( code, name, t2_kind_num )
	383	#define T2_FIELD_FIXED( code, name ) \
	384	T2_FIELD( code, name, t2_kind_fixed )
	385	#define T2_FIELD_STRING( code, name ) \
	386	T2_FIELD( code, name, t2_kind_string )
	387	#define T2_FIELD_BOOL( code, name ) \
	388	T2_FIELD( code, name, t2_kind_bool )
	389	#define T2_FIELD_DELTA( code, name,max ) \
	390	T2_FIELD( code, name, t2_kind_delta )
	391
	392	#define T2_REF( s, f ) ( ((s*)0)->f )
	393
	394	#define T2_FIELD_CALLBACK( code, name ) \
	395	{ \
	396	t2_kind_callback, \
	397	code \| T2CODE, \
	398	0, 0, \
	399	parse_ ## name, \
	400	0, 0 \
	401	},
	402
	403	#undef T2_FIELD
	404	#define T2_FIELD( code, name, kind ) \
	405	{ \
	406	kind, \
	407	code \| T2CODE, \
	408	(FT_UInt)(char*)&T2_REF( T2TYPE, name ), \
	409	sizeof( T2_REF( T2TYPE, name ) ), \
	410	0, 0, 0 \
	411	},
	412
	413	#undef T2_FIELD_DELTA
	414	#define T2_FIELD_DELTA( code, name, max ) \
	415	{ \
	416	t2_kind_delta, \
	417	code \| T2CODE, \
	418	(FT_UInt)(char*)&T2_REF( T2TYPE, name ), \
	419	sizeof( T2_REF( T2TYPE, name )[0] ), \
	420	0, \
	421	max, \
	422	(FT_UInt)(char*)&T2_REF( T2TYPE, num_ ## name ) \
	423	},
	424
	425	#define T2CODE_TOPDICT 0x1000
	426	#define T2CODE_PRIVATE 0x2000
	427
	428	static const T2_Field_Handler t2_field_handlers[] =
	429	{
	430
	431	#ifdef FT_FLAT_COMPILE
	432
	433	#include "t2tokens.h"
	434
	435	#else
	436
	437	#include <cff/t2tokens.h>
	438
	439	#endif
	440
	441	{ 0, 0, 0, 0, 0, 0, 0 }
	442	};
	443
	444
	445	LOCAL_FUNC
	446	FT_Error T2_Parser_Run( T2_Parser* parser,
	447	FT_Byte* start,
	448	FT_Byte* limit )
	449	{
	450	FT_Byte* p = start;
	451	FT_Error error = T2_Err_Ok;
	452
	453
	454	parser->top = parser->stack;
	455	parser->start = start;
	456	parser->limit = limit;
	457	parser->cursor = start;
	458
	459	while ( p < limit )
	460	{
	461	FT_Byte v = *p;
	462
	463
	464	if ( v >= 27 && v != 31 )
	465	{
	466	/* it's a number; we will push its position on the stack */
	467	if ( parser->top - parser->stack >= T2_MAX_STACK_DEPTH )
	468	goto Stack_Overflow;
	469
	470	*parser->top ++ = p;
	471
	472	/* now, skip it */
	473	if ( v == 30 )
	474	{
	475	/* skip real number */
	476	for (;;)
	477	{
	478	if ( p >= limit )
	479	goto Syntax_Error;
	480	v = p[0] >> 4;
	481	if ( v == 15 )
	482	break;
	483	v = p[0] & 0xF;
	484	if ( v == 15 )
	485	break;
	486	p++;
	487	}
	488	p++;
	489	}
	490	else if ( v == 28 )
	491	p += 2;
	492	else if ( v == 29 )
	493	p += 4;
	494	else if ( v > 246 )
	495	p += 1;
	496	}
	497	else
	498	{
	499	/* This is not a number, hence it's an operator. Compute its code */
	500	/* and look for it in our current list. */
	501
	502	FT_UInt code;
	503	FT_UInt num_args = (FT_UInt)
	504	( parser->top - parser->stack );
	505	const T2_Field_Handler* field;
	506
	507
	508	/* first of all, a trivial check */
	509	if ( num_args < 1 )
	510	goto Stack_Underflow;
	511
	512	*parser->top = p;
	513	code = v;
	514	if ( v == 12 )
	515	{
	516	/* two byte operator */
	517	p++;
	518	code = 0x100 \| p[0];
	519	}
	520	code = code \| parser->object_code;
	521
	522	for ( field = t2_field_handlers; field->kind; field++ )
	523	{
	524	if ( field->code == (FT_Int)code )
	525	{
	526	/* we found our field's handler; read it */
	527	FT_Long val;
	528	FT_Byte* q = (FT_Byte*)parser->object + field->offset;
	529
	530
	531	switch ( field->kind )
	532	{
	533	case t2_kind_bool:
	534	case t2_kind_string:
	535	case t2_kind_num:
	536	val = t2_parse_num( parser->stack );
	537	goto Store_Number;
	538
	539	case t2_kind_fixed:
	540	val = t2_parse_fixed( parser->stack );
	541
	542	Store_Number:
	543	switch ( field->size )
	544	{
	545	case 1:
	546	(FT_Byte)q = (FT_Byte)val;
	547	break;
	548
	549	case 2:
	550	(FT_Short)q = (FT_Short)val;
	551	break;
	552
	553	case 4:
	554	(FT_Int32)q = (FT_Int)val;
	555	break;
	556
	557	default: /* for 64-bit systems where long is 8 bytes */
	558	(FT_Long)q = val;
	559	}
	560	break;
	561
	562	case t2_kind_delta:
	563	{
	564	FT_Byte* qcount = (FT_Byte*)parser->object +
	565	field->count_offset;
	566
	567	FT_Long val;
	568	FT_Byte** data = parser->stack;
	569
	570
	571	if ( num_args > field->array_max )
	572	num_args = field->array_max;
	573
	574	/* store count */
	575	*qcount = (FT_Byte)num_args;
	576
	577	val = 0;
	578	while ( num_args > 0 )
	579	{
	580	val += t2_parse_num( data++ );
	581	switch ( field->size )
	582	{
	583	case 1:
	584	(FT_Byte)q = (FT_Byte)val;
	585	break;
	586
	587	case 2:
	588	(FT_Short)q = (FT_Short)val;
	589	break;
	590
	591	case 4:
	592	(FT_Int32)q = (FT_Int)val;
	593	break;
	594
	595	default: /* for 64-bit systems */
	596	(FT_Long)q = val;
	597	}
	598
	599	q += field->size;
	600	num_args--;
	601	}
	602	}
	603	break;
	604
	605	default: /* callback */
	606	error = field->reader( parser );
	607	if ( error )
	608	goto Exit;
	609	}
	610	goto Found;
	611	}
	612	}
	613
	614	/* this is an unknown operator, or it is unsupported; */
	615	/* we will ignore it for now. */
	616
	617	Found:
	618	/* clear stack */
	619	parser->top = parser->stack;
	620	}
	621	p++;
	622	}
	623
	624	Exit:
	625	return error;
	626
	627	Stack_Overflow:
	628	error = T2_Err_Invalid_Argument;
	629	goto Exit;
	630
	631	Stack_Underflow:
	632	error = T2_Err_Invalid_Argument;
	633	goto Exit;
	634
	635	Syntax_Error:
	636	error = T2_Err_Invalid_Argument;
	637	goto Exit;
	638	}
	639
	640
	641	/* END */