| /******************************************************************* |
| * |
| * t1parse.h 1.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 Type1 parser component is in charge of simply parsing |
| * the font input stream and convert simple tokens and elements |
| * into integers, floats, matrices, strings, etc.. |
| * |
| * It is used by the Type1 loader.. |
| * |
| ******************************************************************/ |
| |
| #ifndef T1PARSE_H |
| #define T1PARSE_H |
| |
| #include <ftstream.h> |
| #include <t1tokens.h> |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /************************************************************************* |
| * |
| * <Enum> T1_DictState |
| * |
| * <Description> |
| * An enumeration used to describe the Type 1 parser's state, i.e. |
| * which dictionary (or array) it is scanning and processing at the |
| * current moment.. |
| * |
| */ |
| typedef enum T1_DictState_ |
| { |
| dict_none = 0, |
| dict_font, /* parsing the font dictionary */ |
| dict_fontinfo, /* parsing the font info dictionary */ |
| dict_none2, /* beginning to parse the encrypted section */ |
| dict_private, /* parsing the private dictionary */ |
| dict_encoding, /* parsing the encoding array */ |
| dict_subrs, /* parsing the subrs array */ |
| dict_othersubrs, /* parsing the othersubrs array (?) */ |
| dict_charstrings, /* parsing the charstrings dictionary */ |
| dict_unknown_array, /* parsing/ignoring an unknown array */ |
| dict_unknown_dict, /* parsing/ignoring an unknown dictionary */ |
| |
| dict_max /* do not remove from list */ |
| |
| } T1_DictState; |
| |
| |
| /************************************************************************* |
| * |
| * <Struct> T1_Table |
| * |
| * <Description> |
| * A T1_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 |
| * |
| * 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 |
| * |
| * system :: system object used for memory operations (alloc/realloc) |
| */ |
| |
| typedef struct T1_Table_ |
| { |
| T1_Byte* block; /* current memory block */ |
| T1_Int cursor; /* current cursor in memory block */ |
| T1_Int capacity; /* current size of memory block */ |
| |
| T1_Int max_elems; |
| T1_Int num_elems; |
| T1_Byte** elements; /* addresses of table elements */ |
| T1_Int* lengths; /* lengths of table elements */ |
| |
| FT_Memory memory; |
| |
| } T1_Table; |
| |
| |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Struct> T1_Parser */ |
| /* */ |
| /* <Description> */ |
| /* A Type 1 parser. This object is in charge of parsing Type 1 */ |
| /* ASCII streams and builds dictionaries for a T1_Face object. */ |
| /* */ |
| /* <Fields> */ |
| /* error :: */ |
| /* current error code. 0 means success */ |
| /* */ |
| /* face :: */ |
| /* the target T1_Face object being built */ |
| /* */ |
| /* tokenizer :: */ |
| /* the tokenizer (lexical analyser) used for processing the */ |
| /* input stream. */ |
| /* */ |
| /* stack :: */ |
| /* the current token stack. Note that we don't use intermediate */ |
| /* Postscript objects here ! */ |
| /* */ |
| /* top :: */ |
| /* current top of token stack */ |
| /* */ |
| /* limit :: */ |
| /* current upper bound of the token stack. Used for overflow */ |
| /* checks.. */ |
| /* */ |
| /* args :: */ |
| /* arguments of a given operator. used and increased by the */ |
| /* Copy.... functions.. */ |
| /* */ |
| /* state_index :: */ |
| /* index of top of the dictionary state stack */ |
| /* */ |
| /* state_stack :: */ |
| /* dictionary states stack */ |
| /* */ |
| /* table :: */ |
| /* a T1_Table object used to record various kinds of */ |
| /* dictionaries or arrays (like /Encoding, /Subrs, /CharStrings) */ |
| /* */ |
| /* */ |
| typedef struct T1_Parser_ |
| { |
| T1_Error error; |
| T1_Face face; |
| |
| T1_Tokenizer tokenizer; |
| T1_Bool dump_tokens; |
| |
| T1_Token stack[ T1_MAX_STACK_DEPTH ]; |
| T1_Token* top; |
| T1_Token* limit; |
| T1_Token* args; |
| |
| T1_Int state_index; |
| T1_DictState state_stack[ T1_MAX_DICT_DEPTH ]; |
| |
| T1_Table table; |
| |
| T1_Int cur_name; |
| |
| T1_EncodingType encoding_type; |
| T1_Byte* encoding_names; |
| T1_Int* encoding_lengths; |
| T1_Byte** encoding_offsets; |
| |
| T1_Byte* subrs; |
| T1_Byte* charstrings; |
| |
| } T1_Parser; |
| |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> T1_New_Table */ |
| /* */ |
| /* <Description> */ |
| /* Initialise a T1_Table. */ |
| /* */ |
| /* <Input> */ |
| /* table :: address of target table */ |
| /* count :: table size = maximum number of elements */ |
| /* system :: system object to use for all subsequent reallocations */ |
| /* */ |
| /* <Return> */ |
| /* Error code. 0 means success */ |
| /* */ |
| LOCAL_DEF |
| T1_Error T1_New_Table( T1_Table* table, |
| T1_Int count, |
| FT_Memory memory ); |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> T1_Add_Table */ |
| /* */ |
| /* <Description> */ |
| /* Adds an object to a T1_Table, possibly growing its memory block */ |
| /* */ |
| /* <Input> */ |
| /* table :: target table */ |
| /* index :: index of object in table */ |
| /* object :: address of object to copy in memory */ |
| /* length :: length in bytes of source object */ |
| /* */ |
| /* <Return> */ |
| /* Error code. 0 means success. An error is returned when a */ |
| /* realloc failed.. */ |
| /* */ |
| LOCAL_DEF |
| T1_Error T1_Add_Table( T1_Table* table, |
| T1_Int index, |
| void* object, |
| T1_Int length ); |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> T1_Done_Table */ |
| /* */ |
| /* <Description> */ |
| /* Finalise a T1_Table. (realloc it to its current cursor). */ |
| /* */ |
| /* <Input> */ |
| /* table :: target table */ |
| /* */ |
| /* <Note> */ |
| /* This function does NOT release the heap's memory block. It is up */ |
| /* to the caller to clean it, or reference it in its own structures. */ |
| /* */ |
| LOCAL_DEF |
| void T1_Done_Table( T1_Table* table ); |
| |
| |
| |
| |
| LOCAL_DEF |
| T1_String* CopyString( T1_Parser* parser ); |
| |
| |
| LOCAL_DEF |
| T1_Long CopyInteger( T1_Parser* parser ); |
| |
| |
| LOCAL_DEF |
| T1_Bool CopyBoolean( T1_Parser* parser ); |
| |
| |
| LOCAL_DEF |
| T1_Long CopyFloat( T1_Parser* parser, |
| T1_Int scale ); |
| |
| LOCAL_DEF |
| void CopyBBox( T1_Parser* parser, |
| T1_BBox* bbox ); |
| |
| LOCAL_DEF |
| void CopyMatrix( T1_Parser* parser, |
| T1_Matrix* matrix ); |
| |
| LOCAL_DEF |
| void CopyArray( T1_Parser* parser, |
| T1_Byte* num_elements, |
| T1_Short* elements, |
| T1_Int max_elements ); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* T1PARSE_H */ |
| |
| |
| /* END */ |
| |
