/***************************************************************************//*                                                                         *//*  ttobjs.c                                                               *//*                                                                         *//*    Objects manager (body).                                              *//*                                                                         *//*  Copyright 1996-2001, 2002 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 <ft2build.h>#include FT_INTERNAL_DEBUG_H#include FT_INTERNAL_CALC_H#include FT_INTERNAL_STREAM_H#include FT_TRUETYPE_IDS_H#include FT_TRUETYPE_TAGS_H#include FT_INTERNAL_SFNT_H#include FT_INTERNAL_POSTSCRIPT_NAMES_H#include "ttgload.h"#include "ttpload.h"#include "tterrors.h"#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER#include "ttinterp.h"#endif  /*************************************************************************/  /*                                                                       */  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */  /* messages during execution.                                            */  /*                                                                       */#undef  FT_COMPONENT#define FT_COMPONENT  trace_ttobjs#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER  /*************************************************************************/  /*                                                                       */  /*                       GLYPH ZONE FUNCTIONS                            */  /*                                                                       */  /*************************************************************************/  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    TT_Done_GlyphZone                                                  */  /*                                                                       */  /* <Description>                                                         */  /*    Deallocates a glyph zone.                                          */  /*                                                                       */  /* <Input>                                                               */  /*    zone :: A pointer to the target glyph zone.                        */  /*                                                                       */  FT_LOCAL_DEF( void )  TT_Done_GlyphZone( TT_GlyphZone  zone )  {    FT_Memory  memory = zone->memory;    FT_FREE( zone->contours );    FT_FREE( zone->tags );    FT_FREE( zone->cur );    FT_FREE( zone->org );    zone->max_points   = zone->n_points   = 0;    zone->max_contours = zone->n_contours = 0;  }  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    TT_New_GlyphZone                                                   */  /*                                                                       */  /* <Description>                                                         */  /*    Allocates a new glyph zone.                                        */  /*                                                                       */  /* <Input>                                                               */  /*    memory      :: A handle to the current memory object.              */  /*                                                                       */  /*    maxPoints   :: The capacity of glyph zone in points.               */  /*                                                                       */  /*    maxContours :: The capacity of glyph zone in contours.             */  /*                                                                       */  /* <Output>                                                              */  /*    zone        :: A pointer to the target glyph zone record.          */  /*                                                                       */  /* <Return>                                                              */  /*    FreeType error code.  0 means success.                             */  /*                                                                       */  FT_LOCAL_DEF( FT_Error )  TT_New_GlyphZone( FT_Memory     memory,                    FT_UShort     maxPoints,                    FT_Short      maxContours,                    TT_GlyphZone  zone )  {    FT_Error  error;    if ( maxPoints > 0 )      maxPoints += 2;    FT_MEM_SET( zone, 0, sizeof ( *zone ) );    zone->memory = memory;    if ( FT_NEW_ARRAY( zone->org,      maxPoints * 2 ) ||         FT_NEW_ARRAY( zone->cur,      maxPoints * 2 ) ||         FT_NEW_ARRAY( zone->tags,     maxPoints     ) ||         FT_NEW_ARRAY( zone->contours, maxContours   ) )    {      TT_Done_GlyphZone( zone );    }    return error;  }#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    TT_Face_Init                                                       */  /*                                                                       */  /* <Description>                                                         */  /*    Initializes a given TrueType face object.                          */  /*                                                                       */  /* <Input>                                                               */  /*    stream     :: The source font stream.                              */  /*                                                                       */  /*    face_index :: The index of the font face in the resource.          */  /*                                                                       */  /*    num_params :: Number of additional generic parameters.  Ignored.   */  /*                                                                       */  /*    params     :: Additional generic parameters.  Ignored.             */  /*                                                                       */  /* <InOut>                                                               */  /*    face       :: The newly built face object.                         */  /*                                                                       */  /* <Return>                                                              */  /*    FreeType error code.  0 means success.                             */  /*                                                                       */  FT_LOCAL_DEF( FT_Error )  TT_Face_Init( FT_Stream      stream,                TT_Face        face,                FT_Int         face_index,                FT_Int         num_params,                FT_Parameter*  params )  {    FT_Error      error;    FT_Library    library;    SFNT_Service  sfnt;    library = face->root.driver->root.library;    sfnt    = (SFNT_Service)FT_Get_Module_Interface( library, "sfnt" );    if ( !sfnt )      goto Bad_Format;    /* create input stream from resource */    if ( FT_STREAM_SEEK( 0 ) )      goto Exit;    /* check that we have a valid TrueType file */    error = sfnt->init_face( stream, face, face_index, num_params, params );    if ( error )      goto Exit;    /* We must also be able to accept Mac/GX fonts, as well as OT ones */    if ( face->format_tag != 0x00010000L &&    /* MS fonts  */         face->format_tag != TTAG_true   )     /* Mac fonts */    {      FT_TRACE2(( "[not a valid TTF font]\n" ));      goto Bad_Format;    }    /* If we are performing a simple font format check, exit immediately */    if ( face_index < 0 )      return TT_Err_Ok;    /* Load font directory */    error = sfnt->load_face( stream, face, face_index, num_params, params );    if ( error )      goto Exit;    if ( face->root.face_flags & FT_FACE_FLAG_SCALABLE )      error = TT_Load_Locations( face, stream ) ||              TT_Load_CVT      ( face, stream ) ||              TT_Load_Programs ( face, stream );    /* initialize standard glyph loading routines */    TT_Init_Glyph_Loading( face );  Exit:    return error;  Bad_Format:    error = TT_Err_Unknown_File_Format;    goto Exit;  }  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    TT_Face_Done                                                       */  /*                                                                       */  /* <Description>                                                         */  /*    Finalizes a given face object.                                     */  /*                                                                       */  /* <Input>                                                               */  /*    face :: A pointer to the face object to destroy.                   */  /*                                                                       */  FT_LOCAL_DEF( void )  TT_Face_Done( TT_Face  face )  {    FT_Memory     memory = face->root.memory;    FT_Stream     stream = face->root.stream;    SFNT_Service  sfnt   = (SFNT_Service)face->sfnt;    /* for `extended TrueType formats' (i.e. compressed versions) */    if ( face->extra.finalizer )      face->extra.finalizer( face->extra.data );    if ( sfnt )      sfnt->done_face( face );    /* freeing the locations table */    FT_FREE( face->glyph_locations );    face->num_locations = 0;    /* freeing the CVT */    FT_FREE( face->cvt );    face->cvt_size = 0;    /* freeing the programs */    FT_FRAME_RELEASE( face->font_program );    FT_FRAME_RELEASE( face->cvt_program );    face->font_program_size = 0;    face->cvt_program_size  = 0;  }  /*************************************************************************/  /*                                                                       */  /*                           SIZE  FUNCTIONS                             */  /*                                                                       */  /*************************************************************************/  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    TT_Size_Init                                                       */  /*                                                                       */  /* <Description>                                                         */  /*    Initializes a new TrueType size object.                            */  /*                                                                       */  /* <InOut>                                                               */  /*    size :: A handle to the size object.                               */  /*                                                                       */  /* <Return>                                                              */  /*    FreeType error code.  0 means success.                             */  /*                                                                       */  FT_LOCAL_DEF( FT_Error )  TT_Size_Init( TT_Size  size )  {    FT_Error  error = TT_Err_Ok;#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER    TT_Face    face   = (TT_Face)size->root.face;    FT_Memory  memory = face->root.memory;    FT_Int     i;    TT_ExecContext  exec;    FT_UShort       n_twilight;    TT_MaxProfile*  maxp = &face->max_profile;    size->ttmetrics.valid = FALSE;    size->max_function_defs    = maxp->maxFunctionDefs;    size->max_instruction_defs = maxp->maxInstructionDefs;    size->num_function_defs    = 0;    size->num_instruction_defs = 0;    size->max_func = 0;    size->max_ins  = 0;    size->cvt_size     = face->cvt_size;    size->storage_size = maxp->maxStorage;    /* Set default metrics */    {      FT_Size_Metrics*  metrics  = &size->root.metrics;      TT_Size_Metrics*  metrics2 = &size->ttmetrics;      metrics->x_ppem = 0;      metrics->y_ppem = 0;      metrics2->rotated   = FALSE;      metrics2->stretched = FALSE;      /* set default compensation (all 0) */      for ( i = 0; i < 4; i++ )        metrics2->compensations[i] = 0;    }    /* allocate function defs, instruction defs, cvt, and storage area */    if ( FT_NEW_ARRAY( size->function_defs,    size->max_function_defs    ) ||         FT_NEW_ARRAY( size->instruction_defs, size->max_instruction_defs ) ||         FT_NEW_ARRAY( size->cvt,              size->cvt_size             ) ||         FT_NEW_ARRAY( size->storage,          size->storage_size         ) )      goto Fail_Memory;    /* reserve twilight zone */    n_twilight = maxp->maxTwilightPoints;    error = TT_New_GlyphZone( memory, n_twilight, 0, &size->twilight );    if ( error )      goto Fail_Memory;    size->twilight.n_points = n_twilight;    /* set `face->interpreter' according to the debug hook present */    {      FT_Library  library = face->root.driver->root.library;      face->interpreter = (TT_Interpreter)                            library->debug_hooks[FT_DEBUG_HOOK_TRUETYPE];      if ( !face->interpreter )        face->interpreter = (TT_Interpreter)TT_RunIns;    }    /* Fine, now execute the font program! */    exec = size->context;    /* size objects used during debugging have their own context */    if ( !size->debug )      exec = TT_New_Context( face );    if ( !exec )    {      error = TT_Err_Could_Not_Find_Context;      goto Fail_Memory;    }    size->GS = tt_default_graphics_state;    TT_Load_Context( exec, face, size );    exec->callTop   = 0;    exec->top       = 0;    exec->period    = 64;    exec->phase     = 0;    exec->threshold = 0;    {      FT_Size_Metrics*  metrics    = &exec->metrics;      TT_Size_Metrics*  tt_metrics = &exec->tt_metrics;      metrics->x_ppem   = 0;      metrics->y_ppem   = 0;      metrics->x_scale  = 0;      metrics->y_scale  = 0;      tt_metrics->ppem  = 0;      tt_metrics->scale = 0;      tt_metrics->ratio = 0x10000L;    }    exec->instruction_trap = FALSE;    exec->cvtSize = size->cvt_size;    exec->cvt     = size->cvt;    exec->F_dot_P = 0x10000L;    /* allow font program execution */    TT_Set_CodeRange( exec,                      tt_coderange_font,                      face->font_program,                      face->font_program_size );    /* disable CVT and glyph programs coderange */    TT_Clear_CodeRange( exec, tt_coderange_cvt );    TT_Clear_CodeRange( exec, tt_coderange_glyph );    if ( face->font_program_size > 0 )    {      error = TT_Goto_CodeRange( exec, tt_coderange_font, 0 );      if ( !error )        error = face->interpreter( exec );      if ( error )        goto Fail_Exec;    }    else      error = TT_Err_Ok;    TT_Save_Context( exec, size );    if ( !size->debug )