t2parse.c

qt-embedded-2.3.8.tar.gz源码

  }


  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_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_FIELD_OFFSET( name ), \
            FT_FIELD_SIZE( name ),   \
            0, 0, 0                  \
          },

#undef  T2_FIELD_DELTA
#define T2_FIELD_DELTA( code, name, max ) \
        {                                 \
          t2_kind_delta,                  \
          code | T2CODE,                  \
          FT_FIELD_OFFSET( name ),        \
          FT_FIELD_SIZE_DELTA( name ),    \
          0,                              \
          max,                            \
          FT_FIELD_OFFSET( 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 }
  };


  FT_LOCAL_DEF
  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 */
          p++;
          for (;;)
          {
            if ( p >= limit )
              goto Syntax_Error;
            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;
      }
      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_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 */