[Devel] BUGREPORT: ATARI-PureC-Compiler with FT_SIZEOF_INT=2

[PORTHOS]

Hallo devel,

Here comes just a little bit mor stuff.........

------> means: replace FT_Int by FT_Long
???????means: I do not know
======means: may be it works without changes - but itŽs a question of
honour....


 t1parse.c
 =================
        /* put a safeguard */
----->        parser->private_len = (FT_Int)( write - parser->private_dict );
        *write++ = 0;


t1load.c
==================
    /* each token is an immediate containing the name of the axis */
    for ( n = 0; n < num_axis; n++ )
    {
      T1_Token  token = axis_tokens + n;
      FT_Byte*  name;
----->      FT_Int    len;


      /* skip first slash, if any */
      if ( token->start[0] == '/' )
        token->start++;

----->      len = (FT_Int)( token->limit - token->start );



      /* read the number of entries in the encoding, should be 256 */
=====      count = T1_ToInt( parser );
EITHER count is FT_Long OR it must be count=(FT_Int) T1_ToInt(parser)
      if ( parser->root.error )
        return;

        /* otherwise, we must find a number before anything else */
        if ( (FT_Byte)( c - '0' ) < 10 )
        {
          FT_Int  charcode;


          parser->root.cursor = cur;
=======          charcode = T1_ToInt( parser );
see above
          cur      = parser->root.cursor;

    if ( loader->num_subrs )
      /*  with synthetic fonts, it's possible we get here twice  */
      return;

=====    loader->num_subrs = T1_ToInt( parser );
see above

=====    loader->num_glyphs = T1_ToInt( parser );
see above
    if ( parser->root.error )
      return;

  static void
  parse_font_name( T1_Face    face,
                   T1_Loader  loader )
  {
    T1_Parser  parser = &loader->parser;
    FT_Error   error;
    FT_Memory  memory = parser->root.memory;
----->    FT_Int     len;
    FT_Byte*   cur;
    FT_Byte*   cur2;
    FT_Byte*   limit;


    if ( face->type1.font_name )
      /*  with synthetic fonts, it's possible we get here twice  */
      return;

    T1_Skip_Spaces( parser );

    cur   = parser->root.cursor;
    limit = parser->root.limit;

    if ( cur >= limit - 1 || *cur != '/' )
      return;

    cur++;
    cur2 = cur;
    while ( cur2 < limit && is_alpha( *cur2 ) )
      cur2++;

----->    len = (FT_Int)( cur2 - cur );




???????          FT_Int  charcode;
I do not know....

          parser->root.cursor = cur;
????????          charcode = T1_ToInt( parser );
...see above
          cur      = parser->root.cursor;

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

          if ( cur < limit && *cur == '/' )
          {
            /* bingo, we have an immediate name -- it must be a */
            /* character name                                   */
            FT_Byte*  cur2 = cur + 1;
----->            FT_Int    len;


            while ( cur2 < limit && is_alpha( *cur2 ) )
              cur2++;

----->            len = (FT_Int)( cur2 - cur - 1 );



  static int
  read_binary_data( T1_Parser  parser,
----->                    FT_Int*    size,
                    FT_Byte**  base )





    /* the format is simple:                                 */
    /*                                                       */
    /*   `index' + binary data                               */
    /*                                                       */
    for ( n = 0; n < loader->num_subrs; n++ )
    {
----->      FT_Int    idx, size;
      FT_Byte*  base;





    for (;;)
    {
----->      FT_Long    size;
      FT_Byte*  base;


      /* the format is simple:                    */



      if ( *cur != '/' )
        T1_Skip_Alpha( parser );
      else
      {
        FT_Byte*  cur2 = cur + 1;
----->        FT_Int    len;

        while ( cur2 < limit && is_alpha( *cur2 ) )
          cur2++;
----->        len = (FT_Int)( cur2 - cur - 1 );





----->          len  = (FT_Int)( cur2 - cur );
          if ( len > 0 && len < 22 )
          {
            {
              /* now, compare the immediate name to the keyword table */

                if ( cur[0] == name[0]                             &&
----->                     len == (FT_Int)ft_strlen( (const char*)name ) )




    /* we must now build type1.encoding when we have a custom array */
    if ( type1->encoding_type == T1_ENCODING_TYPE_ARRAY )
    {
      FT_Int    charcode, idx, min_char, max_char;
???????????
16bit really always enough?


 t1afm.c
 =================
  /* read a glyph name and return the equivalent glyph index */
  static FT_UInt
  afm_atoindex( FT_Byte**  start,
                FT_Byte*   limit,
                T1_Font    type1 )
  {
    FT_Byte*  p = *start;
----->    FT_Int    len;
    FT_UInt   result = 0;
    char      temp[64];




    /* now, read glyph name */
    while ( IS_ALPHANUM( *p ) && p < limit )
      p++;

----->    len = (FT_Int)( p - *start );



 t1parse.h
 =================
  typedef struct  T1_ParserRec_
  {
    PS_ParserRec  root;
    FT_Stream     stream;

    FT_Byte*      base_dict;
----->    FT_Int        base_len;


-- 
Mit freundlichen Grüßen,
Wolfgang Domröse
mailto:address@hidden