freetype/src/cff/t2gload.c

/***************************************************************************/
/*                                                                         */
/*  t2gload.c                                                              */
/*                                                                         */
/*    OpenType Glyph Loader (body).                                        */
/*                                                                         */
/*  Copyright 1996-1999 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.                                        */
/*                                                                         */
/***************************************************************************/


#include <freetype/internal/ftdebug.h>
#include <freetype/internal/ftcalc.h>
#include <freetype/internal/ftstream.h>
#include <freetype/internal/sfnt.h>
#include <freetype/tttags.h>

#undef  FT_COMPONENT
#define FT_COMPONENT  trace_t1gload

#include <t2load.h>
#include <t2gload.h>

  typedef enum T2_Operator_
  {
    t2_op_unknown = 0,
    t2_op_rmoveto,
    t2_op_hmoveto,
    t2_op_vmoveto,
    t2_op_rlineto,
    t2_op_hlineto,
    t2_op_vlineto,
    t2_op_rrcurveto,
    t2_op_hhcurveto,
    t2_op_hvcurveto,
    t2_op_rcurveline,
    t2_op_rlinecurve,
    t2_op_vhcurveto,
    t2_op_vvcurveto,
    t2_op_flex,
    t2_op_hflex,
    t2_op_hflex1,
    t2_op_flex1,
    t2_op_endchar,
    t2_op_hstem,
    t2_op_vstem,
    t2_op_hstemhm,
    t2_op_vstemhm,
    t2_op_hintmask,
    t2_op_cntrmask,
    t2_op_abs,
    t2_op_add,
    t2_op_sub,
    t2_op_div,
    t2_op_neg,
    t2_op_random,
    t2_op_mul,
    t2_op_sqrt,
    t2_op_blend,
    t2_op_drop,
    t2_op_exch,
    t2_op_index,
    t2_op_roll,
    t2_op_dup,
    t2_op_put,
    t2_op_get,
    t2_op_store,
    t2_op_load,
    t2_op_and,
    t2_op_or,
    t2_op_not,
    t2_op_eq,
    t2_op_ifelse,
    t2_op_callsubr,
    t2_op_callgsubr,
    t2_op_return,
    /* do not remove */
    t2_op_max
    
  } T2_Operator;

  #define T2_COUNT_CHECK_WIDTH  0x80
  #define T2_COUNT_EXACT        0x40
  #define T2_COUNT_CLEAR_STACK  0x20

  static const FT_Byte  t2_argument_counts[] =
  {
    0,  /* unknown */
    
    2 | T2_COUNT_CHECK_WIDTH | T2_COUNT_EXACT, /* rmoveto */
    1 | T2_COUNT_CHECK_WIDTH | T2_COUNT_EXACT,
    1 | T2_COUNT_CHECK_WIDTH | T2_COUNT_EXACT,

    0 | T2_COUNT_CLEAR_STACK,  /* rlineto */
    0 | T2_COUNT_CLEAR_STACK,
    0 | T2_COUNT_CLEAR_STACK,

    0 | T2_COUNT_CLEAR_STACK,  /* rrcurveto */
    0 | T2_COUNT_CLEAR_STACK,
    0 | T2_COUNT_CLEAR_STACK,
    0 | T2_COUNT_CLEAR_STACK,
    0 | T2_COUNT_CLEAR_STACK,
    0 | T2_COUNT_CLEAR_STACK,
    0 | T2_COUNT_CLEAR_STACK,

    13, /* flex */
    7,
    9,
    11,

    0, /* enchar */
    
    2 | T2_COUNT_CHECK_WIDTH, /* hstem */
    2 | T2_COUNT_CHECK_WIDTH,
    2 | T2_COUNT_CHECK_WIDTH,
    2 | T2_COUNT_CHECK_WIDTH,
    
    0, /* hintmask */
    0, /* cntrmask */
    
    1, /* abs */
    2,
    2,
    2,
    1,
    0,
    2,
    1,
    
    1, /* blend */
    
    1, /* drop */
    2,
    1,
    2,
    1,
    
    2, /* put */
    1,
    4,
    3,
    
    2, /* and */
    2,
    1,
    2,
    4,
    
    1, /* callsubr */
    1,
    0
  };

  /* required for the tracing mode */
#undef  FT_COMPONENT
#define FT_COMPONENT  trace_ttgload


  /**********************************************************************/
  /**********************************************************************/
  /**********************************************************************/
  /**********                                                   *********/
  /**********                                                   *********/
  /**********           GENERIC CHARSTRINGS PARSING             *********/
  /**********                                                   *********/
  /**********                                                   *********/
  /**********************************************************************/
  /**********************************************************************/
  /**********************************************************************/

/*********************************************************************
 *
 * <Function>
 *    T2_Init_Builder
 *
 * <Description>
 *    Initialise a given glyph builder.
 *
 * <Input>
 *    builder :: glyph builder to initialise
 *    face    :: current face object
 *    size    :: current size object
 *    glyph   :: current glyph object
 *
 *********************************************************************/

  static
  void  T2_Init_Builder( T2_Builder*   builder,
                         TT_Face       face,
                         T2_Size       size,
                         T2_GlyphSlot  glyph )
  {
    builder->path_begun  = 0;
    builder->load_points = 1;

    builder->face   = face;
    builder->glyph  = glyph;
    builder->memory = face->root.memory;

    if (glyph)
    {
      builder->base         = glyph->root.outline;
      builder->max_points   = glyph->max_points;
      builder->max_contours = glyph->max_contours;
    }

    if (size)
    {
      builder->scale_x = size->metrics.x_scale;
      builder->scale_y = size->metrics.y_scale;
    }

    builder->pos_x = 0;
    builder->pos_y = 0;

    builder->left_bearing.x = 0;
    builder->left_bearing.y = 0;
    builder->advance.x      = 0;
    builder->advance.y      = 0;

    builder->base.n_points   = 0;
    builder->base.n_contours = 0;
    builder->current         = builder->base;
  }


/*********************************************************************
 *
 * <Function>
 *    T2_Done_Builder
 *
 * <Description>
 *    Finalise a given glyph builder. Its content can still be
 *    used after the call, but the function saves important information
 *    within the corresponding glyph slot.
 *
 * <Input>
 *    builder :: glyph builder to initialise
 *
 *********************************************************************/

  static
  void T2_Done_Builder( T2_Builder*  builder )
  {
    T2_GlyphSlot  glyph = builder->glyph;

    if (glyph)
    {
      glyph->root.outline = builder->base;
      glyph->max_points   = builder->max_points;
      glyph->max_contours = builder->max_contours;
    }
  }



/*********************************************************************
 *
 * <Function>
 *    T2_Init_Decoder
 *
 * <Description>
 *    Initialise a given Type 2 decoder for parsing
 *
 * <Input>
 *    decoder :: Type 1 decoder to initialise
 *    funcs   :: hinter functions interface
 *
 *********************************************************************/

  static FT_Int  t2_compute_bias( FT_UInt  num_subrs )
  {
    FT_Int  result;
    
    if (num_subrs < 1240)
      result = 107;
    else if (num_subrs < 33900)
      result = 1131;
    else
      result = 32768;
      
    return result;
  }


  LOCAL_FUNC
  void  T2_Init_Decoder( T2_Decoder*  decoder,
                         TT_Face      face,
                         T2_Size      size,
                         T2_GlyphSlot slot )
  {
    CFF_Font*  cff = (CFF_Font*)face->other;
    
    /* clear everything */
    MEM_Set( decoder, 0, sizeof(*decoder) );

    /* initialise builder */
    T2_Init_Builder( &decoder->builder, face, size, slot );
    
    /* initialise Type2 decoder */
    decoder->num_locals   = cff->num_local_subrs;
    decoder->num_globals  = cff->num_global_subrs;
    decoder->locals       = cff->local_subrs;
    decoder->globals      = cff->global_subrs;
    decoder->locals_bias  = t2_compute_bias( decoder->num_locals );
    decoder->globals_bias = t2_compute_bias( decoder->num_globals );
    
    decoder->glyph_width   = cff->private_dict.default_width;
    decoder->nominal_width = cff->private_dict.nominal_width;
  }


  /* check that there is enough room for "count" more points */
  static
  FT_Error  check_points( T2_Builder*  builder,
                          FT_Int       count )
  {
    FT_Outline*  base    = &builder->base;
    FT_Outline*  outline = &builder->current;

    if (!builder->load_points)
      return FT_Err_Ok;

    count += base->n_points + outline->n_points;

    /* realloc points table if necessary */
    if ( count >= builder->max_points )
    {
      FT_Error   error;
      FT_Memory  memory    = builder->memory;
      FT_Int     increment = outline->points - base->points;
      FT_Int     current   = builder->max_points;

      while ( builder->max_points < count )
        builder->max_points += 8;

      if ( REALLOC_ARRAY( base->points, current,
                          builder->max_points, FT_Vector )  ||

           REALLOC_ARRAY( base->tags, current,
                          builder->max_points, FT_Byte )    )
      {
        builder->error = error;
        return error;
      }

      outline->points = base->points + increment;
      outline->tags  = base->tags  + increment;
    }
    return FT_Err_Ok;
  }


  /* add a new point, do not check room */
  static
  void  add_point( T2_Builder*  builder,
                   FT_Pos       x,
                   FT_Pos       y,
                   FT_Byte      flag )
  {
    FT_Outline*  outline = &builder->current;

    if (builder->load_points)
    {
      FT_Vector*  point   = outline->points + outline->n_points;
      FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points;

      point->x = x >> 16;
      point->y = y >> 16;
      *control = ( flag ? FT_Curve_Tag_On : FT_Curve_Tag_Cubic );

      builder->last = *point;
    }

    outline->n_points++;
  }


  /* check room for a new on-curve point, then add it */
  static
  FT_Error  add_point1( T2_Builder*  builder,
                        FT_Pos       x,
                        FT_Pos       y )
  {
    FT_Error  error;

    error = check_points(builder,1);
    if (!error)
      add_point( builder, x, y, 1 );

    return error;
  }


  /* check room for a new contour, then add it */
  static
  FT_Error  add_contour( T2_Builder*  builder )
  {
    FT_Outline*  base    = &builder->base;
    FT_Outline*  outline = &builder->current;

    if (!builder->load_points)
    {
      outline->n_contours++;
      return FT_Err_Ok;
    }

    /* realloc contours array if necessary */
    if ( base->n_contours + outline->n_contours >= builder->max_contours &&
         builder->load_points )
    {
      FT_Error  error;
      FT_Memory memory = builder->memory;
      FT_Int    increment = outline->contours - base->contours;
      FT_Int    current   = builder->max_contours;

      builder->max_contours += 4;

      if ( REALLOC_ARRAY( base->contours,
                          current, builder->max_contours, FT_Short ) )
      {
        builder->error = error;
        return error;
      }

      outline->contours = base->contours + increment;
    }

    if (outline->n_contours > 0)
      outline->contours[ outline->n_contours-1 ] = outline->n_points-1;

    outline->n_contours++;
    return FT_Err_Ok;
  }

  /* if a path was begun, add its first on-curve point */
  static
  FT_Error  start_point( T2_Builder*  builder,
                         FT_Pos       x,
                         FT_Pos       y )
  {
    /* test wether we're building a new contour */
    if (!builder->path_begun)
    {
      FT_Error  error;

      builder->path_begun = 1;
      error = add_contour( builder );
      if (error) return error;
    }
    return add_point1( builder, x, y );
  }


  /* close the current contour */
  static
  void  close_contour( T2_Builder*  builder )
  {
    FT_Outline*  outline = &builder->current;

    if ( outline->n_contours > 0 )
      outline->contours[outline->n_contours-1] = outline->n_points-1;
  }


/*********************************************************************
 *
 * <Function>
 *    T2_Parse_CharStrings
 *
 * <Description>
 *    Parses a given Type 1 charstrings program
 *
 * <Input>
 *    decoder          :: current Type 1 decoder
 *    charstring_base  :: base of the charstring stream
 *    charstring_len   :: length in bytes of the charstring stream
 *    num_subrs        :: number of sub-routines
 *    subrs_base       :: array of sub-routines addresses
 *    subrs_len        :: array of sub-routines lengths
 *
 * <Return>
 *    Error code. 0 means success.
 *
 *********************************************************************/

#define USE_ARGS(n)  top -= n; if (top < decoder->stack) goto Stack_Underflow


  LOCAL_FUNC
  FT_Error   T2_Parse_CharStrings( T2_Decoder*  decoder,
                                   FT_Byte*     charstring_base,
                                   FT_Int       charstring_len )
  {
    FT_Error            error;
    T2_Decoder_Zone*    zone;
    FT_Byte*            ip;
    FT_Byte*            limit;
    T2_Builder*         builder = &decoder->builder;
    FT_Outline*         outline;
    FT_Pos              x, y;
    FT_Fixed            seed;
    FT_Fixed*           stack;

    /* set default width */
    decoder->num_hints   = 0;
    decoder->read_width  = 1;
    
    /* compute random seed from stack address of parameter */
    seed                 = (FT_Fixed)(char*)&seed ^
                           (FT_Fixed)(char*)&decoder ^
                           (FT_Fixed)(char*)&charstring_base;
    seed = (seed ^ (seed >> 10) ^ (seed >> 20)) & 0xFFFF;
    if (seed == 0)
      seed = 0x7384;
    
    /* First of all, initialise the decoder */
    decoder->top  = decoder->stack;
    decoder->zone = decoder->zones;
    zone          = decoder->zones;
    stack         = decoder->top;

    builder->path_begun  = 0;

    zone->base           = charstring_base;
    limit = zone->limit  = charstring_base + charstring_len;
    ip    = zone->cursor = zone->base;

    error   = FT_Err_Ok;
    outline = &builder->current;
                                  
    x = builder->pos_x;
    y = builder->pos_y;

    /* now, execute loop */
    while ( ip < limit )
    {
      T2_Operator  op;
      FT_Byte      v;
      FT_Byte      count;

      /********************************************************************/
      /*                                                                  */
      /* Decode operator or operand                                       */
      /*                                                                  */
      /*                                                                  */
      v = *ip++;
      if (v >= 32 || v == 28)
      {
        FT_Int  shift = 16;
        FT_Long val;
        
        /* this is an operand, push it on the stack */
        if ( v == 28)
        {
          if ( ip+1 >= limit ) goto Syntax_Error;
          val = (FT_Short)(((FT_Int)ip[0] << 8) + ip[1]);
          ip += 2;
        }
        else if ( v < 247 )
          val = v - 139;
        else if ( v < 251 )
        {
          if ( ip >= limit ) goto Syntax_Error;
          val = (v-247)*256 + *ip++ + 108;
        }
        else if ( v < 255 )
        {
          if ( ip >= limit ) goto Syntax_Error;
          val = -((v-251)*256) - *ip++ - 108;
        }
        else
        {
          if ( ip + 3 >= limit ) goto Syntax_Error;
          val = ((FT_Long)ip[0] << 24) |
                ((FT_Long)ip[1] << 16) |
                ((FT_Long)ip[2] <<  8) | ip[3];
          ip    += 4;
          shift = 0;
        }
        if (decoder->top - stack >= T2_MAX_OPERANDS)
          goto Stack_Overflow;
          
        val <<= shift;
        *decoder->top ++ = val;
        
        #ifdef FT_DEBUG_LEVEL_TRACE
        if (!(val & 0xFFFF))
          FT_TRACE4(( " %d", (FT_Int)(val >> 16) ));
        else
          FT_TRACE4(( " %.2f", val/65536.0 ));
        #endif
      }
      else
      {
        FT_Fixed*  args    = decoder->top;
        FT_Int     num_args = args - decoder->stack;
        FT_Int     req_args;
        
        /* find operator */
        op = t2_op_unknown;
        switch (v)
        {
          case 1:  op = t2_op_hstem; break;
          case 3:  op = t2_op_vstem; break;
          case 4:  op = t2_op_vmoveto; break;
          case 5:  op = t2_op_rlineto; break;
          case 6:  op = t2_op_hlineto; break;
          case 7:  op = t2_op_vlineto; break;
          case 8:  op = t2_op_rrcurveto; break;
          case 10: op = t2_op_callsubr; break;
          case 11: op = t2_op_return;   break;
          case 12:
            {
              if (ip >= limit) goto Syntax_Error;
              v = *ip++;
              switch (v)
              {
                case 3:  op = t2_op_and; break;
                case 4:  op = t2_op_or; break;
                case 5:  op = t2_op_not; break;
                case 8:  op = t2_op_store; break;
                case 9:  op = t2_op_abs; break;
                case 10: op = t2_op_add; break;
                case 11: op = t2_op_sub; break;
                case 12: op = t2_op_div; break;
                case 13: op = t2_op_load; break;
                case 14: op = t2_op_neg; break;
                case 15: op = t2_op_eq; break;
                case 18: op = t2_op_drop; break;
                case 20: op = t2_op_put; break;
                case 21: op = t2_op_get; break;
                case 22: op = t2_op_ifelse; break;
                case 23: op = t2_op_random; break;
                case 24: op = t2_op_mul; break;
                case 26: op = t2_op_sqrt; break;
                case 27: op = t2_op_dup; break;
                case 28: op = t2_op_exch; break;
                case 29: op = t2_op_index; break;
                case 30: op = t2_op_roll; break;
                case 34: op = t2_op_hflex; break;
                case 35: op = t2_op_flex; break;
                case 36: op = t2_op_hflex1; break;
                case 37: op = t2_op_flex1; break;
              default:
                /* decrement ip for syntax error message */
                ip--;
              }
            }
            break;
            
          case 14: op = t2_op_endchar;   break;
          case 16: op = t2_op_blend;     break;
          case 18: op = t2_op_hstemhm; break;
          case 19: op = t2_op_hintmask; break;
          case 20: op = t2_op_cntrmask; break;
          case 21: op = t2_op_rmoveto; break;
          case 22: op = t2_op_hmoveto; break;
          case 23: op = t2_op_vstemhm; break;
          case 24: op = t2_op_rcurveline; break;
          case 25: op = t2_op_rlinecurve; break;
          case 26: op = t2_op_vvcurveto; break;
          case 27: op = t2_op_hhcurveto; break;
          case 29: op = t2_op_callgsubr; break;
          case 30: op = t2_op_vhcurveto; break;
          case 31: op = t2_op_hvcurveto; break;
          default:
            ;
        }
        if ( op == t2_op_unknown )
          goto Syntax_Error;

        /* check arguments */
        req_args = count = t2_argument_counts[op];
        if (req_args & T2_COUNT_CHECK_WIDTH)
        {
          args = stack;
          if ( decoder->read_width )
          {
            decoder->glyph_width = decoder->nominal_width + (stack[0] >> 16);
            decoder->read_width  = 0;
            num_args--;
            args++;
          }
          req_args = 0;
        }
        
        req_args &= 15;
        if (num_args < req_args) goto Stack_Underflow;
        args     -= req_args;
        num_args -= req_args;
        
        switch (op)
        {
          case t2_op_hstem:
          case t2_op_vstem:
          case t2_op_hstemhm:
          case t2_op_vstemhm:
            {
              /* if the number of arguments is no even, the first one  */
              /* is simply the glyph width.. encoded as the difference */
              /* to nominalWidthX                                      */
              FT_TRACE4(( op == t2_op_hstem ? " hstem" :
                          op == t2_op_vstem ? " vstem" :
                          op == t2_op_hstemhm ? " hstemhm" :
                          " vstemhm" ));
              decoder->num_hints += num_args/2;
              args = stack;
            }
            break;
            
          case t2_op_hintmask:
          case t2_op_cntrmask:
            {
              FT_TRACE4(( op == t2_op_hintmask ? " hintmask" : " cntrmask" ));
              decoder->num_hints += num_args/2;
              ip += (decoder->num_hints+7) >> 3;
              if (ip >= limit) goto Syntax_Error;
              args = stack;
            }
            break;
            
          case t2_op_rmoveto:
            {
              FT_TRACE4(( " rmoveto" ));
              close_contour( builder );
              builder->path_begun = 0;
              x   += args[0];
              y   += args[1];
              args = stack;
            }
            break;
          
          case t2_op_vmoveto:
            {
              FT_TRACE4(( " vmoveto" ));
              close_contour( builder );
              builder->path_begun = 0;
              y   += args[0];
              args = stack;
            }
            break;
            
          case t2_op_hmoveto:
            {
              FT_TRACE4(( " vmoveto" ));
              close_contour( builder );
              builder->path_begun = 0;
              x   += args[0];
              args = stack;
            }
            break;
            
          case t2_op_rlineto:
            {
              FT_TRACE4(( " rlineto" ));

              if ( start_point ( builder, x, y )       ||
                   check_points( builder, num_args/2 ) ) goto Memory_Error;

              if ( num_args < 2 || num_args & 1 ) goto Stack_Underflow;
              args = stack;
              while ( args < decoder->top )
              {
                x += args[0];
                y += args[1];
                add_point( builder, x, y, 1 );
                args += 2;
              }
              args = stack;
            }
            break;

          case t2_op_hlineto:
          case t2_op_vlineto:
            {
              FT_Int  phase = ( op == t2_op_hlineto );

              FT_TRACE4(( op == t2_op_hlineto ? " hlineto" : " vlineto" ));

              if ( start_point ( builder, x, y )     ||
                   check_points( builder, num_args ) ) goto Memory_Error;

              args = stack;
              while (args < decoder->top )
              {
                if (phase) x += args[0];
                      else y += args[0];
                      
                if (add_point1( builder, x, y )) goto Memory_Error;
                args++;
                phase ^= 1;
              }
              args = stack;
            }
            break;

          case t2_op_rrcurveto:
            {
              FT_TRACE4(( " rrcurveto" ));

              /* check number of arguments, must be a multiple of 6 */
              if (num_args % 6 != 0) goto Stack_Underflow;
              
              if ( start_point ( builder, x, y )       ||
                   check_points( builder, num_args/2 ) ) goto Memory_Error;
                   
              args = stack;
              while (args < decoder->top)
              {
                x += args[0];
                y += args[1];
                add_point( builder, x, y, 0 );
                x += args[2];
                y += args[3];
                add_point( builder, x, y, 0 );
                x += args[4];
                y += args[5];
                add_point( builder, x, y, 1 );
                args += 6;
              }
              args = stack;
            }
            break;
            
          case t2_op_vvcurveto:
            {
              FT_TRACE4(( " vvcurveto" ));
              
              if ( start_point ( builder, x, y ) ) goto Memory_Error;
              
              args = stack;
              if (num_args & 1)
              {
                x += args[0];
                args++;
                num_args--;
              }
              if (num_args % 4 != 0) goto Stack_Underflow;
              if (check_points( builder, 3*(num_args/4) )) goto Memory_Error;

              while (args < decoder->top)
              {
                y += args[0];
                add_point( builder, x, y, 0 );
                x += args[1];
                y += args[2];
                add_point( builder, x, y, 0 );
                y += args[3];
                add_point( builder, x, y, 1 );
                args += 4;
              }
              args = stack;
            }
            break;

          case t2_op_hhcurveto:
            {
              FT_TRACE4(( " hhcurveto" ));
              
              if ( start_point ( builder, x, y ) ) goto Memory_Error;
              args = stack;
              if (num_args & 1)
              {
                y += args[0];
                args++;
                num_args--;
              }
              if (num_args % 4 != 0) goto Stack_Underflow;
              if (check_points( builder, 3*(num_args/4) )) goto Memory_Error;

              while (args < decoder->top)
              {
                x += args[0];
                add_point( builder, x, y, 0 );
                x += args[1];
                y += args[2];
                add_point( builder, x, y, 0 );
                x += args[3];
                add_point( builder, x, y, 1 );
                args += 4;
              }
              args = stack;
            }
            break;

          case t2_op_vhcurveto:
          case t2_op_hvcurveto:
            {
              FT_Int  phase;
              
              FT_TRACE4(( op == t2_op_vhcurveto ? " vhcurveto" : " hvcurveto" ));
              
              if ( start_point ( builder, x, y ) ) goto Memory_Error;
              args = stack;
              if (num_args < 4 || (num_args % 4) > 1 ) goto Stack_Underflow;
              if (check_points( builder, (num_args/4)*3 )) goto Stack_Underflow;
              phase = ( op == t2_op_hvcurveto );
              while (num_args >= 4)
              {
                num_args -= 4;
                if (phase)
                {
                  x += args[0];
                  add_point( builder, x, y, 0 );
                  x += args[1];
                  y += args[2];
                  add_point( builder, x, y, 0 );
                  y += args[3];
                  if (num_args == 1)
                    x += args[4];
                  add_point( builder, x, y, 1 );
                }
                else
                {
                  y += args[0];
                  add_point( builder, x, y, 0 );
                  x += args[1];
                  y += args[2];
                  add_point( builder, x, y, 0 );
                  x += args[3];
                  if (num_args == 1)
                    y += args[4];
                  add_point( builder, x, y, 1 );
                }
                args     += 4;
                phase    ^= 1;
              }
              args = stack;
            }
            break;

          case t2_op_rlinecurve:
          case t2_op_rcurveline:
            {
              FT_Int  mod6 = num_args % 6;
              
              FT_TRACE4(( op == t2_op_rcurveline ? " rcurveline" :
                                                   " rlinecurve" ));
              
              if ( num_args < 8 || (mod6 != 0 && mod6 != 2) )
                goto Stack_Underflow;

              if ( start_point ( builder, x, y ) ||
                   check_points( builder, (num_args/6)*3 + mod6/2 ) )
                goto Memory_Error;
              
              args = stack;
              if (op == t2_op_rlinecurve && mod6)
              {
                x += args[0];
                y += args[1];
                add_point( builder, x, y, 1 );
                args     += 2;
                num_args -= 2;
              }
              while (num_args >= 6)
              {
                x += args[0];
                y += args[1];
                add_point( builder, x, y, 0 );
                x += args[2];
                y += args[3];
                add_point( builder, x, y, 0 );
                x += args[4];
                y += args[5];
                add_point( builder, x, y, 1 );
                args     += 6;
                num_args -= 6;
              }
              if ( op == t2_op_rcurveline && num_args)
              {
                x += args[0];
                y += args[1];
                add_point( builder, x, y, 1 );
              }
              args = stack;
            }
            break;
            
          case t2_op_endchar:
            {
              FT_TRACE4(( " endchar" ));
              close_contour( builder );
  
              /* add current outline to the glyph slot */
              builder->base.n_points   += builder->current.n_points;
              builder->base.n_contours += builder->current.n_contours;
  
              /* return now !! */
              FT_TRACE4(( "\n\n" ));
              return FT_Err_Ok;
            }
            
          case t2_op_abs:
            {
              FT_TRACE4(( " abs" ));
              if (args[0] < 0)
                args[0] = -args[0];
              args++;
            }
            break;
            
          case t2_op_add:
            {
              FT_TRACE4(( " add" ));
              args[0] += args[1];
              args++;
            }
            break;
            
          case t2_op_sub:
            {
              FT_TRACE4(( " sub" ));
              args[0] -= args[1];
              args++;
            }
            break;
          
          case t2_op_div:
            {
              FT_TRACE4(( " div" ));
              args[0] = FT_DivFix( args[0], args[1] );
              args++;
            }
            break;
          
          case t2_op_neg:
            {
              FT_TRACE4(( " neg" ));
              args[0] = -args[0];
              args++;
            }
            break;
            
          case t2_op_random:
            {
              FT_Fixed  rand;
              
              FT_TRACE4(( " rand" ));
              rand = seed;
              if (rand >= 0x8000)
                rand++;
                   
              args[0] = rand;
              seed    = FT_MulFix( seed, 0x10000 - seed );
              if (seed == 0) seed += 0x2873;
              args++;
            }
            break;
            
          case t2_op_mul:
            {
              FT_TRACE4(( " mul" ));
              args[0] = FT_MulFix( args[0], args[1] );
              args++;
            }
            break;
          
          case t2_op_sqrt:
            {
              FT_TRACE4(( " sqrt" ));
              if (args[0] > 0)
              {
                FT_Int    count = 9;
                FT_Fixed  root  = args[0];
                FT_Fixed  new_root;
                
                for (;;)
                {
                  new_root = ( root + FT_DivFix(args[0],root) + 1 ) >> 1;
                  if (new_root == root || count <= 0)
                    break;
                  root = new_root;
                }
                args[0] = new_root;
              }
              else
                args[0] = 0;
              args++;
            }
            break;
            
          case t2_op_drop:
            {
              /* nothing */
              FT_TRACE4(( " drop" ));
            }
            break;  
            
          case t2_op_exch:
            {
              FT_Fixed  tmp;
              FT_TRACE4(( " exch" ));
              tmp     = args[0];
              args[0] = args[1];
              args[1] = tmp;
              args   += 2;
            }
            break;
            
          case t2_op_index:
            {
              FT_Int  index = args[0] >> 16;
              FT_TRACE4(( " index" ));
              if (index < 0)
                index = 0;
              else if (index > num_args-2)
                index = num_args-2;
              args[0] = args[-(index+1)];
              args++;
            }
            break;
            
          case t2_op_roll:
            {
              FT_Int count = (FT_Int)(args[0] >> 16);
              FT_Int index = (FT_Int)(args[1] >> 16);
              
              FT_TRACE4(( " roll" ));
              
              if (count <= 0)
                count = 1;
                
              args -= count;
              if (args < stack) goto Stack_Underflow;
              if (index >= 0)
              {
                while (index > 0)
                {
                  FT_Fixed tmp = args[count-1];
                  FT_Int   i;
                  for ( i = count-2; i >= 0; i-- )
                    args[i+1] = args[i];
                  args[0] = tmp;
                  index--;
                }
              }
              else
              {
                while (index < 0)
                {
                  FT_Fixed  tmp = args[0];
                  FT_Int    i;
                  for ( i = 0; i < count-1; i++ )
                    args[i] = args[i+1];
                  args[count-1] = tmp;
                  index++;
                }
              }
              args += count;
            }
            break;
            
          case t2_op_dup:
            {
              FT_TRACE4(( " dup" ));
              args[1] = args[0];
              args++;
            }
            break;
            
          case t2_op_put:
            {
              FT_Fixed  val   = args[0];
              FT_Int    index = (FT_Int)(args[1] >> 16);
              
              FT_TRACE4(( " put" ));
              if (index >= 0 && index < decoder->len_buildchar)
                decoder->buildchar[index] = val;
            }
            break;
                      
          case t2_op_get:
            {
              FT_Int   index = (FT_Int)(args[0] >> 16);
              FT_Fixed val   = 0;
              FT_TRACE4(( " get" ));
              
              if (index >= 0 && index < decoder->len_buildchar)
                val = decoder->buildchar[index];
                
              args[0] = val;
              args++;
            }
            break;

         case t2_op_store:
           FT_TRACE4(( " store "));
           goto Unimplemented;
           
         case t2_op_load:
           FT_TRACE4(( " load" ));
           goto Unimplemented;

         case t2_op_and:
           {
             FT_Fixed  cond = args[0] && args[1];
             FT_TRACE4(( " and" ));
             args[0] = cond ? 0x10000 : 0;
             args++;
           }
           break;

         case t2_op_or:
           {
             FT_Fixed  cond = args[0] || args[1];
             FT_TRACE4(( " or" ));
             args[0] = cond ? 0x10000 : 0;
             args++;
           }
           break;
           
         case t2_op_eq:
           {
             FT_Fixed  cond = !args[0];
             FT_TRACE4(( " eq" ));
             args[0] = cond ? 0x10000 : 0;
             args++;
           }
           break;
           
         case t2_op_ifelse:
           {
             FT_Fixed  cond = args[2] <= args[3];
             FT_TRACE4(( " ifelse" ));
             if (!cond)
               args[0] = args[1];
             args++;
           }
           break;
         
         case t2_op_callsubr:
           {
             FT_UInt  index = (FT_UInt)((args[0] >> 16) + decoder->locals_bias);
             
             FT_TRACE4(( " callsubr(%d)", index ));
             if (index >= decoder->num_locals)
             {
               FT_ERROR(( "T2.Parse_Charstrings: invalid local subr index\n" ));
               goto Syntax_Error;
             }
             
             if ( zone - decoder->zones >= T2_MAX_SUBRS_CALLS )
             {
               FT_ERROR(( "T2.Parse_CharStrings : too many nested subrs\n" ));
               goto Syntax_Error;
             }
 
             zone->cursor = ip;  /* save current instruction pointer */
 
             zone++;
             zone->base    = decoder->locals[index];
             zone->limit   = decoder->locals[index+1];
             zone->cursor  = zone->base;
 
             if (!zone->base)
             {
               FT_ERROR(( "T2.Parse_CharStrings : invoking empty subrs !!\n" ));
               goto Syntax_Error;
             }
 
             decoder->zone = zone;
             ip            = zone->base;
             limit         = zone->limit;
           }
           break;
           
         case t2_op_callgsubr:
           {
             FT_UInt  index = (FT_UInt)((args[0] >> 16) + decoder->globals_bias);
             
             FT_TRACE4(( " callgsubr(%d)", index ));
             if (index >= decoder->num_globals)
             {
               FT_ERROR(( "T2.Parse_Charstrings: invalid global subr index\n" ));
               goto Syntax_Error;
             }

             if ( zone - decoder->zones >= T2_MAX_SUBRS_CALLS )
             {
               FT_ERROR(( "T2.Parse_CharStrings : too many nested subrs\n" ));
               goto Syntax_Error;
             }
 
             zone->cursor = ip;  /* save current instruction pointer */
 
             zone++;
             zone->base    = decoder->globals[index];
             zone->limit   = decoder->globals[index+1];
             zone->cursor  = zone->base;
 
             if (!zone->base)
             {
               FT_ERROR(( "T2.Parse_CharStrings : invoking empty subrs !!\n" ));
               goto Syntax_Error;
             }
 
             decoder->zone = zone;
             ip            = zone->base;
             limit         = zone->limit;
           }
           break;
           
         case t2_op_return:
           {
             FT_TRACE4(( " return" ));
             if ( decoder->zone <= decoder->zones )
             {
               FT_ERROR(( "T2.Parse_CharStrings : unexpected return\n" ));
               goto Syntax_Error;
             }
 
             decoder->zone--;
             zone  = decoder->zone;
             ip    = zone->cursor;
             limit = zone->limit;
           }
           break;

         default:
         
       Unimplemented:  
           FT_ERROR(( "Unimplemented opcode: %d", ip[-1] ));
           if (ip[-1] == 12)
           {
             FT_ERROR(( " %d", ip[0] ));
           }
           FT_ERROR(( "\n" ));
           return FT_Err_Unimplemented_Feature;
        }
        decoder->top = args;
        
      } /* general operator processing */

    } /* while ip < limit */
    FT_TRACE4(( "..end..\n\n" ));
    return error;

  Syntax_Error:
    return FT_Err_Invalid_File_Format;

  Stack_Underflow:
    return T2_Err_Too_Few_Arguments;

  Stack_Overflow:
    return T2_Err_Stack_Overflow;
    
  Memory_Error:
    return builder->error;
  }



  /**********************************************************************/
  /**********************************************************************/
  /**********************************************************************/
  /**********                                                   *********/
  /**********                                                   *********/
  /**********           COMPUTE THE MAXIMUM ADVANCE WIDTH       *********/
  /**********                                                   *********/
  /**********   The following code is in charge of computing    *********/
  /**********   the maximum advance width of the font. It       *********/
  /**********   quickly process each glyph charstring to        *********/
  /**********   extract the value from either a "sbw" or "seac" *********/
  /**********   operator.                                       *********/
  /**********                                                   *********/
  /**********************************************************************/
  /**********************************************************************/
  /**********************************************************************/

#if 0 /* unused until we support pure CFF fonts */
  LOCAL_FUNC
  FT_Error  T2_Compute_Max_Advance( TT_Face  face,
                                    FT_Int  *max_advance )
  {
    FT_Error    error = 0;
    T2_Decoder  decoder;
    FT_Int      glyph_index;
    CFF_Font*   cff = (CFF_Font*)face->other;

    *max_advance = 0;

    /* Initialise load decoder */
    T2_Init_Decoder( &decoder, face, 0, 0 );

    decoder.builder.metrics_only = 1;
    decoder.builder.load_points  = 0;

    /* For each glyph, parse the glyph charstring and extract */
    /* the advance width..                                    */
    for ( glyph_index = 0; glyph_index < face->root.num_glyphs; glyph_index++ )
    {
      FT_Byte*  charstring;
      FT_ULong  charstring_len;
      
      /* now get load the unscaled outline */
      error = T2_Access_Element( &cff->charstrings_index, glyph_index,
                                 &charstring, &charstring_len );
      if (!error)
      {
        error = T2_Parse_CharStrings( &decoder, charstring, charstring_len );
                                      
        T2_Forget_Element( &cff->charstrings_index, &charstring );
      }
      /* ignore the error if one occured - skip to next glyph */
      error = 0;
    }

    *max_advance = decoder.builder.advance.x;
    return FT_Err_Ok;
  }
#endif

  /**********************************************************************/
  /**********************************************************************/
  /**********************************************************************/
  /**********                                                   *********/
  /**********                                                   *********/
  /**********              UNHINTED GLYPH LOADER                *********/
  /**********                                                   *********/
  /**********   The following code is in charge of loading a    *********/
  /**********   single outline. It completely ignores hinting   *********/
  /**********   and is used when FT_LOAD_NO_HINTING is set.     *********/
  /**********                                                   *********/
  /**********************************************************************/
  /**********************************************************************/
  /**********************************************************************/


  LOCAL_FUNC
  FT_Error  T2_Load_Glyph( T2_GlyphSlot  glyph,
                           T2_Size       size,
                           FT_Int        glyph_index,
                           FT_Int        load_flags )
  {
    FT_Error        error;
    T2_Decoder      decoder;
    TT_Face         face = (TT_Face)glyph->root.face;
    FT_Bool         hinting;
    CFF_Font*       cff = (CFF_Font*)face->other;

    if (load_flags & FT_LOAD_NO_RECURSE)
      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;

    glyph->x_scale = size->metrics.x_scale;
    glyph->y_scale = size->metrics.y_scale;

    glyph->root.outline.n_points   = 0;
    glyph->root.outline.n_contours = 0;

    hinting = ( load_flags & FT_LOAD_NO_SCALE   ) == 0 &&
              ( load_flags & FT_LOAD_NO_HINTING ) == 0;

    glyph->root.format = ft_glyph_format_none;

    {
      FT_Byte*  charstring;
      FT_ULong  charstring_len;
      
      T2_Init_Decoder( &decoder, face, size, glyph );

      decoder.builder.no_recurse = (FT_Bool)!!(load_flags & FT_LOAD_NO_RECURSE);

      /* now load the unscaled outline */
      error = T2_Access_Element( &cff->charstrings_index, glyph_index,
                                 &charstring, &charstring_len );
      if (!error)
      {
        error = T2_Parse_CharStrings( &decoder, charstring, charstring_len );
                                      
        T2_Forget_Element( &cff->charstrings_index, &charstring );
      }

      /* save new glyph tables */
      T2_Done_Builder( &decoder.builder );
    }

    /* Now, set the metrics.. - this is rather simple, as : */
    /* the left side bearing is the xMin, and the top side  */
    /* bearing the yMax..                                   */
    if (!error)
    {
      /* for composite glyphs, return only the left side bearing and the */
      /* advance width..                                                 */
      if ( load_flags & FT_LOAD_NO_RECURSE )
      {
#if 0      
        glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
        glyph->root.metrics.horiAdvance  = decoder.builder.advance.x;
#else
        glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
        glyph->root.metrics.horiAdvance  = decoder.glyph_width;
#endif        
      }
      else
      {
        FT_BBox           cbox;
        FT_Glyph_Metrics* metrics = &glyph->root.metrics;

        /* copy the _unscaled_ advance width */
#if 0        
        metrics->horiAdvance  = decoder.builder.advance.x;
#else
        metrics->horiAdvance  = decoder.glyph_width;
#endif
        /* make up vertical metrics */
        metrics->vertBearingX = 0;
        metrics->vertBearingY = 0;
        metrics->vertAdvance  = 0;

        glyph->root.format = ft_glyph_format_outline;

        glyph->root.outline.flags &= ft_outline_owner;
        if ( size && size->metrics.y_ppem < 24 )
          glyph->root.outline.flags |= ft_outline_high_precision;

        glyph->root.outline.flags |= ft_outline_reverse_fill;

        /*
        glyph->root.outline.second_pass    = TRUE;
        glyph->root.outline.high_precision = ( size->root.metrics.y_ppem < 24 );
        glyph->root.outline.dropout_mode   = 2;
        */

        if ( (load_flags & FT_LOAD_NO_SCALE) == 0 )
        {
          /* scale the outline and the metrics */
          FT_Int       n;
          FT_Outline*  cur = &decoder.builder.base;
          FT_Vector*   vec = cur->points;
          FT_Fixed     x_scale = glyph->x_scale;
          FT_Fixed     y_scale = glyph->y_scale;

          /* First of all, scale the points */
          for ( n = cur->n_points; n > 0; n--, vec++ )
          {
            vec->x = FT_MulFix( vec->x, x_scale );
            vec->y = FT_MulFix( vec->y, y_scale );
          }

          FT_Outline_Get_CBox( &glyph->root.outline, &cbox );

          /* Then scale the metrics */
          metrics->horiAdvance  = FT_MulFix( metrics->horiAdvance,  x_scale );

          metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale );
          metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale );
          metrics->vertAdvance  = FT_MulFix( metrics->vertAdvance,  x_scale );
        }

        /* apply the font matrix */
        /* FT_Outline_Transform( &glyph->root.outline, cff->font_matrix ); */

        /* compute the other metrics */
        FT_Outline_Get_CBox( &glyph->root.outline, &cbox );

        /* grid fit the bounding box if necessary */
        if (hinting)
        {
          cbox.xMin &= -64;
          cbox.yMin &= -64;
          cbox.xMax = ( cbox.xMax+63 ) & -64;
          cbox.yMax = ( cbox.yMax+63 ) & -64;
        }

        metrics->width  = cbox.xMax - cbox.xMin;
        metrics->height = cbox.yMax - cbox.yMin;

        metrics->horiBearingX = cbox.xMin;
        metrics->horiBearingY = cbox.yMax;
      }
    }
    return error;
  }

/* END */