/*******************************************************************
*
* t1tokens.c
*
* Type 1 tokenizer
*
* Copyright 1996 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.
*
*
* The tokenizer is in charge of loading and reading a Type1 font
* file (either in PFB or PFA format), and extract successive tokens
* and keywords from its two streams (i.e. the font program, and the
* private dictionary).
*
* Eexec decryption is performed automatically when entering the
* private dictionary, or when retrieving char strings..
*
******************************************************************/
#include <ftstream.h>
#include <ftdebug.h>
#include <t1tokens.h>
#include <t1load.h>
#undef READ_BUFFER_INCREMENT
#define READ_BUFFER_INCREMENT 0x400
#undef FT_COMPONENT
#define FT_COMPONENT trace_t1load
/* array of Type1 keywords supported by this engine. This table places */
/* the keyword in lexicographical order. It should always correspond */
/* to the enums key_XXXX !! */
/* */
const char* t1_keywords[ key_max - key_first_ ] =
{
"-|", "ExpertEncoding", "ND", "NP", "RD", "StandardEncoding", "array",
"begin", "closefile", "currentdict", "currentfile", "def", "dict", "dup",
"eexec", "end", "executeonly", "false", "for", "index", "noaccess",
"put", "readonly", "true", "userdict", "|", "|-"
};
const char* t1_immediates[ imm_max - imm_first_ ] =
{
"-|", ".notdef", "BlueFuzz", "BlueScale", "BlueShift", "BlueValues",
"CharStrings", "Encoding", "FamilyBlues", "FamilyName", "FamilyOtherBlues",
"FID", "FontBBox", "FontID", "FontInfo", "FontMatrix", "FontName",
"FontType", "ForceBold", "FullName", "ItalicAngle", "LanguageGroup",
"Metrics", "MinFeature", "ND", "NP", "Notice", "OtherBlues", "OtherSubrs",
"PaintType", "Private", "RD", "RndStemUp", "StdHW", "StdVW", "StemSnapH",
"StemSnapV", "StrokeWidth", "Subrs", "UnderlinePosition",
"UnderlineThickness", "UniqueID", "Weight", "isFixedPitch", "lenIV",
"password", "version", "|", "|-"
};
/* lexicographic comparison of two strings */
static
int lexico_strcmp( const char* str1,
int str1_len,
const char* str2 )
{
int c2 = 0;
for ( ; str1_len > 0; str1_len-- )
{
int c1, diff;
c1 = *str1++;
c2 = *str2++;
diff = c1 - c2;
if (diff) return diff;
};
return -*str2;
}
/* Find a given token/name, perform binary search */
static
int Find_Name( char* base, int length,
const char** table, int table_len )
{
/* performs a binary search */
T1_Int left, right;
left = 0;
right = table_len-1;
while ( right-left > 1 )
{
T1_Int middle = left + (( right-left ) >> 1);
T1_Int cmp;
cmp = lexico_strcmp( base, length, table[middle] );
if (!cmp) return middle;
if ( cmp < 0 )
right = middle;
else
left = middle;
}
if ( !lexico_strcmp( base, length, table[left ] ) ) return left;
if ( !lexico_strcmp( base, length, table[right] ) ) return right;
return -1;
}
/* read the small PFB section header */
static
T1_Error Read_PFB_Tag( FT_Stream stream,
T1_UShort* atag,
T1_ULong* asize )
{
T1_UShort tag;
T1_ULong size;
T1_Error error;
FT_TRACE2(( "Read_PFB_Tag : reading\n" ));
if ( ACCESS_Frame( 6L ) ) return error;
tag = GET_UShort();
size = GET_ULong();
FORGET_Frame();
*atag = tag;
*asize = ( (size & 0xFF) << 24 ) |
( ((size >> 8) & 0xFF) << 16 ) |
( ((size >> 16) & 0xFF) << 8 ) |
( ((size >> 24) & 0xFF) );
FT_TRACE2(( " tag = %04x\n", tag ));
FT_TRACE4(( " asze = %08x\n", size ));
FT_TRACE2(( " size = %08x\n", *asize ));
return T1_Err_Ok;
}
static
T1_Error grow( T1_Tokenizer tokzer )
{
T1_Error error;
T1_Long left_bytes;
FT_Memory memory = tokzer->memory;
left_bytes = tokzer->max - tokzer->limit;
if ( left_bytes > 0 )
{
FT_Stream stream = tokzer->stream;
if ( left_bytes > READ_BUFFER_INCREMENT )
left_bytes = READ_BUFFER_INCREMENT;
FT_TRACE2(( "Growing tokenizer buffer by %d bytes\n", left_bytes ));
(void)stream; /* unused in non reentrant mode */
if ( !REALLOC( tokzer->base, tokzer->limit,
tokzer->limit + left_bytes ) &&
!FILE_Read( tokzer->base + tokzer->limit, left_bytes ) )
tokzer->limit += left_bytes;
}
else
{
FT_ERROR(( "Unexpected end of Type1 fragment !!\n" ));
error = T1_Err_Invalid_File_Format;
}
tokzer->error = error;
return error;
}
LOCAL_FUNC
void t1_decrypt( T1_Byte* buffer,
T1_Int length,
T1_UShort seed )
{
while ( length > 0 )
{
T1_Byte plain;
plain = (*buffer ^ (seed >> 8));
seed = (*buffer+seed)*52845+22719;
*buffer++ = plain;
length--;
}
}
/*************************************************************************/
/* */
/* <Function> New_Tokenizer */
/* */
/* <Description> */
/* Creates a new tokenizer from a given input stream. This function */
/* automatically recognizes "pfa" or "pfb" files. The function */
/* "Read_Token" can then be used to extract successive tokens from */
/* the stream.. */
/* */
/* <Input> */
/* stream :: input stream */
/* */
/* <Output> */
/* tokenizer :: handle to new tokenizer object.. */
/* */
/* <Return> */
/* Type1 error code. 0 means success.. */
/* */
/* <Note> */
/* This function copies the stream handle within the object. Callers */
/* should not discard "stream". This is done by the Done_Tokenizer */
/* function.. */
/* */
LOCAL_FUNC
T1_Error New_Tokenizer( FT_Stream stream,
T1_Tokenizer* tokenizer )
{
FT_Memory memory = stream->memory;
T1_Tokenizer tokzer;
T1_Error error;
T1_UShort tag;
T1_ULong size;
T1_Byte* tok_base;
T1_ULong tok_limit;
T1_ULong tok_max;
*tokenizer = 0;
/* allocate object */
if ( FILE_Seek( 0L ) ||
ALLOC( tokzer, sizeof(*tokzer) ) )
return error;
tokzer->stream = stream;
tokzer->memory = stream->memory;
tokzer->in_pfb = 0;
tokzer->in_private = 0;
tok_base = 0;
tok_limit = 0;
tok_max = stream->size;
error = Read_PFB_Tag( stream, &tag, &size );
if (error) goto Fail;
if ( tag != 0x8001 )
{
/* assume that it is a PFA file - an error will be produced later */
/* if a character with value > 127 is encountered.. */
/* rewind to start of file */
if ( FILE_Seek(0L) ) goto Fail;
size = stream->size;
}
else
tokzer->in_pfb = 1;
/* if it's a memory-based resource, set up pointer */
if ( !stream->read )
{
tok_base = (T1_Byte*)stream->base + stream->pos;
tok_limit = size;
tok_max = size;
/* check that the "size" field is valid */
if ( FILE_Skip(size) ) goto Fail;
}
else if ( tag == 0x8001 )
{
/* read segment in memory */
if ( ALLOC( tok_base, size ) )
goto Fail;
if ( FILE_Read( tok_base, size ) )
{
FREE( tok_base );
goto Fail;
}
tok_limit = size;
tok_max = size;
}
tokzer->base = tok_base;
tokzer->limit = tok_limit;
tokzer->max = tok_max;
tokzer->cursor = 0;
*tokenizer = tokzer;
/* Now check font format, we must see a '%!PS-AdobeFont-1' */
/* or a '%!FontType' */
{
if ( 16 > tokzer->limit )
grow( tokzer );
if ( tokzer->limit <= 16 ||
( strncmp( (const char*)tokzer->base, "%!PS-AdobeFont-1", 16 ) &&
strncmp( (const char*)tokzer->base, "%!FontType", 10 ) ) )
{
FT_TRACE2(( "Not a Type1 font\n" ));
error = T1_Err_Invalid_File_Format;
goto Fail;
}
}
return T1_Err_Ok;
Fail:
FREE( tokzer );
return error;
}
/* return the value of an hexadecimal digit */
static
int hexa_value( char c )
{
unsigned int d;
d = (unsigned int)(c-'0');
if ( d <= 9 ) return (int)d;
d = (unsigned int)(c-'a');
if ( d <= 5 ) return (int)(d+10);
d = (unsigned int)(c-'A');
if ( d <= 5 ) return (int)(d+10);
return -1;
}
/*************************************************************************/
/* */
/* <Function> Done_Tokenizer */
/* */
/* <Description> */
/* Closes a given tokenizer. This function will also close the */
/* stream embedded in the object.. */
/* */
/* <Input> */
/* tokenizer :: target tokenizer object */
/* */
/* <Return> */
/* Type1 error code. 0 means success.. */
/* */
LOCAL_FUNC
T1_Error Done_Tokenizer( T1_Tokenizer tokenizer )
{
FT_Memory memory = tokenizer->memory;
/* clear read buffer if needed (disk-based resources) */
if ( tokenizer->in_private || !tokenizer->stream->base )
FREE( tokenizer->base );
FREE( tokenizer );
return T1_Err_Ok;
}
/*************************************************************************/
/* */
/* <Function> Open_PrivateDict */
/* */
/* <Description> */
/* This function must be called to set the tokenizer to the private */
/* section of the Type1 file. It recognizes automatically the */
/* the kind of eexec encryption used (ascii or binary).. */
/* */
/* <Input> */
/* tokenizer :: target tokenizer object */
/* lenIV :: value of the "lenIV" variable.. */
/* */
/* <Return> */
/* Type1 error code. 0 means success.. */
/* */
LOCAL_FUNC
T1_Error Open_PrivateDict( T1_Tokenizer tokenizer )
{
T1_Tokenizer tokzer = tokenizer;
FT_Stream stream = tokzer->stream;
FT_Memory memory = tokzer->memory;
T1_Error error = 0;
T1_UShort tag;
T1_ULong size;
T1_Byte* private;
/* are we already in the private dictionary ? */
if ( tokzer->in_private )
return 0;
if ( tokzer->in_pfb )
{
/* in the case of the PFB format, the private dictionary can be */
/* made of several segments. We thus first read the number of */
/* segments to compute the total size of the private dictionary */
/* then re-read them into memory.. */
T1_Long start_pos = FILE_Pos();
T1_ULong private_size = 0;
do
{
error = Read_PFB_Tag( stream, &tag, &size );
if (error || tag != 0x8002) break;
private_size += size;
if ( FILE_Skip(size) )
goto Fail;
}
while (1);
/* Check that we have a private dictionary there */
/* and allocate private dictionary buffer */
if ( private_size == 0 )
{
FT_ERROR(( "T1.Open_Private: invalid private dictionary section\n" ));
error = T1_Err_Invalid_File_Format;
goto Fail;
}
if ( ALLOC( private, private_size ) )
goto Fail;
/* read all sections into buffer */
if ( FILE_Seek( start_pos ) )
goto Fail_Private;
private_size = 0;
do
{
error = Read_PFB_Tag( stream, &tag, &size );
if (error || tag != 0x8002) { error = 0; break; }
if ( FILE_Read( private + private_size, size ) )
goto Fail_Private;
private_size += size;
}
while (1);
tokzer->base = private;
tokzer->cursor = 0;
tokzer->limit = private_size;
tokzer->max = private_size;
}
else
{
char* base;
/* we're in a PFA file, read each token until we find "eexec" */
while ( tokzer->token.kind2 != key_eexec )
{
error = Read_Token( tokzer );
if (error) goto Fail;
}
/* now determine wether the private dictionary is encoded in binary */
/* or hexadecimal ASCII format.. */
/* we need to access the next 4 bytes (after the final \r following */
/* the 'eexec' keyword..) if they all are hexadecimal digits, then */
/*we have a case of ASCII storage.. */
while ( tokzer->cursor+5 > tokzer->limit )
{
error = grow( tokzer );
if (error) goto Fail;
}
/* skip whitespace/line feed after "eexec" */
base = (char*)tokzer->base + tokzer->cursor + 1;
if ( ( hexa_value( base[0] ) | hexa_value( base[1] ) |
hexa_value( base[2] ) | hexa_value( base[3] ) ) < 0 )
{
/* binary encoding - "simply" read the stream */
/* if it's a memory-based resource, we need to allocate a new */
/* storage buffer for the private dictionary, as it needs to */
/* be decrypted later.. */
if ( stream->base )
{
size = stream->size - tokzer->cursor-1; /* remaining bytes */
if ( ALLOC( private, size ) ) /* allocate private dict buffer */
goto Fail;
/* copy eexec-encrypted bytes */
MEM_Copy( private, tokzer->base + tokzer->cursor+1, size );
/* reset pointers - forget about file mapping */
tokzer->base = private;
tokzer->limit = size;
tokzer->max = size;
tokzer->cursor = 0;
}
/* on the opposite, for disk based resources, we simply grow */
/* the current buffer until its completion, and decrypt the */
/* bytes within it. In all cases, the "base" buffer will be */
/* discarded on DoneTokenizer if we're in the private dict.. */
else
{
/* grow the read buffer to the full file.. */
while ( tokzer->limit < tokzer->max )
{
error = grow( tokenizer );
if (error) goto Fail;
}
/* set up cursor to first encrypted byte */
tokzer->cursor++;
}
}
else
{
/* ASCII hexadecimal encoding.. This sucks.. */
T1_Byte* write;
T1_Byte* cur;
T1_Byte* limit;
T1_Int count;
/* Allocate a buffer, read each one byte at a time .. */
count = ( stream->size - tokzer->cursor );
size = count/2;
if ( ALLOC( private, size ) ) /* allocate private dict buffer */
goto Fail;
write = private;
cur = tokzer->base + tokzer->cursor;
limit = tokzer->base + tokzer->limit;
/* read each bytes */
while ( count > 0 )
{
/* ensure that we can read the next 2 bytes !! */
while ( cur+2 > limit )
{
int cursor = cur - tokzer->base;
error = grow( tokzer );
if (error) goto Fail_Private;
cur = tokzer->base + cursor;
limit = tokzer->base + tokzer->limit;
}
/* check for new line */
if ( cur[0] == '\r' || cur[0] == '\n' )
{
cur++;
count--;
}
else
{
int hex1 = hexa_value(cur[0]);
/* exit if we have a non hexa-decimal digit which isn't */
/* a new-line character.. */
if (hex1 < 0)
break;
/* otherwise, store byte */
*write++ = ( hex1 << 4 ) | hexa_value( cur[1] );
cur += 2;
count -= 2;
}
}
/* get rid of old buffer in the case of disk-based resources */
if ( !stream->base )
FREE( tokzer->base );
/* set up pointers */
tokzer->base = private;
tokzer->limit = size;
tokzer->max = size;
tokzer->cursor = 0;
}
}
/* finally, decrypt the private dictionary - and skip the lenIV bytes */
t1_decrypt( tokzer->base, tokzer->limit, 55665 );
tokzer->cursor += 4;
Fail:
return error;
Fail_Private:
FREE( private );
goto Fail;
}
/*************************************************************************/
/* */
/* <Function> Read_Token */
/* */
/* <Description> */
/* Read a new token from the current input stream. This function */
/* extracts a token from the font program until "Open_PrivateDict" */
/* has been called. After this, it returns tokens from the */
/* (eexec-encrypted) private dictionnary.. */
/* */
/* <Input> */
/* tokenizer :: target tokenizer object */
/* */
/* <Return> */
/* Type1 error code. 0 means success.. */
/* */
/* <Note> */
/* One should use the function Read_CharStrings to read the binary */
/* charstrings from the private dict.. */
/* */
LOCAL_FUNC
T1_Error Read_Token( T1_Tokenizer tokenizer )
{
T1_Tokenizer tok = tokenizer;
T1_Long cur, limit;
T1_Byte* base;
char c, starter, ender;
T1_Bool token_started;
T1_TokenType kind;
tok->error = T1_Err_Ok;
tok->token.kind = tok_any;
base = tok->base;
limit = tok->limit;
cur = tok->cursor;
token_started = 0;
for (;;)
{
if ( cur >= limit )
{
if ( grow( tok ) ) goto Exit;
base = tok->base;
limit = tok->limit;
}
c = (char)base[cur++];
/* check that we have an ASCII character */
if ( (T1_Byte)c > 127 )
{
FT_ERROR(( "Unexpected binary data in Type1 fragment !!\n" ));
tok->error = T1_Err_Invalid_File_Format;
goto Exit;
}
switch (c)
{
case '\r' :
case '\n' :
case ' ' :
case '\t' : /* skip initial whitespace => skip to next */
if (token_started)
{
/* possibly a name, keyword, wathever */
tok->token.kind = tok_any;
tok->token.len = cur-tok->token.start-1;
goto Exit;
}
/* otherwise, skip everything */
break;
case '%' : /* this is a comment - skip everything */
for (;;)
{
T1_Int left = limit - cur;
while (left > 0)
{
c = (char)base[cur++];
if ( c == '\r' || c == '\n' )
goto Next;
left--;
}
if ( grow( tokenizer ) ) goto Exit;
base = tok->base;
limit = tok->limit;
}
case '(' : /* a Postscript string */
kind = tok_string;
ender = ')';
L1:
if (!token_started)
{
token_started = 1;
tok->token.start = cur-1;
}
{
T1_Int nest_level = 1;
starter = c;
for (;;)
{
T1_Int left = limit-cur;
while (left > 0)
{
c = (char)base[cur++];
if ( c == starter )
nest_level++;
else if ( c == ender )
{
nest_level--;
if (nest_level <= 0)
{
tok->token.kind = kind;
tok->token.len = cur - tok->token.start;
goto Exit;
}
}
left--;
}
if ( grow( tok ) ) goto Exit;
base = tok->base;
limit = tok->limit;
}
}
case '[' : /* a Postscript array */
if (token_started)
goto Any_Token;
kind = tok_array;
ender = ']';
goto L1;
break;
case '{' : /* a Postscript program */
if (token_started)
goto Any_Token;
kind = tok_program;
ender = '}';
goto L1;
break;
case '<' : /* a Postscript hex byte array ?? */
if (token_started)
goto Any_Token;
kind = tok_hexarray;
ender = '>';
goto L1;
break;
case '0': /* any number */
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (token_started)
goto Next;
tok->token.kind = tok_number;
token_started = 1;
tok->token.start = cur-1;
L2:
for (;;)
{
T1_Int left = limit-cur;
while (left > 0)
{
c = (char)base[cur++];
switch (c)
{
case '[':
case '{':
case '(':
case '<':
case '/':
goto Any_Token;
case ' ':
case '\r':
case '\t':
case '\n':
tok->token.len = cur - tok->token.start - 1;
goto Exit;
default:
;
}
left--;
}
if (grow( tok )) goto Exit;
base = tok->base;
limit = tok->limit;
}
case '.': /* maybe a number */
case '-':
case '+':
if (token_started)
goto Next;
token_started = 1;
tok->token.start = cur-1;
for (;;)
{
T1_Int left = limit-cur;
if ( left > 0 )
{
/* test for any following digit, interpreted as number */
c = (char)base[cur];
tok->token.kind = ( c >= '0' && c <= '9' ? tok_number : tok_any );
goto L2;
}
if (grow( tok )) goto Exit;
base = tok->base;
limit = tok->limit;
}
case '/': /* maybe an immediate name */
if (!token_started)
{
token_started = 1;
tok->token.start = cur-1;
for (;;)
{
T1_Int left = limit-cur;
if ( left > 0 )
{
/* test for single '/', interpreted as garbage */
c = (char)base[cur];
tok->token.kind = ( c == ' ' || c == '\t' ||
c == '\r' || c == '\n' ?
tok_any : tok_immediate );
goto L2;
}
if (grow( tok )) goto Exit;
base = tok->base;
limit = tok->limit;
}
}
else
{
Any_Token: /* possibly a name or wathever */
cur--;
tok->token.len = cur - tok->token.start;
goto Exit;
}
default:
if (!token_started)
{
token_started = 1;
tok->token.start = cur-1;
}
}
Next:
;
}
Exit:
tok->cursor = cur;
if (!tok->error)
{
/* now, tries to match keywords and immediate names */
T1_Int index;
switch ( tok->token.kind )
{
case tok_immediate : /* immediate name */
index = Find_Name( (char*)(tok->base + tok->token.start+1),
tok->token.len-1,
t1_immediates,
imm_max - imm_first_ );
tok->token.kind2 = ( index >= 0 ? imm_first_ + index : 0 );
break;
case tok_any : /* test for keyword */
index = Find_Name( (char*)(tok->base + tok->token.start),
tok->token.len,
t1_keywords,
key_max - key_first_ );
if ( index >= 0 )
{
tok->token.kind = tok_keyword;
tok->token.kind2 = key_first_ + index;
}
else
tok->token.kind2 = 0;
break;
default:
tok->token.kind2 = 0;
}
}
return tokenizer->error;
}
/*************************************************************************/
/* */
/* <Function> Read_CharStrings */
/* */
/* <Description> */
/* Read a charstrings from the current input stream. These are */
/* binary bytes that encode each individual glyph outline. */
/* */
/* The caller is responsible for skipping the "lenIV" bytes at */
/* the start of the record.. */
/* */
/* <Input> */
/* tokenizer :: target tokenizer object */
/* num_chars :: number of binary bytes to read */
/* */
/* <Output> */
/* buffer :: target array of bytes. These are eexec-decrypted.. */
/* */
/* <Return> */
/* Type1 error code. 0 means success.. */
/* */
/* <Note> */
/* One should use the function Read_CharStrings to read the binary */
/* charstrings from the private dict.. */
/* */
LOCAL_FUNC
T1_Error Read_CharStrings( T1_Tokenizer tokenizer,
T1_Int num_chars,
T1_Byte* buffer )
{
for (;;)
{
T1_Int left = tokenizer->limit - tokenizer->cursor;
if ( left >= num_chars )
{
MEM_Copy( buffer, tokenizer->base + tokenizer->cursor, num_chars );
t1_decrypt( buffer, num_chars, 4330 );
tokenizer->cursor += num_chars;
return T1_Err_Ok;
}
if ( grow(tokenizer) ) return tokenizer->error;
}
}
