297 lines
12 KiB
C
297 lines
12 KiB
C
/*******************************************************************
|
|
*
|
|
* 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;
|
|
|
|
|
|
typedef enum T1_EncodingType_
|
|
{
|
|
encoding_none = 0,
|
|
encoding_array,
|
|
encoding_standard,
|
|
encoding_expert
|
|
|
|
} T1_EncodingType;
|
|
/*************************************************************************
|
|
*
|
|
* <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 */
|
|
|