/****************************************************************************/
/*                                                                          */
/* 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;
  }