ref: 9b3d1c75ad150b7964b7e8cc5619c0f5b49ec72f
dir: /src/type1/t1load.c/
/***************************************************************************/ /* */ /* 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> #include <t1tokens.h> #include <t1parse.h> #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 */