#include "psft.h"

#include FT_INTERNAL_DEBUG_H

#include FT_SERVICE_CFF_TABLE_LOAD_H

#include "psglue.h"

#include "psfont.h"

#include "psstack.h"

#include "pshints.h"

#include "psintrp.h"

#include "pserror.h"

#include "psobjs.h"   /* for cff_random */

#include "t1decode.h" /* for t1 seac    */

#undef  FT_COMPONENT

  FT_LOCAL_DEF( void )

  cf2_hintmask_init( CF2_HintMask  hintmask,

                     FT_Error*     error )

  {

    FT_ZERO( hintmask );

    hintmask->error = error;

  }

  FT_LOCAL_DEF( FT_Bool )

  cf2_hintmask_isValid( const CF2_HintMask  hintmask )

  {

    return hintmask->isValid;

  }

  FT_LOCAL_DEF( FT_Bool )

  cf2_hintmask_isNew( const CF2_HintMask  hintmask )

  {

    return hintmask->isNew;

  }

  FT_LOCAL_DEF( void )

  cf2_hintmask_setNew( CF2_HintMask  hintmask,

                       FT_Bool       val )

  {

    hintmask->isNew = val;

  }

  /* clients call `getMaskPtr' in order to iterate */

  /* through hint mask                             */

  FT_LOCAL_DEF( FT_Byte* )

  cf2_hintmask_getMaskPtr( CF2_HintMask  hintmask )

  {

    return hintmask->mask;

  }

  static size_t

  cf2_hintmask_setCounts( CF2_HintMask  hintmask,

                          size_t        bitCount )

  {

    if ( bitCount > CF2_MAX_HINTS )

    {

      /* total of h and v stems must be <= 96 */

      CF2_SET_ERROR( hintmask->error, Invalid_Glyph_Format );

      return 0;

    }

    hintmask->bitCount  = bitCount;

    hintmask->byteCount = ( hintmask->bitCount + 7 ) / 8;

    hintmask->isValid = TRUE;

    hintmask->isNew   = TRUE;

    return bitCount;

  }

  /* consume the hintmask bytes from the charstring, advancing the src */

  /* pointer                                                           */

  static void

  cf2_hintmask_read( CF2_HintMask  hintmask,

                     CF2_Buffer    charstring,

                     size_t        bitCount )

  {

    size_t  i;

#ifndef CF2_NDEBUG

    /* these are the bits in the final mask byte that should be zero  */

    /* Note: this variable is only used in an assert expression below */

    /* and then only if CF2_NDEBUG is not defined                     */

    CF2_UInt  mask = ( 1 << ( -(CF2_Int)bitCount & 7 ) ) - 1;

#endif

    /* initialize counts and isValid */

    if ( cf2_hintmask_setCounts( hintmask, bitCount ) == 0 )

      return;

    FT_ASSERT( hintmask->byteCount > 0 );

    FT_TRACE4(( " (maskbytes:" ));

    /* set mask and advance interpreter's charstring pointer */

    for ( i = 0; i < hintmask->byteCount; i++ )

    {

      hintmask->mask[i] = (FT_Byte)cf2_buf_readByte( charstring );

      FT_TRACE4(( " 0x%02X", hintmask->mask[i] ));

    }

    FT_TRACE4(( ")\n" ));

    /* assert any unused bits in last byte are zero unless there's a prior */

    /* error                                                               */

    /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1      */

#ifndef CF2_NDEBUG

    FT_ASSERT( ( hintmask->mask[hintmask->byteCount - 1] & mask ) == 0 ||

               *hintmask->error                                        );

#endif

  }

  FT_LOCAL_DEF( void )

  cf2_hintmask_setAll( CF2_HintMask  hintmask,

                       size_t        bitCount )

  {

    size_t    i;

    CF2_UInt  mask = ( 1 << ( -(CF2_Int)bitCount & 7 ) ) - 1;

    /* initialize counts and isValid */

    if ( cf2_hintmask_setCounts( hintmask, bitCount ) == 0 )

      return;

    FT_ASSERT( hintmask->byteCount > 0 );

    FT_ASSERT( hintmask->byteCount <=

                 sizeof ( hintmask->mask ) / sizeof ( hintmask->mask[0] ) );

    /* set mask to all ones */

    for ( i = 0; i < hintmask->byteCount; i++ )

      hintmask->mask[i] = 0xFF;

    /* clear unused bits                                              */

    /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1 */

    hintmask->mask[hintmask->byteCount - 1] &= ~mask;

  }

  /* Type2 charstring opcodes */

  enum

  {

    cf2_cmdRESERVED_0,   /* 0 */

    cf2_cmdHSTEM,        /* 1 */

    cf2_cmdRESERVED_2,   /* 2 */

    cf2_cmdVSTEM,        /* 3 */

    cf2_cmdVMOVETO,      /* 4 */

    cf2_cmdRLINETO,      /* 5 */

    cf2_cmdHLINETO,      /* 6 */

    cf2_cmdVLINETO,      /* 7 */

    cf2_cmdRRCURVETO,    /* 8 */

    cf2_cmdCLOSEPATH,    /* 9      T1 only */

    cf2_cmdCALLSUBR,     /* 10 */

    cf2_cmdRETURN,       /* 11 */

    cf2_cmdESC,          /* 12 */

    cf2_cmdHSBW,         /* 13     T1 only */

    cf2_cmdENDCHAR,      /* 14 */

    cf2_cmdVSINDEX,      /* 15 */

    cf2_cmdBLEND,        /* 16 */

    cf2_cmdRESERVED_17,  /* 17 */

    cf2_cmdHSTEMHM,      /* 18 */

    cf2_cmdHINTMASK,     /* 19 */

    cf2_cmdCNTRMASK,     /* 20 */

    cf2_cmdRMOVETO,      /* 21 */

    cf2_cmdHMOVETO,      /* 22 */

    cf2_cmdVSTEMHM,      /* 23 */

    cf2_cmdRCURVELINE,   /* 24 */

    cf2_cmdRLINECURVE,   /* 25 */

    cf2_cmdVVCURVETO,    /* 26 */

    cf2_cmdHHCURVETO,    /* 27 */

    cf2_cmdEXTENDEDNMBR, /* 28 */

    cf2_cmdCALLGSUBR,    /* 29 */

    cf2_cmdVHCURVETO,    /* 30 */

    cf2_cmdHVCURVETO     /* 31 */

  };

  enum

  {

    cf2_escDOTSECTION,   /* 0 */

    cf2_escVSTEM3,       /* 1      T1 only */

    cf2_escHSTEM3,       /* 2      T1 only */

    cf2_escAND,          /* 3 */

    cf2_escOR,           /* 4 */

    cf2_escNOT,          /* 5 */

    cf2_escSEAC,         /* 6      T1 only */

    cf2_escSBW,          /* 7      T1 only */

    cf2_escRESERVED_8,   /* 8 */

    cf2_escABS,          /* 9 */

    cf2_escADD,          /* 10     like otherADD */

    cf2_escSUB,          /* 11     like otherSUB */

    cf2_escDIV,          /* 12 */

    cf2_escRESERVED_13,  /* 13 */

    cf2_escNEG,          /* 14 */

    cf2_escEQ,           /* 15 */

    cf2_escCALLOTHERSUBR,/* 16     T1 only */

    cf2_escPOP,          /* 17     T1 only */

    cf2_escDROP,         /* 18 */

    cf2_escRESERVED_19,  /* 19 */

    cf2_escPUT,          /* 20     like otherPUT    */

    cf2_escGET,          /* 21     like otherGET    */

    cf2_escIFELSE,       /* 22     like otherIFELSE */

    cf2_escRANDOM,       /* 23     like otherRANDOM */

    cf2_escMUL,          /* 24     like otherMUL    */

    cf2_escRESERVED_25,  /* 25 */

    cf2_escSQRT,         /* 26 */

    cf2_escDUP,          /* 27     like otherDUP    */

    cf2_escEXCH,         /* 28     like otherEXCH   */

    cf2_escINDEX,        /* 29 */

    cf2_escROLL,         /* 30 */

    cf2_escRESERVED_31,  /* 31 */

    cf2_escRESERVED_32,  /* 32 */

    cf2_escSETCURRENTPT, /* 33     T1 only */

    cf2_escHFLEX,        /* 34 */

    cf2_escFLEX,         /* 35 */

    cf2_escHFLEX1,       /* 36 */

    cf2_escFLEX1,        /* 37 */

    cf2_escRESERVED_38   /* 38     & all higher     */

  };

  /* `stemHintArray' does not change once we start drawing the outline. */

  static void

  cf2_doStems( const CF2_Font  font,

               CF2_Stack       opStack,

               CF2_ArrStack    stemHintArray,

               CF2_Fixed*      width,

               FT_Bool*        haveWidth,

               CF2_Fixed       hintOffset )

  {

    CF2_UInt  i;

    CF2_UInt  count       = cf2_stack_count( opStack );

    /* variable accumulates delta values from operand stack */

    CF2_Fixed  position = hintOffset;

    if ( font->isT1 && !font->decoder->flex_state && !*haveWidth )

      FT_ERROR(( "cf2_doStems (Type 1 mode):"

                 " No width. Use hsbw/sbw as first op\n" ));

    if ( !font->isT1 && hasWidthArg && !*haveWidth )

      *width = ADD_INT32( cf2_stack_getReal( opStack, 0 ),

                          cf2_getNominalWidthX( font->decoder ) );

    if ( font->decoder->width_only )

      goto exit;

    for ( i = hasWidthArg ? 1 : 0; i < count; i += 2 )

    {

      /* construct a CF2_StemHint and push it onto the list */

      CF2_StemHintRec  stemhint;

      stemhint.min =

      position     = ADD_INT32( position,

                                cf2_stack_getReal( opStack, i ) );

      stemhint.max =

      position     = ADD_INT32( position,

                                cf2_stack_getReal( opStack, i + 1 ) );

      stemhint.used  = FALSE;

      stemhint.maxDS =

      stemhint.minDS = 0;

      cf2_arrstack_push( stemHintArray, &stemhint ); /* defer error check */

    }

    cf2_stack_clear( opStack );

  exit:

    /* cf2_doStems must define a width (may be default) */

    *haveWidth = TRUE;

  }

  static void

  cf2_doFlex( CF2_Stack       opStack,

              CF2_Fixed*      curX,

              CF2_Fixed*      curY,

              CF2_GlyphPath   glyphPath,

              const FT_Bool*  readFromStack,

              FT_Bool         doConditionalLastRead )

  {

    CF2_Fixed  vals[14];

    CF2_UInt   idx;

    FT_Bool    isHFlex;

    CF2_Int    top, i, j;

    vals[0] = *curX;

    vals[1] = *curY;

    idx     = 0;

    isHFlex = FT_BOOL( readFromStack[9] == FALSE );

    top     = isHFlex ? 9 : 10;

    for ( i = 0; i < top; i++ )

    {

      vals[i + 2] = vals[i];

      if ( readFromStack[i] )

        vals[i + 2] = ADD_INT32( vals[i + 2], cf2_stack_getReal( opStack,

                                                                 idx++ ) );

    }

    if ( isHFlex )

      vals[9 + 2] = *curY;

    if ( doConditionalLastRead )

    {

                             cf2_fixedAbs( SUB_INT32( vals[10], *curX ) ) >

                             cf2_fixedAbs( SUB_INT32( vals[11], *curY ) ) );

      CF2_Fixed  lastVal = cf2_stack_getReal( opStack, idx );

      if ( lastIsX )

      {

        vals[12] = ADD_INT32( vals[10], lastVal );

        vals[13] = *curY;

      }

      else

      {

        vals[12] = *curX;

        vals[13] = ADD_INT32( vals[11], lastVal );

      }

    }

    else

    {

      if ( readFromStack[10] )

        vals[12] = ADD_INT32( vals[10],

                              cf2_stack_getReal( opStack, idx++ ) );

      else

        vals[12] = *curX;

      if ( readFromStack[11] )

        vals[13] = ADD_INT32( vals[11],

                              cf2_stack_getReal( opStack, idx ) );

      else

        vals[13] = *curY;

    }

    for ( j = 0; j < 2; j++ )

      cf2_glyphpath_curveTo( glyphPath, vals[j * 6 + 2],

                                        vals[j * 6 + 3],

                                        vals[j * 6 + 4],

                                        vals[j * 6 + 5],

                                        vals[j * 6 + 6],

                                        vals[j * 6 + 7] );

    cf2_stack_clear( opStack );

    *curX = vals[12];

    *curY = vals[13];

  }

  /* Blend numOperands on the stack,                */

  /* store results into the first numBlends values, */

  /* then pop remaining arguments.                  */

  static void

  cf2_doBlend( const CFF_Blend  blend,

               CF2_Stack        opStack,

               CF2_UInt         numBlends )

  {

    CF2_UInt  delta;

    CF2_UInt  base;

    CF2_UInt  i, j;

    CF2_UInt  numOperands = (CF2_UInt)( numBlends * blend->lenBV );

    base  = cf2_stack_count( opStack ) - numOperands;

    delta = base + numBlends;

    for ( i = 0; i < numBlends; i++ )

    {

      const CF2_Fixed*  weight = &blend->BV[1];

      /* start with first term */

      CF2_Fixed  sum = cf2_stack_getReal( opStack, i + base );

      for ( j = 1; j < blend->lenBV; j++ )

        sum = ADD_INT32( sum,

                         FT_MulFix( *weight++,

                                    cf2_stack_getReal( opStack,

                                                       delta++ ) ) );

      /* store blended result  */

      cf2_stack_setReal( opStack, i + base, sum );

    }

    /* leave only `numBlends' results on stack */

    cf2_stack_pop( opStack, numOperands - numBlends );

  }

  /*

   * `error' is a shared error code used by many objects in this

   * routine.  Before the code continues from an error, it must check and

   * record the error in `*error'.  The idea is that this shared

   * error code will record the first error encountered.  If testing

   * for an error anyway, the cost of `goto exit' is small, so we do it,

   * even if continuing would be safe.  In this case, `lastError' is

   * set, so the testing and storing can be done in one place, at `exit'.

   *

   * Continuing after an error is intended for objects which do their own

   * testing of `*error', e.g., array stack functions.  This allows us to

   * avoid an extra test after the call.

   *

   * Unimplemented opcodes are ignored.

   *

   */

  FT_LOCAL_DEF( void )

  cf2_interpT2CharString( CF2_Font              font,

                          CF2_Buffer            buf,

                          CF2_OutlineCallbacks  callbacks,

                          const FT_Vector*      translation,

                          FT_Bool               doingSeac,

                          CF2_Fixed             curX,

                          CF2_Fixed             curY,

                          CF2_Fixed*            width )

  {

    /* lastError is used for errors that are immediately tested */

    FT_Error  lastError = FT_Err_Ok;

    /* pointer to parsed font object */

    PS_Decoder*  decoder = font->decoder;

    FT_Error*  error  = &font->error;

    FT_Memory  memory = font->memory;

    CF2_Fixed  scaleY        = font->innerTransform.d;

    CF2_Fixed  nominalWidthX = cf2_getNominalWidthX( decoder );

    /* stuff for Type 1 */

    FT_Int   known_othersubr_result_cnt = 0;

    FT_Bool  large_int                  = FALSE;

    FT_Bool  initial_map_ready          = FALSE;

#define PS_STORAGE_SIZE 3

    CF2_F16Dot16  results[PS_STORAGE_SIZE];   /* for othersubr results */

    FT_Int        result_cnt = 0;

    /* save this for hinting seac accents */

    CF2_Fixed  hintOriginY = curY;

    CF2_Stack  opStack = NULL;

    FT_UInt    stackSize;

    FT_Byte    op1;                       /* first opcode byte */

    CF2_F16Dot16  storage[CF2_STORAGE_SIZE];    /* for `put' and `get' */

    CF2_F16Dot16  flexStore[6];                 /* for Type 1 flex     */

    /* instruction limit; 20,000,000 matches Avalon */

    FT_UInt32  instructionLimit = 20000000UL;

    CF2_ArrStackRec  subrStack;

    FT_Bool     haveWidth;

    CF2_Buffer  charstring = NULL;

    CF2_Int  charstringIndex = -1;       /* initialize to empty */

    /* TODO: placeholders for hint structures */

    /* objects used for hinting */

    CF2_ArrStackRec  hStemHintArray;

    CF2_ArrStackRec  vStemHintArray;