Update freetype to latest version of ASOP.

src/psaux/psobjs.c

 /***************************************************************************/
 /*                                                                         */
 /*  psobjs.c                                                               */
 /*                                                                         */
 /*    Auxiliary functions for PostScript fonts (body).                     */
 /*                                                                         */
-/*  Copyright 1996-2012 by                                                 */
+/*  Copyright 1996-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 88 matching lines @@
 
     for ( ; offset < limit; offset++ )
     {
       if ( offset[0] )
         offset[0] += delta;
     }
   }
 
 
   static FT_Error
-  reallocate_t1_table( PS_Table  table,
-                       FT_Long   new_size )
+  reallocate_t1_table( PS_Table   table,
+                       FT_Offset  new_size )
   {
     FT_Memory  memory   = table->memory;
     FT_Byte*   old_base = table->block;
     FT_Error   error;
 
 
     /* allocate new base block */
     if ( FT_ALLOC( table->block, new_size ) )
     {
       table->block = old_base;
       return error;
     }
 
     /* copy elements and shift offsets */
     if ( old_base )
     {
       FT_MEM_COPY( table->block, old_base, table->capacity );
       shift_elements( table, old_base );
       FT_FREE( old_base );
     }
 
     table->capacity = new_size;
 
-    return PSaux_Err_Ok;
+    return FT_Err_Ok;
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    ps_table_add                                                       */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Adds an object to a PS_Table, possibly growing its memory block.   */
@@ skipping 14 matching lines @@
   /*                                                                       */
   FT_LOCAL_DEF( FT_Error )
   ps_table_add( PS_Table    table,
                 FT_Int      idx,
                 void*       object,
                 FT_PtrDist  length )
   {
     if ( idx < 0 || idx >= table->max_elems )
     {
       FT_ERROR(( "ps_table_add: invalid index\n" ));
-      return PSaux_Err_Invalid_Argument;
+      return FT_THROW( Invalid_Argument );
     }
 
     if ( length < 0 )
     {
       FT_ERROR(( "ps_table_add: invalid length\n" ));
-      return PSaux_Err_Invalid_Argument;
+      return FT_THROW( Invalid_Argument );
     }
 
     /* grow the base block if needed */
     if ( table->cursor + length > table->capacity )
     {
       FT_Error    error;
       FT_Offset   new_size = table->capacity;
       FT_PtrDist  in_offset;
 
 
@@ skipping 16 matching lines @@
       if ( in_offset >= 0 )
         object = table->block + in_offset;
     }
 
     /* add the object to the base block and adjust offset */
     table->elements[idx] = table->block + table->cursor;
     table->lengths [idx] = length;
     FT_MEM_COPY( table->block + table->cursor, object, length );
 
     table->cursor += length;
-    return PSaux_Err_Ok;
+    return FT_Err_Ok;
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    ps_table_done                                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Finalizes a PS_TableRec (i.e., reallocate it to its current        */
@@ skipping 104 matching lines @@
 
   /* first character must be `(';                               */
   /* *acur is positioned at the character after the closing `)' */
 
   static FT_Error
   skip_literal_string( FT_Byte*  *acur,
                        FT_Byte*   limit )
   {
     FT_Byte*      cur   = *acur;
     FT_Int        embed = 0;
-    FT_Error      error = PSaux_Err_Invalid_File_Format;
+    FT_Error      error = FT_ERR( Invalid_File_Format );
     unsigned int  i;
 
 
     while ( cur < limit )
     {
       FT_Byte  c = *cur;
 
 
       ++cur;
 
@@ skipping 35 matching lines @@
           }
         }
       }
       else if ( c == '(' )
         embed++;
       else if ( c == ')' )
       {
         embed--;
         if ( embed == 0 )
         {
-          error = PSaux_Err_Ok;
+          error = FT_Err_Ok;
           break;
         }
       }
     }
 
     *acur = cur;
 
     return error;
   }
 
 
   /* first character must be `<' */
 
   static FT_Error
   skip_string( FT_Byte*  *acur,
                FT_Byte*   limit )
   {
     FT_Byte*  cur = *acur;
-    FT_Error  err =  PSaux_Err_Ok;
+    FT_Error  err =  FT_Err_Ok;
 
 
     while ( ++cur < limit )
     {
       /* All whitespace characters are ignored. */
       skip_spaces( &cur, limit );
       if ( cur >= limit )
         break;
 
       if ( !IS_PS_XDIGIT( *cur ) )
         break;
     }
 
     if ( cur < limit && *cur != '>' )
     {
       FT_ERROR(( "skip_string: missing closing delimiter `>'\n" ));
-      err = PSaux_Err_Invalid_File_Format;
+      err = FT_THROW( Invalid_File_Format );
     }
     else
       cur++;
 
     *acur = cur;
     return err;
   }
 
 
   /* first character must be the opening brace that */
   /* starts the procedure                           */
 
   /* NB: [ and ] need not match:                    */
   /* `/foo {[} def' is a valid PostScript fragment, */
   /* even within a Type1 font                       */
 
   static FT_Error
   skip_procedure( FT_Byte*  *acur,
                   FT_Byte*   limit )
   {
     FT_Byte*  cur;
     FT_Int    embed = 0;
-    FT_Error  error = PSaux_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
 
 
     FT_ASSERT( **acur == '{' );
 
-    for ( cur = *acur; cur < limit && error == PSaux_Err_Ok; ++cur )
+    for ( cur = *acur; cur < limit && error == FT_Err_Ok; ++cur )
     {
       switch ( *cur )
       {
       case '{':
         ++embed;
         break;
 
       case '}':
         --embed;
         if ( embed == 0 )
@@ skipping 12 matching lines @@
         break;
 
       case '%':
         skip_comment( &cur, limit );
         break;
       }
     }
 
   end:
     if ( embed != 0 )
-      error = PSaux_Err_Invalid_File_Format;
+      error = FT_THROW( Invalid_File_Format );
 
     *acur = cur;
 
     return error;
   }
 
 
   /***********************************************************************/
   /*                                                                     */
   /* All exported parsing routines handle leading whitespace and stop at */
   /* the first character which isn't part of the just handled token.     */
   /*                                                                     */
   /***********************************************************************/
 
 
   FT_LOCAL_DEF( void )
   ps_parser_skip_PS_token( PS_Parser  parser )
   {
     /* Note: PostScript allows any non-delimiting, non-whitespace        */
     /*       character in a name (PS Ref Manual, 3rd ed, p31).           */
     /*       PostScript delimiters are (, ), <, >, [, ], {, }, /, and %. */
 
     FT_Byte*  cur   = parser->cursor;
     FT_Byte*  limit = parser->limit;
-    FT_Error  error = PSaux_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
 
 
     skip_spaces( &cur, limit );             /* this also skips comments */
     if ( cur >= limit )
       goto Exit;
 
     /* self-delimiting, single-character tokens */
     if ( *cur == '[' || *cur == ']' )
     {
       cur++;
@@ skipping 27 matching lines @@
       goto Exit;
     }
 
     if ( *cur == '>' )
     {
       cur++;
       if ( cur >= limit || *cur != '>' )             /* >> */
       {
         FT_ERROR(( "ps_parser_skip_PS_token:"
                    " unexpected closing delimiter `>'\n" ));
-        error = PSaux_Err_Invalid_File_Format;
+        error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
       cur++;
       goto Exit;
     }
 
     if ( *cur == '/' )
       cur++;
 
     /* anything else */
     while ( cur < limit )
     {
       /* *cur might be invalid (e.g., ')' or '}'), but this   */
       /* is handled by the test `cur == parser->cursor' below */
       if ( IS_PS_DELIM( *cur ) )
         break;
 
       cur++;
     }
 
   Exit:
     if ( cur < limit && cur == parser->cursor )
     {
       FT_ERROR(( "ps_parser_skip_PS_token:"
                  " current token is `%c' which is self-delimiting\n"
                  "                        "
                  " but invalid at this point\n",
                  *cur ));
 
-      error = PSaux_Err_Invalid_File_Format;
+      error = FT_THROW( Invalid_File_Format );
     }
 
     parser->error  = error;
     parser->cursor = cur;
   }
 
 
   FT_LOCAL_DEF( void )
   ps_parser_skip_spaces( PS_Parser  parser )
   {
@@ skipping 26 matching lines @@
     if ( cur >= limit )
       return;
 
     switch ( *cur )
     {
       /************* check for literal string *****************/
     case '(':
       token->type  = T1_TOKEN_TYPE_STRING;
       token->start = cur;
 
-      if ( skip_literal_string( &cur, limit ) == PSaux_Err_Ok )
+      if ( skip_literal_string( &cur, limit ) == FT_Err_Ok )
         token->limit = cur;
       break;
 
       /************* check for programs/array *****************/
     case '{':
       token->type  = T1_TOKEN_TYPE_ARRAY;
       token->start = cur;
 
-      if ( skip_procedure( &cur, limit ) == PSaux_Err_Ok )
+      if ( skip_procedure( &cur, limit ) == FT_Err_Ok )
         token->limit = cur;
       break;
 
       /************* check for table/array ********************/
       /* XXX: in theory we should also look for "<<"          */
       /*      since this is semantically equivalent to "[";   */
       /*      in practice it doesn't matter (?)               */
     case '[':
       token->type  = T1_TOKEN_TYPE_ARRAY;
       embed        = 1;
@@ skipping 353 matching lines @@
 
   /* load a simple field (i.e. non-table) into the current list of objects */
 
   FT_LOCAL_DEF( FT_Error )
   ps_parser_load_field( PS_Parser       parser,
                         const T1_Field  field,
                         void**          objects,
                         FT_UInt         max_objects,
                         FT_ULong*       pflags )
   {
-    T1_TokenRec  token;
-    FT_Byte*     cur;
-    FT_Byte*     limit;
-    FT_UInt      count;
-    FT_UInt      idx;
-    FT_Error     error;
+    T1_TokenRec   token;
+    FT_Byte*      cur;
+    FT_Byte*      limit;
+    FT_UInt       count;
+    FT_UInt       idx;
+    FT_Error      error;
+    T1_FieldType  type;
 
 
     /* this also skips leading whitespace */
     ps_parser_to_token( parser, &token );
     if ( !token.type )
       goto Fail;
 
     count = 1;
     idx   = 0;
     cur   = token.start;
     limit = token.limit;
 
+    type = field->type;
+
     /* we must detect arrays in /FontBBox */
-    if ( field->type == T1_FIELD_TYPE_BBOX )
+    if ( type == T1_FIELD_TYPE_BBOX )
     {
       T1_TokenRec  token2;
       FT_Byte*     old_cur   = parser->cursor;
       FT_Byte*     old_limit = parser->limit;
 
 
       /* don't include delimiters */
       parser->cursor = token.start + 1;
       parser->limit  = token.limit - 1;
 
       ps_parser_to_token( parser, &token2 );
       parser->cursor = old_cur;
       parser->limit  = old_limit;
 
       if ( token2.type == T1_TOKEN_TYPE_ARRAY )
+      {
+        type = T1_FIELD_TYPE_MM_BBOX;
         goto FieldArray;
+      }
     }
     else if ( token.type == T1_TOKEN_TYPE_ARRAY )
     {
+      count = max_objects;
+
     FieldArray:
       /* if this is an array and we have no blend, an error occurs */
       if ( max_objects == 0 )
         goto Fail;
 
-      count = max_objects;
-      idx   = 1;
+      idx = 1;
 
       /* don't include delimiters */
       cur++;
       limit--;
     }
 
     for ( ; count > 0; count--, idx++ )
     {
       FT_Byte*    q = (FT_Byte*)objects[idx] + field->offset;
       FT_Long     val;
       FT_String*  string;
 
 
       skip_spaces( &cur, limit );
 
-      switch ( field->type )
+      switch ( type )
       {
       case T1_FIELD_TYPE_BOOL:
         val = ps_tobool( &cur, limit );
         goto Store_Integer;
 
       case T1_FIELD_TYPE_FIXED:
         val = PS_Conv_ToFixed( &cur, limit, 0 );
         goto Store_Integer;
 
       case T1_FIELD_TYPE_FIXED_1000:
@@ skipping 51 matching lines @@
             cur++;
             len -= 2;
           }
           else
           {
             FT_ERROR(( "ps_parser_load_field:"
                        " expected a name or string\n"
                        "                     "
                        " but found token of type %d instead\n",
                        token.type ));
-            error = PSaux_Err_Invalid_File_Format;
+            error = FT_THROW( Invalid_File_Format );
             goto Exit;
           }
 
           /* for this to work (FT_String**)q must have been */
           /* initialized to NULL                            */
           if ( *(FT_String**)q != NULL )
           {
             FT_TRACE0(( "ps_parser_load_field: overwriting field %s\n",
                         field->ident ));
             FT_FREE( *(FT_String**)q );
@@ skipping 16 matching lines @@
           FT_BBox*  bbox = (FT_BBox*)q;
           FT_Int    result;
 
 
           result = ps_tofixedarray( &cur, limit, 4, temp, 0 );
 
           if ( result < 0 )
           {
             FT_ERROR(( "ps_parser_load_field:"
                        " expected four integers in bounding box\n" ));
-            error = PSaux_Err_Invalid_File_Format;
+            error = FT_THROW( Invalid_File_Format );
             goto Exit;
           }
 
           bbox->xMin = FT_RoundFix( temp[0] );
           bbox->yMin = FT_RoundFix( temp[1] );
           bbox->xMax = FT_RoundFix( temp[2] );
           bbox->yMax = FT_RoundFix( temp[3] );
         }
         break;
 
+      case T1_FIELD_TYPE_MM_BBOX:
+        {
+          FT_Memory  memory = parser->memory;
+          FT_Fixed*  temp;
+          FT_Int     result;
+          FT_UInt    i;
+
+
+          if ( FT_NEW_ARRAY( temp, max_objects * 4 ) )
+            goto Exit;
+
+          for ( i = 0; i < 4; i++ )
+          {
+            result = ps_tofixedarray( &cur, limit, max_objects,
+                                      temp + i * max_objects, 0 );
+            if ( result < 0 )
+            {
+              FT_ERROR(( "ps_parser_load_field:"
+                         " expected %d integers in the %s subarray\n"
+                         "                     "
+                         " of /FontBBox in the /Blend dictionary\n",
+                         max_objects,
+                         i == 0 ? "first"
+                                : ( i == 1 ? "second"
+                                           : ( i == 2 ? "third"
+                                                      : "fourth" ) ) ));
+              error = FT_THROW( Invalid_File_Format );
+              goto Exit;
+            }
+
+            skip_spaces( &cur, limit );
+          }
+
+          for ( i = 0; i < max_objects; i++ )
+          {
+            FT_BBox*  bbox = (FT_BBox*)objects[i];
+
+
+            bbox->xMin = FT_RoundFix( temp[i                  ] );
+            bbox->yMin = FT_RoundFix( temp[i +     max_objects] );
+            bbox->xMax = FT_RoundFix( temp[i + 2 * max_objects] );
+            bbox->yMax = FT_RoundFix( temp[i + 3 * max_objects] );
+          }
+
+          FT_FREE( temp );
+        }
+        break;
+
       default:
         /* an error occurred */
         goto Fail;
       }
     }
 
 #if 0  /* obsolete -- keep for reference */
     if ( pflags )
       *pflags |= 1L << field->flag_bit;
 #else
     FT_UNUSED( pflags );
 #endif
 
-    error = PSaux_Err_Ok;
+    error = FT_Err_Ok;
 
   Exit:
     return error;
 
   Fail:
-    error = PSaux_Err_Invalid_File_Format;
+    error = FT_THROW( Invalid_File_Format );
     goto Exit;
   }
 
 
 #define T1_MAX_TABLE_ELEMENTS  32
 
 
   FT_LOCAL_DEF( FT_Error )
   ps_parser_load_field_table( PS_Parser       parser,
                               const T1_Field  field,
                               void**          objects,
                               FT_UInt         max_objects,
                               FT_ULong*       pflags )
   {
     T1_TokenRec  elements[T1_MAX_TABLE_ELEMENTS];
     T1_Token     token;
     FT_Int       num_elements;
-    FT_Error     error = PSaux_Err_Ok;
+    FT_Error     error = FT_Err_Ok;
     FT_Byte*     old_cursor;
     FT_Byte*     old_limit;
     T1_FieldRec  fieldrec = *(T1_Field)field;
 
 
     fieldrec.type = T1_FIELD_TYPE_INTEGER;
     if ( field->type == T1_FIELD_TYPE_FIXED_ARRAY ||
          field->type == T1_FIELD_TYPE_BBOX        )
       fieldrec.type = T1_FIELD_TYPE_FIXED;
 
     ps_parser_to_token_array( parser, elements,
                               T1_MAX_TABLE_ELEMENTS, &num_elements );
     if ( num_elements < 0 )
     {
-      error = PSaux_Err_Ignore;
+      error = FT_ERR( Ignore );
       goto Exit;
     }
     if ( (FT_UInt)num_elements > field->array_max )
       num_elements = field->array_max;
 
     old_cursor = parser->cursor;
     old_limit  = parser->limit;
 
     /* we store the elements count if necessary;           */
     /* we further assume that `count_offset' can't be zero */
@@ skipping 36 matching lines @@
 
   /* first character must be `<' if `delimiters' is non-zero */
 
   FT_LOCAL_DEF( FT_Error )
   ps_parser_to_bytes( PS_Parser  parser,
                       FT_Byte*   bytes,
                       FT_Offset  max_bytes,
                       FT_Long*   pnum_bytes,
                       FT_Bool    delimiters )
   {
-    FT_Error  error = PSaux_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
     FT_Byte*  cur;
 
 
     ps_parser_skip_spaces( parser );
     cur = parser->cursor;
 
     if ( cur >= parser->limit )
       goto Exit;
 
     if ( delimiters )
     {
       if ( *cur != '<' )
       {
         FT_ERROR(( "ps_parser_to_bytes: Missing starting delimiter `<'\n" ));
-        error = PSaux_Err_Invalid_File_Format;
+        error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
 
       cur++;
     }
 
     *pnum_bytes = PS_Conv_ASCIIHexDecode( &cur,
                                           parser->limit,
                                           bytes,
                                           max_bytes );
 
     if ( delimiters )
     {
       if ( cur < parser->limit && *cur != '>' )
       {
         FT_ERROR(( "ps_parser_to_bytes: Missing closing delimiter `>'\n" ));
-        error = PSaux_Err_Invalid_File_Format;
+        error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
 
       cur++;
     }
 
     parser->cursor = cur;
 
   Exit:
     return error;
@@ skipping 49 matching lines @@
 
 #endif /* 0 */
 
 
   FT_LOCAL_DEF( void )
   ps_parser_init( PS_Parser  parser,
                   FT_Byte*   base,
                   FT_Byte*   limit,
                   FT_Memory  memory )
   {
-    parser->error  = PSaux_Err_Ok;
+    parser->error  = FT_Err_Ok;
     parser->base   = base;
     parser->limit  = limit;
     parser->cursor = base;
     parser->memory = memory;
     parser->funcs  = ps_parser_funcs;
   }
 
 
   FT_LOCAL_DEF( void )
   ps_parser_done( PS_Parser  parser )
@@ skipping 152 matching lines @@
   t1_builder_add_contour( T1_Builder  builder )
   {
     FT_Outline*  outline = builder->current;
     FT_Error     error;
 
 
     /* this might happen in invalid fonts */
     if ( !outline )
     {
       FT_ERROR(( "t1_builder_add_contour: no outline to add points to\n" ));
-      return PSaux_Err_Invalid_File_Format;
+      return FT_THROW( Invalid_File_Format );
     }
 
     if ( !builder->load_points )
     {
       outline->n_contours++;
-      return PSaux_Err_Ok;
+      return FT_Err_Ok;
     }
 
     error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
     if ( !error )
     {
       if ( outline->n_contours > 0 )
         outline->contours[outline->n_contours - 1] =
           (short)( outline->n_points - 1 );
 
       outline->n_contours++;
     }
 
     return error;
   }
 
 
   /* if a path was begun, add its first on-curve point */
   FT_LOCAL_DEF( FT_Error )
   t1_builder_start_point( T1_Builder  builder,
                           FT_Pos      x,
                           FT_Pos      y )
   {
-    FT_Error  error = PSaux_Err_Invalid_File_Format;
+    FT_Error  error = FT_ERR( Invalid_File_Format );
 
 
     /* test whether we are building a new contour */
 
     if ( builder->parse_state == T1_Parse_Have_Path )
-      error = PSaux_Err_Ok;
+      error = FT_Err_Ok;
     else
     {
       builder->parse_state = T1_Parse_Have_Path;
       error = t1_builder_add_contour( builder );
       if ( !error )
         error = t1_builder_add_point1( builder, x, y );
     }
 
     return error;
   }
@@ skipping 60 matching lines @@
   {
     PS_Conv_EexecDecode( &buffer,
                          buffer + length,
                          buffer,
                          length,
                          &seed );
   }
 
 
 /* END */