src/freetype/cid/cidparse.h

/***************************************************************************/
/*                                                                         */
/*  cidparse.h                                                             */
/*                                                                         */
/*    CID-keyed Type1 parser (specification).                              */
/*                                                                         */
/*  Copyright 1996-2000 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.                                        */
/*                                                                         */
/***************************************************************************/


#ifndef CIDPARSE_H
#define CIDPARSE_H

#include <freetype/internal/t1types.h>


#ifdef __cplusplus
  extern "C" {
#endif


#if 0

  /*************************************************************************/
  /*                                                                       */
  /* <Struct>                                                              */
  /*    CID_Table                                                          */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A CID_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 the use    */
  /*                 of `realloc()'.                                       */
  /*                                                                       */
  /*    cursor    :: The current top of the growheap within its block.     */
  /*                                                                       */
  /*    capacity  :: The current size of the heap block.  Increments by    */
  /*                 blocks of 1 kByte.                                    */
  /*                                                                       */
  /*    init      :: A boolean.  Set when the table has been initialized   */
  /*                 (the table user should set this field).               */
  /*                                                                       */
  /*    max_elems :: The maximal number of elements in the table.          */
  /*                                                                       */
  /*    num_elems :: The current number of elements (in use) in the table. */
  /*                                                                       */
  /*    elements  :: A table of element addresses within the block.        */
  /*                                                                       */
  /*    lengths   :: A table of element sizes within the block.            */
  /*                                                                       */
  /*    memory    :: The memory object used for memory operations          */
  /*                 (allocation resp. reallocation).                      */
  /*                                                                       */
  typedef struct  CID_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;

  } CID_Table;


  LOCAL_DEF
  FT_Error  CID_New_Table( CID_Table*  table,
                           FT_Int      count,
                           CID_Memory  memory );

  LOCAL_DEF
  FT_Error  CID_Add_Table( CID_Table*  table,
                           FT_Int      index,
                           void*       object,
                           FT_Int      length );

  LOCAL_DEF
  void  CID_Release_Table( CID_Table*  table );

#endif /* 0 */


  /*************************************************************************/
  /*                                                                       */
  /* <Struct>                                                              */
  /*    CID_Parser                                                         */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A CID_Parser is an object used to parse a Type 1 fonts very        */
  /*    quickly.                                                           */
  /*                                                                       */
  /* <Fields>                                                              */
  /*    stream         :: The current input stream.                        */
  /*                                                                       */
  /*    memory         :: The current memory object.                       */
  /*                                                                       */
  /*    postscript     :: A pointer to the data to be parsed.              */
  /*                                                                       */
  /*    postscript_len :: The length of the data to be parsed.             */
  /*                                                                       */
  /*    data_offset    :: The start position of the binary data (i.e., the */
  /*                      end of the data to be parsed.                    */
  /*                                                                       */
  /*    cursor         :: The current parser cursor.                       */
  /*                                                                       */
  /*    limit          :: The current parser limit (i.e., the first byte   */
  /*                      after the current dictionary).                   */
  /*                                                                       */
  /*    error          :: The current parsing error.                       */
  /*                                                                       */
  /*    cid            :: A structure which holds the information about    */
  /*                      the current font.                                */
  /*                                                                       */
  /*    num_dict       :: The number of font dictionaries.                 */
  /*                                                                       */
  typedef struct CID_Parser_
  {
    FT_Stream  stream;
    FT_Memory  memory;

    FT_Byte*   postscript;
    FT_Int     postscript_len;

    FT_ULong   data_offset;

    FT_Byte*   cursor;
    FT_Byte*   limit;
    FT_Error   error;

    CID_Info*  cid;
    FT_Int     num_dict;

  } CID_Parser;


  LOCAL_DEF
  FT_Error  CID_New_Parser( CID_Parser*  parser,
                            FT_Stream    stream,
                            FT_Memory    memory );

  LOCAL_DEF
  void  CID_Done_Parser( CID_Parser*  parser );


  /*************************************************************************/
  /*                                                                       */
  /*                            PARSING ROUTINES                           */
  /*                                                                       */
  /*************************************************************************/

  LOCAL_DEF
  FT_Long  CID_ToInt( CID_Parser*  parser );

  LOCAL_DEF
  FT_Int  CID_ToCoordArray( CID_Parser*  parser,
                            FT_Int       max_coords,
                            FT_Short*    coords );

  LOCAL_DEF
  FT_Int  CID_ToFixedArray( CID_Parser*  parser,
                            FT_Int       max_values,
                            FT_Fixed*    values,
                            FT_Int       power_ten );

  LOCAL_DEF
  void  CID_Skip_Spaces( CID_Parser*  parser );


  /* simple enumeration type used to identify token types */
  typedef enum  CID_Token_Type_
  {
    t1_token_none = 0,
    t1_token_any,
    t1_token_string,
    t1_token_array,

    /* do not remove */
    t1_token_max

  } CID_Token_Type;


  /* a simple structure used to identify tokens */
  typedef struct  CID_Token_Rec_
  {
    FT_Byte*        start;   /* first character of token in input stream */
    FT_Byte*        limit;   /* first character after the token          */
    CID_Token_Type  type;    /* type of token                            */

  } CID_Token_Rec;


  LOCAL_DEF
  void  CID_ToToken( CID_Parser*     parser,
                     CID_Token_Rec*  token );


  /* enumeration type used to identify object fields */
  typedef enum  CID_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,
    t1_field_callback,

    /* do not remove */
    t1_field_max

  } CID_Field_Type;

  typedef enum  CID_Field_Location_
  {
    t1_field_cid_info,
    t1_field_font_dict,
    t1_field_font_info,
    t1_field_private,

    /* do not remove */
    t1_field_location_max

  } CID_Field_Location;


  typedef FT_Error  (*CID_Field_Parser)( CID_Face     face,
                                         CID_Parser*  parser );

  /* structure type used to model object fields */
  typedef struct  CID_Field_Rec_
  {
    const char*         ident;        /* field identifier                  */
    CID_Field_Location  location;
    CID_Field_Type      type;         /* type of field                     */
    CID_Field_Parser    reader;
    FT_UInt             offset;       /* offset of field in object         */
    FT_UInt             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                            */
  } CID_Field_Rec;


#define CID_FIELD_REF( s, f )  ( ((s*)0)->f )

#define CID_NEW_SIMPLE_FIELD( _ident, _type, _fname )         \
          {                                                   \
            _ident, T1CODE, _type,                            \
            0,                                                \
            (FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, _fname ), \
            sizeof ( CID_FIELD_REF( T1TYPE, _fname ) ),       \
            0, 0                                              \
          },

#define CID_NEW_CALLBACK_FIELD( _ident, _reader ) \
          {                                       \
            _ident, T1CODE, t1_field_callback,    \
            _reader,                              \
            0, 0,                                 \
            0, 0                                  \
          },

#define CID_NEW_TABLE_FIELD( _ident, _type, _fname, _max )           \
          {                                                          \
            _ident, T1CODE, _type,                                   \
            0,                                                       \
            (FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, _fname ),        \
            sizeof ( CID_FIELD_REF( T1TYPE, _fname )[0] ),           \
            _max,                                                    \
            (FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, num_ ## _fname ) \
          },

#define CID_NEW_TABLE_FIELD2( _ident, _type, _fname, _max )   \
          {                                                   \
            _ident, T1CODE, _type,                            \
            0,                                                \
            (FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, _fname ), \
            sizeof ( CID_FIELD_REF( T1TYPE, _fname )[0] ),    \
            _max, 0                                           \
          },


#define CID_FIELD_BOOL( _ident, _fname )                           \
          CID_NEW_SIMPLE_FIELD( _ident, t1_field_bool, _fname )

#define CID_FIELD_NUM( _ident, _fname )                            \
          CID_NEW_SIMPLE_FIELD( _ident, t1_field_integer, _fname )

#define CID_FIELD_FIXED( _ident, _fname )                          \
          CID_NEW_SIMPLE_FIELD( _ident, t1_field_fixed, _fname )

#define CID_FIELD_STRING( _ident, _fname )                         \
          CID_NEW_SIMPLE_FIELD( _ident, t1_field_string, _fname )

#define CID_FIELD_NUM_TABLE( _ident, _fname, _fmax )               \
          CID_NEW_TABLE_FIELD( _ident, t1_field_integer_array,     \
                               _fname, _fmax )

#define CID_FIELD_FIXED_TABLE( _ident, _fname, _fmax )             \
          CID_NEW_TABLE_FIELD( _ident, t1_field_fixed_array,       \
                               _fname, _fmax )

#define CID_FIELD_NUM_TABLE2( _ident, _fname, _fmax )              \
          CID_NEW_TABLE_FIELD2( _ident, t1_field_integer_array,    \
                                _fname, _fmax )

#define CID_FIELD_FIXED_TABLE2( _ident, _fname, _fmax )            \
          CID_NEW_TABLE_FIELD2( _ident, t1_field_fixed_array,      \
                                _fname, _fmax )

#define CID_FIELD_CALLBACK( _ident, _name )                        \
          CID_NEW_CALLBACK_FIELD( _ident, parse_ ## _name )


  LOCAL_DEF
  FT_Error  CID_Load_Field( CID_Parser*           parser,
                            const CID_Field_Rec*  field,
                            void*                 object );

  LOCAL_DEF
  FT_Error  CID_Load_Field_Table( CID_Parser*           parser,
                                  const CID_Field_Rec*  field,
                                  void*                 object );


#ifdef __cplusplus
  }
#endif


#endif /* CIDPARSE_H */


/* END */
Commit	Line	Data
	1	/***************************************************************************/
	2	/* */
	3	/* cidparse.h */
	4	/* */
	5	/* CID-keyed Type1 parser (specification). */
	6	/* */
	7	/* Copyright 1996-2000 by */
	8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
	9	/* */
	10	/* This file is part of the FreeType project, and may only be used, */
	11	/* modified, and distributed under the terms of the FreeType project */
	12	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
	13	/* this file you indicate that you have read the license and */
	14	/* understand and accept it fully. */
	15	/* */
	16	/***************************************************************************/
	17
	18
	19	#ifndef CIDPARSE_H
	20	#define CIDPARSE_H
	21
	22	#include <freetype/internal/t1types.h>
	23
	24
	25	#ifdef __cplusplus
	26	extern "C" {
	27	#endif
	28
	29
	30	#if 0
	31
	32	/*************************************************************************/
	33	/* */
	34	/* <Struct> */
	35	/* CID_Table */
	36	/* */
	37	/* <Description> */
	38	/* A CID_Table is a simple object used to store an array of objects */
	39	/* in a single memory block. */
	40	/* */
	41	/* <Fields> */
	42	/* block :: The address in memory of the growheap's block. This */
	43	/* can change between two object adds, due to the use */
	44	/* of `realloc()'. */
	45	/* */
	46	/* cursor :: The current top of the growheap within its block. */
	47	/* */
	48	/* capacity :: The current size of the heap block. Increments by */
	49	/* blocks of 1 kByte. */
	50	/* */
	51	/* init :: A boolean. Set when the table has been initialized */
	52	/* (the table user should set this field). */
	53	/* */
	54	/* max_elems :: The maximal number of elements in the table. */
	55	/* */
	56	/* num_elems :: The current number of elements (in use) in the table. */
	57	/* */
	58	/* elements :: A table of element addresses within the block. */
	59	/* */
	60	/* lengths :: A table of element sizes within the block. */
	61	/* */
	62	/* memory :: The memory object used for memory operations */
	63	/* (allocation resp. reallocation). */
	64	/* */
	65	typedef struct CID_Table_
	66	{
	67	FT_Byte* block; /* current memory block */
	68	FT_Int cursor; /* current cursor in memory block */
	69	FT_Int capacity; /* current size of memory block */
	70	FT_Long init;
	71
	72	FT_Int max_elems;
	73	FT_Int num_elems;
	74	FT_Byte** elements; /* addresses of table elements */
	75	FT_Int* lengths; /* lengths of table elements */
	76
	77	FT_Memory memory;
	78
	79	} CID_Table;
	80
	81
	82	LOCAL_DEF
	83	FT_Error CID_New_Table( CID_Table* table,
	84	FT_Int count,
	85	CID_Memory memory );
	86
	87	LOCAL_DEF
	88	FT_Error CID_Add_Table( CID_Table* table,
	89	FT_Int index,
	90	void* object,
	91	FT_Int length );
	92
	93	LOCAL_DEF
	94	void CID_Release_Table( CID_Table* table );
	95
	96	#endif /* 0 */
	97
	98
	99	/*************************************************************************/
	100	/* */
	101	/* <Struct> */
	102	/* CID_Parser */
	103	/* */
	104	/* <Description> */
	105	/* A CID_Parser is an object used to parse a Type 1 fonts very */
	106	/* quickly. */
	107	/* */
	108	/* <Fields> */
	109	/* stream :: The current input stream. */
	110	/* */
	111	/* memory :: The current memory object. */
	112	/* */
	113	/* postscript :: A pointer to the data to be parsed. */
	114	/* */
	115	/* postscript_len :: The length of the data to be parsed. */
	116	/* */
	117	/* data_offset :: The start position of the binary data (i.e., the */
	118	/* end of the data to be parsed. */
	119	/* */
	120	/* cursor :: The current parser cursor. */
	121	/* */
	122	/* limit :: The current parser limit (i.e., the first byte */
	123	/* after the current dictionary). */
	124	/* */
	125	/* error :: The current parsing error. */
	126	/* */
	127	/* cid :: A structure which holds the information about */
	128	/* the current font. */
	129	/* */
	130	/* num_dict :: The number of font dictionaries. */
	131	/* */
	132	typedef struct CID_Parser_
	133	{
	134	FT_Stream stream;
	135	FT_Memory memory;
	136
	137	FT_Byte* postscript;
	138	FT_Int postscript_len;
	139
	140	FT_ULong data_offset;
	141
	142	FT_Byte* cursor;
	143	FT_Byte* limit;
	144	FT_Error error;
	145
	146	CID_Info* cid;
	147	FT_Int num_dict;
	148
	149	} CID_Parser;
	150
	151
	152	LOCAL_DEF
	153	FT_Error CID_New_Parser( CID_Parser* parser,
	154	FT_Stream stream,
	155	FT_Memory memory );
	156
	157	LOCAL_DEF
	158	void CID_Done_Parser( CID_Parser* parser );
	159
	160
	161	/*************************************************************************/
	162	/* */
	163	/* PARSING ROUTINES */
	164	/* */
	165	/*************************************************************************/
	166
	167	LOCAL_DEF
	168	FT_Long CID_ToInt( CID_Parser* parser );
	169
	170	LOCAL_DEF
	171	FT_Int CID_ToCoordArray( CID_Parser* parser,
	172	FT_Int max_coords,
	173	FT_Short* coords );
	174
	175	LOCAL_DEF
	176	FT_Int CID_ToFixedArray( CID_Parser* parser,
	177	FT_Int max_values,
	178	FT_Fixed* values,
	179	FT_Int power_ten );
	180
	181	LOCAL_DEF
	182	void CID_Skip_Spaces( CID_Parser* parser );
	183
	184
	185	/* simple enumeration type used to identify token types */
	186	typedef enum CID_Token_Type_
	187	{
	188	t1_token_none = 0,
	189	t1_token_any,
	190	t1_token_string,
	191	t1_token_array,
	192
	193	/* do not remove */
	194	t1_token_max
	195
	196	} CID_Token_Type;
	197
	198
	199	/* a simple structure used to identify tokens */
	200	typedef struct CID_Token_Rec_
	201	{
	202	FT_Byte* start; /* first character of token in input stream */
	203	FT_Byte* limit; /* first character after the token */
	204	CID_Token_Type type; /* type of token */
	205
	206	} CID_Token_Rec;
	207
	208
	209	LOCAL_DEF
	210	void CID_ToToken( CID_Parser* parser,
	211	CID_Token_Rec* token );
	212
	213
	214	/* enumeration type used to identify object fields */
	215	typedef enum CID_Field_Type_
	216	{
	217	t1_field_none = 0,
	218	t1_field_bool,
	219	t1_field_integer,
	220	t1_field_fixed,
	221	t1_field_string,
	222	t1_field_integer_array,
	223	t1_field_fixed_array,
	224	t1_field_callback,
	225
	226	/* do not remove */
	227	t1_field_max
	228
	229	} CID_Field_Type;
	230
	231	typedef enum CID_Field_Location_
	232	{
	233	t1_field_cid_info,
	234	t1_field_font_dict,
	235	t1_field_font_info,
	236	t1_field_private,
	237
	238	/* do not remove */
	239	t1_field_location_max
	240
	241	} CID_Field_Location;
	242
	243
	244	typedef FT_Error (*CID_Field_Parser)( CID_Face face,
	245	CID_Parser* parser );
	246
	247	/* structure type used to model object fields */
	248	typedef struct CID_Field_Rec_
	249	{
	250	const char* ident; /* field identifier */
	251	CID_Field_Location location;
	252	CID_Field_Type type; /* type of field */
	253	CID_Field_Parser reader;
	254	FT_UInt offset; /* offset of field in object */
	255	FT_UInt size; /* size of field in bytes */
	256	FT_UInt array_max; /* maximal number of elements for */
	257	/* array */
	258	FT_UInt count_offset; /* offset of element count for */
	259	/* arrays */
	260	} CID_Field_Rec;
	261
	262
	263	#define CID_FIELD_REF( s, f ) ( ((s*)0)->f )
	264
	265	#define CID_NEW_SIMPLE_FIELD( _ident, _type, _fname ) \
	266	{ \
	267	_ident, T1CODE, _type, \
	268	0, \
	269	(FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, _fname ), \
	270	sizeof ( CID_FIELD_REF( T1TYPE, _fname ) ), \
	271	0, 0 \
	272	},
	273
	274	#define CID_NEW_CALLBACK_FIELD( _ident, _reader ) \
	275	{ \
	276	_ident, T1CODE, t1_field_callback, \
	277	_reader, \
	278	0, 0, \
	279	0, 0 \
	280	},
	281
	282	#define CID_NEW_TABLE_FIELD( _ident, _type, _fname, _max ) \
	283	{ \
	284	_ident, T1CODE, _type, \
	285	0, \
	286	(FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, _fname ), \
	287	sizeof ( CID_FIELD_REF( T1TYPE, _fname )[0] ), \
	288	_max, \
	289	(FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, num_ ## _fname ) \
	290	},
	291
	292	#define CID_NEW_TABLE_FIELD2( _ident, _type, _fname, _max ) \
	293	{ \
	294	_ident, T1CODE, _type, \
	295	0, \
	296	(FT_UInt)(char*)&CID_FIELD_REF( T1TYPE, _fname ), \
	297	sizeof ( CID_FIELD_REF( T1TYPE, _fname )[0] ), \
	298	_max, 0 \
	299	},
	300
	301
	302	#define CID_FIELD_BOOL( _ident, _fname ) \
	303	CID_NEW_SIMPLE_FIELD( _ident, t1_field_bool, _fname )
	304
	305	#define CID_FIELD_NUM( _ident, _fname ) \
	306	CID_NEW_SIMPLE_FIELD( _ident, t1_field_integer, _fname )
	307
	308	#define CID_FIELD_FIXED( _ident, _fname ) \
	309	CID_NEW_SIMPLE_FIELD( _ident, t1_field_fixed, _fname )
	310
	311	#define CID_FIELD_STRING( _ident, _fname ) \
	312	CID_NEW_SIMPLE_FIELD( _ident, t1_field_string, _fname )
	313
	314	#define CID_FIELD_NUM_TABLE( _ident, _fname, _fmax ) \
	315	CID_NEW_TABLE_FIELD( _ident, t1_field_integer_array, \
	316	_fname, _fmax )
	317
	318	#define CID_FIELD_FIXED_TABLE( _ident, _fname, _fmax ) \
	319	CID_NEW_TABLE_FIELD( _ident, t1_field_fixed_array, \
	320	_fname, _fmax )
	321
	322	#define CID_FIELD_NUM_TABLE2( _ident, _fname, _fmax ) \
	323	CID_NEW_TABLE_FIELD2( _ident, t1_field_integer_array, \
	324	_fname, _fmax )
	325
	326	#define CID_FIELD_FIXED_TABLE2( _ident, _fname, _fmax ) \
	327	CID_NEW_TABLE_FIELD2( _ident, t1_field_fixed_array, \
	328	_fname, _fmax )
	329
	330	#define CID_FIELD_CALLBACK( _ident, _name ) \
	331	CID_NEW_CALLBACK_FIELD( _ident, parse_ ## _name )
	332
	333
	334	LOCAL_DEF
	335	FT_Error CID_Load_Field( CID_Parser* parser,
	336	const CID_Field_Rec* field,
	337	void* object );
	338
	339	LOCAL_DEF
	340	FT_Error CID_Load_Field_Table( CID_Parser* parser,
	341	const CID_Field_Rec* field,
	342	void* object );
	343
	344
	345	#ifdef __cplusplus
	346	}
	347	#endif
	348
	349
	350	#endif /* CIDPARSE_H */
	351
	352
	353	/* END */