t42parse.h File Reference

#include "t42objs.h"

Include dependency graph for t42parse.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	T42_ParserRec_
struct	T42_Loader_

Typedefs
typedef FT_BEGIN_HEADER struct T42_ParserRec_	T42_ParserRec
typedef FT_BEGIN_HEADER struct T42_ParserRec_ *	T42_Parser
typedef struct T42_Loader_	T42_LoaderRec
typedef struct T42_Loader_ *	T42_Loader

Functions
	t42_parser_init (T42_Parser parser, FT_Stream stream, FT_Memory memory, PSAux_Service psaux)
	t42_parser_done (T42_Parser parser)
	t42_parse_dict (T42_Face face, T42_Loader loader, FT_Byte *base, FT_Long size)
	t42_loader_init (T42_Loader loader, T42_Face face)
	t42_loader_done (T42_Loader loader)

Typedef Documentation

T42_Loader

typedef struct T42_Loader_ * T42_Loader

T42_LoaderRec

typedef struct T42_Loader_ T42_LoaderRec

T42_Parser

typedef FT_BEGIN_HEADER struct T42_ParserRec_ * T42_Parser

T42_ParserRec

typedef FT_BEGIN_HEADER struct T42_ParserRec_ T42_ParserRec

Function Documentation

t42_loader_done()

t42_loader_done

(

T42_Loader

loader

)

Definition at line 1283 of file t42parse.c.

  {
    T42_Parser  parser = &loader->parser;
 
 
    /* finalize tables */
    T1_Release_Table( &loader->encoding_table );
    T1_Release_Table( &loader->charstrings );
    T1_Release_Table( &loader->glyph_names );
    T1_Release_Table( &loader->swap_table );
 
    /* finalize parser */
    t42_parser_done( parser );
  }

Referenced by T42_Open_Face().

t42_loader_init()

t42_loader_init	(	T42_Loader	loader,
		T42_Face	face
	)

Definition at line 1266 of file t42parse.c.

  {
    FT_UNUSED( face );
 
    FT_ZERO( loader );
    loader->num_glyphs = 0;
    loader->num_chars  = 0;
 
    /* initialize the tables -- simply set their `init' field to 0 */
    loader->encoding_table.init = 0;
    loader->charstrings.init    = 0;
    loader->glyph_names.init    = 0;
  }

Referenced by T42_Open_Face().

t42_parse_dict()

t42_parse_dict	(	T42_Face	face,
		T42_Loader	loader,
		FT_Byte *	base,
		FT_Long	size
	)

Definition at line 1135 of file t42parse.c.

  {
    T42_Parser  parser     = &loader->parser;
    FT_Byte*    limit;
    FT_Int      n_keywords = (FT_Int)( sizeof ( t42_keywords ) /
                                         sizeof ( t42_keywords[0] ) );
 
 
    parser->root.cursor = base;
    parser->root.limit  = base + size;
    parser->root.error  = FT_Err_Ok;
 
    limit = parser->root.limit;
 
    T1_Skip_Spaces( parser );
 
    while ( parser->root.cursor < limit )
    {
      FT_Byte*  cur;
 
 
      cur = parser->root.cursor;
 
      /* look for `FontDirectory' which causes problems for some fonts */
      if ( *cur == 'F' && cur + 25 < limit                    &&
           ft_strncmp( (char*)cur, "FontDirectory", 13 ) == 0 )
      {
        FT_Byte*  cur2;
 
 
        /* skip the `FontDirectory' keyword */
        T1_Skip_PS_Token( parser );
        T1_Skip_Spaces  ( parser );
        cur = cur2 = parser->root.cursor;
 
        /* look up the `known' keyword */
        while ( cur < limit )
        {
          if ( *cur == 'k' && cur + 5 < limit             &&
                ft_strncmp( (char*)cur, "known", 5 ) == 0 )
            break;
 
          T1_Skip_PS_Token( parser );
          if ( parser->root.error )
            goto Exit;
          T1_Skip_Spaces  ( parser );
          cur = parser->root.cursor;
        }
 
        if ( cur < limit )
        {
          T1_TokenRec  token;
 
 
          /* skip the `known' keyword and the token following it */
          T1_Skip_PS_Token( parser );
          T1_ToToken( parser, &token );
 
          /* if the last token was an array, skip it! */
          if ( token.type == T1_TOKEN_TYPE_ARRAY )
            cur2 = parser->root.cursor;
        }
        parser->root.cursor = cur2;
      }
 
      /* look for immediates */
      else if ( *cur == '/' && cur + 2 < limit )
      {
        FT_UInt  len;
 
 
        cur++;
 
        parser->root.cursor = cur;
        T1_Skip_PS_Token( parser );
        if ( parser->root.error )
          goto Exit;
 
        len = (FT_UInt)( parser->root.cursor - cur );
 
        if ( len > 0 && len < 22 && parser->root.cursor < limit )
        {
          int  i;
 
 
          /* now compare the immediate name to the keyword table */
 
          /* loop through all known keywords */
          for ( i = 0; i < n_keywords; i++ )
          {
            T1_Field  keyword = (T1_Field)&t42_keywords[i];
            FT_Byte   *name   = (FT_Byte*)keyword->ident;
 
 
            if ( !name )
              continue;
 
            if ( cur[0] == name[0]                      &&
                 len == ft_strlen( (const char *)name ) &&
                 ft_memcmp( cur, name, len ) == 0       )
            {
              /* we found it -- run the parsing callback! */
              parser->root.error = t42_load_keyword( face,
                                                     loader,
                                                     keyword );
              if ( parser->root.error )
                return parser->root.error;
              break;
            }
          }
        }
      }
      else
      {
        T1_Skip_PS_Token( parser );
        if ( parser->root.error )
          goto Exit;
      }
 
      T1_Skip_Spaces( parser );
    }
 
  Exit:
    return parser->root.error;
  }

Referenced by T42_Open_Face().

t42_parser_done()

t42_parser_done

(

T42_Parser

parser

)

Definition at line 220 of file t42parse.c.

  {
    FT_Memory  memory = parser->root.memory;
 
 
    /* free the base dictionary only when we have a disk stream */
    if ( !parser->in_memory )
      FT_FREE( parser->base_dict );
 
    parser->root.funcs.done( &parser->root );
  }

Referenced by t42_loader_done().

t42_parser_init()

t42_parser_init	(	T42_Parser	parser,
		FT_Stream	stream,
		FT_Memory	memory,
		PSAux_Service	psaux
	)

Definition at line 136 of file t42parse.c.

  {
    FT_Error  error = FT_Err_Ok;
    FT_Long   size;
 
 
    psaux->ps_parser_funcs->init( &parser->root, NULL, NULL, memory );
 
    parser->stream    = stream;
    parser->base_len  = 0;
    parser->base_dict = NULL;
    parser->in_memory = 0;
 
    /*******************************************************************/
    /*                                                                 */
    /* Here a short summary of what is going on:                       */
    /*                                                                 */
    /*   When creating a new Type 42 parser, we try to locate and load */
    /*   the base dictionary, loading the whole font into memory.      */
    /*                                                                 */
    /*   When `loading' the base dictionary, we only set up pointers   */
    /*   in the case of a memory-based stream.  Otherwise, we allocate */
    /*   and load the base dictionary in it.                           */
    /*                                                                 */
    /*   parser->in_memory is set if we have a memory stream.          */
    /*                                                                 */
 
    if ( FT_STREAM_SEEK( 0L ) ||
         FT_FRAME_ENTER( 17 ) )
      goto Exit;
 
    if ( ft_memcmp( stream->cursor, "%!PS-TrueTypeFont", 17 ) != 0 )
    {
      FT_TRACE2(( "  not a Type42 font\n" ));
      error = FT_THROW( Unknown_File_Format );
    }
 
    FT_FRAME_EXIT();
 
    if ( error || FT_STREAM_SEEK( 0 ) )
      goto Exit;
 
    size = (FT_Long)stream->size;
 
    /* now, try to load `size' bytes of the `base' dictionary we */
    /* found previously                                          */
 
    /* if it is a memory-based resource, set up pointers */
    if ( !stream->read )
    {
      parser->base_dict = (FT_Byte*)stream->base + stream->pos;
      parser->base_len  = size;
      parser->in_memory = 1;
 
      /* check that the `size' field is valid */
      if ( FT_STREAM_SKIP( size ) )
        goto Exit;
    }
    else
    {
      /* read segment in memory */
      if ( FT_ALLOC( parser->base_dict, size )       ||
           FT_STREAM_READ( parser->base_dict, size ) )
        goto Exit;
 
      parser->base_len = size;
    }
 
    parser->root.base   = parser->base_dict;
    parser->root.cursor = parser->base_dict;
    parser->root.limit  = parser->root.cursor + parser->base_len;
 
  Exit:
    if ( error && !parser->in_memory )
      FT_FREE( parser->base_dict );
 
    return error;
  }

Referenced by T42_Open_Face().