cidparse.h File Reference

#include <freetype/internal/t1types.h>
#include <freetype/internal/ftstream.h>
#include <freetype/internal/psaux.h>

Include dependency graph for cidparse.h:

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

Go to the source code of this file.

Classes
struct	CID_Parser_

Macros
#define	cid_parser_skip_spaces(p)    (p)->root.funcs.skip_spaces( &(p)->root )
#define	cid_parser_skip_PS_token(p)    (p)->root.funcs.skip_PS_token( &(p)->root )
#define	cid_parser_to_int(p)   (p)->root.funcs.to_int( &(p)->root )
#define	cid_parser_to_fixed(p, t)   (p)->root.funcs.to_fixed( &(p)->root, t )
#define	cid_parser_to_coord_array(p, m, c)    (p)->root.funcs.to_coord_array( &(p)->root, m, c )
#define	cid_parser_to_fixed_array(p, m, f, t)    (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )
#define	cid_parser_to_token(p, t)    (p)->root.funcs.to_token( &(p)->root, t )
#define	cid_parser_to_token_array(p, t, m, c)    (p)->root.funcs.to_token_array( &(p)->root, t, m, c )
#define	cid_parser_load_field(p, f, o)    (p)->root.funcs.load_field( &(p)->root, f, o, 0, 0 )
#define	cid_parser_load_field_table(p, f, o)    (p)->root.funcs.load_field_table( &(p)->root, f, o, 0, 0 )

Typedefs
typedef FT_BEGIN_HEADER struct CID_Parser_	CID_Parser

Functions
	cid_parser_new (CID_Parser *parser, FT_Stream stream, FT_Memory memory, PSAux_Service psaux)
	cid_parser_done (CID_Parser *parser)

Macro Definition Documentation

cid_parser_load_field

#define cid_parser_load_field	(		p,
			f,
			o
	)		(p)->root.funcs.load_field( &(p)->root, f, o, 0, 0 )

Definition at line 119 of file cidparse.h.

cid_parser_load_field_table

#define cid_parser_load_field_table	(		p,
			f,
			o
	)		(p)->root.funcs.load_field_table( &(p)->root, f, o, 0, 0 )

Definition at line 121 of file cidparse.h.

cid_parser_skip_PS_token

#define cid_parser_skip_PS_token

(

p

)

(p)->root.funcs.skip_PS_token( &(p)->root )

Definition at line 104 of file cidparse.h.

cid_parser_skip_spaces

#define cid_parser_skip_spaces

(

p

)

(p)->root.funcs.skip_spaces( &(p)->root )

Definition at line 102 of file cidparse.h.

cid_parser_to_coord_array

#define cid_parser_to_coord_array	(		p,
			m,
			c
	)		(p)->root.funcs.to_coord_array( &(p)->root, m, c )

Definition at line 110 of file cidparse.h.

cid_parser_to_fixed

#define cid_parser_to_fixed	(		p,
			t
	)		(p)->root.funcs.to_fixed( &(p)->root, t )

Definition at line 108 of file cidparse.h.

cid_parser_to_fixed_array

#define cid_parser_to_fixed_array	(		p,
			m,
			f,
			t
	)		(p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )

Definition at line 112 of file cidparse.h.

cid_parser_to_int

#define cid_parser_to_int

(

p

)

(p)->root.funcs.to_int( &(p)->root )

Definition at line 107 of file cidparse.h.

cid_parser_to_token

#define cid_parser_to_token	(		p,
			t
	)		(p)->root.funcs.to_token( &(p)->root, t )

Definition at line 114 of file cidparse.h.

cid_parser_to_token_array

#define cid_parser_to_token_array	(		p,
			t,
			m,
			c
	)		(p)->root.funcs.to_token_array( &(p)->root, t, m, c )

Definition at line 116 of file cidparse.h.

Typedef Documentation

CID_Parser

typedef FT_BEGIN_HEADER struct CID_Parser_ CID_Parser

Function Documentation

cid_parser_done()

cid_parser_done

(

CID_Parser *

parser

)

Definition at line 262 of file cidparse.c.

  {
    /* always free the private dictionary */
    if ( parser->postscript )
    {
      FT_Stream  stream = parser->stream;
 
 
      FT_FRAME_RELEASE( parser->postscript );
    }
    parser->root.funcs.done( &parser->root );
  }

Referenced by cid_done_loader().

cid_parser_new()

cid_parser_new	(	CID_Parser *	parser,
		FT_Stream	stream,
		FT_Memory	memory,
		PSAux_Service	psaux
	)

Definition at line 56 of file cidparse.c.

  {
    FT_Error  error;
    FT_ULong  base_offset, offset, ps_len;
    FT_Byte   *cur, *limit;
    FT_Byte   *arg1, *arg2;
 
 
    FT_ZERO( parser );
    psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );
 
    parser->stream = stream;
 
    base_offset = FT_STREAM_POS();
 
    /* first of all, check the font format in the header */
    if ( FT_FRAME_ENTER( 31 ) )
      goto Exit;
 
    if ( ft_strncmp( (char *)stream->cursor,
                     "%!PS-Adobe-3.0 Resource-CIDFont", 31 ) )
    {
      FT_TRACE2(( "  not a CID-keyed font\n" ));
      error = FT_THROW( Unknown_File_Format );
    }
 
    FT_FRAME_EXIT();
    if ( error )
      goto Exit;
 
  Again:
    /* now, read the rest of the file until we find */
    /* `StartData' or `/sfnts'                      */
    {
      /*
       * The algorithm is as follows (omitting the case with less than 256
       * bytes to fill for simplicity).
       *
       * 1. Fill the buffer with 256 + STARTDATA_LEN bytes.
       *
       * 2. Search for the STARTDATA and SFNTS strings at positions
       *    buffer[0], buffer[1], ...,
       *    buffer[255 + STARTDATA_LEN - SFNTS_LEN].
       *
       * 3. Move the last STARTDATA_LEN bytes to buffer[0].
       *
       * 4. Fill the buffer with 256 bytes, starting at STARTDATA_LEN.
       *
       * 5. Repeat with step 2.
       *
       */
      FT_Byte  buffer[256 + STARTDATA_LEN + 1];
 
      /* values for the first loop */
      FT_ULong  read_len    = 256 + STARTDATA_LEN;
      FT_ULong  read_offset = 0;
      FT_Byte*  p           = buffer;
 
 
      for ( offset = FT_STREAM_POS(); ; offset += 256 )
      {
        FT_ULong  stream_len;
 
 
        stream_len = stream->size - FT_STREAM_POS();
 
        read_len = FT_MIN( read_len, stream_len );
        if ( FT_STREAM_READ( p, read_len ) )
          goto Exit;
 
        /* ensure that we do not compare with data beyond the buffer */
        p[read_len] = '\0';
 
        limit = p + read_len - SFNTS_LEN;
 
        for ( p = buffer; p < limit; p++ )
        {
          if ( p[0] == 'S'                                           &&
               ft_strncmp( (char*)p, STARTDATA, STARTDATA_LEN ) == 0 )
          {
            /* save offset of binary data after `StartData' */
            offset += (FT_ULong)( p - buffer ) + STARTDATA_LEN + 1;
            goto Found;
          }
          else if ( p[1] == 's'                                   &&
                    ft_strncmp( (char*)p, SFNTS, SFNTS_LEN ) == 0 )
          {
            offset += (FT_ULong)( p - buffer ) + SFNTS_LEN + 1;
            goto Found;
          }
        }
 
        if ( read_offset + read_len < STARTDATA_LEN )
        {
          FT_TRACE2(( "cid_parser_new: no `StartData' keyword found\n" ));
          error = FT_THROW( Invalid_File_Format );
          goto Exit;
        }
 
        FT_MEM_MOVE( buffer,
                     buffer + read_offset + read_len - STARTDATA_LEN,
                     STARTDATA_LEN );
 
        /* values for the next loop */
        read_len    = 256;
        read_offset = STARTDATA_LEN;
        p           = buffer + read_offset;
      }
    }
 
  Found:
    /* We have found the start of the binary data or the `/sfnts' token. */
    /* Now rewind and extract the frame corresponding to this PostScript */
    /* section.                                                          */
 
    ps_len = offset - base_offset;
    if ( FT_STREAM_SEEK( base_offset )                  ||
         FT_FRAME_EXTRACT( ps_len, parser->postscript ) )
      goto Exit;
 
    parser->data_offset    = offset;
    parser->postscript_len = ps_len;
    parser->root.base      = parser->postscript;
    parser->root.cursor    = parser->postscript;
    parser->root.limit     = parser->root.cursor + ps_len;
    parser->num_dict       = -1;
 
    /* Finally, we check whether `StartData' or `/sfnts' was real --  */
    /* it could be in a comment or string.  We also get the arguments */
    /* of `StartData' to find out whether the data is represented in  */
    /* binary or hex format.                                          */
 
    arg1 = parser->root.cursor;
    cid_parser_skip_PS_token( parser );
    cid_parser_skip_spaces  ( parser );
    arg2 = parser->root.cursor;
    cid_parser_skip_PS_token( parser );
    cid_parser_skip_spaces  ( parser );
 
    limit = parser->root.limit;
    cur   = parser->root.cursor;
 
    while ( cur <= limit - SFNTS_LEN )
    {
      if ( parser->root.error )
      {
        error = parser->root.error;
        goto Exit;
      }
 
      if ( cur[0] == 'S'                                           &&
           cur <= limit - STARTDATA_LEN                            &&
           ft_strncmp( (char*)cur, STARTDATA, STARTDATA_LEN ) == 0 )
      {
        if ( ft_strncmp( (char*)arg1, "(Hex)", 5 ) == 0 )
        {
          FT_Long  tmp = ft_strtol( (const char *)arg2, NULL, 10 );
 
 
          if ( tmp < 0 )
          {
            FT_ERROR(( "cid_parser_new: invalid length of hex data\n" ));
            error = FT_THROW( Invalid_File_Format );
          }
          else
            parser->binary_length = (FT_ULong)tmp;
        }
 
        goto Exit;
      }
      else if ( cur[1] == 's'                                   &&
                ft_strncmp( (char*)cur, SFNTS, SFNTS_LEN ) == 0 )
      {
        FT_TRACE2(( "cid_parser_new: cannot handle Type 11 fonts\n" ));
        error = FT_THROW( Unknown_File_Format );
        goto Exit;
      }
 
      cid_parser_skip_PS_token( parser );
      cid_parser_skip_spaces  ( parser );
      arg1 = arg2;
      arg2 = cur;
      cur  = parser->root.cursor;
    }
 
    /* we haven't found the correct `StartData'; go back and continue */
    /* searching                                                      */
    FT_FRAME_RELEASE( parser->postscript );
    if ( !FT_STREAM_SEEK( offset ) )
      goto Again;
 
  Exit:
    return error;
  }

Referenced by cid_face_open().