src/freetype/type1/t1tokens.h

/***************************************************************************/
/*                                                                         */
/*  t1tokens.h                                                             */
/*                                                                         */
/*    Type 1 tokenizer (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 T1TOKENS_H
#define T1TOKENS_H


#ifdef FT_FLAT_COMPILE

#include "t1objs.h"

#else

#include <type1/t1objs.h>

#endif


#ifdef __cplusplus
  extern "C" {
#endif


  /* enum value of first keyword */
#define key_first_  100

  /* enum value of first immediate name */
#define imm_first_  200


  typedef enum  T1_TokenType_
  {
    tok_error = 0,

    tok_eof,             /* end of file                  */

    /* simple token types */

    tok_keyword,         /* keyword                      */
    tok_number,          /* number (integer or real)     */
    tok_string,          /* postscript string            */
    tok_program,         /* postscript program           */
    tok_immediate,       /* any immediate name           */
    tok_array,           /* matrix, array, etc..         */
    tok_hexarray,        /* array of hexadecimal nibbles */
    tok_any,             /* anything else                */

    /* Postscript keywords -- placed in lexicographical order */

    key_RD_alternate = key_first_,      /* `-|' = alternate form of RD */
    key_ExpertEncoding,
    key_ND,
    key_NP,
    key_RD,
    key_StandardEncoding,
    key_array,
    key_begin,
    key_closefile,
    key_currentdict,
    key_currentfile,
    key_def,
    key_dict,
    key_dup,
    key_eexec,
    key_end,
    key_execonly,
    key_false,
    key_for,
    key_index,
    key_noaccess,
    key_put,
    key_readonly,
    key_true,
    key_userdict,
    key_NP_alternate,                   /* `|' = alternate form of NP  */
    key_ND_alternate,                   /* `|-' = alternate form of ND */

    key_max,   /* always keep this value there */

    /* Postscript immediate names -- other names will be ignored, except */
    /* in charstrings                                                    */

    imm_RD_alternate = imm_first_,      /* `-|' = alternate form of RD */
    imm_notdef,                         /* `/.notdef' immediate        */
    imm_BlendAxisTypes,
    imm_BlueFuzz,
    imm_BlueScale,
    imm_BlueShift,
    imm_BlueValues,
    imm_CharStrings,
    imm_Encoding,
    imm_FamilyBlues,
    imm_FamilyName,
    imm_FamilyOtherBlues,
    imm_FID,
    imm_FontBBox,
    imm_FontID,
    imm_FontInfo,
    imm_FontMatrix,
    imm_FontName,
    imm_FontType,
    imm_ForceBold,
    imm_FullName,
    imm_ItalicAngle,
    imm_LanguageGroup,
    imm_Metrics,
    imm_MinFeature,
    imm_ND,
    imm_NP,
    imm_Notice,
    imm_OtherBlues,
    imm_OtherSubrs,
    imm_PaintType,
    imm_Private,
    imm_RD,
    imm_RndStemUp,
    imm_StdHW,
    imm_StdVW,
    imm_StemSnapH,
    imm_StemSnapV,
    imm_StrokeWidth,
    imm_Subrs,
    imm_UnderlinePosition,
    imm_UnderlineThickness,
    imm_UniqueID,
    imm_Weight,

    imm_isFixedPitch,
    imm_lenIV,
    imm_password,
    imm_version,

    imm_NP_alternate,                   /* `|'  = alternate form of NP */
    imm_ND_alternate,                   /* `|-' = alternate form of ND */

    imm_max   /* always keep this value here */

  } T1_TokenType;


  /* these arrays are visible for debugging purposes */
  extern const char*  t1_keywords[];
  extern const char*  t1_immediates[];


  /*************************************************************************/
  /*                                                                       */
  /* <Struct>                                                              */
  /*    T1_Token                                                           */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A structure used to describe a token in the current input stream.  */
  /*    Note that the Type1 driver doesn't try to interpret tokens until   */
  /*    it really needs to.                                                */
  /*                                                                       */
  /* <Fields>                                                              */
  /*    kind  :: The token type.  Describes the token to the loader.       */
  /*                                                                       */
  /*    kind2 :: Detailed token type.                                      */
  /*                                                                       */
  /*    start :: The index of the first character of token in the input    */
  /*             stream.                                                   */
  /*                                                                       */
  /*    len   :: The length of the token in characters.                    */
  /*                                                                       */
  typedef struct  T1_Token_
  {
    T1_TokenType  kind;     /* simple type                    */
    T1_TokenType  kind2;    /* detailed type                  */
    FT_Int        start;    /* index of first token character */
    FT_Int        len;      /* length of token in chars       */

  } T1_Token;


  typedef struct  T1_TokenParser_
  {
    FT_Memory  memory;
    FT_Stream  stream;

    FT_Bool    in_pfb;      /* true if PFB file, PFA otherwise */
    FT_Bool    in_private;  /* true if in private dictionary   */

    FT_Byte*   base;        /* base address of current read buffer */
    FT_Long    cursor;      /* current position in read buffer     */
    FT_Long    limit;       /* limit of current read buffer        */
    FT_Long    max;         /* maximum size of read buffer         */

    FT_Error   error;       /* last error                          */
    T1_Token   token;       /* last token read                     */

  } T1_TokenParser;


  /*************************************************************************/
  /*                                                                       */
  /* <Type>                                                                */
  /*    T1_Tokenizer                                                       */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A handle to an object used to extract tokens from the input.  The  */
  /*    object is able to perform PFA/PFB recognition, eexec decryption of */
  /*    the private dictionary, as well as eexec decryption of the         */
  /*    charstrings.                                                       */
  /*                                                                       */
  typedef T1_TokenParser*  T1_Tokenizer;


  LOCAL_DEF
  FT_Error  New_Tokenizer( FT_Stream      stream,
                           T1_Tokenizer*  tokenizer );

  LOCAL_DEF
  FT_Error  Done_Tokenizer( T1_Tokenizer  tokenizer );

  LOCAL_DEF
  FT_Error  Open_PrivateDict( T1_Tokenizer  tokenizer );

  LOCAL_DEF
  FT_Error  Read_Token( T1_Tokenizer  tokenizer );


#if 0
  LOCAL_DEF
  FT_Error  Read_CharStrings( T1_Tokenizer  tokenizer,
                              FT_Int        num_chars,
                              FT_Byte*      buffer );
#endif /* 0 */

  LOCAL_DEF
  void  t1_decrypt( FT_Byte*   buffer,
                    FT_Int     length,
                    FT_UShort  seed );


#ifdef __cplusplus
  }
#endif

#endif /* T1TOKENS_H */


/* END */
Commit	Line	Data
	1	/***************************************************************************/
	2	/* */
	3	/* t1tokens.h */
	4	/* */
	5	/* Type 1 tokenizer (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 T1TOKENS_H
	20	#define T1TOKENS_H
	21
	22
	23	#ifdef FT_FLAT_COMPILE
	24
	25	#include "t1objs.h"
	26
	27	#else
	28
	29	#include <type1/t1objs.h>
	30
	31	#endif
	32
	33
	34	#ifdef __cplusplus
	35	extern "C" {
	36	#endif
	37
	38
	39	/* enum value of first keyword */
	40	#define key_first_ 100
	41
	42	/* enum value of first immediate name */
	43	#define imm_first_ 200
	44
	45
	46	typedef enum T1_TokenType_
	47	{
	48	tok_error = 0,
	49
	50	tok_eof, /* end of file */
	51
	52	/* simple token types */
	53
	54	tok_keyword, /* keyword */
	55	tok_number, /* number (integer or real) */
	56	tok_string, /* postscript string */
	57	tok_program, /* postscript program */
	58	tok_immediate, /* any immediate name */
	59	tok_array, /* matrix, array, etc.. */
	60	tok_hexarray, /* array of hexadecimal nibbles */
	61	tok_any, /* anything else */
	62
	63	/* Postscript keywords -- placed in lexicographical order */
	64
	65	key_RD_alternate = key_first_, /* `-\|' = alternate form of RD */
	66	key_ExpertEncoding,
	67	key_ND,
	68	key_NP,
	69	key_RD,
	70	key_StandardEncoding,
	71	key_array,
	72	key_begin,
	73	key_closefile,
	74	key_currentdict,
	75	key_currentfile,
	76	key_def,
	77	key_dict,
	78	key_dup,
	79	key_eexec,
	80	key_end,
	81	key_execonly,
	82	key_false,
	83	key_for,
	84	key_index,
	85	key_noaccess,
	86	key_put,
	87	key_readonly,
	88	key_true,
	89	key_userdict,
	90	key_NP_alternate, /* `\|' = alternate form of NP */
	91	key_ND_alternate, /* `\|-' = alternate form of ND */
	92
	93	key_max, /* always keep this value there */
	94
	95	/* Postscript immediate names -- other names will be ignored, except */
	96	/* in charstrings */
	97
	98	imm_RD_alternate = imm_first_, /* `-\|' = alternate form of RD */
	99	imm_notdef, /* `/.notdef' immediate */
	100	imm_BlendAxisTypes,
	101	imm_BlueFuzz,
	102	imm_BlueScale,
	103	imm_BlueShift,
	104	imm_BlueValues,
	105	imm_CharStrings,
	106	imm_Encoding,
	107	imm_FamilyBlues,
	108	imm_FamilyName,
	109	imm_FamilyOtherBlues,
	110	imm_FID,
	111	imm_FontBBox,
	112	imm_FontID,
	113	imm_FontInfo,
	114	imm_FontMatrix,
	115	imm_FontName,
	116	imm_FontType,
	117	imm_ForceBold,
	118	imm_FullName,
	119	imm_ItalicAngle,
	120	imm_LanguageGroup,
	121	imm_Metrics,
	122	imm_MinFeature,
	123	imm_ND,
	124	imm_NP,
	125	imm_Notice,
	126	imm_OtherBlues,
	127	imm_OtherSubrs,
	128	imm_PaintType,
	129	imm_Private,
	130	imm_RD,
	131	imm_RndStemUp,
	132	imm_StdHW,
	133	imm_StdVW,
	134	imm_StemSnapH,
	135	imm_StemSnapV,
	136	imm_StrokeWidth,
	137	imm_Subrs,
	138	imm_UnderlinePosition,
	139	imm_UnderlineThickness,
	140	imm_UniqueID,
	141	imm_Weight,
	142
	143	imm_isFixedPitch,
	144	imm_lenIV,
	145	imm_password,
	146	imm_version,
	147
	148	imm_NP_alternate, /* `\|' = alternate form of NP */
	149	imm_ND_alternate, /* `\|-' = alternate form of ND */
	150
	151	imm_max /* always keep this value here */
	152
	153	} T1_TokenType;
	154
	155
	156	/* these arrays are visible for debugging purposes */
	157	extern const char* t1_keywords[];
	158	extern const char* t1_immediates[];
	159
	160
	161	/*************************************************************************/
	162	/* */
	163	/* <Struct> */
	164	/* T1_Token */
	165	/* */
	166	/* <Description> */
	167	/* A structure used to describe a token in the current input stream. */
	168	/* Note that the Type1 driver doesn't try to interpret tokens until */
	169	/* it really needs to. */
	170	/* */
	171	/* <Fields> */
	172	/* kind :: The token type. Describes the token to the loader. */
	173	/* */
	174	/* kind2 :: Detailed token type. */
	175	/* */
	176	/* start :: The index of the first character of token in the input */
	177	/* stream. */
	178	/* */
	179	/* len :: The length of the token in characters. */
	180	/* */
	181	typedef struct T1_Token_
	182	{
	183	T1_TokenType kind; /* simple type */
	184	T1_TokenType kind2; /* detailed type */
	185	FT_Int start; /* index of first token character */
	186	FT_Int len; /* length of token in chars */
	187
	188	} T1_Token;
	189
	190
	191	typedef struct T1_TokenParser_
	192	{
	193	FT_Memory memory;
	194	FT_Stream stream;
	195
	196	FT_Bool in_pfb; /* true if PFB file, PFA otherwise */
	197	FT_Bool in_private; /* true if in private dictionary */
	198
	199	FT_Byte* base; /* base address of current read buffer */
	200	FT_Long cursor; /* current position in read buffer */
	201	FT_Long limit; /* limit of current read buffer */
	202	FT_Long max; /* maximum size of read buffer */
	203
	204	FT_Error error; /* last error */
	205	T1_Token token; /* last token read */
	206
	207	} T1_TokenParser;
	208
	209
	210	/*************************************************************************/
	211	/* */
	212	/* <Type> */
	213	/* T1_Tokenizer */
	214	/* */
	215	/* <Description> */
	216	/* A handle to an object used to extract tokens from the input. The */
	217	/* object is able to perform PFA/PFB recognition, eexec decryption of */
	218	/* the private dictionary, as well as eexec decryption of the */
	219	/* charstrings. */
	220	/* */
	221	typedef T1_TokenParser* T1_Tokenizer;
	222
	223
	224	LOCAL_DEF
	225	FT_Error New_Tokenizer( FT_Stream stream,
	226	T1_Tokenizer* tokenizer );
	227
	228	LOCAL_DEF
	229	FT_Error Done_Tokenizer( T1_Tokenizer tokenizer );
	230
	231	LOCAL_DEF
	232	FT_Error Open_PrivateDict( T1_Tokenizer tokenizer );
	233
	234	LOCAL_DEF
	235	FT_Error Read_Token( T1_Tokenizer tokenizer );
	236
	237
	238	#if 0
	239	LOCAL_DEF
	240	FT_Error Read_CharStrings( T1_Tokenizer tokenizer,
	241	FT_Int num_chars,
	242	FT_Byte* buffer );
	243	#endif /* 0 */
	244
	245	LOCAL_DEF
	246	void t1_decrypt( FT_Byte* buffer,
	247	FT_Int length,
	248	FT_UShort seed );
	249
	250
	251	#ifdef __cplusplus
	252	}
	253	#endif
	254
	255	#endif /* T1TOKENS_H */
	256
	257
	258	/* END */