/***************************************************************************/

/*                                                                         */

/*  psaux.h                                                                */

/*                                                                         */

/*    Auxiliary functions and data structures related to PostScript fonts  */

/*    (specification).                                                     */

/*                                                                         */

/*  Copyright 1996-2001, 2002, 2003, 2004, 2006 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, FTL.TXT.  By continuing to use, modify, or distribute     */

/*  this file you indicate that you have read the license and              */

/*  understand and accept it fully.                                        */

/*                                                                         */

/***************************************************************************/

#ifndef __PSAUX_H__

#define __PSAUX_H__

#include <ft2build.h>

#include FT_INTERNAL_OBJECTS_H

#include FT_INTERNAL_TYPE1_TYPES_H

#include FT_SERVICE_POSTSCRIPT_CMAPS_H

FT_BEGIN_HEADER

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                             T1_TABLE                          *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  typedef struct PS_TableRec_*              PS_Table;

  typedef const struct PS_Table_FuncsRec_*  PS_Table_Funcs;

  /*************************************************************************/

  /*                                                                       */

  /* <Struct>                                                              */

  /*    PS_Table_FuncsRec                                                  */

  /*                                                                       */

  /* <Description>                                                         */

  /*    A set of function pointers to manage PS_Table objects.             */

  /*                                                                       */

  /* <Fields>                                                              */

  /*    table_init    :: Used to initialize a table.                       */

  /*                                                                       */

  /*    table_done    :: Finalizes resp. destroy a given table.            */

  /*                                                                       */

  /*    table_add     :: Adds a new object to a table.                     */

  /*                                                                       */

  /*    table_release :: Releases table data, then finalizes it.           */

  /*                                                                       */

  typedef struct  PS_Table_FuncsRec_

  {

    FT_Error

    (*init)( PS_Table   table,

             FT_Int     count,

             FT_Memory  memory );

    void

    (*done)( PS_Table  table );

    FT_Error

    (*add)( PS_Table    table,

            FT_Int      idx,

            void*       object,

            FT_PtrDist  length );

    void

    (*release)( PS_Table  table );

  } PS_Table_FuncsRec;

  /*************************************************************************/

  /*                                                                       */

  /* <Struct>                                                              */

  /*    PS_TableRec                                                        */

  /*                                                                       */

  /* <Description>                                                         */

  /*    A PS_Table is a simple object used to store an array of objects in */

  /*    a single memory block.                                             */

  /*                                                                       */

  /* <Fields>                                                              */

  /*    block     :: The address in memory of the growheap's block.  This  */

  /*                 can change between two object adds, due to            */

  /*                 reallocation.                                         */

  /*                                                                       */

  /*    cursor    :: The current top of the grow heap within its block.    */

  /*                                                                       */

  /*    capacity  :: The current size of the heap block.  Increments by    */

  /*                 1kByte chunks.                                        */

  /*                                                                       */

  /*    max_elems :: The maximum number of elements in table.              */

  /*                                                                       */

  /*    num_elems :: The current number of elements in table.              */

  /*                                                                       */

  /*    elements  :: A table of element addresses within the block.        */

  /*                                                                       */

  /*    lengths   :: A table of element sizes within the block.            */

  /*                                                                       */

  /*    memory    :: The object used for memory operations                 */

  /*                 (alloc/realloc).                                      */

  /*                                                                       */

  /*    funcs     :: A table of method pointers for this object.           */

  /*                                                                       */

  typedef struct  PS_TableRec_

  {

    FT_Byte*           block;          /* current memory block           */

    FT_Offset          cursor;         /* current cursor in memory block */

    FT_Offset          capacity;       /* current size of memory block   */

    FT_Long            init;

    FT_Int             max_elems;

    FT_Int             num_elems;

    FT_Byte**          elements;       /* addresses of table elements */

    FT_PtrDist*        lengths;        /* lengths of table elements   */

    FT_Memory          memory;

    PS_Table_FuncsRec  funcs;

  } PS_TableRec;

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                       T1 FIELDS & TOKENS                      *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  typedef struct PS_ParserRec_*  PS_Parser;

  typedef struct T1_TokenRec_*   T1_Token;

  typedef struct T1_FieldRec_*   T1_Field;

  /* simple enumeration type used to identify token types */

  typedef enum  T1_TokenType_

  {

    T1_TOKEN_TYPE_NONE = 0,

    T1_TOKEN_TYPE_ANY,

    T1_TOKEN_TYPE_STRING,

    T1_TOKEN_TYPE_ARRAY,

    /* do not remove */

    T1_TOKEN_TYPE_MAX

  } T1_TokenType;

  /* a simple structure used to identify tokens */

  typedef struct  T1_TokenRec_

  {

    FT_Byte*      start;   /* first character of token in input stream */

    FT_Byte*      limit;   /* first character after the token          */

    T1_TokenType  type;    /* type of token                            */

  } T1_TokenRec;

  /* enumeration type used to identify object fields */

  typedef enum  T1_FieldType_

  {

    T1_FIELD_TYPE_NONE = 0,

    T1_FIELD_TYPE_BOOL,

    T1_FIELD_TYPE_INTEGER,

    T1_FIELD_TYPE_FIXED,

    T1_FIELD_TYPE_FIXED_1000,

    T1_FIELD_TYPE_STRING,

    T1_FIELD_TYPE_KEY,

    T1_FIELD_TYPE_BBOX,

    T1_FIELD_TYPE_INTEGER_ARRAY,

    T1_FIELD_TYPE_FIXED_ARRAY,

    T1_FIELD_TYPE_CALLBACK,

    /* do not remove */

    T1_FIELD_TYPE_MAX

  } T1_FieldType;

  typedef enum  T1_FieldLocation_

  {

    T1_FIELD_LOCATION_CID_INFO,

    T1_FIELD_LOCATION_FONT_DICT,

    T1_FIELD_LOCATION_FONT_INFO,

    T1_FIELD_LOCATION_PRIVATE,

    T1_FIELD_LOCATION_BBOX,

    /* do not remove */

    T1_FIELD_LOCATION_MAX

  } T1_FieldLocation;

  typedef void

  (*T1_Field_ParseFunc)( FT_Face     face,

                         FT_Pointer  parser );

  /* structure type used to model object fields */

  typedef struct  T1_FieldRec_

  {

    const char*         ident;        /* field identifier               */

    T1_FieldLocation    location;

    T1_FieldType        type;         /* type of field                  */

    T1_Field_ParseFunc  reader;

    FT_UInt             offset;       /* offset of field in object      */

    FT_Byte             size;         /* size of field in bytes         */

    FT_UInt             array_max;    /* maximal number of elements for */

                                      /* array                          */

    FT_UInt             count_offset; /* offset of element count for    */

                                      /* arrays                         */

  } T1_FieldRec;

#define T1_NEW_SIMPLE_FIELD( _ident, _type, _fname ) \

          {                                          \

            _ident, T1CODE, _type,                   \

            0,                                       \

            FT_FIELD_OFFSET( _fname ),               \

            FT_FIELD_SIZE( _fname ),                 \

            0, 0                                     \

          },

#define T1_NEW_CALLBACK_FIELD( _ident, _reader )    \

          {                                         \

            _ident, T1CODE, T1_FIELD_TYPE_CALLBACK, \

            (T1_Field_ParseFunc)_reader,            \

            0, 0,                                   \

            0, 0                                    \

          },

#define T1_NEW_TABLE_FIELD( _ident, _type, _fname, _max ) \

          {                                               \

            _ident, T1CODE, _type,                        \

            0,                                            \

            FT_FIELD_OFFSET( _fname ),                    \

            FT_FIELD_SIZE_DELTA( _fname ),                \

            _max,                                         \

            FT_FIELD_OFFSET( num_ ## _fname )             \

          },

#define T1_NEW_TABLE_FIELD2( _ident, _type, _fname, _max ) \

          {                                                \

            _ident, T1CODE, _type,                         \

            0,                                             \

            FT_FIELD_OFFSET( _fname ),                     \

            FT_FIELD_SIZE_DELTA( _fname ),                 \

            _max, 0                                        \

          },

#define T1_FIELD_BOOL( _ident, _fname )                             \

          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_BOOL, _fname )

#define T1_FIELD_NUM( _ident, _fname )                                 \

          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER, _fname )

#define T1_FIELD_FIXED( _ident, _fname )                             \

          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_FIXED, _fname )

#define T1_FIELD_FIXED_1000( _ident, _fname )                             \

          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_FIXED_1000, _fname )

#define T1_FIELD_STRING( _ident, _fname )                             \

          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_STRING, _fname )

#define T1_FIELD_KEY( _ident, _fname )                             \

          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_KEY, _fname )

#define T1_FIELD_BBOX( _ident, _fname )                             \

          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_BBOX, _fname )

#define T1_FIELD_NUM_TABLE( _ident, _fname, _fmax )                \

          T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \

                              _fname, _fmax )

#define T1_FIELD_FIXED_TABLE( _ident, _fname, _fmax )            \

          T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \

                              _fname, _fmax )

#define T1_FIELD_NUM_TABLE2( _ident, _fname, _fmax )                \

          T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \

                               _fname, _fmax )

#define T1_FIELD_FIXED_TABLE2( _ident, _fname, _fmax )            \

          T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \

                               _fname, _fmax )

#define T1_FIELD_CALLBACK( _ident, _name )       \

          T1_NEW_CALLBACK_FIELD( _ident, _name )

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                            T1 PARSER                          *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  typedef const struct PS_Parser_FuncsRec_*  PS_Parser_Funcs;

  typedef struct  PS_Parser_FuncsRec_

  {

    void

    (*init)( PS_Parser  parser,

             FT_Byte*   base,

             FT_Byte*   limit,

             FT_Memory  memory );

    void

    (*done)( PS_Parser  parser );

    void

    (*skip_spaces)( PS_Parser  parser );

    void

    (*skip_PS_token)( PS_Parser  parser );

    FT_Long

    (*to_int)( PS_Parser  parser );

    FT_Fixed

    (*to_fixed)( PS_Parser  parser,

                 FT_Int     power_ten );

    FT_Error

    (*to_bytes)( PS_Parser  parser,

                 FT_Byte*   bytes,

                 FT_Long    max_bytes,

                 FT_Long*   pnum_bytes,

                 FT_Bool    delimiters );

    FT_Int

    (*to_coord_array)( PS_Parser  parser,

                       FT_Int     max_coords,

                       FT_Short*  coords );

    FT_Int

    (*to_fixed_array)( PS_Parser  parser,

                       FT_Int     max_values,

                       FT_Fixed*  values,

                       FT_Int     power_ten );

    void

    (*to_token)( PS_Parser  parser,

                 T1_Token   token );

    void

    (*to_token_array)( PS_Parser  parser,

                       T1_Token   tokens,

                       FT_UInt    max_tokens,

                       FT_Int*    pnum_tokens );

    FT_Error

    (*load_field)( PS_Parser       parser,

                   const T1_Field  field,

                   void**          objects,

                   FT_UInt         max_objects,

                   FT_ULong*       pflags );

    FT_Error

    (*load_field_table)( PS_Parser       parser,

                         const T1_Field  field,

                         void**          objects,

                         FT_UInt         max_objects,

                         FT_ULong*       pflags );

  } PS_Parser_FuncsRec;

  /*************************************************************************/

  /*                                                                       */

  /* <Struct>                                                              */

  /*    PS_ParserRec                                                       */

  /*                                                                       */

  /* <Description>                                                         */

  /*    A PS_Parser is an object used to parse a Type 1 font very quickly. */

  /*                                                                       */

  /* <Fields>                                                              */

  /*    cursor :: The current position in the text.                        */

  /*                                                                       */

  /*    base   :: Start of the processed text.                             */

  /*                                                                       */

  /*    limit  :: End of the processed text.                               */

  /*                                                                       */

  /*    error  :: The last error returned.                                 */

  /*                                                                       */

  /*    memory :: The object used for memory operations (alloc/realloc).   */

  /*                                                                       */

  /*    funcs  :: A table of functions for the parser.                     */

  /*                                                                       */

  typedef struct  PS_ParserRec_

  {

    FT_Byte*   cursor;

    FT_Byte*   base;

    FT_Byte*   limit;

    FT_Error   error;

    FT_Memory  memory;

    PS_Parser_FuncsRec  funcs;

  } PS_ParserRec;

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                         T1 BUILDER                            *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  typedef struct T1_BuilderRec_*  T1_Builder;

  typedef FT_Error

  (*T1_Builder_Check_Points_Func)( T1_Builder  builder,

                                   FT_Int      count );

  typedef void

  (*T1_Builder_Add_Point_Func)( T1_Builder  builder,

                                FT_Pos      x,

                                FT_Pos      y,

                                FT_Byte     flag );

  typedef FT_Error

  (*T1_Builder_Add_Point1_Func)( T1_Builder  builder,

                                 FT_Pos      x,

                                 FT_Pos      y );

  typedef FT_Error

  (*T1_Builder_Add_Contour_Func)( T1_Builder  builder );

  typedef FT_Error

  (*T1_Builder_Start_Point_Func)( T1_Builder  builder,

                                  FT_Pos      x,

                                  FT_Pos      y );

  typedef void

  (*T1_Builder_Close_Contour_Func)( T1_Builder  builder );

  typedef const struct T1_Builder_FuncsRec_*  T1_Builder_Funcs;

  typedef struct  T1_Builder_FuncsRec_

  {

    void

    (*init)( T1_Builder    builder,

             FT_Face       face,

             FT_Size       size,

             FT_GlyphSlot  slot,

             FT_Bool       hinting );

    void

    (*done)( T1_Builder   builder );

    T1_Builder_Check_Points_Func   check_points;

    T1_Builder_Add_Point_Func      add_point;

    T1_Builder_Add_Point1_Func     add_point1;

    T1_Builder_Add_Contour_Func    add_contour;

    T1_Builder_Start_Point_Func    start_point;

    T1_Builder_Close_Contour_Func  close_contour;

  } T1_Builder_FuncsRec;

  /* an enumeration type to handle charstring parsing states */

  typedef enum  T1_ParseState_

  {

    T1_Parse_Start,

    T1_Parse_Have_Width,

    T1_Parse_Have_Moveto,

    T1_Parse_Have_Path

  } T1_ParseState;

  /*************************************************************************/

  /*                                                                       */

  /* <Structure>                                                           */

  /*    T1_BuilderRec                                                      */

  /*                                                                       */

  /* <Description>                                                         */

  /*     A structure used during glyph loading to store its outline.       */

  /*                                                                       */

  /* <Fields>                                                              */

  /*    memory       :: The current memory object.                         */

  /*                                                                       */

  /*    face         :: The current face object.                           */

  /*                                                                       */

  /*    glyph        :: The current glyph slot.                            */

  /*                                                                       */

  /*    loader       :: XXX                                                */

  /*                                                                       */

  /*    base         :: The base glyph outline.                            */

  /*                                                                       */

  /*    current      :: The current glyph outline.                         */

  /*                                                                       */

  /*    max_points   :: maximum points in builder outline                  */

  /*                                                                       */

  /*    max_contours :: Maximal number of contours in builder outline.     */

  /*                                                                       */

  /*    last         :: The last point position.                           */

  /*                                                                       */

  /*    scale_x      :: The horizontal scaling value (FUnits to            */

  /*                    sub-pixels).                                       */

  /*                                                                       */

  /*    scale_y      :: The vertical scaling value (FUnits to sub-pixels). */

  /*                                                                       */

  /*    pos_x        :: The horizontal translation (if composite glyph).   */

  /*                                                                       */

  /*    pos_y        :: The vertical translation (if composite glyph).     */

  /*                                                                       */

  /*    left_bearing :: The left side bearing point.                       */

  /*                                                                       */