ref: e97cb9127dbc8a10d07209aee679a0717346f1f6
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>
#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 */