[wxWidgets.git] / 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
cabec872 RR	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 */