Interner Verarbeitungsfehler F1001 - zlib-1.2.7 / libewf-20120603

[Alter Mann]

Hallo,

wenn ich versuche die libewf-20120603 zu kompolieren kommt der [BCC32 Fataler Fehler] libfvalue_string.c(2393): F1001 Interner Verarbeitungsfehler im Code-Generator.

Code:

/* Copies an UTF-16 encoded string of a hexadecimal value to a 64-bit value
 * Returns 1 if successful or -1 on error
 */
int libfvalue_utf16_string_hexadecimal_copy_to_64bit(
     const uint16_t *utf16_string,
     size_t utf16_string_size,
     uint64_t *value_64bit,
     liberror_error_t **error )
{
   static char *function = "libfvalue_utf16_string_hexadecimal_copy_to_64bit";
   size_t string_index   = 0;
   uint8_t byte_value    = 0;

   if( utf16_string == NULL )
   {
      liberror_error_set(
       error,
       LIBERROR_ERROR_DOMAIN_ARGUMENTS,
       LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
       "%s: invalid UTF-16 string.",
       function );

      return( -1 );
   }
   if( utf16_string_size > (size_t) SSIZE_MAX )
   {
      liberror_error_set(
       error,
       LIBERROR_ERROR_DOMAIN_ARGUMENTS,
       LIBERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
       "%s: invalid UTF-16 string size value exceeds maximum.",
       function );

      return( -1 );
   }
   if( value_64bit == NULL )
   {
      liberror_error_set(
       error,
       LIBERROR_ERROR_DOMAIN_ARGUMENTS,
       LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
       "%s: invalid value 64-bit.",
       function );

      return( -1 );
   }
   if( ( utf16_string_size > 2 )
    && ( utf16_string[ 0 ] == (uint16_t) '0' )
    && ( utf16_string[ 1 ] == (uint16_t) 'x' ) )
   {
      string_index = 2;
   }
   *value_64bit = 0;

   while( string_index < utf16_string_size )
   {
      if( utf16_string[ string_index ] == 0 )
      {
         break;
      }
      if( string_index > (size_t) 20 )
      {
         liberror_error_set(
          error,
          LIBERROR_ERROR_DOMAIN_ARGUMENTS,
          LIBERROR_ARGUMENT_ERROR_VALUE_TOO_LARGE,
          "%s: string too large.",
          function );

         return( -1 );
      }
      *value_64bit <<= 4;

      if( ( utf16_string[ string_index ] >= (uint16_t) '0' )
       && ( utf16_string[ string_index ] <= (uint16_t) '9' ) )
      {
         byte_value = (uint8_t) ( utf16_string[ string_index ] - (uint16_t) '0' );
      }
      else if( ( utf16_string[ string_index ] >= (uint16_t) 'A' )
            && ( utf16_string[ string_index ] <= (uint16_t) 'F' ) )
      {
         byte_value = (uint8_t) ( utf16_string[ string_index ] - (uint16_t) 'A' + 10 );
      }
      else if( ( utf16_string[ string_index ] >= (uint16_t) 'a' )
            && ( utf16_string[ string_index ] <= (uint16_t) 'f' ) )
      {
         byte_value = (uint8_t) ( utf16_string[ string_index ] - (uint16_t) 'a' + 10 );
      }
      else
      {
         liberror_error_set(
          error,
          LIBERROR_ERROR_DOMAIN_RUNTIME,
          LIBERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
          "%s: unsupported character value: %c at index: %d.",
          function,
          (char) utf16_string[ string_index ],
          string_index );

         return( -1 );
      }
      *value_64bit += byte_value;

      string_index++;
   }
   return( 1 );
}             // <- hier??

Das gleiche passiert mir auch bei der zlib-1.2.7 ([BCC32 Fataler Fehler] deflate.c(619): F1001 Interner Verarbeitungsfehler im Code-Generator).

Code:

/* =========================================================================
 * For the default windowBits of 15 and memLevel of 8, this function returns
 * a close to exact, as well as small, upper bound on the compressed size.
 * They are coded as constants here for a reason--if the #define's are
 * changed, then this function needs to be changed as well.  The return
 * value for 15 and 8 only works for those exact settings.
 *
 * For any setting other than those defaults for windowBits and memLevel,
 * the value returned is a conservative worst case for the maximum expansion
 * resulting from using fixed blocks instead of stored blocks, which deflate
 * can emit on compressed data for some combinations of the parameters.
 *
 * This function could be more sophisticated to provide closer upper bounds for
 * every combination of windowBits and memLevel.  But even the conservative
 * upper bound of about 14% expansion does not seem onerous for output buffer
 * allocation.
 */
uLong ZEXPORT deflateBound(strm, sourceLen)
    z_streamp strm;
    uLong sourceLen;
{
    deflate_state *s;
    uLong complen, wraplen;
    Bytef *str;

    /* conservative upper bound for compressed data */
    complen = sourceLen +
              ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;

    /* if can't get parameters, return conservative bound plus zlib wrapper */
    if (strm == Z_NULL || strm->state == Z_NULL)
        return complen + 6;

    /* compute wrapper length */
    s = strm->state;
    switch (s->wrap) {
    case 0:                                 /* raw deflate */
        wraplen = 0;
        break;
    case 1:                                 /* zlib wrapper */
        wraplen = 6 + (s->strstart ? 4 : 0);
        break;
    case 2:                                 /* gzip wrapper */
        wraplen = 18;
        if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
            if (s->gzhead->extra != Z_NULL)
                wraplen += 2 + s->gzhead->extra_len;
            str = s->gzhead->name;
            if (str != Z_NULL)
                do {
                    wraplen++;
                } while (*str++);
            str = s->gzhead->comment;
            if (str != Z_NULL)
                do {
                    wraplen++;
                } while (*str++);
            if (s->gzhead->hcrc)
                wraplen += 2;
        }
        break;
    default:                                /* for compiler happiness */
        wraplen = 6;
    }

    /* if not default parameters, return conservative bound */
    if (s->w_bits != 15 || s->hash_bits != 8 + 7)
        return complen + wraplen;

    /* default settings: return tight bound for that case */
    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
           (sourceLen >> 25) + 13 - 6 + wraplen;
}  // <- hier??

Kennt jemand die Ursache oder Abhilfe?