/****************************************************************************/
/* */
/* t1dump.c 1.0 */
/* */
/* Copyright 1999 - The FreeType Project http://www.freetype.org */
/* */
/* T1Dump is a very simply Type 1 font dumper. It can be used to */
/* write the following information to the standard ouput, or any */
/* given file: */
/* */
/* - a description of the font file (including name, properties, etc..) */
/* - the decrypted private dictionary, 'as is', i.e. in binary form */
/* - the stream of tokens from the font file (useful to debug the */
/* Type1 driver or to look at the font's internal structure..) */
/* - the charstring commands of a given subroutine */
/* - the charstring commands of a given glyph */
/* - the encoding */
/* - the glyph names */
/* */
#include <stdio.h>
#include <stdlib.h>
#include "freetype.h"
#include <t1tokens.h>
#include <t1gload.h>
#include <t1load.h>
#include <t1parse.h>
FT_Library library; /* root library object */
FT_Face face; /* truetype face */
T1_Face t1_face;
FT_Error error;
FILE* target;
void Panic( const char* message )
{
fprintf( stderr, "%s\n error code = 0x%04x\n", message, error );
exit(1);
}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/********** *********/
/********** *********/
/********** DUMP FONT INFORMATION *********/
/********** *********/
/********** *********/
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
static
T1_Error Dump_Font_Info( void )
{
T1_FontInfo* info = &t1_face->font_info;
T1_Private* priv = &t1_face->private_dict;
T1_Int n;
fprintf( target, "Font Name : %s\n", t1_face->font_name );
fprintf( target, "Version : %s\n", info->version );
fprintf( target, "Full Name : %s\n", info->full_name );
fprintf( target, "Family : %s\n", info->family_name );
fprintf( target, "Weight : %s\n", info->weight );
fprintf( target, "Italic angle : %ld\n", info->italic_angle );
fprintf( target, "Fixed pitch : %s\n",
info->is_fixed_pitch ? "yes" : "no" );
fprintf( target, "Underline : pos %d, thickness %d\n",
info->underline_position,
info->underline_thickness );
fprintf( target, "Unique ID : %d\n", priv->unique_id );
fprintf( target, "lenIV : %d\n", priv->lenIV );
fprintf( target, "blues : [" );
for ( n = 0; n < priv->num_blues; n++ )
fprintf( target, " %d", priv->blue_values[n] );
fprintf( target, " ]\n" );
fprintf( target, "other blues : [" );
for ( n = 0; n < priv->num_other_blues; n++ )
fprintf( target, " %d", priv->other_blues[n] );
fprintf( target, " ]\n" );
fprintf( target, "family blues : [" );
for ( n = 0; n < priv->num_family_blues; n++ )
fprintf( target, " %d", priv->family_blues[n] );
fprintf( target, " ]\n" );
fprintf( target, "family other : [" );
for ( n = 0; n < priv->num_family_other_blues; n++ )
fprintf( target, " %d", priv->family_other_blues[n] );
fprintf( target, " ]\n" );
fprintf( target, "Blue scale : %f\n", priv->blue_scale*1.0/65536.0 );
fprintf( target, "Blue shift : %d\n", priv->blue_shift );
fprintf( target, "Blue fuzz : %d\n", priv->blue_fuzz );
fprintf( target, "Std width : %d\n", priv->standard_width );
fprintf( target, "Std height : %d\n", priv->standard_height );
fprintf( target, "Force bold : %s\n", priv->force_bold ? "yes" : "no" );
fprintf( target, "Round stem : %s\n", priv->round_stem_up ? "yes" : "no" );
fprintf( target, "Stem snap W : [" );
for ( n = 0; n < priv->num_snap_widths; n++ )
fprintf( target, " %d", priv->stem_snap_widths[n] );
fprintf( target, " ]\n" );
fprintf( target, "Stem snap H : [" );
for ( n = 0; n < priv->num_snap_heights; n++ )
fprintf( target, " %d", priv->stem_snap_heights[n] );
fprintf( target, " ]\n" );
fprintf( target, "Language : %ld\n", priv->language_group );
fprintf( target, "Password : %ld\n", priv->password );
fprintf( target, "Min feature : [ %d %d ]\n",
priv->min_feature[0],
priv->min_feature[1] );
fprintf( target, "Font BBOX : [ %ld %ld %ld %ld ]\n",
t1_face->font_bbox.xMin,
t1_face->font_bbox.yMin,
t1_face->font_bbox.xMax,
t1_face->font_bbox.yMax );
fprintf( target, "Font matrix : [ %f %f %f %f ]\n",
1.0*t1_face->font_matrix.xx/65536000.0,
1.0*t1_face->font_matrix.xy/65536000.0,
1.0*t1_face->font_matrix.yx/65536000.0,
1.0*t1_face->font_matrix.yy/65536000.0 );
#if 0
fprintf( target,
fprintf( target,
fprintf( target,
fprintf( target,
fprintf( target,
fprintf( target,
#endif
fprintf( target, "Num glyphs : %d\n", t1_face->num_glyphs );
fprintf( target, "Num subrs : %d\n", t1_face->num_subrs );
return 0;
}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/********** *********/
/********** *********/
/********** DUMP PRIVATE DICT IN RAW FORM *********/
/********** *********/
/********** *********/
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
static
T1_Error parse_int( T1_Tokenizer tokzer,
T1_Long* result )
{
T1_Bool sign = 0;
T1_Long sum = 0;
T1_Token* token = &tokzer->token;
T1_Byte* base = tokzer->base + token->start;
T1_Byte* limit = base + token->len;
if (base >= limit)
goto Fail;
/* check sign */
if ( *base == '+' )
base++;
else if ( *base == '-' )
{
sign++;
base++;
}
/* parse digits */
if ( base >= limit )
goto Fail;
do
{
sum = ( 10*sum + (*base++ - '0') );
} while (base < limit);
if (sign)
sum = -sum;
*result = sum;
return T1_Err_Ok;
Fail:
*result = 0;
return T1_Err_Syntax_Error;
}
static
T1_Error Dump_Private_Dict( const char* filename )
{
struct FT_StreamRec_ stream_rec;
FT_Stream stream = &stream_rec;
T1_Error error;
T1_Tokenizer tokenizer;
error = FT_New_Stream( filename, stream );
if (error) return error;
stream->memory = library->memory;
error = New_Tokenizer( stream, &tokenizer );
if (error) goto Exit;
/* go directly to the Private dictionary */
error = Open_PrivateDict( tokenizer );
if (error)
Panic( "Could not open private dictionary !!" );
/* Write it to the target file */
fwrite( tokenizer->base, tokenizer->limit, 1, target );
Exit:
if (stream->close)
stream->close(stream);
return error;
}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/********** *********/
/********** *********/
/********** DUMP TYPE 1 TOKEN STREAM *********/
/********** *********/
/********** *********/
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
static
T1_Error Dump_Type1_Tokens( const char* filename )
{
struct FT_StreamRec_ stream_rec;
FT_Stream stream = &stream_rec;
T1_Error error;
T1_Tokenizer tokenizer;
error = FT_New_Stream( filename, stream );
if (error) return error;
stream->memory = library->memory;
error = New_Tokenizer( stream, &tokenizer );
if (error) goto Exit;
/* Dump the first segment of the Type1 font */
do
{
T1_Token* token;
T1_String temp_string[128];
T1_Int len;
error = Read_Token( tokenizer );
if (error) { error = 0; break; }
/* dump the token */
token = &tokenizer->token;
len = token->len;
if (len > 127) len = 127;
strncpy( temp_string,
(T1_String*)(tokenizer->base + token->start),
len );
temp_string[len] = '\0';
fprintf( target, "%s\n", temp_string );
/* Exit the loop when we encounter a "currentfile" token */
if ( token->kind == tok_keyword &&
token->kind2 == key_currentfile )
break;
} while (1);
error = Open_PrivateDict( tokenizer );
if (error)
Panic( "** could not open private dictionary **\n" );
else
{
T1_Int num = 0;
T1_Bool last_num = 0;
do
{
T1_Token* token;
T1_String temp_string[128];
T1_Int len;
error = Read_Token( tokenizer );
if (error) { error = 0; break; }
/* dump the token */
token = &tokenizer->token;
len = token->len;
if (len > 127) len = 127;
strncpy( temp_string,
(T1_String*)(tokenizer->base + token->start),
len );
temp_string[len] = '\0';
/* detect "RD" uses */
if ( token->kind == tok_keyword &&
( token->kind2 == key_RD ||
token->kind2 == key_RD_alternate ) &&
last_num )
{
fprintf( target, "%s [%d binary bytes] ", temp_string, num );
tokenizer->cursor += num;
}
else
{
fprintf( target, "%s\n", temp_string );
/* exit dump when we encounter a 'closefile' */
if ( token->kind == tok_keyword &&
token->kind2 == key_closefile )
break;
/* record numerical value if any */
if ( token->kind == tok_number )
{
T1_Long sum;
if ( !parse_int( tokenizer, &sum ) )
{
num = sum;
last_num = 1;
}
else
last_num = 0;
}
else
last_num = 0;
}
} while (1);
}
Exit:
if (stream->close)
stream->close(stream);
return error;
}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/********** *********/
/********** *********/
/********** DUMP CHARACTER ENCODING *********/
/********** *********/
/********** *********/
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
static
void Dump_Encoding( void )
{
T1_Encoding* encode = &t1_face->encoding;
int n;
fprintf( target, "characters count = %d\n", encode->num_chars );
fprintf( target, "first code = %d, last code = %d\n",
encode->code_first, encode->code_last );
for ( n = 0; n < encode->num_chars; n++ )
{
int code = (int)encode->char_index[n];
if (code || n == 0)
fprintf( target, "%3d %s\n", n, t1_face->glyph_names[code] );
}
}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/********** *********/
/********** *********/
/********** DUMP SUBROUTINES AND GLYPH CHARSTRINGS *********/
/********** *********/
/********** *********/
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
static
void Dump_CharStrings( T1_Byte* base,
T1_Int len )
{
T1_Byte* cur = base;
T1_Byte* limit = base + len;
T1_String temp_name[128];
T1_String* string;
T1_Int x = 0;
while ( cur < limit )
{
switch (*cur++)
{
case 1: string = "hstem"; break;
case 3: string = "vstem"; break;
case 4: string = "vmoveto"; break;
case 5: string = "rlineto"; break;
case 6: string = "hlineto"; break;
case 7: string = "vlineto"; break;
case 8: string = "rrcurveto"; break;
case 9: string = "closepath"; break;
case 10: string = "callsubr"; break;
case 11: string = "return"; break;
case 13: string = "hsbw"; break;
case 14: string = "endchar"; break;
case 21: string = "rmoveto"; break;
case 22: string = "hmoveto"; break;
case 30: string = "vhcurveto"; break;
case 31: string = "hvcurveto"; break;
case 12:
{
if (cur > limit)
Panic( "invalid charstrings stream\n" );
switch (*cur++)
{
case 0: string = "dotsection"; break;
case 1: string = "vstem3"; break;
case 2: string = "hstem3"; break;
case 6: string = "seac"; break;
case 7: string = "sbw"; break;
case 12: string = "div"; break;
case 16: string = "callothersubr"; break;
case 17: string = "pop"; break;
case 33: string = "setcurrentpoint"; break;
default:
sprintf( temp_name, "escape(12)+unknown(%d)", cur[1] );
string = temp_name;
}
}
break;
case 255: /* four bytes integer */
{
T1_Long sum;
if (cur+4 > limit)
Panic( "invalid charstrings stream\n" );
sum = ((long)cur[0] << 24) |
((long)cur[1] << 16) |
((long)cur[2] << 8) |
cur[3];
sprintf( temp_name, "%ld ", sum );
string = temp_name;
cur += 4;
}
break;
default:
if (cur[-1] >= 32)
{
if (cur[-1] < 247)
{
sprintf( temp_name, "%ld", (long)cur[-1] - 139 );
}
else if (cur[-1] < 251)
{
cur++;
sprintf( temp_name, "%ld",
((long)(cur[-2]-247) << 8) + cur[-1] + 108 );
}
else
{
cur++;
sprintf( temp_name, "%ld",
-((long)(cur[-2]-251) << 8) - cur[-1] - 108 );
}
string = temp_name;
}
else
{
sprintf( temp_name, "unknown(%d)", cur[-1] );
string = temp_name;
}
}
/* now print the charstring command */
{
int len = strlen(string)+1;
if ( x+len > 60 )
{
x = 0;
fprintf( target, "\n" );
}
else
fprintf( target, " " );
fprintf( target, "%s", string );
x += len;
}
}
}
static
void Dump_Glyph( int glyph_index )
{
fprintf( target, "glyph name: %s\n", t1_face->glyph_names[glyph_index] );
Dump_CharStrings( t1_face->charstrings [glyph_index],
t1_face->charstrings_len [glyph_index] );
}
static
void Dump_Subrs( int subrs_index )
{
Dump_CharStrings( t1_face->subrs [ subrs_index ],
t1_face->subrs_len[ subrs_index ] );
}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/********** *********/
/********** *********/
/********** EXECUTE GLYPH CHARSTRINGS *********/
/********** *********/
/********** *********/
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
static
T1_Error operator_endchar( T1_Builder* builder )
{
(void)builder;
fprintf( target, "endchar\n" );
return 0;
}
static
T1_Error operator_sbw( T1_Builder* builder,
T1_Pos sbx,
T1_Pos sby,
T1_Pos wx,
T1_Pos wy )
{
(void)builder;
fprintf( target, "set bearing [%ld,%ld] width [%ld,%ld]\n",
sbx, sby, wx, wy );
return 0;
}
#if 0
static
T1_Error operator_seac( T1_Builder* builder,
T1_Pos asb,
T1_Pos adx,
T1_Pos ady,
T1_Int bchar,
T1_Int achar )
{
(void)builder;
fprintf( target, "accented char: %ld [%ld,%ld] b=%d, a=%d\n",
asb, adx, ady, bchar, achar );
return 0;
}
#endif
static
T1_Error operator_closepath( T1_Builder* builder )
{
(void)builder;
fprintf( target, "closepath\n" );
return 0;
}
static
T1_Error operator_rlineto( T1_Builder* builder,
T1_Pos dx,
T1_Pos dy )
{
(void)builder;
fprintf( target, "%ld %ld rlineto\n", dx, dy );
return 0;
}
static
T1_Error operator_rmoveto( T1_Builder* builder,
T1_Pos dx,
T1_Pos dy )
{
(void)builder;
fprintf( target, "%ld %ld rmoveto\n", dx, dy );
return 0;
}
static
T1_Error operator_rrcurveto( T1_Builder* builder,
T1_Pos dx1,
T1_Pos dy1,
T1_Pos dx2,
T1_Pos dy2,
T1_Pos dx3,
T1_Pos dy3 )
{
(void)builder;
fprintf( target, "%ld %ld %ld %ld %ld %ld rrcurveto\n",
dx1, dy1, dx2, dy2, dx3, dy3 );
return 0;
}
static
T1_Error operator_dotsection( T1_Builder* builder )
{
(void)builder;
fprintf( target, "dotsection\n" );
return 0;
}
static
T1_Error operator_stem( T1_Builder* builder,
T1_Pos pos,
T1_Pos width,
T1_Bool vertical )
{
(void)builder;
fprintf( target, "%ld %ld %s\n", pos, width,
vertical ? "vstem" : "hstem" );
return 0;
}
static
T1_Error operator_stem3( T1_Builder* builder,
T1_Pos pos0,
T1_Pos width0,
T1_Pos pos1,
T1_Pos width1,
T1_Pos pos2,
T1_Pos width2,
T1_Bool vertical )
{
(void)builder;
fprintf( target, "%ld %ld %ld %ld %ld %ld %s\n",
pos0, width0, pos1, width1, pos2, width2,
vertical ? "vstem3" : "hstem3" );
return 0;
}
#if 0
static
T1_Error operator_flex( T1_Builder* builder,
T1_Pos threshold,
T1_Pos end_x,
T1_Pos end_y )
{
(void)builder;
fprintf( target, "%ld %ld %ld flex\n", threshold, end_x, end_y );
return 0;
}
#endif
static
T1_Error operator_changehints( T1_Builder* builder )
{
(void)builder;
fprintf( target, "-- change hints --\n" );
return 0;
}
static
T1_Error Execute_CharString( int glyph_index )
{
static const T1_Builder_Funcs builds =
{
operator_endchar,
operator_sbw,
operator_closepath,
operator_rlineto,
operator_rmoveto,
operator_rrcurveto,
};
static const T1_Hinter_Funcs hints =
{
operator_dotsection,
operator_changehints,
operator_stem,
operator_stem3,
};
T1_Decoder decoder;
T1_Error error;
T1_Init_Decoder( &decoder, &hints );
T1_Init_Builder( &decoder.builder, t1_face, 0, 0, &builds );
error = T1_Parse_CharStrings( &decoder,
t1_face->charstrings [glyph_index],
t1_face->charstrings_len[glyph_index],
t1_face->num_subrs,
t1_face->subrs,
t1_face->subrs_len );
return error;
}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/********** *********/
/********** *********/
/********** DEBUG FONT LOADING *********/
/********** *********/
/********** *********/
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
static
T1_Error Debug_Type1_Font( const char* filename )
{
struct FT_StreamRec_ stream_rec;
T1_FaceRec t1facerec;
T1_Tokenizer tokenizer;
T1_Parser parser;
T1_Error error;
FT_Stream stream = &stream_rec;
error = FT_New_Stream( filename, stream );
if (error) goto Exit;
stream->memory = library->memory;
/* create an empty face record */
memset( &t1facerec, 0, sizeof(t1facerec) );
t1facerec.root.memory = library->memory;
t1facerec.root.stream = stream;
t1_face = &t1facerec;
/* open the tokenizer, this will also check the font format */
error = New_Tokenizer( stream, &tokenizer );
if (error) goto Fail;
/* Now, load the font program into the face object */
Init_T1_Parser( &parser, t1_face, tokenizer );
/* force token dump */
parser.dump_tokens = 1;
error = Parse_T1_FontProgram( &parser );
Done_Tokenizer( tokenizer );
Fail:
if (stream->close)
stream->close( stream );
Exit:
return error;
}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/********** *********/
/********** *********/
/********** MAIN PROGRAM *********/
/********** *********/
/********** *********/
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
static
void Usage()
{
fprintf( stderr, "t1dump - a simple Type 1 font dumper\n" );
fprintf( stderr, "(c) The FreeType project - www.freetype.org\n" );
fprintf( stderr, "-------------------------------------------\n\n" );
fprintf( stderr, "usage : t1dump [options] fontfile(.pfb|.pfa)\n\n" );
fprintf( stderr, " options\n" );
fprintf( stderr, " -o filename : dumps to a specific file\n" );
fprintf( stderr, " -g index : dump glyph charstring\n" );
fprintf( stderr, " -s index : dump subrs charstring\n" );
fprintf( stderr, " -x index : execute glyph charstring\n" );
fprintf( stderr, " -e : dump encoding\n" );
fprintf( stderr, " -t : dumps the Type 1 token stream\n" );
fprintf( stderr, " -d : debug font loading\n" );
fprintf( stderr, " -p : dumps private dictionary 'as is'\n\n" );
exit(1);
}
typedef enum Request_
{
req_dump_info,
req_dump_private,
req_dump_tokens,
req_dump_encoding,
req_dump_glyph,
req_dump_subr,
req_load_font,
req_execute_glyph,
req_debug_font
} Request;
static char* file_name;
static int glyph_index;
static Request request = req_dump_info;
static FT_Driver t1_driver;
int main( int argc, char** argv )
{
char valid;
/* Check number of arguments */
if ( argc < 2 ) Usage();
/* Check options */
target = stdout;
argv++;
while (argv[0][0] == '-')
{
valid = 0;
switch (argv[0][1])
{
case 'p':
request = req_dump_private;
valid = 1;
break;
case 't':
request = req_dump_tokens;
valid = 1;
break;
case 'e':
request = req_dump_encoding;
valid = 1;
break;
case 'd':
request = req_debug_font;
valid = 1;
break;
case 'o':
if (argc < 2) Usage();
target = fopen( argv[1], "w" );
if (!target)
Panic( "Could not open/create destination file" );
argv++;
argc--;
valid = 1;
break;
case 'g':
case 's':
case 'x':
if (argc < 2) Usage();
if ( sscanf( argv[1], "%d", &glyph_index ) != 1 )
Usage();
switch (argv[0][1])
{
case 'g': request = req_dump_glyph; break;
case 's': request = req_dump_subr; break;
case 'x': request = req_execute_glyph; break;
}
argv++;
argc--;
valid = 1;
break;
default:
;
}
if (valid)
{
argv++;
argc--;
if (argc < 2) Usage();
}
else
break;
}
/* Get file name */
file_name = argv[0];
/* Instead of calling FT_Init_FreeType, we set up our own system */
/* object and library. This is reserved for FreeType 2 wizards !! */
/* Init library, read face object, get driver, create size */
error = FT_Init_FreeType( &library );
if (error) Panic( "could not initialise FreeType library" );
t1_driver = FT_Get_Driver( library, "type1" );
if (!t1_driver) Panic( "no Type1 driver in current FreeType lib" );
error = FT_New_Face( library, file_name, 0, &face );
if (error) Panic( "could not find/open/create font file" );
if (face->driver != t1_driver)
Panic( "font format is not Type 1 !" );
switch (request)
{
case req_dump_private:
error = Dump_Private_Dict(file_name);
break;
case req_dump_tokens:
error = Dump_Type1_Tokens(file_name);
break;
case req_debug_font:
error = Debug_Type1_Font(file_name);
break;
default:
error = FT_New_Face( library, file_name, 0, &face );
if (error) Panic( "could not load Type 1 font" );
t1_face = (T1_Face)face;
/* check glyph index, it is 0 by default */
if ( glyph_index < 0 || glyph_index >= t1_face->num_glyphs )
Panic( "invalid glyph index\n" );
switch (request)
{
case req_dump_glyph:
Dump_Glyph( glyph_index );
break;
case req_dump_subr:
Dump_Subrs( glyph_index );
break;
case req_execute_glyph:
Execute_CharString( glyph_index );
break;
case req_dump_encoding:
Dump_Encoding();
break;
default:
Dump_Font_Info();
}
}
if (error) Panic( "could not dump Type 1 font" );
FT_Done_FreeType( library );
return 0;
}
