| /******************************************************************* |
| * |
| * t1parse.h 2.0 |
| * |
| * Type1 parser. |
| * |
| * Copyright 1996-1998 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. |
| * |
| * The Type 1 parser is in charge of the following: |
| * |
| * - provide an implementation of a growing sequence of |
| * objects called a Z1_Table (used to build various tables |
| * needed by the loader). |
| * |
| * - opening .pfb and .pfa files to extract their top-level |
| * and private dictionaries |
| * |
| * - read numbers, arrays & strings from any dictionary |
| * |
| * See "t1load.c" to see how data is loaded from the font file |
| * |
| ******************************************************************/ |
| |
| #ifndef Z1PARSE_H |
| #define Z1PARSE_H |
| |
| #include <freetype/internal/t1types.h> |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| |
| /* simple enumeration type used to identify token types */ |
| typedef enum Z1_Token_Type_ |
| { |
| t1_token_none = 0, |
| t1_token_any, |
| t1_token_string, |
| t1_token_array, |
| |
| /* do not remove */ |
| t1_token_max |
| |
| } Z1_Token_Type; |
| |
| /* a simple structure used to identify tokens */ |
| typedef struct Z1_Token_Rec_ |
| { |
| FT_Byte* start; /* first character of token in input stream */ |
| FT_Byte* limit; /* first character after the token */ |
| Z1_Token_Type type; /* type of token.. */ |
| |
| } Z1_Token_Rec; |
| |
| /* enumeration type used to identify object fields */ |
| typedef enum Z1_Field_Type_ |
| { |
| t1_field_none = 0, |
| t1_field_bool, |
| t1_field_integer, |
| t1_field_fixed, |
| t1_field_string, |
| t1_field_integer_array, |
| t1_field_fixed_array, |
| |
| /* do not remove */ |
| t1_field_max |
| |
| } Z1_Field_Type; |
| |
| /* structure type used to model object fields */ |
| typedef struct Z1_Field_Rec_ |
| { |
| Z1_Field_Type type; /* type of field */ |
| FT_UInt offset; /* offset of field in object */ |
| FT_UInt size; /* size of field in bytes */ |
| FT_UInt array_max; /* maximum number of elements for array */ |
| FT_UInt count_offset; /* offset of element count for arrays */ |
| FT_Int flag_bit; /* bit number for field flag */ |
| |
| } Z1_Field_Rec; |
| |
| #define Z1_FIELD_REF(s,f) (((s*)0)->f) |
| |
| #define Z1_FIELD_BOOL( _ftype, _fname ) \ |
| { t1_field_bool, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fname), \ |
| sizeof(Z1_FIELD_REF(_ftype,_fname)), \ |
| 0, 0, 0 } |
| |
| #define Z1_FIELD_NUM( _ftype, _fname ) \ |
| { t1_field_integer, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fname), \ |
| sizeof(Z1_FIELD_REF(_ftype,_fname)), \ |
| 0, 0, 0 } |
| |
| #define Z1_FIELD_FIXED( _ftype, _fname, _power ) \ |
| { t1_field_fixed, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fname), \ |
| sizeof(Z1_FIELD_REF(_ftype,_fname)), \ |
| 0, 0, 0 } |
| |
| #define Z1_FIELD_STRING( _ftype, _fname ) \ |
| { t1_field_string, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fname), \ |
| sizeof(Z1_FIELD_REF(_ftype,_fname)), \ |
| 0, 0, 0 } |
| |
| #define Z1_FIELD_NUM_ARRAY( _ftype, _fname, _fcount, _fmax ) \ |
| { t1_field_integer, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fname), \ |
| sizeof(Z1_FIELD_REF(_ftype,_fname)[0]), \ |
| _fmax, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fcount), \ |
| 0 } |
| |
| #define Z1_FIELD_FIXED_ARRAY( _ftype, _fname, _fcount, _fmax ) \ |
| { t1_field_fixed, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fname), \ |
| sizeof(Z1_FIELD_REF(_ftype,_fname)[0]), \ |
| _fmax, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fcount), \ |
| 0 } |
| |
| #define Z1_FIELD_NUM_ARRAY2( _ftype, _fname, _fmax ) \ |
| { t1_field_integer, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fname), \ |
| sizeof(Z1_FIELD_REF(_ftype,_fname)[0]), \ |
| _fmax, \ |
| 0, 0 } |
| |
| #define Z1_FIELD_FIXED_ARRAY2( _ftype, _fname, _fmax ) \ |
| { t1_field_fixed, \ |
| (FT_UInt)(char*)&Z1_FIELD_REF(_ftype,_fname), \ |
| sizeof(Z1_FIELD_REF(_ftype,_fname)[0]), \ |
| _fmax, \ |
| 0, 0 } |
| |
| |
| |
| /************************************************************************* |
| * |
| * <Struct> Z1_Table |
| * |
| * <Description> |
| * A Z1_Table is a simple object used to store an array of objects |
| * in a single memory block. |
| * |
| * <Fields> |
| * block :: address in memory of the growheap's block. This |
| * can change between two object adds, due to the use |
| * of 'realloc'. |
| * |
| * cursor :: current top of the grow heap within its block |
| * |
| * capacity :: current size of the heap block. Increments by 1 Kb |
| * |
| * init :: boolean. set when the table has been initialized |
| * (the table user should set this field) |
| * |
| * max_elems :: maximum number of elements in table |
| * num_elems :: current number of elements in table |
| * |
| * elements :: table of element addresses within the block |
| * lengths :: table of element sizes within the block |
| * |
| * memory :: memory object used for memory operations (alloc/realloc) |
| */ |
| |
| typedef struct Z1_Table_ |
| { |
| FT_Byte* block; /* current memory block */ |
| FT_Int cursor; /* current cursor in memory block */ |
| FT_Int 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_Int* lengths; /* lengths of table elements */ |
| |
| FT_Memory memory; |
| |
| } Z1_Table; |
| |
| |
| /************************************************************************* |
| * |
| * <Struct> Z1_Parser |
| * |
| * <Description> |
| * A Z1_Parser is an object used to parse a Type 1 fonts very |
| * quickly. |
| * |
| * <Fields> |
| * stream :: current input stream |
| * memory :: current memory object |
| * |
| * base_dict :: pointer to top-level dictionary |
| * base_len :: length in bytes of top dict |
| * |
| * private_dict :: pointer to private dictionary |
| * private_len :: length in bytes of private dict |
| * |
| * in_pfb :: boolean. Indicates that we're in a .pfb file |
| * in_memory :: boolean. Indicates a memory-based stream |
| * single_block :: boolean. Indicates that the private dict |
| * is stored in lieu of the base dict |
| * |
| * cursor :: current parser cursor |
| * limit :: current parser limit (first byte after current |
| * dictionary). |
| * |
| * error :: current parsing error |
| */ |
| typedef struct Z1_Parser_ |
| { |
| FT_Stream stream; |
| FT_Memory memory; |
| |
| FT_Byte* base_dict; |
| FT_Int base_len; |
| |
| FT_Byte* private_dict; |
| FT_Int private_len; |
| |
| FT_Byte in_pfb; |
| FT_Byte in_memory; |
| FT_Byte single_block; |
| |
| FT_Byte* cursor; |
| FT_Byte* limit; |
| FT_Error error; |
| |
| } Z1_Parser; |
| |
| |
| LOCAL_DEF |
| FT_Error Z1_New_Table( Z1_Table* table, |
| FT_Int count, |
| FT_Memory memory ); |
| |
| |
| LOCAL_DEF |
| FT_Error Z1_Add_Table( Z1_Table* table, |
| FT_Int index, |
| void* object, |
| FT_Int length ); |
| |
| #if 0 |
| LOCAL_DEF |
| void Z1_Done_Table( Z1_Table* table ); |
| #endif |
| |
| LOCAL_DEF |
| void Z1_Release_Table( Z1_Table* table ); |
| |
| LOCAL_DEF |
| FT_Long Z1_ToInt ( Z1_Parser* parser ); |
| |
| LOCAL_DEF |
| FT_Long Z1_ToFixed( Z1_Parser* parser, FT_Int power_ten ); |
| |
| LOCAL_DEF |
| FT_Int Z1_ToCoordArray( Z1_Parser* parser, |
| FT_Int max_coords, |
| FT_Short* coords ); |
| |
| LOCAL_DEF |
| FT_Int Z1_ToFixedArray( Z1_Parser* parser, |
| FT_Int max_values, |
| FT_Fixed* values, |
| FT_Int power_ten ); |
| |
| #if 0 |
| LOCAL_DEF |
| FT_String* Z1_ToString( Z1_Parser* parser ); |
| |
| LOCAL_DEF |
| FT_Bool Z1_ToBool( Z1_Parser* parser ); |
| #endif |
| |
| |
| |
| |
| |
| |
| LOCAL_DEF |
| void Z1_Skip_Spaces( Z1_Parser* parser ); |
| |
| LOCAL_DEF |
| void Z1_ToToken( Z1_Parser* parser, |
| Z1_Token_Rec* token ); |
| |
| LOCAL_FUNC |
| void Z1_ToTokenArray( Z1_Parser* parser, |
| Z1_Token_Rec* tokens, |
| FT_UInt max_tokens, |
| FT_Int* pnum_tokens ); |
| |
| LOCAL_DEF |
| FT_Error Z1_Load_Field( Z1_Parser* parser, |
| const Z1_Field_Rec* field, |
| void** objects, |
| FT_UInt max_objects, |
| FT_ULong* pflags ); |
| |
| LOCAL_DEF |
| FT_Error Z1_Load_Field_Table( Z1_Parser* parser, |
| const Z1_Field_Rec* field, |
| void** objects, |
| FT_UInt max_objects, |
| FT_ULong* pflags ); |
| |
| |
| LOCAL_DEF |
| FT_Error Z1_New_Parser( Z1_Parser* parser, |
| FT_Stream stream, |
| FT_Memory memory ); |
| |
| LOCAL_DEF |
| FT_Error Z1_Get_Private_Dict( Z1_Parser* parser ); |
| |
| LOCAL_DEF |
| void Z1_Decrypt( FT_Byte* buffer, |
| FT_Int length, |
| FT_UShort seed ); |
| |
| LOCAL_DEF |
| void Z1_Done_Parser( Z1_Parser* parser ); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* Z1PARSE_H */ |
| |
| |
| /* END */ |
| |