Update freetype to latest version of ASOP.

src/pshinter/pshrec.c

 /***************************************************************************/
 /*                                                                         */
 /*  pshrec.c                                                               */
 /*                                                                         */
 /*    FreeType PostScript hints recorder (body).                           */
 /*                                                                         */
-/*  Copyright 2001, 2002, 2003, 2004, 2007, 2009 by                        */
+/*  Copyright 2001-2004, 2007, 2009, 2013 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.                                        */
 /*                                                                         */
 /***************************************************************************/
 
@@ skipping 39 matching lines @@
 
 
   /* ensure that a table can contain "count" elements */
   static FT_Error
   ps_hint_table_ensure( PS_Hint_Table  table,
                         FT_UInt        count,
                         FT_Memory      memory )
   {
     FT_UInt   old_max = table->max_hints;
     FT_UInt   new_max = count;
-    FT_Error  error   = PSH_Err_Ok;
+    FT_Error  error   = FT_Err_Ok;
 
 
     if ( new_max > old_max )
     {
       /* try to grow the table */
       new_max = FT_PAD_CEIL( new_max, 8 );
       if ( !FT_RENEW_ARRAY( table->hints, old_max, new_max ) )
         table->max_hints = new_max;
     }
     return error;
   }
 
 
   static FT_Error
   ps_hint_table_alloc( PS_Hint_Table  table,
                        FT_Memory      memory,
                        PS_Hint       *ahint )
   {
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
     FT_UInt   count;
     PS_Hint   hint = 0;
 
 
     count = table->num_hints;
     count++;
 
     if ( count >= table->max_hints )
     {
       error = ps_hint_table_ensure( table, count, memory );
@@ skipping 35 matching lines @@
 
 
   /* ensure that a mask can contain "count" bits */
   static FT_Error
   ps_mask_ensure( PS_Mask    mask,
                   FT_UInt    count,
                   FT_Memory  memory )
   {
     FT_UInt   old_max = ( mask->max_bits + 7 ) >> 3;
     FT_UInt   new_max = ( count          + 7 ) >> 3;
-    FT_Error  error   = PSH_Err_Ok;
+    FT_Error  error   = FT_Err_Ok;
 
 
     if ( new_max > old_max )
     {
       new_max = FT_PAD_CEIL( new_max, 8 );
       if ( !FT_RENEW_ARRAY( mask->bytes, old_max, new_max ) )
         mask->max_bits = new_max * 8;
     }
     return error;
   }
@@ skipping 26 matching lines @@
     p[0] = (FT_Byte)( p[0] & ~( 0x80 >> ( idx & 7 ) ) );
   }
 
 
   /* set a given bit, possibly grow the mask */
   static FT_Error
   ps_mask_set_bit( PS_Mask    mask,
                    FT_Int     idx,
                    FT_Memory  memory )
   {
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
     FT_Byte*  p;
 
 
     if ( idx < 0 )
       goto Exit;
 
     if ( (FT_UInt)idx >= mask->num_bits )
     {
       error = ps_mask_ensure( mask, idx + 1, memory );
       if ( error )
@@ skipping 29 matching lines @@
 
 
   /* ensure that a mask table can contain "count" masks */
   static FT_Error
   ps_mask_table_ensure( PS_Mask_Table  table,
                         FT_UInt        count,
                         FT_Memory      memory )
   {
     FT_UInt   old_max = table->max_masks;
     FT_UInt   new_max = count;
-    FT_Error  error   = PSH_Err_Ok;
+    FT_Error  error   = FT_Err_Ok;
 
 
     if ( new_max > old_max )
     {
       new_max = FT_PAD_CEIL( new_max, 8 );
       if ( !FT_RENEW_ARRAY( table->masks, old_max, new_max ) )
         table->max_masks = new_max;
     }
     return error;
   }
 
 
   /* allocate a new mask in a table */
   static FT_Error
   ps_mask_table_alloc( PS_Mask_Table  table,
                        FT_Memory      memory,
                        PS_Mask       *amask )
   {
     FT_UInt   count;
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
     PS_Mask   mask  = 0;
 
 
     count = table->num_masks;
     count++;
 
     if ( count > table->max_masks )
     {
       error = ps_mask_table_ensure( table, count, memory );
       if ( error )
@@ skipping 10 matching lines @@
     return error;
   }
 
 
   /* return last hint mask in a table, create one if the table is empty */
   static FT_Error
   ps_mask_table_last( PS_Mask_Table  table,
                       FT_Memory      memory,
                       PS_Mask       *amask )
   {
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
     FT_UInt   count;
     PS_Mask   mask;
 
 
     count = table->num_masks;
     if ( count == 0 )
     {
       error = ps_mask_table_alloc( table, memory, &mask );
       if ( error )
         goto Exit;
     }
     else
       mask = table->masks + count - 1;
 
   Exit:
     *amask = mask;
     return error;
   }
 
 
   /* set a new mask to a given bit range */
   static FT_Error
   ps_mask_table_set_bits( PS_Mask_Table   table,
                           const FT_Byte*  source,
                           FT_UInt         bit_pos,
                           FT_UInt         bit_count,
                           FT_Memory       memory )
   {
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error;
     PS_Mask   mask;
 
 
     error = ps_mask_table_last( table, memory, &mask );
     if ( error )
       goto Exit;
 
     error = ps_mask_ensure( mask, bit_count, memory );
     if ( error )
       goto Exit;
@@ skipping 47 matching lines @@
   {
     PS_Mask   mask1  = table->masks + index1;
     PS_Mask   mask2  = table->masks + index2;
     FT_Byte*  p1     = mask1->bytes;
     FT_Byte*  p2     = mask2->bytes;
     FT_UInt   count1 = mask1->num_bits;
     FT_UInt   count2 = mask2->num_bits;
     FT_UInt   count;
 
 
-    count = ( count1 <= count2 ) ? count1 : count2;
+    count = FT_MIN( count1, count2 );
     for ( ; count >= 8; count -= 8 )
     {
       if ( p1[0] & p2[0] )
         return 1;
 
       p1++;
       p2++;
     }
 
     if ( count == 0 )
       return 0;
 
     return ( p1[0] & p2[0] ) & ~( 0xFF >> count );
   }
 
 
   /* merge two masks, used by ps_mask_table_merge_all */
   static FT_Error
   ps_mask_table_merge( PS_Mask_Table  table,
                        FT_Int         index1,
                        FT_Int         index2,
                        FT_Memory      memory )
   {
     FT_UInt   temp;
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
 
 
     /* swap index1 and index2 so that index1 < index2 */
     if ( index1 > index2 )
     {
       temp   = index1;
       index1 = index2;
       index2 = temp;
     }
 
@@ skipping 69 matching lines @@
 
 
   /* Try to merge all masks in a given table.  This is used to merge */
   /* all counter masks into independent counter "paths".             */
   /*                                                                 */
   static FT_Error
   ps_mask_table_merge_all( PS_Mask_Table  table,
                            FT_Memory      memory )
   {
     FT_Int    index1, index2;
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
 
 
     for ( index1 = table->num_masks - 1; index1 > 0; index1-- )
     {
       for ( index2 = index1 - 1; index2 >= 0; index2-- )
       {
         if ( ps_mask_table_test_intersect( table, index1, index2 ) )
         {
           error = ps_mask_table_merge( table, index2, index1, memory );
           if ( error )
@@ skipping 41 matching lines @@
 
 #if 0
 
   /* set a bit at a given index in the current hint mask */
   static FT_Error
   ps_dimension_set_mask_bit( PS_Dimension  dim,
                              FT_UInt       idx,
                              FT_Memory     memory )
   {
     PS_Mask   mask;
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
 
 
     /* get last hint mask */
     error = ps_mask_table_last( &dim->masks, memory, &mask );
     if ( error )
       goto Exit;
 
     error = ps_mask_set_bit( mask, idx, memory );
 
   Exit:
     return error;
   }
 
 #endif
 
   /* set the end point in a mask, called from "End" & "Reset" methods */
   static void
   ps_dimension_end_mask( PS_Dimension  dim,
                          FT_UInt       end_point )
   {
     FT_UInt  count = dim->masks.num_masks;
-    PS_Mask  mask;
 
 
     if ( count > 0 )
     {
-      mask            = dim->masks.masks + count - 1;
+      PS_Mask  mask = dim->masks.masks + count - 1;
+
+
       mask->end_point = end_point;
     }
   }
 
 
   /* set the end point in the current mask, then create a new empty one */
   /* (called by "Reset" method)                                         */
   static FT_Error
   ps_dimension_reset_mask( PS_Dimension  dim,
                            FT_UInt       end_point,
@@ skipping 12 matching lines @@
 
   /* set a new mask, called from the "T2Stem" method */
   static FT_Error
   ps_dimension_set_mask_bits( PS_Dimension    dim,
                               const FT_Byte*  source,
                               FT_UInt         source_pos,
                               FT_UInt         source_bits,
                               FT_UInt         end_point,
                               FT_Memory       memory )
   {
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error;
 
 
     /* reset current mask, if any */
     error = ps_dimension_reset_mask( dim, end_point, memory );
     if ( error )
       goto Exit;
 
     /* set bits in new mask */
     error = ps_mask_table_set_bits( &dim->masks, source,
                                     source_pos, source_bits, memory );
 
   Exit:
     return error;
   }
 
 
   /* add a new single stem (called from "T1Stem" method) */
   static FT_Error
   ps_dimension_add_t1stem( PS_Dimension  dim,
                            FT_Int        pos,
                            FT_Int        len,
                            FT_Memory     memory,
                            FT_Int       *aindex )
   {
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
     FT_UInt   flags = 0;
 
 
     /* detect ghost stem */
     if ( len < 0 )
     {
       flags |= PS_HINT_FLAG_GHOST;
       if ( len == -21 )
       {
         flags |= PS_HINT_FLAG_BOTTOM;
@@ skipping 50 matching lines @@
 
 
   /* add a "hstem3/vstem3" counter to our dimension table */
   static FT_Error
   ps_dimension_add_counter( PS_Dimension  dim,
                             FT_Int        hint1,
                             FT_Int        hint2,
                             FT_Int        hint3,
                             FT_Memory     memory )
   {
-    FT_Error  error   = PSH_Err_Ok;
+    FT_Error  error   = FT_Err_Ok;
     FT_UInt   count   = dim->counters.num_masks;
     PS_Mask   counter = dim->counters.masks;
 
 
     /* try to find an existing counter mask that already uses */
     /* one of these stems here                                */
     for ( ; count > 0; count--, counter++ )
     {
       if ( ps_mask_test_bit( counter, hint1 ) ||
            ps_mask_test_bit( counter, hint2 ) ||
@@ skipping 53 matching lines @@
   /* destroy hints */
   FT_LOCAL( void )
   ps_hints_done( PS_Hints  hints )
   {
     FT_Memory  memory = hints->memory;
 
 
     ps_dimension_done( &hints->dimension[0], memory );
     ps_dimension_done( &hints->dimension[1], memory );
 
-    hints->error  = PSH_Err_Ok;
+    hints->error  = FT_Err_Ok;
     hints->memory = 0;
   }
 
 
   FT_LOCAL( FT_Error )
   ps_hints_init( PS_Hints   hints,
                  FT_Memory  memory )
   {
     FT_MEM_ZERO( hints, sizeof ( *hints ) );
     hints->memory = memory;
-    return PSH_Err_Ok;
+    return FT_Err_Ok;
   }
 
 
   /* initialize a hints for a new session */
   static void
   ps_hints_open( PS_Hints      hints,
                  PS_Hint_Type  hint_type )
   {
     switch ( hint_type )
     {
     case PS_HINT_TYPE_1:
     case PS_HINT_TYPE_2:
-      hints->error     = PSH_Err_Ok;
+      hints->error     = FT_Err_Ok;
       hints->hint_type = hint_type;
 
       ps_dimension_init( &hints->dimension[0] );
       ps_dimension_init( &hints->dimension[1] );
       break;
 
     default:
-      hints->error     = PSH_Err_Invalid_Argument;
+      hints->error     = FT_THROW( Invalid_Argument );
       hints->hint_type = hint_type;
 
       FT_TRACE0(( "ps_hints_open: invalid charstring type\n" ));
       break;
     }
   }
 
 
   /* add one or more stems to the current hints table */
   static void
@@ skipping 50 matching lines @@
     }
   }
 
 
   /* add one Type1 counter stem to the current hints table */
   static void
   ps_hints_t1stem3( PS_Hints   hints,
                     FT_Int     dimension,
                     FT_Fixed*  stems )
   {
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
 
 
     if ( !hints->error )
     {
       PS_Dimension  dim;
       FT_Memory     memory = hints->memory;
       FT_Int        count;
       FT_Int        idx[3];
 
 
@@ skipping 23 matching lines @@
 
         /* now, add the hints to the counters table */
         error = ps_dimension_add_counter( dim, idx[0], idx[1], idx[2],
                                           memory );
         if ( error )
           goto Fail;
       }
       else
       {
         FT_ERROR(( "ps_hints_t1stem3: called with invalid hint type\n" ));
-        error = PSH_Err_Invalid_Argument;
+        error = FT_THROW( Invalid_Argument );
         goto Fail;
       }
     }
 
     return;
 
   Fail:
     FT_ERROR(( "ps_hints_t1stem3: could not add counter stems to table\n" ));
     hints->error = error;
   }
 
 
   /* reset hints (only with Type 1 hints) */
   static void
   ps_hints_t1reset( PS_Hints  hints,
                     FT_UInt   end_point )
   {
-    FT_Error  error = PSH_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
 
 
     if ( !hints->error )
     {
       FT_Memory  memory = hints->memory;
 
 
       if ( hints->hint_type == PS_HINT_TYPE_1 )
       {
         error = ps_dimension_reset_mask( &hints->dimension[0],
                                          end_point, memory );
         if ( error )
           goto Fail;
 
         error = ps_dimension_reset_mask( &hints->dimension[1],
                                          end_point, memory );
         if ( error )
           goto Fail;
       }
       else
       {
         /* invalid hint type */
-        error = PSH_Err_Invalid_Argument;
+        error = FT_THROW( Invalid_Argument );
         goto Fail;
       }
     }
     return;
 
   Fail:
     hints->error = error;
   }
 
 
@@ skipping 222 matching lines @@
     funcs->open    = (T2_Hints_OpenFunc)   t2_hints_open;
     funcs->close   = (T2_Hints_CloseFunc)  ps_hints_close;
     funcs->stems   = (T2_Hints_StemsFunc)  t2_hints_stems;
     funcs->hintmask= (T2_Hints_MaskFunc)   ps_hints_t2mask;
     funcs->counter = (T2_Hints_CounterFunc)ps_hints_t2counter;
     funcs->apply   = (T2_Hints_ApplyFunc)  ps_hints_apply;
   }
 
 
 /* END */