--- /dev/null
+/***************************************************************************/
+/* */
+/* t1load.c */
+/* */
+/* Type 1 font loader (body). */
+/* */
+/* 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. */
+/* */
+/***************************************************************************/
+
+
+#include <freetype/config/ftconfig.h>
+#include <freetype/internal/ftdebug.h>
+#include <freetype/internal/t1types.h>
+
+
+#ifdef FT_FLAT_COMPILE
+
+#include "t1tokens.h"
+#include "t1parse.h"
+
+#else
+
+#include <type1/t1tokens.h>
+#include <type1/t1parse.h>
+
+#endif
+
+
+#include <stdio.h>
+
+#include <string.h> /* for strncpy(), strncmp(), strlen() */
+
+
+ /*************************************************************************/
+ /* */
+ /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
+ /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
+ /* messages during execution. */
+ /* */
+#undef FT_COMPONENT
+#define FT_COMPONENT trace_t1load
+
+
+ typedef FT_Error (*T1_Parse_Func)( T1_Parser* parser );
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Init_T1_Parser */
+ /* */
+ /* <Description> */
+ /* Initializes a given parser object to build a given T1_Face. */
+ /* */
+ /* <InOut> */
+ /* parser :: A handle to the newly built parser object. */
+ /* */
+ /* <Input> */
+ /* face :: A handle to the target Type 1 face object. */
+ /* */
+ /* tokenizer :: A handle to the target Type 1 token manager. */
+ /* */
+ LOCAL_FUNC
+ void Init_T1_Parser( T1_Parser* parser,
+ T1_Face face,
+ T1_Tokenizer tokenizer )
+ {
+ parser->error = 0;
+ parser->face = face;
+ parser->tokenizer = tokenizer;
+ parser->top = parser->stack;
+ parser->limit = parser->stack + T1_MAX_STACK_DEPTH;
+
+ parser->state_index = 0;
+ parser->state_stack[0] = dict_none;
+
+ parser->encoding_type = t1_encoding_none;
+ parser->encoding_names = 0;
+ parser->encoding_offsets = 0;
+ parser->encoding_lengths = 0;
+
+ parser->dump_tokens = 0;
+ face->type1.private_dict.lenIV = 4; /* XXX : is it sure? */
+ }
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Next_T1_Token */
+ /* */
+ /* <Description> */
+ /* Grabs the next significant token from a parser's input stream. */
+ /* This function ignores a number of tokens, and translates */
+ /* alternate forms into their common ones. */
+ /* */
+ /* <Input> */
+ /* parser :: A handle to the source parser. */
+ /* */
+ /* <Output> */
+ /* token :: The extracted token descriptor. */
+ /* */
+ /* <Return> */
+ /* FreeTyoe error code. 0 means success. */
+ /* */
+ LOCAL_FUNC
+ FT_Error Next_T1_Token( T1_Parser* parser,
+ T1_Token* token )
+ {
+ FT_Error error;
+ T1_Tokenizer tokzer = parser->tokenizer;
+
+
+ L1:
+ error = Read_Token( tokzer );
+ if ( error )
+ return error;
+
+ /* we now must ignore a number of tokens like `dup', `executeonly', */
+ /* `readonly', etc. */
+ *token = tokzer->token;
+ if ( token->kind == tok_keyword )
+ switch( token->kind2 )
+ {
+ case key_dup:
+ case key_execonly:
+ case key_readonly:
+ case key_noaccess:
+ case key_userdict:
+ /* do nothing - loop */
+ goto L1;
+
+ /* we also translate some other keywords from their alternative */
+ /* to their `normal' form */
+
+ case key_NP_alternate:
+ token->kind2 = key_NP;
+ break;
+
+ case key_RD_alternate:
+ token->kind2 = key_RD;
+ break;
+
+ case key_ND_alternate:
+ token->kind2 = key_ND;
+ break;
+
+ default:
+ ;
+ }
+
+#if defined( FT_DEBUG_LEVEL_ERROR ) || defined( FT_DEBUG_LEVEL_TRACE )
+
+ /* Dump the token when requested. This feature is only available */
+ /* in the `error' and `trace' debug levels. */
+ if ( parser->dump_tokens )
+ {
+ FT_String temp_string[128];
+ FT_Int len;
+
+
+ len = token->len;
+ if ( len > 127 )
+ len = 127;
+ strncpy( temp_string,
+ (FT_String*)tokzer->base + token->start,
+ len );
+ temp_string[len] = '\0';
+ FT_ERROR(( "%s\n", temp_string ));
+ }
+
+#endif /* FT_DEBUG_LEVEL_ERROR or FT_DEBUG_LEVEL_TRACE */
+
+ return T1_Err_Ok;
+ }
+
+
+ static
+ FT_Error Expect_Keyword( T1_Parser* parser,
+ T1_TokenType keyword )
+ {
+ T1_Token token;
+ FT_Error error;
+
+
+ error = Next_T1_Token( parser, &token );
+ if ( error )
+ goto Exit;
+
+ if ( token.kind != tok_keyword ||
+ token.kind2 != keyword )
+ {
+ error = T1_Err_Syntax_Error;
+ FT_ERROR(( "Expect_Keyword: keyword `%s' expected.\n",
+ t1_keywords[keyword - key_first_] ));
+ }
+
+ Exit:
+ return error;
+ }
+
+
+ static
+ FT_Error Expect_Keyword2( T1_Parser* parser,
+ T1_TokenType keyword1,
+ T1_TokenType keyword2 )
+ {
+ T1_Token token;
+ FT_Error error;
+
+
+ error = Next_T1_Token( parser, &token );
+ if ( error )
+ goto Exit;
+
+ if ( token.kind != tok_keyword ||
+ ( token.kind2 != keyword1 &&
+ token.kind2 != keyword2 ) )
+ {
+ error = T1_Err_Syntax_Error;
+ FT_ERROR(( "Expect_Keyword2: keyword `%s' or `%s' expected.\n",
+ t1_keywords[keyword1 - key_first_],
+ t1_keywords[keyword2 - key_first_] ));
+ }
+
+ Exit:
+ return error;
+ }
+
+
+ static
+ void Parse_Encoding( T1_Parser* parser )
+ {
+ T1_Token* token = parser->top+1;
+ FT_Memory memory = parser->face->root.memory;
+ T1_Encoding* encode = &parser->face->type1.encoding;
+ FT_Error error = 0;
+
+
+ if ( token->kind == tok_keyword &&
+ ( token->kind2 == key_StandardEncoding ||
+ token->kind2 == key_ExpertEncoding ) )
+ {
+ encode->num_chars = 256;
+ encode->code_first = 32;
+ encode->code_last = 255;
+
+ if ( ALLOC_ARRAY( encode->char_index, 256, FT_Short ) )
+ goto Exit;
+
+ encode->char_name = 0; /* no need to store glyph names */
+
+ /* Now copy the encoding */
+ switch ( token->kind2 )
+ {
+ case key_ExpertEncoding:
+ parser->encoding_type = t1_encoding_expert;
+ break;
+
+ default:
+ parser->encoding_type = t1_encoding_standard;
+ break;
+ }
+ }
+ else
+ {
+ FT_ERROR(( "Parse_Encoding: invalid encoding type\n" ));
+ error = T1_Err_Syntax_Error;
+ }
+
+ Exit:
+ parser->error = error;
+ }
+
+
+ /*************************************************************************/
+ /* */
+ /* */
+ /* IMPLEMENTATION OF THE `DEF' KEYWORD DEPENDING ON */
+ /* CURRENT DICTIONARY STATE */
+ /* */
+ /* */
+ /*************************************************************************/
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Do_Def_Font */
+ /* */
+ /* <Description> */
+ /* This function performs a `def' if in the Font dictionary. Its */
+ /* purpose is to build the T1_Face attributes directly from the */
+ /* stream. */
+ /* */
+ /* <InOut> */
+ /* parser :: A handle to the current parser. */
+ /* */
+ /* <Return> */
+ /* FreeType error code. 0 means success. */
+ /* */
+ static
+ FT_Error Do_Def_Font( T1_Parser* parser )
+ {
+ T1_Token* top = parser->top;
+ T1_Face face = parser->face;
+ T1_Font* type1 = &face->type1;
+
+
+ switch ( top[0].kind2 )
+ {
+ case imm_FontName:
+ /* in some cases, the /FontName is an immediate like */
+ /* /TimesNewRoman. In this case, we simply copy the */
+ /* token string (without the /). */
+ if ( top[1].kind == tok_immediate )
+ {
+ FT_Memory memory = parser->tokenizer->memory;
+ FT_Error error;
+ FT_Int len = top[1].len;
+
+
+ if ( ALLOC( type1->font_name, len + 1 ) )
+ {
+ parser->error = error;
+ return error;
+ }
+
+ MEM_Copy( type1->font_name,
+ parser->tokenizer->base + top[1].start,
+ len );
+ type1->font_name[len] = '\0';
+ }
+ else
+ type1->font_name = CopyString( parser );
+ break;
+
+ case imm_Encoding:
+ Parse_Encoding( parser );
+ break;
+
+ case imm_PaintType:
+ type1->paint_type = (FT_Byte)CopyInteger( parser );
+ break;
+
+ case imm_FontType:
+ type1->font_type = (FT_Byte)CopyInteger( parser );
+ break;
+
+ case imm_FontMatrix:
+ CopyMatrix( parser, &type1->font_matrix );
+ break;
+
+ case imm_FontBBox:
+ CopyBBox( parser, &type1->font_bbox );
+ break;
+
+ case imm_UniqueID:
+ type1->private_dict.unique_id = CopyInteger( parser );
+ break;
+
+ case imm_StrokeWidth:
+ type1->stroke_width = CopyInteger( parser );
+ break;
+
+ case imm_FontID:
+ type1->font_id = CopyInteger( parser );
+ break;
+
+ default:
+ /* ignore all other things */
+ parser->error = T1_Err_Ok;
+ }
+
+ return parser->error;
+ }
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Do_Def_FontInfo */
+ /* */
+ /* <Description> */
+ /* This function performs a `def' if in the FontInfo dictionary. Its */
+ /* purpose is to build the T1_FontInfo structure directly from the */
+ /* stream. */
+ /* */
+ /* <InOut> */
+ /* parser :: A handle to the current parser. */
+ /* */
+ /* <Return> */
+ /* FreeTyoe error code. 0 means success. */
+ /* */
+ static
+ FT_Error Do_Def_FontInfo( T1_Parser* parser )
+ {
+ T1_Token* top = parser->top;
+ T1_FontInfo* info = &parser->face->type1.font_info;
+
+
+ switch ( top[0].kind2 )
+ {
+ case imm_version:
+ info->version = CopyString( parser );
+ break;
+
+ case imm_Notice:
+ info->notice = CopyString( parser );
+ break;
+
+ case imm_FullName:
+ info->full_name = CopyString( parser );
+ break;
+
+ case imm_FamilyName:
+ info->family_name = CopyString( parser );
+ break;
+
+ case imm_Weight:
+ info->weight = CopyString( parser );
+ break;
+
+ case imm_ItalicAngle:
+ info->italic_angle = CopyInteger( parser );
+ break;
+
+ case imm_isFixedPitch:
+ info->is_fixed_pitch = CopyBoolean( parser );
+ break;
+
+ case imm_UnderlinePosition:
+ info->underline_position = (FT_Short)CopyInteger( parser );
+ break;
+
+ case imm_UnderlineThickness:
+ info->underline_thickness = (FT_Short)CopyInteger( parser );
+ break;
+
+ default:
+ /* ignore all other things */
+ parser->error = T1_Err_Ok;
+ }
+
+ return parser->error;
+ }
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Do_Def_Private */
+ /* */
+ /* <Description> */
+ /* This function performs a `def' if in the Private dictionary. Its */
+ /* purpose is to build the T1_Private structure directly from the */
+ /* stream. */
+ /* */
+ /* <InOut> */
+ /* parser :: A handle to the current parser. */
+ /* */
+ /* <Return> */
+ /* FreeTyoe error code. 0 means success. */
+ /* */
+ static
+ FT_Error Do_Def_Private( T1_Parser* parser )
+ {
+ T1_Token* top = parser->top;
+ T1_Private* priv = &parser->face->type1.private_dict;
+
+
+ switch ( top[0].kind2 )
+ {
+ /* Ignore the definitions of RD, NP, ND, and their alternate forms */
+ case imm_RD:
+ case imm_RD_alternate:
+ case imm_ND:
+ case imm_ND_alternate:
+ case imm_NP:
+ case imm_NP_alternate:
+ parser->error = T1_Err_Ok;
+ break;
+
+ case imm_BlueValues:
+ CopyArray( parser, &priv->num_blue_values,
+ priv->blue_values, 14 );
+ break;
+
+ case imm_OtherBlues:
+ CopyArray( parser, &priv->num_other_blues,
+ priv->other_blues, 10 );
+ break;
+
+ case imm_FamilyBlues:
+ CopyArray( parser, &priv->num_family_blues,
+ priv->family_blues, 14 );
+ break;
+
+ case imm_FamilyOtherBlues:
+ CopyArray( parser, &priv->num_family_other_blues,
+ priv->family_other_blues, 10 );
+ break;
+
+ case imm_BlueScale:
+ priv->blue_scale = CopyFloat( parser, 0x10000L );
+ break;
+
+ case imm_BlueShift:
+ priv->blue_shift = CopyInteger( parser );
+ break;
+
+ case imm_BlueFuzz:
+ priv->blue_fuzz = CopyInteger( parser );
+ break;
+
+ case imm_StdHW:
+ CopyArray( parser, 0, (FT_Short*)&priv->standard_width, 1 );
+ break;
+
+ case imm_StdVW:
+ CopyArray( parser, 0, (FT_Short*)&priv->standard_height, 1 );
+ break;
+
+ case imm_StemSnapH:
+ CopyArray( parser, &priv->num_snap_widths,
+ priv->snap_widths, 12 );
+ break;
+
+ case imm_StemSnapV:
+ CopyArray( parser, &priv->num_snap_heights,
+ priv->snap_heights, 12 );
+ break;
+
+ case imm_ForceBold:
+ priv->force_bold = CopyBoolean( parser );
+ break;
+
+ case imm_LanguageGroup:
+ priv->language_group = CopyInteger( parser );
+ break;
+
+ case imm_password:
+ priv->password = CopyInteger( parser );
+ break;
+
+ case imm_UniqueID:
+ priv->unique_id = CopyInteger( parser );
+ break;
+
+ case imm_lenIV:
+ priv->lenIV = CopyInteger( parser );
+ break;
+
+ case imm_MinFeature:
+ CopyArray( parser, 0, priv->min_feature, 2 );
+ break;
+
+ default:
+ /* ignore all other things */
+ parser->error = T1_Err_Ok;
+ }
+
+ return parser->error;
+ }
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Do_Def_Error */
+ /* */
+ /* <Description> */
+ /* This function returns a simple syntax error when invoked. It is */
+ /* used for the `def' keyword if in the `encoding', `subrs', */
+ /* `othersubrs', and `charstrings' dictionary states. */
+ /* */
+ /* <InOut> */
+ /* parser :: A handle to the current parser. */
+ /* */
+ /* <Return> */
+ /* FreeType error code. 0 means success. */
+ /* */
+ static
+ FT_Error Do_Def_Error( T1_Parser* parser )
+ {
+ FT_ERROR(( "Do_Def_Error:" ));
+ FT_ERROR(( " `def' keyword encountered in bad dictionary/array\n" ));
+
+ parser->error = T1_Err_Syntax_Error;
+
+ return parser->error;
+ }
+
+
+ static
+ FT_Error Do_Def_Ignore( T1_Parser* parser )
+ {
+ FT_UNUSED( parser );
+ return T1_Err_Ok;
+ }
+
+
+ static
+ T1_Parse_Func def_funcs[dict_max] =
+ {
+ Do_Def_Error,
+ Do_Def_Font,
+ Do_Def_FontInfo,
+ Do_Def_Ignore,
+ Do_Def_Private,
+ Do_Def_Ignore,
+ Do_Def_Ignore,
+ Do_Def_Ignore,
+ Do_Def_Ignore,
+ Do_Def_Ignore,
+ Do_Def_Ignore,
+ };
+
+
+ /*************************************************************************/
+ /* */
+ /* */
+ /* IMPLEMENTATION OF THE `PUT' KEYWORD DEPENDING ON */
+ /* CURRENT DICTIONARY STATE */
+ /* */
+ /* */
+ /*************************************************************************/
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Do_Put_Encoding */
+ /* */
+ /* <Description> */
+ /* This function performs a `put' if in the Encoding array. The */
+ /* glyph name is copied into the T1 recorder, and the charcode and */
+ /* glyph name pointer are written into the face object encoding. */
+ /* */
+ /* <InOut> */
+ /* parser :: A handle to the current parser. */
+ /* */
+ /* <Return> */
+ /* FreeType error code. 0 means success. */
+ /* */
+ static
+ FT_Error Do_Put_Encoding( T1_Parser* parser )
+ {
+ FT_Error error = T1_Err_Ok;
+ T1_Face face = parser->face;
+ T1_Token* top = parser->top;
+ T1_Encoding* encode = &face->type1.encoding;
+ FT_Int index;
+
+
+ /* record and check the character code */
+ if ( top[0].kind != tok_number )
+ {
+ FT_TRACE4(( "Do_Put_Encoding: number expected\n" ));
+ goto Syntax_Error;
+ }
+ index = (FT_Int)CopyInteger( parser );
+ if ( parser->error )
+ return parser->error;
+
+ if ( index < 0 || index >= encode->num_chars )
+ {
+ FT_TRACE4(( "Do_Put_Encoding: invalid character code\n" ));
+ goto Syntax_Error;
+ }
+
+ /* record the immediate name */
+ if ( top[1].kind != tok_immediate )
+ {
+ FT_TRACE4(( "Do_Put_Encoding: immediate name expected\n" ));
+ goto Syntax_Error;
+ }
+
+ /* if the glyph name is `.notdef', store a NULL char name; */
+ /* otherwise, record the glyph name */
+ if ( top[1].kind == imm_notdef )
+ {
+ parser->table.elements[index] = 0;
+ parser->table.lengths [index] = 0;
+ }
+ else
+ {
+ FT_String temp_name[128];
+ T1_Token* token = top + 1;
+ FT_Int len = token->len - 1;
+
+
+ /* copy immediate name */
+ if ( len > 127 )
+ len = 127;
+ MEM_Copy( temp_name, parser->tokenizer->base + token->start + 1, len );
+ temp_name[len] = '\0';
+
+ error = T1_Add_Table( &parser->table, index,
+ (FT_Byte*)temp_name, len + 1 );
+
+ /* adjust code_first and code_last */
+ if ( index < encode->code_first ) encode->code_first = index;
+ if ( index > encode->code_last ) encode->code_last = index;
+ }
+ return error;
+
+ Syntax_Error:
+ /* ignore the error, and simply clear the stack */
+ FT_TRACE4(( "Do_Put_Encoding: invalid syntax encountered\n" ));
+ parser->top = parser->stack;
+
+ return T1_Err_Ok;
+ }
+
+
+ /*************************************************************************/
+ /* */
+ /* */
+ /* IMPLEMENTATION OF THE "RD" KEYWORD DEPENDING ON */
+ /* CURRENT DICTIONARY STATE */
+ /* */
+ /* */
+ /*************************************************************************/
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Do_RD_Subrs */
+ /* */
+ /* <Description> */
+ /* This function performs an `RD' if in the Subrs dictionary. It */
+ /* simply records the array of bytecodes/charstrings corresponding to */
+ /* the sub-routine. */
+ /* */
+ /* <InOut> */
+ /* parser :: A handle to the current parser. */
+ /* */
+ /* <Return> */
+ /* FreeType error code. 0 means success. */
+ /* */
+ static
+ FT_Error Do_RD_Subrs( T1_Parser* parser )
+ {
+ FT_Error error = T1_Err_Ok;
+ T1_Face face = parser->face;
+ T1_Token* top = parser->top;
+ T1_Tokenizer tokzer = parser->tokenizer;
+ FT_Int index, count;
+
+
+ /* record and check the character code */
+ if ( top[0].kind != tok_number ||
+ top[1].kind != tok_number )
+ {
+ FT_ERROR(( "Do_RD_Subrs: number expected\n" ));
+ goto Syntax_Error;
+ }
+ index = (FT_Int)CopyInteger( parser );
+ error = parser->error;
+ if ( error )
+ goto Exit;
+
+ count = (FT_Int)CopyInteger( parser );
+ error = parser->error;
+ if ( error )
+ goto Exit;
+
+ if ( index < 0 || index >= face->type1.num_subrs )
+ {
+ FT_ERROR(( "Do_RD_Subrs: invalid character code\n" ));
+ goto Syntax_Error;
+ }
+
+ /* decrypt charstring and skip it */
+ {
+ FT_Byte* base = tokzer->base + tokzer->cursor;
+
+
+ tokzer->cursor += count;
+
+ /* some fonts use a value of -1 for lenIV to indicate that */
+ /* the charstrings are unencoded. */
+ /* */
+ /* Thanks to Tom Kacvinsky for pointing this out. */
+ /* */
+ if ( face->type1.private_dict.lenIV >= 0 )
+ {
+ t1_decrypt( base, count, 4330 );
+
+ base += face->type1.private_dict.lenIV;
+ count -= face->type1.private_dict.lenIV;
+ }
+
+ error = T1_Add_Table( &parser->table, index, base, count );
+ }
+
+ /* consume the closing NP or `put' */
+ error = Expect_Keyword2( parser, key_NP, key_put );
+
+ Exit:
+ return error;
+
+ Syntax_Error:
+ return T1_Err_Syntax_Error;
+ }
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Do_RD_CharStrings */
+ /* */
+ /* <Description> */
+ /* This function performs an `RD' if in the CharStrings dictionary. */
+ /* It simply records the array of bytecodes/charstrings corresponding */
+ /* to the glyph program string. */
+ /* */
+ /* <InOut> */
+ /* parser :: A handle to the current parser. */
+ /* */
+ /* <Return> */
+ /* FreeType error code. 0 means success. */
+ /* */
+ static
+ FT_Error Do_RD_Charstrings( T1_Parser* parser )
+ {
+ FT_Error error = T1_Err_Ok;
+ T1_Face face = parser->face;
+ T1_Token* top = parser->top;
+ T1_Tokenizer tokzer = parser->tokenizer;
+ FT_Int index, count;
+
+
+ /* check the character name argument */
+ if ( top[0].kind != tok_immediate )
+ {
+ FT_ERROR(( "Do_RD_Charstrings: immediate character name expected\n" ));
+ goto Syntax_Error;
+ }
+
+ /* check the count argument */
+ if ( top[1].kind != tok_number )
+ {
+ FT_ERROR(( "Do_RD_Charstrings: number expected\n" ));
+ goto Syntax_Error;
+ }
+
+ parser->args++;
+ count = (FT_Int)CopyInteger( parser );
+ error = parser->error;
+ if ( error )
+ goto Exit;
+
+ /* record the glyph name and get the corresponding glyph index */
+ if ( top[0].kind2 == imm_notdef )
+ index = 0;
+ else
+ {
+ FT_String temp_name[128];
+ T1_Token* token = top;
+ FT_Int len = token->len - 1;
+
+
+ /* copy immediate name */
+ if ( len > 127 )
+ len = 127;
+ MEM_Copy( temp_name, parser->tokenizer->base + token->start + 1, len );
+ temp_name[len] = '\0';
+
+ index = parser->cur_name++;
+ error = T1_Add_Table( &parser->table, index * 2,
+ (FT_Byte*)temp_name, len + 1 );
+ if ( error )
+ goto Exit;
+ }
+
+ /* decrypt and record charstring, then skip them */
+ {
+ FT_Byte* base = tokzer->base + tokzer->cursor;
+
+
+ tokzer->cursor += count; /* skip */
+
+ if ( face->type1.private_dict.lenIV >= 0 )
+ {
+ t1_decrypt( base, count, 4330 );
+
+ base += face->type1.private_dict.lenIV;
+ count -= face->type1.private_dict.lenIV;
+ }
+
+ error = T1_Add_Table( &parser->table, index * 2 + 1, base, count );
+ }
+
+ /* consume the closing `ND' */
+ if ( !error )
+ error = Expect_Keyword( parser, key_ND );
+
+ Exit:
+ return error;
+
+ Syntax_Error:
+ return T1_Err_Syntax_Error;
+ }
+
+
+ static
+ FT_Error Expect_Dict_Arguments( T1_Parser* parser,
+ FT_Int num_args,
+ T1_TokenType immediate,
+ T1_DictState new_state,
+ FT_Int* count )
+ {
+ /* check that we have enough arguments in the stack, including */
+ /* the `dict' keyword */
+ if ( parser->top - parser->stack < num_args )
+ {
+ FT_ERROR(( "Expect_Dict_Arguments: expecting at least %d arguments",
+ num_args ));
+ goto Syntax_Error;
+ }
+
+ /* check that we have the correct immediate, if needed */
+ if ( num_args == 2 )
+ {
+ if ( parser->top[-2].kind != tok_immediate ||
+ parser->top[-2].kind2 != immediate )
+ {
+ FT_ERROR(( "Expect_Dict_Arguments: expecting `/%s' dictionary\n",
+ t1_immediates[immediate - imm_first_] ));
+ goto Syntax_Error;
+ }
+ }
+
+ parser->args = parser->top-1;
+
+ /* check that the count argument is a number */
+ if ( parser->args->kind != tok_number )
+ {
+ FT_ERROR(( "Expect_Dict_Arguments:" ));
+ FT_ERROR(( " expecting numerical count argument for `dict'\n" ));
+ goto Syntax_Error;
+ }
+
+ if ( count )
+ {
+ *count = CopyInteger( parser );
+ if ( parser->error )
+ return parser->error;
+ }
+
+ /* save the dictionary state */
+ parser->state_stack[++parser->state_index] = new_state;
+
+ /* consume the `begin' keyword and clear the stack */
+ parser->top -= num_args;
+ return Expect_Keyword( parser, key_begin );
+
+ Syntax_Error:
+ return T1_Err_Syntax_Error;
+ }
+
+
+ static
+ FT_Error Expect_Array_Arguments( T1_Parser* parser )
+ {
+ T1_Token* top = parser->top;
+ FT_Error error = T1_Err_Ok;
+ T1_DictState new_state;
+ FT_Int count;
+ T1_Face face = parser->face;
+ FT_Memory memory = face->root.memory;
+
+
+ /* Check arguments format */
+ if ( top - parser->stack < 2 )
+ {
+ FT_ERROR(( "Expect_Array_Arguments: two arguments expected\n" ));
+ error = T1_Err_Stack_Underflow;
+ goto Exit;
+ }
+
+ parser->top -= 2;
+ top -= 2;
+ parser->args = top + 1;
+
+ if ( top[0].kind != tok_immediate )
+ {
+ FT_ERROR(( "Expect_Array_Arguments:" ));
+ FT_ERROR(( " first argument must be an immediate name\n" ));
+ goto Syntax_Error;
+ }
+
+ if ( top[1].kind != tok_number )
+ {
+ FT_ERROR(( "Expect_Array_Arguments:" ));
+ FT_ERROR(( " second argument must be a number\n" ));
+ goto Syntax_Error;
+ }
+
+ count = (FT_Int)CopyInteger( parser );
+
+ /* Is this an array we know about? */
+ switch ( top[0].kind2 )
+ {
+ case imm_Encoding:
+ {
+ T1_Encoding* encode = &face->type1.encoding;
+
+
+ new_state = dict_encoding;
+
+ encode->code_first = count;
+ encode->code_last = 0;
+ encode->num_chars = count;
+
+ /* Allocate the table of character indices. The table of */
+ /* character names is allocated through init_t1_recorder(). */
+ if ( ALLOC_ARRAY( encode->char_index, count, FT_Short ) )
+ return error;
+
+ error = T1_New_Table( &parser->table, count, memory );
+ if ( error )
+ goto Exit;
+
+ parser->encoding_type = t1_encoding_array;
+ }
+ break;
+
+ case imm_Subrs:
+ new_state = dict_subrs;
+ face->type1.num_subrs = count;
+
+ error = T1_New_Table( &parser->table, count, memory );
+ if ( error )
+ goto Exit;
+ break;
+
+ case imm_CharStrings:
+ new_state = dict_charstrings;
+ break;
+
+ default:
+ new_state = dict_unknown_array;
+ }
+
+ parser->state_stack[++parser->state_index] = new_state;
+
+ Exit:
+ return error;
+
+ Syntax_Error:
+ return T1_Err_Syntax_Error;
+ }
+
+
+ static
+ FT_Error Finalize_Parsing( T1_Parser* parser )
+ {
+ T1_Face face = parser->face;
+ T1_Font* type1 = &face->type1;
+ FT_Memory memory = face->root.memory;
+ T1_Table* strings = &parser->table;
+ PSNames_Interface* psnames = (PSNames_Interface*)face->psnames;
+
+ FT_Int num_glyphs;
+ FT_Int n;
+ FT_Error error;
+
+
+ num_glyphs = type1->num_glyphs = parser->cur_name;
+
+ /* allocate glyph names and charstrings arrays */
+ if ( ALLOC_ARRAY( type1->glyph_names, num_glyphs, FT_String* ) ||
+ ALLOC_ARRAY( type1->charstrings, num_glyphs, FT_Byte* ) ||
+ ALLOC_ARRAY( type1->charstrings_len, num_glyphs, FT_Int* ) )
+ return error;
+
+ /* copy glyph names and charstrings offsets and lengths */
+ type1->charstrings_block = strings->block;
+ for ( n = 0; n < num_glyphs; n++ )
+ {
+ type1->glyph_names[n] = (FT_String*)strings->elements[2 * n];
+ type1->charstrings[n] = strings->elements[2 * n + 1];
+ type1->charstrings_len[n] = strings->lengths [2 * n + 1];
+ }
+
+ /* now free the old tables */
+ FREE( strings->elements );
+ FREE( strings->lengths );
+
+ if ( !psnames )
+ {
+ FT_ERROR(( "Finalize_Parsing: `PSNames' module missing!\n" ));
+ return T1_Err_Unimplemented_Feature;
+ }
+
+ /* compute encoding if required */
+ if ( parser->encoding_type == t1_encoding_none )
+ {
+ FT_ERROR(( "Finalize_Parsing: no encoding specified in font file\n" ));
+ return T1_Err_Syntax_Error;
+ }
+
+ {
+ FT_Int n;
+ T1_Encoding* encode = &type1->encoding;
+
+
+ encode->code_first = encode->num_chars - 1;
+ encode->code_last = 0;
+
+ for ( n = 0; n < encode->num_chars; n++ )
+ {
+ FT_String** names;
+ FT_Int index;
+ FT_Int m;
+
+
+ switch ( parser->encoding_type )
+ {
+ case t1_encoding_standard:
+ index = psnames->adobe_std_encoding[n];
+ names = 0;
+ break;
+
+ case t1_encoding_expert:
+ index = psnames->adobe_expert_encoding[n];
+ names = 0;
+ break;
+
+ default:
+ index = n;
+ names = (FT_String**)parser->encoding_offsets;
+ }
+
+ encode->char_index[n] = 0;
+
+ if ( index )
+ {
+ FT_String* name;
+
+
+ if ( names )
+ name = names[index];
+ else
+ name = (FT_String*)psnames->adobe_std_strings(index);
+
+ if ( name )
+ {
+ FT_Int len = strlen( name );
+
+
+ /* lookup glyph index from name */
+ for ( m = 0; m < num_glyphs; m++ )
+ {
+ if ( strncmp( type1->glyph_names[m], name, len ) == 0 )
+ {
+ encode->char_index[n] = m;
+ break;
+ }
+ }
+
+ if ( n < encode->code_first ) encode->code_first = n;
+ if ( n > encode->code_last ) encode->code_last = n;
+ }
+ }
+ }
+
+ parser->encoding_type = t1_encoding_none;
+
+ FREE( parser->encoding_names );
+ FREE( parser->encoding_lengths );
+ FREE( parser->encoding_offsets );
+ }
+
+ return T1_Err_Ok;
+ }
+
+
+ /*************************************************************************/
+ /* */
+ /* <Function> */
+ /* Parse_T1_FontProgram */
+ /* */
+ /* <Description> */
+ /* Parses a given Type 1 font file and builds its face object. */
+ /* */
+ /* <InOut> */
+ /* parser :: A handle to the target parser object. */
+ /* */
+ /* <Return> */
+ /* FreeType error code. 0 means success. */
+ /* */
+ /* <Note> */
+ /* The parser contains a handle to the target face object. */
+ /* */
+ LOCAL_FUNC
+ FT_Error Parse_T1_FontProgram( T1_Parser* parser )
+ {
+ FT_Error error;
+ T1_Font* type1 = &parser->face->type1;
+
+
+ for (;;)
+ {
+ T1_Token token;
+ T1_Token* top;
+ T1_DictState dict_state;
+ FT_Int dict_index;
+
+
+ error = Next_T1_Token( parser, &token );
+ top = parser->top;
+ dict_index = parser->state_index;
+ dict_state = parser->state_stack[dict_index];
+
+ switch ( token.kind )
+ {
+ /* a keyword has been detected */
+ case tok_keyword:
+ switch ( token.kind2 )
+ {
+ case key_dict:
+ switch ( dict_state )
+ {
+ case dict_none:
+ /* All right, we are beginning the font dictionary. */
+ /* Check that we only have one number argument, then */
+ /* consume the `begin' and change to `dict_font' */
+ /* state. */
+ error = Expect_Dict_Arguments( parser, 1, tok_error,
+ dict_font, 0 );
+ if ( error )
+ goto Exit;
+
+ /* clear stack from all the previous content. This */
+ /* could be some stupid Postscript code. */
+ parser->top = parser->stack;
+ break;
+
+ case dict_font:
+ /* This must be the /FontInfo dictionary, so check */
+ /* that we have at least two arguments, that they */
+ /* are `/FontInfo' and a number, then change the */
+ /* dictionary state. */
+ error = Expect_Dict_Arguments( parser, 2, imm_FontInfo,
+ dict_fontinfo, 0 );
+ if ( error )
+ goto Exit;
+ break;
+
+ case dict_none2:
+ error = Expect_Dict_Arguments( parser, 2, imm_Private,
+ dict_private, 0 );
+ if ( error )
+ goto Exit;
+ break;
+
+ case dict_private:
+ {
+ T1_Face face = parser->face;
+ FT_Int count;
+
+
+ error = Expect_Dict_Arguments( parser, 2, imm_CharStrings,
+ dict_charstrings, &count );
+ if ( error )
+ goto Exit;
+
+ type1->num_glyphs = count;
+ error = T1_New_Table( &parser->table, count * 2,
+ face->root.memory );
+ if ( error )
+ goto Exit;
+
+ /* record `.notdef' as the first glyph in the font */
+ error = T1_Add_Table( &parser->table, 0,
+ (FT_Byte*)".notdef", 8 );
+ parser->cur_name = 1;
+ /* XXX: DO SOMETHING HERE */
+ }
+ break;
+
+ default:
+ /* All other uses are invalid */
+ FT_ERROR(( "Parse_T1_FontProgram:" ));
+ FT_ERROR(( " invalid use of `dict' keyword\n" ));
+ goto Syntax_Error;
+ }
+ break;
+
+ case key_array:
+ /* Are we in an array yet? If so, raise an error */
+ switch ( dict_state )
+ {
+ case dict_encoding:
+ case dict_subrs:
+ case dict_othersubrs:
+ case dict_charstrings:
+ case dict_unknown_array:
+ FT_ERROR(( "Parse_T1_FontProgram: nested array definitions\n" ));
+ goto Syntax_Error;
+
+ default:
+ ;
+ }
+ error = Expect_Array_Arguments( parser );
+ if ( error )
+ goto Exit;
+ break;
+
+ case key_ND:
+ case key_NP:
+ case key_def:
+ /* Are we in an array? If so, finalize it. */
+ switch ( dict_state )
+ {
+ case dict_encoding: /* finish encoding array */
+ /* copy table names to the face object */
+ T1_Done_Table( &parser->table );
+
+ parser->encoding_names = parser->table.block;
+ parser->encoding_lengths = parser->table.lengths;
+ parser->encoding_offsets = parser->table.elements;
+
+ parser->state_index--;
+ break;
+
+ case dict_subrs:
+ /* copy recorder sub-routines */
+ T1_Done_Table( &parser->table );
+
+ parser->subrs = parser->table.block;
+ type1->subrs = parser->table.elements;
+ type1->subrs_len = parser->table.lengths;
+ type1->subrs_block = parser->table.block;
+
+ parser->state_index--;
+ break;
+
+ case dict_charstrings:
+ case dict_othersubrs:
+ case dict_unknown_array:
+ FT_ERROR(( "Parse_T1_FontProgram: unsupported array\n" ));
+ goto Syntax_Error;
+ break;
+
+ default: /* normal `def' processing */
+ /* Check that we have sufficient operands in the stack */
+ if ( top >= parser->stack + 2 )
+ {
+ /* Now check that the first operand is an immediate. */
+ /* If so, call the appropriate `def' routine based */
+ /* on the current parser state. */
+ if ( top[-2].kind == tok_immediate )
+ {
+ parser->top -= 2;
+ parser->args = parser->top + 1;
+ error = def_funcs[dict_state](parser);
+ }
+ else
+ {
+ /* This is an error, but some fonts contain */
+ /* stupid Postscript code. We simply ignore */
+ /* an invalid `def' by clearing the stack. */
+#if 0
+ FT_ERROR(( "Parse_T1_FontProgram: immediate expected\n" ));
+ goto Syntax_Error;
+#else
+ parser->top = parser->stack;
+#endif
+ }
+ }
+ else
+ {
+ FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
+ goto Stack_Underflow;
+ }
+ }
+ break;
+
+ case key_index:
+ if ( top <= parser->stack )
+ {
+ FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
+ goto Stack_Underflow;
+ }
+
+ /* simply ignore? */
+ parser->top --;
+ break;
+
+ case key_put:
+ /* Check that we have sufficient operands in stack */
+ if ( top < parser->stack + 2 )
+ {
+ FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
+ goto Stack_Underflow;
+ }
+
+ parser->top -= 2;
+ parser->args = parser->top;
+
+ switch ( dict_state )
+ {
+ case dict_encoding:
+ error = Do_Put_Encoding( parser );
+ if ( error )
+ goto Exit;
+ break;
+
+ case dict_unknown_array: /* ignore the `put' */
+ break;
+
+ default:
+#if 0
+ FT_ERROR(( "Parse_T1_FontProgram: invalid context\n" ));
+ goto Syntax_Error;
+#else
+ /* invalid context; simply ignore the `put' and */
+ /* clear the stack (stupid Postscript code) */
+ FT_TRACE4(( "Parse_T1_FontProgram: invalid context ignored.\n" ));
+ parser->top = parser->stack;
+#endif
+ }
+ break;
+
+ case key_RD:
+ /* Check that we have sufficient operands in stack */
+ if ( top < parser->stack + 2 )
+ {
+ FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
+ goto Stack_Underflow;
+ }
+
+ parser->top -= 2;
+ parser->args = parser->top;
+ switch ( dict_state )
+ {
+ case dict_subrs:
+ error = Do_RD_Subrs( parser );
+ if ( error )
+ goto Exit;
+ break;
+
+ case dict_charstrings:
+ error = Do_RD_Charstrings( parser );
+ if ( error )
+ goto Exit;
+ break;
+
+ default:
+ FT_ERROR(( "Parse_T1_FontProgram: invalid context\n" ));
+ goto Syntax_Error;
+ }
+ break;
+
+ case key_end:
+ /* Were we in a dictionary or in an array? */
+ if ( dict_index <= 0 )
+ {
+ FT_ERROR(( "Parse_T1_FontProgram: no dictionary defined\n" ));
+ goto Syntax_Error;
+ }
+
+ switch ( dict_state )
+ {
+ /* jump to the private dictionary if we are closing the */
+ /* `/Font' dictionary */
+ case dict_font:
+ goto Open_Private;
+
+ /* exit the parser when closing the CharStrings dictionary */
+ case dict_charstrings:
+ return Finalize_Parsing( parser );
+
+ default:
+ /* Pop the current dictionary state and return to previous */
+ /* one. Consume the `def'. */
+
+ /* Because some buggy fonts (BitStream) have incorrect */
+ /* syntax, we never escape from the private dictionary */
+ if ( dict_state != dict_private )
+ parser->state_index--;
+
+ /* many fonts use `NP' instead of `def' or `put', so */
+ /* we simply ignore the next token */
+#if 0
+ error = Expect_Keyword2( parser, key_def, key_put );
+ if ( error )
+ goto Exit;
+#else
+ (void)Expect_Keyword2( parser, key_def, key_put );
+#endif
+ }
+ break;
+
+ case key_for:
+ /* check that we have four arguments and simply */
+ /* ignore them */
+ if ( top - parser->stack < 4 )
+ {
+ FT_ERROR(( "Parse_T1_FontProgram: not enough arguments\n" ));
+ goto Stack_Underflow;
+ }
+
+ parser->top -= 4;
+ break;
+
+ case key_currentdict:
+ Open_Private:
+ parser->state_index = 0;
+ parser->state_stack[0] = dict_none2;
+ error = Open_PrivateDict( parser->tokenizer );
+ if ( error )
+ goto Exit;
+ break;
+
+ case key_true:
+ case key_false:
+ case key_StandardEncoding:
+ case key_ExpertEncoding:
+ goto Push_Element;
+
+ default:
+ FT_ERROR(( "Parse_T1_FontProgram:" ));
+ FT_ERROR(( " invalid keyword in context\n" ));
+ error = T1_Err_Syntax_Error;
+ }
+ break;
+
+ /* check for the presence of `/BlendAxisTypes' -- we cannot deal */
+ /* with multiple master fonts, so we must return a correct error */
+ /* code to allow another driver to load them */
+ case tok_immediate:
+ if ( token.kind2 == imm_BlendAxisTypes )
+ {
+ error = FT_Err_Unknown_File_Format;
+ goto Exit;
+ }
+ /* fallthrough */
+
+ /* A number was detected */
+ case tok_string:
+ case tok_program:
+ case tok_array:
+ case tok_hexarray:
+ case tok_any:
+ case tok_number: /* push number on stack */
+
+ Push_Element:
+ if ( top >= parser->limit )
+ {
+ error = T1_Err_Stack_Overflow;
+ goto Exit;
+ }
+ else
+ *parser->top++ = token;
+ break;
+
+ /* anything else is an error per se the spec, but we */
+ /* frequently encounter stupid postscript code in fonts, */
+ /* so just ignore them */
+ default:
+ error = T1_Err_Ok; /* ignore token */
+ }
+
+ if ( error )
+ return error;
+ }
+
+ Exit:
+ return error;
+
+ Syntax_Error:
+ return T1_Err_Syntax_Error;
+
+ Stack_Underflow:
+ return T1_Err_Stack_Underflow;
+ }
+
+
+/* END */
projects / wxWidgets.git / blobdiff