src/freetype/type1/t1parse.c

/***************************************************************************/
/*                                                                         */
/*  t1parse.c                                                              */
/*                                                                         */
/*    Type 1 parser (body).                                                */
/*                                                                         */
/*  Copyright 1996-2000 by                                                 */
/*  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.                                        */
/*                                                                         */
/***************************************************************************/


#include <freetype/internal/ftdebug.h>
#include <freetype/internal/t1types.h>


#ifdef FT_FLAT_COMPILE

#include "t1parse.h"

#else

#include <type1/t1parse.h>

#endif


#include <stdio.h>  /* for sscanf()  */
#include <string.h> /* for strncpy() */


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    T1_New_Table                                                       */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Initializes a T1_Table structure.                                  */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    table  :: The address of the target table.                         */
  /*                                                                       */
  /* <Input>                                                               */
  /*    count  :: The table size (i.e. maximum number of elements).        */
  /*    memory :: The memory object to use for all subsequent              */
  /*              reallocations.                                           */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  LOCAL_FUNC
  FT_Error  T1_New_Table( T1_Table*  table,
                          FT_Int     count,
                          FT_Memory  memory )
  {
	 FT_Error  error;


	 table->memory = memory;

	 if ( ALLOC_ARRAY( table->elements, count, FT_Byte* ) )
		 return error;

	 if ( ALLOC_ARRAY( table->lengths, count, FT_Byte* ) )
	 {
	   FREE( table->elements );
	   return error;
	}

	table->max_elems = count;
	table->num_elems = 0;

	table->block        = 0;
	table->capacity     = 0;
	table->cursor       = 0;

	return error;
  }


  static
  FT_Error  reallocate_t1_table( T1_Table*  table,
                                 FT_Int     new_size )
  {
    FT_Memory  memory   = table->memory;
    FT_Byte*   old_base = table->block;
    FT_Error   error;


    /* reallocate the base block */
    if ( REALLOC( table->block, table->capacity, new_size ) )
      return error;
    table->capacity = new_size;

    /* shift all offsets if necessary */
    if ( old_base )
    {
      FT_Long    delta  = table->block - old_base;
      FT_Byte**  offset = table->elements;
      FT_Byte**  limit  = offset + table->max_elems;


      if ( delta )
        for ( ; offset < limit; offset ++ )
          if (offset[0])
            offset[0] += delta;
    }

    return T1_Err_Ok;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    T1_Add_Table                                                       */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Adds an object to a T1_Table, possibly growing its memory block.   */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    table  :: The target table.                                        */
  /*                                                                       */
  /* <Input>                                                               */
  /*    index  :: The index of the object in the table.                    */
  /*                                                                       */
  /*    object :: The address of the object to copy in memory.             */
  /*                                                                       */
  /*    length :: The length in bytes of the source object.                */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.  An error is returned if a  */
  /*    reallocation failed.                                               */
  /*                                                                       */
  LOCAL_FUNC
  FT_Error  T1_Add_Table( T1_Table*  table,
                          FT_Int     index,
                          void*      object,
                          FT_Int     length )
  {
	if ( index < 0 || index > table->max_elems )
    {
	  FT_ERROR(( "T1_Add_Table: invalid index\n" ));
	  return T1_Err_Syntax_Error;
    }

    /* grow the base block if needed */
    if ( table->cursor + length > table->capacity )
    {
      FT_Error  error;
      FT_Int    new_size = table->capacity;


      while ( new_size < table->cursor + length )
        new_size += 1024;

      error = reallocate_t1_table( table, new_size );
      if ( error )
        return error;
    }

    /* add the object to the base block and adjust offset */
    table->elements[index] = table->block + table->cursor;
    table->lengths [index] = length;
    MEM_Copy( table->block + table->cursor, object, length );

    table->cursor += length;

    return T1_Err_Ok;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    T1_Done_Table                                                      */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Finalize a T1_Table (reallocate it to its current cursor).         */
  /*                                                                       */
  /* <Input>                                                               */
  /*    table :: The target table.                                         */
  /*                                                                       */
  /* <Note>                                                                */
  /*    This function does NOT release the heap's memory block.  It is up  */
  /*    to the caller to clean it, or reference it in its own structures.  */
  /*                                                                       */
  LOCAL_FUNC
  void  T1_Done_Table( T1_Table*  table )
  {
    FT_Memory  memory = table->memory;
    FT_Error   error;
    FT_Byte*   old_base;


    /* should never fail, as rec.cursor <= rec.size */
    old_base = table->block;
    if ( !old_base )
      return;

    (void)REALLOC( table->block, table->capacity, table->cursor );
    table->capacity = table->cursor;

    if ( old_base != table->block )
    {
      FT_Long    delta   = table->block - old_base;
      FT_Byte**  element = table->elements;
      FT_Byte**  limit   = element + table->max_elems;


      for ( ; element < limit; element++ )
        if ( element[0] )
          element[0] += delta;
    }
  }


  LOCAL_FUNC
  FT_String*  CopyString( T1_Parser*  parser )
  {
    FT_String*  string = NULL;
    T1_Token*   token  = parser->args++;
    FT_Memory   memory = parser->tokenizer->memory;
    FT_Error    error;


    if ( token->kind == tok_string )
    {
      FT_Int  len = token->len - 2;


      if ( ALLOC( string, len + 1 ) )
      {
        parser->error = error;
        return 0;
      }

      MEM_Copy( string, parser->tokenizer->base + token->start + 1, len );
      string[len] = '\0';

      parser->error = T1_Err_Ok;
    }
    else
    {
      FT_ERROR(( "T1_CopyString: syntax error, string token expected!\n" ));
      parser->error = T1_Err_Syntax_Error;
    }

    return string;
  }


  static
  FT_Error  parse_int( FT_Byte*  base,
                       FT_Byte*  limit,
                       FT_Long*  result )
  {
    FT_Bool  sign = 0;
    FT_Long  sum  = 0;


    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:
    FT_ERROR(( "parse_int: integer expected\n" ));
    *result = 0;
    return T1_Err_Syntax_Error;
  }


  static
  FT_Error  parse_float( FT_Byte*  base,
                         FT_Byte*  limit,
                         FT_Long   scale,
                         FT_Long*  result )
  {
#if 1

    /* XXX: We are simply much too lazy to code this function   */
    /*      properly for now.  We will do that when the rest of */
    /*      the driver works properly.                          */
    char    temp[32];
    int     len = limit - base;
    double  value;


    if ( len > 31 )
      goto Fail;

    strncpy( temp, (char*)base, len );
    temp[len] = '\0';
    if ( sscanf( temp, "%lf", &value ) != 1 )
      goto Fail;

    *result = (FT_Long)( scale * value );
    return 0;

#else

    FT_Byte*  cur;
    FT_Bool   sign        = 0;  /* sign                        */
    FT_Long   number_int  = 0;  /* integer part                */
    FT_Long   number_frac = 0;  /* fractional part             */
    FT_Long   exponent    = 0;  /* exponent value              */
    FT_Int    num_frac    = 0;  /* number of fractional digits */


    /* check sign */
    if ( *base == '+' )
      base++;

    else if ( *base == '-' )
    {
      sign++;
      base++;
    }

    /* find integer part */
    cur = base;
    while ( cur < limit )
    {
      FT_Byte  c = *cur;


      if ( c == '.' || c == 'e' || c == 'E' )
        break;

      cur++;
    }

    if ( cur > base )
    {
      error = parse_integer( base, cur, &number_int );
      if ( error )
        goto Fail;
    }

    /* read fractional part, if any */
    if ( *cur == '.' )
    {
      cur++;
      base = cur;
      while ( cur < limit )
      {
        FT_Byte  c = *cur;


        if ( c == 'e' || c == 'E' )
          break;
        cur++;
      }

      num_frac = cur - base;

      if ( cur > base )
      {
        error = parse_integer( base, cur, &number_frac );
        if ( error )
          goto Fail;
        base = cur;
      }
   }

    /* read exponent, if any */
    if ( *cur == 'e' || *cur == 'E' )
    {
      cur++;
      base = cur;
      error = parse_integer( base, limit, &exponent );
      if ( error )
        goto Fail;

      /* now check that exponent is within `correct bounds' */
      /* i.e. between -6 and 6                              */
      if ( exponent < -6 || exponent > 6 )
        goto Fail;
    }

    /* now adjust integer value and exponent for fractional part */
    while ( num_frac > 0 )
    {
      number_int *= 10;
      exponent--;
      num_frac--;
    }

    number_int += num_frac;

    /* skip point if any, read fractional part */
    if ( cur + 1 < limit )
    {
      if (*cur..
    }

    /* now compute scaled float value */
    /* XXX: incomplete!               */

#endif /* 1 */

  Fail:
    FT_ERROR(( "parse_float: syntax error!\n" ));
    return T1_Err_Syntax_Error;
  }


  static
  FT_Error  parse_integer( FT_Byte*  base,
                           FT_Byte*  limit,
                           FT_Long*  result )
  {
    FT_Byte*  cur;


    /* the lexical analyser accepts floats as well as integers */
    /* now; check that we really have an int in this token     */
    cur = base;
    while ( cur < limit )
    {
      FT_Byte  c = *cur++;


      if ( c == '.' || c == 'e' || c == 'E' )
        goto Float_Number;
    }

    /* now read the number's value */
    return parse_int( base, limit, result );

  Float_Number:
    /* we really have a float there; simply call parse_float in this */
    /* case with a scale of `10' to perform round                    */
    {
      FT_Error error;


      error = parse_float( base, limit, 10, result );
      if ( !error )
      {
        if ( *result >= 0 )
          *result = ( *result + 5 ) / 10;      /* round value */
        else
          *result = -( ( 5 - *result ) / 10 );
      }
      return error;
    }
  }


  LOCAL_FUNC
  FT_Long  CopyInteger( T1_Parser*  parser )
  {
    FT_Long    sum   = 0;
    T1_Token*  token = parser->args++;


    if ( token->kind == tok_number )
    {
      FT_Byte*  base  = parser->tokenizer->base + token->start;
      FT_Byte*  limit = base + token->len;


      /* now read the number's value */
      parser->error = parse_integer( base, limit, &sum );
      return sum;
    }

    FT_ERROR(( "CopyInteger: number expected\n" ));
    parser->args--;
    parser->error = T1_Err_Syntax_Error;
    return 0;
  }


  LOCAL_FUNC
  FT_Bool   CopyBoolean( T1_Parser*  parser )
  {
    FT_Error   error  = T1_Err_Ok;
    FT_Bool    result = 0;
    T1_Token*  token  = parser->args++;


    if ( token->kind == tok_keyword )
    {
      if ( token->kind2 == key_false )
        result = 0;

      else if ( token->kind2 == key_true )
        result = !0;

      else
        goto Fail;
    }
    else
    {
      Fail:
        FT_ERROR(( "CopyBoolean:" ));
        FT_ERROR(( " syntax error; `false' or `true' expected\n" ));
        error = T1_Err_Syntax_Error;
    }
    parser->error = error;
    return result;
  }


  LOCAL_FUNC
  FT_Long   CopyFloat( T1_Parser*  parser,
                       FT_Int      scale )
  {
    FT_Error   error;
    FT_Long    sum = 0;
    T1_Token*  token = parser->args++;


    if ( token->kind == tok_number )
    {
      FT_Byte*  base  = parser->tokenizer->base + token->start;
      FT_Byte*  limit = base + token->len;


      error = parser->error = parse_float( base, limit, scale, &sum );
      if ( error )
        goto Fail;

      return sum;
    }

  Fail:
    FT_ERROR(( "CopyFloat: syntax error!\n" ));
    parser->error = T1_Err_Syntax_Error;
    return 0;
  }


  LOCAL_FUNC
  void  CopyBBox( T1_Parser*  parser,
                  FT_BBox*    bbox )
  {
    T1_Token*  token = parser->args++;
    FT_Int     n;
    FT_Error   error;


    if ( token->kind == tok_program ||
         token->kind == tok_array   )
    {
      /* get rid of `['/`]', or `{'/`}' */
      FT_Byte*  base  = parser->tokenizer->base + token->start + 1;
      FT_Byte*  limit = base + token->len - 2;
      FT_Byte*  cur;
      FT_Byte*  start;


      /* read each parameter independently */
      cur = base;
      for ( n = 0; n < 4; n++ )
      {
        FT_Long*  result;


        /* skip whitespace */
        while ( cur < limit && *cur == ' ' )
          cur++;

        /* skip numbers */
        start = cur;
        while ( cur < limit && *cur != ' ' )
          cur++;

        /* compute result address */
        switch ( n )
        {
        case 0:
          result = &bbox->xMin;
          break;
        case 1:
          result = &bbox->yMin;
          break;
        case 2:
          result = &bbox->xMax;
          break;
        default:
          result = &bbox->yMax;
        }

        error = parse_integer( start, cur, result );
        if ( error )
          goto Fail;
      }
      parser->error = 0;
      return;
    }

  Fail:
    FT_ERROR(( "CopyBBox: syntax error!\n" ));
    parser->error = T1_Err_Syntax_Error;
  }


  LOCAL_FUNC
  void  CopyMatrix( T1_Parser*  parser,
                    FT_Matrix*  matrix )
  {
    T1_Token* token = parser->args++;
    FT_Error  error;


    if ( token->kind == tok_array )
    {
      /* get rid of `[' and `]' */
      FT_Byte*  base  = parser->tokenizer->base + token->start + 1;
      FT_Byte*  limit = base + token->len - 2;
      FT_Byte*  cur;
      FT_Byte*  start;
      FT_Int    n;


      /* read each parameter independently */
      cur = base;
      for ( n = 0; n < 4; n++ )
      {
        FT_Long*  result;


        /* skip whitespace */
        while ( cur < limit && *cur == ' ' )
          cur++;

        /* skip numbers */
        start = cur;
        while ( cur < limit && *cur != ' ')
          cur++;

        /* compute result address */
        switch ( n )
        {
        case 0:
          result = &matrix->xx;
          break;
        case 1:
          result = &matrix->yx;
          break;
        case 2:
          result = &matrix->xy;
          break;
        default:
          result = &matrix->yy;
        }

        error = parse_float( start, cur, 65536000L, result );
        if ( error )
          goto Fail;
      }
      parser->error = 0;
      return;
    }

  Fail:
    FT_ERROR(( "CopyMatrix: syntax error!\n" ));
    parser->error = T1_Err_Syntax_Error;
  }


  LOCAL_FUNC
  void  CopyArray( T1_Parser*  parser,
                   FT_Byte*    num_elements,
                   FT_Short*   elements,
                   FT_Int      max_elements )
  {
    T1_Token* token = parser->args++;
    FT_Error  error;


    if ( token->kind == tok_array   ||
         token->kind == tok_program )   /* in the case of MinFeature */
    {
      /* get rid of `['/`]', or `{'/`}' */
      FT_Byte*  base  = parser->tokenizer->base + token->start + 1;
      FT_Byte*  limit = base + token->len - 2;
      FT_Byte*  cur;
      FT_Byte*  start;
      FT_Int    n;


      /* read each parameter independently */
      cur = base;
      for ( n = 0; n < max_elements; n++ )
      {
        FT_Long  result;


        /* test end of string */
        if ( cur >= limit )
          break;

        /* skip whitespace */
        while ( cur < limit && *cur == ' ' )
          cur++;

        /* end of list? */
        if ( cur >= limit )
          break;

        /* skip numbers */
        start = cur;
        while ( cur < limit && *cur != ' ' )
          cur++;

        error = parse_integer( start, cur, &result );
        if ( error )
          goto Fail;

        *elements++ = (FT_Short)result;
      }

      if ( num_elements )
        *num_elements = (FT_Byte)n;

      parser->error = 0;
      return;
    }

  Fail:
    FT_ERROR(( "CopyArray: syntax error!\n" ));
    parser->error = T1_Err_Syntax_Error;
  }


/* END */
Commit	Line	Data
	1	/***************************************************************************/
	2	/* */
	3	/* t1parse.c */
	4	/* */
	5	/* Type 1 parser (body). */
	6	/* */
	7	/* Copyright 1996-2000 by */
	8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
	9	/* */
	10	/* This file is part of the FreeType project, and may only be used, */
	11	/* modified, and distributed under the terms of the FreeType project */
	12	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
	13	/* this file you indicate that you have read the license and */
	14	/* understand and accept it fully. */
	15	/* */
	16	/***************************************************************************/
	17
	18
	19	#include <freetype/internal/ftdebug.h>
	20	#include <freetype/internal/t1types.h>
	21
	22
	23	#ifdef FT_FLAT_COMPILE
	24
	25	#include "t1parse.h"
	26
	27	#else
	28
	29	#include <type1/t1parse.h>
	30
	31	#endif
	32
	33
	34	#include <stdio.h> /* for sscanf() */
	35	#include <string.h> /* for strncpy() */
	36
	37
	38	/*************************************************************************/
	39	/* */
	40	/* <Function> */
	41	/* T1_New_Table */
	42	/* */
	43	/* <Description> */
	44	/* Initializes a T1_Table structure. */
	45	/* */
	46	/* <InOut> */
	47	/* table :: The address of the target table. */
	48	/* */
	49	/* <Input> */
	50	/* count :: The table size (i.e. maximum number of elements). */
	51	/* memory :: The memory object to use for all subsequent */
	52	/* reallocations. */
	53	/* */
	54	/* <Return> */
	55	/* FreeType error code. 0 means success. */
	56	/* */
	57	LOCAL_FUNC
	58	FT_Error T1_New_Table( T1_Table* table,
	59	FT_Int count,
	60	FT_Memory memory )
	61	{
	62	FT_Error error;
	63
	64
	65	table->memory = memory;
	66
	67	if ( ALLOC_ARRAY( table->elements, count, FT_Byte* ) )
	68	return error;
	69
	70	if ( ALLOC_ARRAY( table->lengths, count, FT_Byte* ) )
	71	{
	72	FREE( table->elements );
	73	return error;
	74	}
	75
	76	table->max_elems = count;
	77	table->num_elems = 0;
	78
	79	table->block = 0;
	80	table->capacity = 0;
	81	table->cursor = 0;
	82
	83	return error;
	84	}
	85
	86
	87	static
	88	FT_Error reallocate_t1_table( T1_Table* table,
	89	FT_Int new_size )
	90	{
	91	FT_Memory memory = table->memory;
	92	FT_Byte* old_base = table->block;
	93	FT_Error error;
	94
	95
	96	/* reallocate the base block */
	97	if ( REALLOC( table->block, table->capacity, new_size ) )
	98	return error;
	99	table->capacity = new_size;
	100
	101	/* shift all offsets if necessary */
	102	if ( old_base )
	103	{
	104	FT_Long delta = table->block - old_base;
	105	FT_Byte** offset = table->elements;
	106	FT_Byte** limit = offset + table->max_elems;
	107
	108
	109	if ( delta )
	110	for ( ; offset < limit; offset ++ )
	111	if (offset[0])
	112	offset[0] += delta;
	113	}
	114
	115	return T1_Err_Ok;
	116	}
	117
	118
	119	/*************************************************************************/
	120	/* */
	121	/* <Function> */
	122	/* T1_Add_Table */
	123	/* */
	124	/* <Description> */
	125	/* Adds an object to a T1_Table, possibly growing its memory block. */
	126	/* */
	127	/* <InOut> */
	128	/* table :: The target table. */
	129	/* */
	130	/* <Input> */
	131	/* index :: The index of the object in the table. */
	132	/* */
	133	/* object :: The address of the object to copy in memory. */
	134	/* */
	135	/* length :: The length in bytes of the source object. */
	136	/* */
	137	/* <Return> */
	138	/* FreeType error code. 0 means success. An error is returned if a */
	139	/* reallocation failed. */
	140	/* */
	141	LOCAL_FUNC
	142	FT_Error T1_Add_Table( T1_Table* table,
	143	FT_Int index,
	144	void* object,
	145	FT_Int length )
	146	{
	147	if ( index < 0 \|\| index > table->max_elems )
	148	{
	149	FT_ERROR(( "T1_Add_Table: invalid index\n" ));
	150	return T1_Err_Syntax_Error;
	151	}
	152
	153	/* grow the base block if needed */
	154	if ( table->cursor + length > table->capacity )
	155	{
	156	FT_Error error;
	157	FT_Int new_size = table->capacity;
	158
	159
	160	while ( new_size < table->cursor + length )
	161	new_size += 1024;
	162
	163	error = reallocate_t1_table( table, new_size );
	164	if ( error )
	165	return error;
	166	}
	167
	168	/* add the object to the base block and adjust offset */
	169	table->elements[index] = table->block + table->cursor;
	170	table->lengths [index] = length;
	171	MEM_Copy( table->block + table->cursor, object, length );
	172
	173	table->cursor += length;
	174
	175	return T1_Err_Ok;
	176	}
	177
	178
	179	/*************************************************************************/
	180	/* */
	181	/* <Function> */
	182	/* T1_Done_Table */
	183	/* */
	184	/* <Description> */
	185	/* Finalize a T1_Table (reallocate it to its current cursor). */
	186	/* */
	187	/* <Input> */
	188	/* table :: The target table. */
	189	/* */
	190	/* <Note> */
	191	/* This function does NOT release the heap's memory block. It is up */
	192	/* to the caller to clean it, or reference it in its own structures. */
	193	/* */
	194	LOCAL_FUNC
	195	void T1_Done_Table( T1_Table* table )
	196	{
	197	FT_Memory memory = table->memory;
	198	FT_Error error;
	199	FT_Byte* old_base;
	200
	201
	202	/* should never fail, as rec.cursor <= rec.size */
	203	old_base = table->block;
	204	if ( !old_base )
	205	return;
	206
	207	(void)REALLOC( table->block, table->capacity, table->cursor );
	208	table->capacity = table->cursor;
	209
	210	if ( old_base != table->block )
	211	{
	212	FT_Long delta = table->block - old_base;
	213	FT_Byte** element = table->elements;
	214	FT_Byte** limit = element + table->max_elems;
	215
	216
	217	for ( ; element < limit; element++ )
	218	if ( element[0] )
	219	element[0] += delta;
	220	}
	221	}
	222
	223
	224	LOCAL_FUNC
	225	FT_String* CopyString( T1_Parser* parser )
	226	{
	227	FT_String* string = NULL;
	228	T1_Token* token = parser->args++;
	229	FT_Memory memory = parser->tokenizer->memory;
	230	FT_Error error;
	231
	232
	233	if ( token->kind == tok_string )
	234	{
	235	FT_Int len = token->len - 2;
	236
	237
	238	if ( ALLOC( string, len + 1 ) )
	239	{
	240	parser->error = error;
	241	return 0;
	242	}
	243
	244	MEM_Copy( string, parser->tokenizer->base + token->start + 1, len );
	245	string[len] = '\0';
	246
	247	parser->error = T1_Err_Ok;
	248	}
	249	else
	250	{
	251	FT_ERROR(( "T1_CopyString: syntax error, string token expected!\n" ));
	252	parser->error = T1_Err_Syntax_Error;
	253	}
	254
	255	return string;
	256	}
	257
	258
	259	static
	260	FT_Error parse_int( FT_Byte* base,
	261	FT_Byte* limit,
	262	FT_Long* result )
	263	{
	264	FT_Bool sign = 0;
	265	FT_Long sum = 0;
	266
	267
	268	if ( base >= limit )
	269	goto Fail;
	270
	271	/* check sign */
	272	if ( *base == '+' )
	273	base++;
	274
	275	else if ( *base == '-' )
	276	{
	277	sign++;
	278	base++;
	279	}
	280
	281	/* parse digits */
	282	if ( base >= limit )
	283	goto Fail;
	284
	285	do
	286	{
	287	sum = ( 10 * sum + ( *base++ - '0' ) );
	288
	289	} while ( base < limit );
	290
	291	if ( sign )
	292	sum = -sum;
	293
	294	*result = sum;
	295	return T1_Err_Ok;
	296
	297	Fail:
	298	FT_ERROR(( "parse_int: integer expected\n" ));
	299	*result = 0;
	300	return T1_Err_Syntax_Error;
	301	}
	302
	303
	304	static
	305	FT_Error parse_float( FT_Byte* base,
	306	FT_Byte* limit,
	307	FT_Long scale,
	308	FT_Long* result )
	309	{
	310	#if 1
	311
	312	/* XXX: We are simply much too lazy to code this function */
	313	/* properly for now. We will do that when the rest of */
	314	/* the driver works properly. */
	315	char temp[32];
	316	int len = limit - base;
	317	double value;
	318
	319
	320	if ( len > 31 )
	321	goto Fail;
	322
	323	strncpy( temp, (char*)base, len );
	324	temp[len] = '\0';
	325	if ( sscanf( temp, "%lf", &value ) != 1 )
	326	goto Fail;
	327
	328	result = (FT_Long)( scale value );
	329	return 0;
	330
	331	#else
	332
	333	FT_Byte* cur;
	334	FT_Bool sign = 0; /* sign */
	335	FT_Long number_int = 0; /* integer part */
	336	FT_Long number_frac = 0; /* fractional part */
	337	FT_Long exponent = 0; /* exponent value */
	338	FT_Int num_frac = 0; /* number of fractional digits */
	339
	340
	341	/* check sign */
	342	if ( *base == '+' )
	343	base++;
	344
	345	else if ( *base == '-' )
	346	{
	347	sign++;
	348	base++;
	349	}
	350
	351	/* find integer part */
	352	cur = base;
	353	while ( cur < limit )
	354	{
	355	FT_Byte c = *cur;
	356
	357
	358	if ( c == '.' \|\| c == 'e' \|\| c == 'E' )
	359	break;
	360
	361	cur++;
	362	}
	363
	364	if ( cur > base )
	365	{
	366	error = parse_integer( base, cur, &number_int );
	367	if ( error )
	368	goto Fail;
	369	}
	370
	371	/* read fractional part, if any */
	372	if ( *cur == '.' )
	373	{
	374	cur++;
	375	base = cur;
	376	while ( cur < limit )
	377	{
	378	FT_Byte c = *cur;
	379
	380
	381	if ( c == 'e' \|\| c == 'E' )
	382	break;
	383	cur++;
	384	}
	385
	386	num_frac = cur - base;
	387
	388	if ( cur > base )
	389	{
	390	error = parse_integer( base, cur, &number_frac );
	391	if ( error )
	392	goto Fail;
	393	base = cur;
	394	}
	395	}
	396
	397	/* read exponent, if any */
	398	if ( cur == 'e' \|\| cur == 'E' )
	399	{
	400	cur++;
	401	base = cur;
	402	error = parse_integer( base, limit, &exponent );
	403	if ( error )
	404	goto Fail;
	405
	406	/* now check that exponent is within `correct bounds' */
	407	/* i.e. between -6 and 6 */
	408	if ( exponent < -6 \|\| exponent > 6 )
	409	goto Fail;
	410	}
	411
	412	/* now adjust integer value and exponent for fractional part */
	413	while ( num_frac > 0 )
	414	{
	415	number_int *= 10;
	416	exponent--;
	417	num_frac--;
	418	}
	419
	420	number_int += num_frac;
	421
	422	/* skip point if any, read fractional part */
	423	if ( cur + 1 < limit )
	424	{
	425	if (*cur..
	426	}
	427
	428	/* now compute scaled float value */
	429	/* XXX: incomplete! */
	430
	431	#endif /* 1 */
	432
	433	Fail:
	434	FT_ERROR(( "parse_float: syntax error!\n" ));
	435	return T1_Err_Syntax_Error;
	436	}
	437
	438
	439	static
	440	FT_Error parse_integer( FT_Byte* base,
	441	FT_Byte* limit,
	442	FT_Long* result )
	443	{
	444	FT_Byte* cur;
	445
	446
	447	/* the lexical analyser accepts floats as well as integers */
	448	/* now; check that we really have an int in this token */
	449	cur = base;
	450	while ( cur < limit )
	451	{
	452	FT_Byte c = *cur++;
	453
	454
	455	if ( c == '.' \|\| c == 'e' \|\| c == 'E' )
	456	goto Float_Number;
	457	}
	458
	459	/* now read the number's value */
	460	return parse_int( base, limit, result );
	461
	462	Float_Number:
	463	/* we really have a float there; simply call parse_float in this */
	464	/* case with a scale of `10' to perform round */
	465	{
	466	FT_Error error;
	467
	468
	469	error = parse_float( base, limit, 10, result );
	470	if ( !error )
	471	{
	472	if ( *result >= 0 )
	473	result = ( result + 5 ) / 10; /* round value */
	474	else
	475	result = -( ( 5 - result ) / 10 );
	476	}
	477	return error;
	478	}
	479	}
	480
	481
	482	LOCAL_FUNC
	483	FT_Long CopyInteger( T1_Parser* parser )
	484	{
	485	FT_Long sum = 0;
	486	T1_Token* token = parser->args++;
	487
	488
	489	if ( token->kind == tok_number )
	490	{
	491	FT_Byte* base = parser->tokenizer->base + token->start;
	492	FT_Byte* limit = base + token->len;
	493
	494
	495	/* now read the number's value */
	496	parser->error = parse_integer( base, limit, &sum );
	497	return sum;
	498	}
	499
	500	FT_ERROR(( "CopyInteger: number expected\n" ));
	501	parser->args--;
	502	parser->error = T1_Err_Syntax_Error;
	503	return 0;
	504	}
	505
	506
	507	LOCAL_FUNC
	508	FT_Bool CopyBoolean( T1_Parser* parser )
	509	{
	510	FT_Error error = T1_Err_Ok;
	511	FT_Bool result = 0;
	512	T1_Token* token = parser->args++;
	513
	514
	515	if ( token->kind == tok_keyword )
	516	{
	517	if ( token->kind2 == key_false )
	518	result = 0;
	519
	520	else if ( token->kind2 == key_true )
	521	result = !0;
	522
	523	else
	524	goto Fail;
	525	}
	526	else
	527	{
	528	Fail:
	529	FT_ERROR(( "CopyBoolean:" ));
	530	FT_ERROR(( " syntax error; `false' or `true' expected\n" ));
	531	error = T1_Err_Syntax_Error;
	532	}
	533	parser->error = error;
	534	return result;
	535	}
	536
	537
	538	LOCAL_FUNC
	539	FT_Long CopyFloat( T1_Parser* parser,
	540	FT_Int scale )
	541	{
	542	FT_Error error;
	543	FT_Long sum = 0;
	544	T1_Token* token = parser->args++;
	545
	546
	547	if ( token->kind == tok_number )
	548	{
	549	FT_Byte* base = parser->tokenizer->base + token->start;
	550	FT_Byte* limit = base + token->len;
	551
	552
	553	error = parser->error = parse_float( base, limit, scale, &sum );
	554	if ( error )
	555	goto Fail;
	556
	557	return sum;
	558	}
	559
	560	Fail:
	561	FT_ERROR(( "CopyFloat: syntax error!\n" ));
	562	parser->error = T1_Err_Syntax_Error;
	563	return 0;
	564	}
	565
	566
	567	LOCAL_FUNC
	568	void CopyBBox( T1_Parser* parser,
	569	FT_BBox* bbox )
	570	{
	571	T1_Token* token = parser->args++;
	572	FT_Int n;
	573	FT_Error error;
	574
	575
	576	if ( token->kind == tok_program \|\|
	577	token->kind == tok_array )
	578	{
	579	/* get rid of `['/`]', or `{'/`}' */
	580	FT_Byte* base = parser->tokenizer->base + token->start + 1;
	581	FT_Byte* limit = base + token->len - 2;
	582	FT_Byte* cur;
	583	FT_Byte* start;
	584
	585
	586	/* read each parameter independently */
	587	cur = base;
	588	for ( n = 0; n < 4; n++ )
	589	{
	590	FT_Long* result;
	591
	592
	593	/* skip whitespace */
	594	while ( cur < limit && *cur == ' ' )
	595	cur++;
	596
	597	/* skip numbers */
	598	start = cur;
	599	while ( cur < limit && *cur != ' ' )
	600	cur++;
	601
	602	/* compute result address */
	603	switch ( n )
	604	{
	605	case 0:
	606	result = &bbox->xMin;
	607	break;
	608	case 1:
	609	result = &bbox->yMin;
	610	break;
	611	case 2:
	612	result = &bbox->xMax;
	613	break;
	614	default:
	615	result = &bbox->yMax;
	616	}
	617
	618	error = parse_integer( start, cur, result );
	619	if ( error )
	620	goto Fail;
	621	}
	622	parser->error = 0;
	623	return;
	624	}
	625
	626	Fail:
	627	FT_ERROR(( "CopyBBox: syntax error!\n" ));
	628	parser->error = T1_Err_Syntax_Error;
	629	}
	630
	631
	632	LOCAL_FUNC
	633	void CopyMatrix( T1_Parser* parser,
	634	FT_Matrix* matrix )
	635	{
	636	T1_Token* token = parser->args++;
	637	FT_Error error;
	638
	639
	640	if ( token->kind == tok_array )
	641	{
	642	/* get rid of `[' and `]' */
	643	FT_Byte* base = parser->tokenizer->base + token->start + 1;
	644	FT_Byte* limit = base + token->len - 2;
	645	FT_Byte* cur;
	646	FT_Byte* start;
	647	FT_Int n;
	648
	649
	650	/* read each parameter independently */
	651	cur = base;
	652	for ( n = 0; n < 4; n++ )
	653	{
	654	FT_Long* result;
	655
	656
	657	/* skip whitespace */
	658	while ( cur < limit && *cur == ' ' )
	659	cur++;
	660
	661	/* skip numbers */
	662	start = cur;
	663	while ( cur < limit && *cur != ' ')
	664	cur++;
	665
	666	/* compute result address */
	667	switch ( n )
	668	{
	669	case 0:
	670	result = &matrix->xx;
	671	break;
	672	case 1:
	673	result = &matrix->yx;
	674	break;
	675	case 2:
	676	result = &matrix->xy;
	677	break;
	678	default:
	679	result = &matrix->yy;
	680	}
	681
	682	error = parse_float( start, cur, 65536000L, result );
	683	if ( error )
	684	goto Fail;
	685	}
	686	parser->error = 0;
	687	return;
	688	}
	689
	690	Fail:
	691	FT_ERROR(( "CopyMatrix: syntax error!\n" ));
	692	parser->error = T1_Err_Syntax_Error;
	693	}
	694
	695
	696	LOCAL_FUNC
	697	void CopyArray( T1_Parser* parser,
	698	FT_Byte* num_elements,
	699	FT_Short* elements,
	700	FT_Int max_elements )
	701	{
	702	T1_Token* token = parser->args++;
	703	FT_Error error;
	704
	705
	706	if ( token->kind == tok_array \|\|
	707	token->kind == tok_program ) /* in the case of MinFeature */
	708	{
	709	/* get rid of `['/`]', or `{'/`}' */
	710	FT_Byte* base = parser->tokenizer->base + token->start + 1;
	711	FT_Byte* limit = base + token->len - 2;
	712	FT_Byte* cur;
	713	FT_Byte* start;
	714	FT_Int n;
	715
	716
	717	/* read each parameter independently */
	718	cur = base;
	719	for ( n = 0; n < max_elements; n++ )
	720	{
	721	FT_Long result;
	722
	723
	724	/* test end of string */
	725	if ( cur >= limit )
	726	break;
	727
	728	/* skip whitespace */
	729	while ( cur < limit && *cur == ' ' )
	730	cur++;
	731
	732	/* end of list? */
	733	if ( cur >= limit )
	734	break;
	735
	736	/* skip numbers */
	737	start = cur;
	738	while ( cur < limit && *cur != ' ' )
	739	cur++;
	740
	741	error = parse_integer( start, cur, &result );
	742	if ( error )
	743	goto Fail;
	744
	745	*elements++ = (FT_Short)result;
	746	}
	747
	748	if ( num_elements )
	749	*num_elements = (FT_Byte)n;
	750
	751	parser->error = 0;
	752	return;
	753	}
	754
	755	Fail:
	756	FT_ERROR(( "CopyArray: syntax error!\n" ));
	757	parser->error = T1_Err_Syntax_Error;
	758	}
	759
	760
	761	/* END */