From 3f35a033b66234e144252c4f55e76766644d1a8d Mon Sep 17 00:00:00 2001 From: Nikhil Ramakrishnan Date: Wed, 14 Aug 2019 17:39:55 +0530 Subject: [PATCH] [woff2] Formatting. * src/sfnt/sfobjs.c, src/sfnt/sfwoff2.c: Better formatting. --- src/sfnt/sfobjs.c | 2 +- src/sfnt/sfwoff2.c | 383 +++++++++++++++++++++++---------------------- 2 files changed, 194 insertions(+), 191 deletions(-) diff --git a/src/sfnt/sfobjs.c b/src/sfnt/sfobjs.c index f6da955ba..08b99fe2e 100644 --- a/src/sfnt/sfobjs.c +++ b/src/sfnt/sfobjs.c @@ -716,7 +716,7 @@ face->root.face_index = face_instance_index; /* `num_faces' for a WOFF2 needs to be handled separately. */ - if( woff2_num_faces ) + if ( woff2_num_faces ) face->root.num_faces = woff2_num_faces; return error; diff --git a/src/sfnt/sfwoff2.c b/src/sfnt/sfwoff2.c index d9268d97a..2781d7689 100644 --- a/src/sfnt/sfwoff2.c +++ b/src/sfnt/sfwoff2.c @@ -135,26 +135,26 @@ FT_Byte result_byte = 0; FT_UShort result_short = 0; - if( FT_READ_BYTE( code ) ) + if ( FT_READ_BYTE( code ) ) return error; - if( code == wordCode ) + if ( code == wordCode ) { /* Read next two bytes and store FT_UShort value */ - if( FT_READ_USHORT( result_short ) ) + if ( FT_READ_USHORT( result_short ) ) return error; *value = result_short; return FT_Err_Ok; } - else if( code == oneMoreByteCode1 ) + else if ( code == oneMoreByteCode1 ) { - if( FT_READ_BYTE( result_byte ) ) + if ( FT_READ_BYTE( result_byte ) ) return error; *value = result_byte + lowestUCode; return FT_Err_Ok; } - else if( code == oneMoreByteCode2 ) + else if ( code == oneMoreByteCode2 ) { - if( FT_READ_BYTE( result_byte ) ) + if ( FT_READ_BYTE( result_byte ) ) return error; *value = result_byte + lowestUCode * 2; return FT_Err_Ok; @@ -178,7 +178,7 @@ for ( i = 0; i < 5; ++i ) { code = 0; - if( FT_READ_BYTE( code ) ) + if ( FT_READ_BYTE( code ) ) return error; /* Leading zeros are invalid. */ @@ -216,18 +216,18 @@ FT_Byte* dst = *dst_bytes; /* Check if we are within limits. */ - if( ( *offset + size ) > WOFF2_DEFAULT_MAX_SIZE ) + if ( ( *offset + size ) > WOFF2_DEFAULT_MAX_SIZE ) return FT_THROW( Array_Too_Large ); /* Reallocate `dst'. */ - if( ( *offset + size ) > *dst_size ) + if ( ( *offset + size ) > *dst_size ) { /* DEBUG - Remove later */ FT_TRACE2(( "Reallocating %lu to %lu.\n", *dst_size, (*offset + size) )); if ( FT_REALLOC( dst, - (FT_ULong)( *dst_size ), - (FT_ULong)( *offset + size ) ) ) + (FT_ULong)( *dst_size ), + (FT_ULong)( *offset + size ) ) ) goto Exit; *dst_size = *offset + size; @@ -263,7 +263,7 @@ pad_bytes = ROUND4( dest_offset ) - dest_offset; if ( pad_bytes > 0 ) { - if( WRITE_SFNT_BUF( &zeroes[0], pad_bytes ) ) + if ( WRITE_SFNT_BUF( &zeroes[0], pad_bytes ) ) return FT_THROW( Invalid_Table ); } @@ -282,17 +282,17 @@ FT_ULong i; FT_ULong v; - for( i = 0; i < aligned_size; i += 4 ) + for ( i = 0; i < aligned_size; i += 4 ) { checksum += ( buf[i] << 24 ) | ( buf[i+1] << 16 ) | ( buf[i+2] << 8 ) | ( buf[i+3] << 0 ); } /* If size is not aligned to 4, treat as if it is padded with 0s. */ - if( size != aligned_size ) + if ( size != aligned_size ) { v = 0; - for( i = aligned_size ; i < size; ++i ) + for ( i = aligned_size ; i < size; ++i ) v |= buf[i] << ( 24 - 8 * ( i & 3 ) ); checksum += v; } @@ -314,8 +314,8 @@ result = BrotliDecoderDecompress( src_size, src, &uncompressed_size, dst); - if( result != BROTLI_DECODER_RESULT_SUCCESS || - uncompressed_size != dst_size ) + if ( result != BROTLI_DECODER_RESULT_SUCCESS || + uncompressed_size != dst_size ) { FT_ERROR(( "woff2_uncompress: Stream length mismatch.\n" )); return FT_THROW( Invalid_Table ); @@ -333,15 +333,15 @@ static WOFF2_Table - find_table( WOFF2_Table* tables, - FT_UShort num_tables, - FT_ULong tag ) + find_table( WOFF2_Table* tables, + FT_UShort num_tables, + FT_ULong tag ) { FT_Int i; for ( i = 0; i < num_tables; i++ ) { - if( tables[i]->Tag == tag ) + if ( tables[i]->Tag == tag ) return tables[i]; } return NULL; @@ -357,10 +357,10 @@ FT_Error error = FT_Err_Ok; FT_UShort num_metrics; - if( FT_STREAM_SKIP( 34 ) ) + if ( FT_STREAM_SKIP( 34 ) ) return FT_THROW( Invalid_Table ); - if( FT_READ_USHORT( num_metrics ) ) + if ( FT_READ_USHORT( num_metrics ) ) return FT_THROW( Invalid_Table ); *num_hmetrics = num_metrics; @@ -386,8 +386,8 @@ FT_Int b, FT_Int* result ) { - if( ( ( a > 0 ) && ( b > FT_INT_MAX - a ) ) || - ( ( a < 0 ) && ( b < FT_INT_MIN - a ) ) ) + if ( ( ( a > 0 ) && ( b > FT_INT_MAX - a ) ) || + ( ( a < 0 ) && ( b < FT_INT_MIN - a ) ) ) return FT_THROW( Invalid_Table ); *result = a + b; @@ -422,18 +422,18 @@ FT_Byte flag = flags_in[i]; FT_Bool on_curve = !( flag >> 7 ); flag &= 0x7f; - if( flag < 84 ) + if ( flag < 84 ) data_bytes = 1; - else if( flag < 120 ) + else if ( flag < 120 ) data_bytes = 2; - else if( flag < 124 ) + else if ( flag < 124 ) data_bytes = 3; else data_bytes = 4; /* Overflow checks */ - if ( triplet_index + data_bytes > in_size || - triplet_index + data_bytes < triplet_index ) + if ( triplet_index + data_bytes > in_size || + triplet_index + data_bytes < triplet_index ) return FT_THROW( Invalid_Table ); if ( flag < 10 ) @@ -685,7 +685,7 @@ FT_Bool we_have_inst = FALSE; FT_UShort flags = FLAG_MORE_COMPONENTS; - if( FT_STREAM_SEEK( start_offset ) ) + if ( FT_STREAM_SEEK( start_offset ) ) goto Exit; while ( flags & FLAG_MORE_COMPONENTS ) { @@ -708,7 +708,7 @@ else if ( flags & FLAG_WE_HAVE_A_TWO_BY_TWO ) arg_size += 8; - if( FT_STREAM_SKIP( arg_size ) ) + if ( FT_STREAM_SKIP( arg_size ) ) goto Exit; } @@ -742,18 +742,18 @@ const FT_ULong offset_size = index_format ? 4 : 2; - if( ( loca_values_size << 2 ) >> 2 != loca_values_size ) + if ( ( loca_values_size << 2 ) >> 2 != loca_values_size ) goto Fail; loca_buf_size = loca_values_size * offset_size; - if( FT_NEW_ARRAY( loca_buf, loca_buf_size ) ) + if ( FT_NEW_ARRAY( loca_buf, loca_buf_size ) ) goto Fail; dst = loca_buf; for ( i = 0; i < loca_values_size; i++ ) { FT_ULong value = loca_values[i]; - if( index_format ) + if ( index_format ) WRITE_ULONG( dst, value ); else WRITE_USHORT( dst, ( value >> 1 ) ); @@ -761,7 +761,7 @@ *checksum = compute_ULong_sum( loca_buf, loca_buf_size ); /* Write loca table to sfnt buffer. */ - if( WRITE_SFNT_BUF( loca_buf, loca_buf_size ) ) + if ( WRITE_SFNT_BUF( loca_buf, loca_buf_size ) ) goto Fail; /* Set pointer `sfnt_bytes' to its correct value. */ @@ -772,7 +772,7 @@ return error; Fail: - if( !error ) + if ( !error ) error = FT_THROW( Invalid_Table ); FT_FREE( loca_buf ); @@ -821,14 +821,14 @@ FT_Byte* glyph_buf = NULL; WOFF2_Point points = NULL; - if( FT_NEW_ARRAY( substreams, num_substreams ) ) + if ( FT_NEW_ARRAY( substreams, num_substreams ) ) goto Fail; - if( FT_STREAM_SKIP( 4 ) ) + if ( FT_STREAM_SKIP( 4 ) ) goto Fail; - if( FT_READ_USHORT( num_glyphs ) ) + if ( FT_READ_USHORT( num_glyphs ) ) goto Fail; - if( FT_READ_USHORT( index_format ) ) + if ( FT_READ_USHORT( index_format ) ) goto Fail; FT_TRACE2(( "Num_glyphs = %u; index_format = %u\n", @@ -842,19 +842,19 @@ /* index_format = 1 => Long version `loca'. */ expected_loca_length = ( index_format ? 4 : 2 ) * ( (FT_ULong)num_glyphs + 1 ); - if( loca_table->dst_length != expected_loca_length ) + if ( loca_table->dst_length != expected_loca_length ) goto Fail; offset = ( 2 + num_substreams ) * 4; - if( offset > glyf_table->TransformLength ) + if ( offset > glyf_table->TransformLength ) goto Fail; for ( i = 0; i < num_substreams; ++i ) { FT_ULong substream_size; - if( FT_READ_ULONG( substream_size ) ) + if ( FT_READ_ULONG( substream_size ) ) goto Fail; - if( substream_size > glyf_table->TransformLength - offset ) + if ( substream_size > glyf_table->TransformLength - offset ) goto Fail; substreams[i].start = pos + offset; @@ -867,7 +867,7 @@ offset += substream_size; } - if( FT_NEW_ARRAY( loca_values, num_glyphs + 1 ) ) + if ( FT_NEW_ARRAY( loca_values, num_glyphs + 1 ) ) goto Fail; points_size = 0; @@ -878,10 +878,10 @@ substreams[BBOX_STREAM].offset += bitmap_length; glyph_buf_size = WOFF2_DEFAULT_GLYPH_BUF; - if( FT_NEW_ARRAY( glyph_buf, glyph_buf_size ) ) + if ( FT_NEW_ARRAY( glyph_buf, glyph_buf_size ) ) goto Fail; - if( FT_NEW_ARRAY( info->x_mins, num_glyphs ) ) + if ( FT_NEW_ARRAY( info->x_mins, num_glyphs ) ) goto Fail; for ( i = 0; i < num_glyphs; ++i ) @@ -895,19 +895,19 @@ /* Set `have_bbox'. */ bbox_offset = bbox_bitmap_offset + ( i >> 3 ); - if( FT_STREAM_SEEK( bbox_offset ) || - FT_READ_BYTE( bbox_bitmap ) ) + if ( FT_STREAM_SEEK( bbox_offset ) || + FT_READ_BYTE( bbox_bitmap ) ) goto Fail; - if( bbox_bitmap & ( 0x80 >> ( i & 7 ) ) ) + if ( bbox_bitmap & ( 0x80 >> ( i & 7 ) ) ) have_bbox = TRUE; /* Read value from `nContourStream' */ - if( FT_STREAM_SEEK( substreams[N_CONTOUR_STREAM].offset ) || - FT_READ_USHORT( n_contours ) ) + if ( FT_STREAM_SEEK( substreams[N_CONTOUR_STREAM].offset ) || + FT_READ_USHORT( n_contours ) ) goto Fail; substreams[N_CONTOUR_STREAM].offset += 2; - if( n_contours == 0xffff ) + if ( n_contours == 0xffff ) { /* Composite glyph */ FT_Bool have_instructions = FALSE; @@ -917,27 +917,27 @@ FT_Byte* pointer = NULL; /* Composite glyphs must have explicit bbox. */ - if( !have_bbox ) + if ( !have_bbox ) goto Fail; - if( compositeGlyph_size( stream, + if ( compositeGlyph_size( stream, substreams[COMPOSITE_STREAM].offset, &composite_size, &have_instructions) ) goto Fail; - if( have_instructions ) + if ( have_instructions ) { - if( FT_STREAM_SEEK( substreams[GLYPH_STREAM].offset ) || - READ_255USHORT( instruction_size ) ) + if ( FT_STREAM_SEEK( substreams[GLYPH_STREAM].offset ) || + READ_255USHORT( instruction_size ) ) goto Fail; substreams[GLYPH_STREAM].offset = FT_STREAM_POS(); } size_needed = 12 + composite_size + instruction_size; - if( glyph_buf_size < size_needed ) + if ( glyph_buf_size < size_needed ) { - if( FT_RENEW_ARRAY( glyph_buf, glyph_buf_size, size_needed ) ) + if ( FT_RENEW_ARRAY( glyph_buf, glyph_buf_size, size_needed ) ) goto Fail; glyph_buf_size = size_needed; } @@ -947,36 +947,36 @@ glyph_size += 2; /* Read x_min for current glyph. */ - if( FT_STREAM_SEEK( substreams[BBOX_STREAM].offset ) || - FT_READ_USHORT( x_min ) ) + if ( FT_STREAM_SEEK( substreams[BBOX_STREAM].offset ) || + FT_READ_USHORT( x_min ) ) goto Fail; /* No increment here because we read again. */ - if( FT_STREAM_SEEK( substreams[BBOX_STREAM].offset ) || - FT_STREAM_READ( glyph_buf + glyph_size, 8 ) ) + if ( FT_STREAM_SEEK( substreams[BBOX_STREAM].offset ) || + FT_STREAM_READ( glyph_buf + glyph_size, 8 ) ) goto Fail; substreams[BBOX_STREAM].offset += 8; glyph_size += 8; - if( FT_STREAM_SEEK( substreams[COMPOSITE_STREAM].offset ) || - FT_STREAM_READ( glyph_buf + glyph_size, composite_size ) ) + if ( FT_STREAM_SEEK( substreams[COMPOSITE_STREAM].offset ) || + FT_STREAM_READ( glyph_buf + glyph_size, composite_size ) ) goto Fail; substreams[COMPOSITE_STREAM].offset += composite_size; glyph_size += composite_size; - if( have_instructions ) + if ( have_instructions ) { pointer = glyph_buf + glyph_size; WRITE_USHORT( pointer, instruction_size ); glyph_size += 2; - if( FT_STREAM_SEEK( substreams[INSTRUCTION_STREAM].offset ) || - FT_STREAM_READ( glyph_buf + glyph_size, instruction_size ) ) + if ( FT_STREAM_SEEK( substreams[INSTRUCTION_STREAM].offset ) || + FT_STREAM_READ( glyph_buf + glyph_size, instruction_size ) ) goto Fail; substreams[INSTRUCTION_STREAM].offset += instruction_size; glyph_size += instruction_size; } } - else if( n_contours > 0 ) + else if ( n_contours > 0 ) { /* Simple glyph */ FT_ULong total_n_points = 0; @@ -994,25 +994,25 @@ FT_Byte* pointer = NULL; - if( FT_NEW_ARRAY( n_points_arr, n_contours ) ) + if ( FT_NEW_ARRAY( n_points_arr, n_contours ) ) goto Fail; - if( FT_STREAM_SEEK( substreams[N_POINTS_STREAM].offset ) ) + if ( FT_STREAM_SEEK( substreams[N_POINTS_STREAM].offset ) ) goto Fail; - for( j = 0; j < n_contours; ++j ) + for ( j = 0; j < n_contours; ++j ) { - if( READ_255USHORT( n_points_contour ) ) + if ( READ_255USHORT( n_points_contour ) ) goto Fail; n_points_arr[j] = n_points_contour; /* Prevent negative/overflow. */ - if( total_n_points + n_points_contour < total_n_points ) + if ( total_n_points + n_points_contour < total_n_points ) goto Fail; total_n_points += n_points_contour; } substreams[N_POINTS_STREAM].offset = FT_STREAM_POS(); flag_size = total_n_points; - if( flag_size > substreams[FLAG_STREAM].size ) + if ( flag_size > substreams[FLAG_STREAM].size ) goto Fail; flags_buf = stream->base + substreams[FLAG_STREAM].offset; @@ -1024,29 +1024,29 @@ triplet_bytes_used = 0; /* Create array to store point information. */ points_size = total_n_points; - if( FT_NEW_ARRAY( points, points_size ) ) + if ( FT_NEW_ARRAY( points, points_size ) ) goto Fail; - if( triplet_decode( flags_buf, triplet_buf, - triplet_size, total_n_points, - points, &triplet_bytes_used ) ) + if ( triplet_decode( flags_buf, triplet_buf, + triplet_size, total_n_points, + points, &triplet_bytes_used ) ) goto Fail; substreams[FLAG_STREAM].offset += flag_size; substreams[GLYPH_STREAM].offset += triplet_bytes_used; - if( FT_STREAM_SEEK( substreams[GLYPH_STREAM].offset ) || - READ_255USHORT( instruction_size ) ) + if ( FT_STREAM_SEEK( substreams[GLYPH_STREAM].offset ) || + READ_255USHORT( instruction_size ) ) goto Fail; substreams[GLYPH_STREAM].offset = FT_STREAM_POS(); - if( total_n_points >= ( 1 << 27 ) || - instruction_size >= ( 1 << 30 ) ) + if ( total_n_points >= ( 1 << 27 ) || + instruction_size >= ( 1 << 30 ) ) goto Fail; size_needed = 12 + ( 2 * n_contours ) + ( 5 * total_n_points ) + instruction_size; - if( glyph_buf_size < size_needed ) + if ( glyph_buf_size < size_needed ) { - if( FT_RENEW_ARRAY( glyph_buf, glyph_buf_size, size_needed ) ) + if ( FT_RENEW_ARRAY( glyph_buf, glyph_buf_size, size_needed ) ) goto Fail; glyph_buf_size = size_needed; } @@ -1055,16 +1055,16 @@ WRITE_USHORT( pointer, n_contours ); glyph_size += 2; - if( have_bbox ) + if ( have_bbox ) { /* Read x_min for current glyph. */ - if( FT_STREAM_SEEK( substreams[BBOX_STREAM].offset ) || - FT_READ_USHORT( x_min ) ) + if ( FT_STREAM_SEEK( substreams[BBOX_STREAM].offset ) || + FT_READ_USHORT( x_min ) ) goto Fail; /* No increment here because we read again. */ - if( FT_STREAM_SEEK( substreams[BBOX_STREAM].offset ) || - FT_STREAM_READ( glyph_buf + glyph_size, 8 ) ) + if ( FT_STREAM_SEEK( substreams[BBOX_STREAM].offset ) || + FT_STREAM_READ( glyph_buf + glyph_size, 8 ) ) goto Fail; substreams[BBOX_STREAM].offset += 8; } @@ -1074,10 +1074,10 @@ glyph_size = CONTOUR_OFFSET_END_POINT; pointer = glyph_buf + glyph_size; end_point = -1; - for( contour_ix = 0; contour_ix < n_contours; ++contour_ix ) + for ( contour_ix = 0; contour_ix < n_contours; ++contour_ix ) { end_point += n_points_arr[contour_ix]; - if( end_point >= 65536 ) + if ( end_point >= 65536 ) goto Fail; WRITE_SHORT( pointer, end_point ); @@ -1086,15 +1086,15 @@ WRITE_USHORT( pointer, instruction_size ); glyph_size += 2; - if( FT_STREAM_SEEK( substreams[INSTRUCTION_STREAM].offset ) || - FT_STREAM_READ( glyph_buf + glyph_size, instruction_size ) ) + if ( FT_STREAM_SEEK( substreams[INSTRUCTION_STREAM].offset ) || + FT_STREAM_READ( glyph_buf + glyph_size, instruction_size ) ) goto Fail; substreams[INSTRUCTION_STREAM].offset += instruction_size; glyph_size += instruction_size; - if( store_points( total_n_points, points, n_contours, - instruction_size, glyph_buf, - glyph_buf_size, &glyph_size ) ) + if ( store_points( total_n_points, points, n_contours, + instruction_size, glyph_buf, + glyph_buf_size, &glyph_size ) ) goto Fail; FT_FREE( points ); @@ -1104,17 +1104,17 @@ { /* Empty glyph. */ /* Must not have a bbox. */ - if( have_bbox ) + if ( have_bbox ) { FT_ERROR(( "Empty glyph has a bbox.\n" )); goto Fail; } } loca_values[i] = dest_offset - glyf_start; - if( WRITE_SFNT_BUF( glyph_buf, glyph_size ) ) + if ( WRITE_SFNT_BUF( glyph_buf, glyph_size ) ) goto Fail; - if( pad4( &sfnt, sfnt_size, &dest_offset, memory ) ) + if ( pad4( &sfnt, sfnt_size, &dest_offset, memory ) ) goto Fail; *glyf_checksum += compute_ULong_sum( glyph_buf, glyph_size ); @@ -1129,9 +1129,9 @@ /* loca[n] will be equal the length of the `glyf' table. */ loca_values[num_glyphs] = glyf_table->dst_length; - if( store_loca( loca_values, num_glyphs + 1, index_format, - loca_checksum, &sfnt, sfnt_size, - &dest_offset, memory ) ) + if ( store_loca( loca_values, num_glyphs + 1, index_format, + loca_checksum, &sfnt, sfnt_size, + &dest_offset, memory ) ) goto Fail; loca_table->dst_length = dest_offset - loca_table->dst_offset; @@ -1145,7 +1145,7 @@ *sfnt_bytes = sfnt; *out_offset = dest_offset; /* DEBUG - Remove later */ - if( !error ) + if ( !error ) FT_TRACE2(( "reconstruct_glyf proceeding w/o errors.\n" )); FT_FREE( substreams ); @@ -1157,7 +1157,7 @@ return error; Fail: - if( !error ) + if ( !error ) error = FT_THROW( Invalid_Table ); FT_FREE( substreams ); @@ -1200,7 +1200,7 @@ if ( FT_STREAM_SEEK( maxp_table->src_offset ) && FT_STREAM_SKIP( 8 ) ) return error; - if( FT_READ_USHORT( num_glyphs ) ) + if ( FT_READ_USHORT( num_glyphs ) ) return error; info->num_glyphs = num_glyphs; @@ -1208,35 +1208,35 @@ FT_TRACE2(( "num_glyphs = %d", num_glyphs )); /* Read `indexToLocFormat' from head table. */ - if( FT_STREAM_SEEK( head_table->src_offset ) && FT_STREAM_SKIP( 50 ) ) + if ( FT_STREAM_SEEK( head_table->src_offset ) && FT_STREAM_SKIP( 50 ) ) return error; - if( FT_READ_USHORT( index_format ) ) + if ( FT_READ_USHORT( index_format ) ) return error; offset_size = index_format ? 4 : 2; /* Create x_mins array. */ - if( FT_NEW_ARRAY( info->x_mins, num_glyphs ) ) + if ( FT_NEW_ARRAY( info->x_mins, num_glyphs ) ) return error; loca_offset = loca_table->src_offset; - for( i = 0; i < num_glyphs; ++i ) + for ( i = 0; i < num_glyphs; ++i ) { - if( FT_STREAM_SEEK( loca_offset ) ) + if ( FT_STREAM_SEEK( loca_offset ) ) return error; loca_offset += offset_size; - if( index_format ) + if ( index_format ) { - if( FT_READ_ULONG( glyf_offset ) ) + if ( FT_READ_ULONG( glyf_offset ) ) return error; } else { - if( FT_READ_USHORT( glyf_offset_short ) ) + if ( FT_READ_USHORT( glyf_offset_short ) ) return error; glyf_offset = (FT_ULong)( glyf_offset_short ); @@ -1245,10 +1245,10 @@ glyf_offset += glyf_table->src_offset; - if( FT_STREAM_SEEK( glyf_offset ) && FT_STREAM_SKIP( 2 ) ) + if ( FT_STREAM_SEEK( glyf_offset ) && FT_STREAM_SKIP( 2 ) ) return error; - if( FT_READ_USHORT( info->x_mins[i] ) ) + if ( FT_READ_USHORT( info->x_mins[i] ) ) return error; } @@ -1284,7 +1284,7 @@ FT_TRACE2(( "Reconstructing hmtx.\n" )); - if( FT_READ_BYTE( hmtx_flags ) ) + if ( FT_READ_BYTE( hmtx_flags ) ) goto Fail; has_proportional_lsbs = ( hmtx_flags & 1 ) == 0; @@ -1356,14 +1356,14 @@ /* Build the hmtx table. */ hmtx_table_size = 2 * num_hmetrics + 2 * num_glyphs; - if( FT_NEW_ARRAY( hmtx_table, hmtx_table_size ) ) + if ( FT_NEW_ARRAY( hmtx_table, hmtx_table_size ) ) goto Fail; dst = hmtx_table; FT_TRACE2(( "hmtx values: \n" )); - for( i = 0; i < num_glyphs; i++ ) + for ( i = 0; i < num_glyphs; i++ ) { - if( i < num_hmetrics ) + if ( i < num_hmetrics ) { WRITE_SHORT( dst, advance_widths[i] ); FT_TRACE2(( "%d ", advance_widths[i] )); @@ -1376,7 +1376,7 @@ FT_TRACE2(( "\n" )); *checksum = compute_ULong_sum( hmtx_table, hmtx_table_size ); /* Write hmtx table to sfnt buffer. */ - if( WRITE_SFNT_BUF( hmtx_table, hmtx_table_size ) ) + if ( WRITE_SFNT_BUF( hmtx_table, hmtx_table_size ) ) goto Fail; /* Set pointer `sfnt_bytes' to its correct value. */ @@ -1386,7 +1386,7 @@ return error; Fail: - if( !error ) + if ( !error ) error = FT_THROW( Invalid_Table ); return error; } @@ -1430,18 +1430,18 @@ const WOFF2_Table loca_table = find_table( indices, num_tables, TTAG_loca ); - if( ( !glyf_table && loca_table ) || - ( !loca_table && glyf_table ) ) + if ( ( !glyf_table && loca_table ) || + ( !loca_table && glyf_table ) ) { FT_ERROR(( "Cannot have only one of glyf/loca.\n" )); return FT_THROW( Invalid_Table ); } /* Both `glyf' and `loca' must have same transformation. */ - if( glyf_table != NULL ) + if ( glyf_table != NULL ) { - if( ( glyf_table->flags & WOFF2_FLAGS_TRANSFORM ) != - ( loca_table->flags & WOFF2_FLAGS_TRANSFORM ) ) + if ( ( glyf_table->flags & WOFF2_FLAGS_TRANSFORM ) != + ( loca_table->flags & WOFF2_FLAGS_TRANSFORM ) ) { FT_ERROR(( "Transformation mismatch in glyf and loca." )); return FT_THROW( Invalid_Table ); @@ -1478,25 +1478,25 @@ if ( FT_STREAM_SEEK( table.src_offset ) ) return FT_THROW( Invalid_Table ); - if( table.src_offset + table.src_length > transformed_buf_size ) + if ( table.src_offset + table.src_length > transformed_buf_size ) return FT_THROW( Invalid_Table ); /* Get stream size for fields of `hmtx' table. */ - if( table.Tag == TTAG_hhea ) + if ( table.Tag == TTAG_hhea ) { - if( read_num_hmetrics( stream, table.src_length, &num_hmetrics ) ) + if ( read_num_hmetrics( stream, table.src_length, &num_hmetrics ) ) return FT_THROW( Invalid_Table ); } info->num_hmetrics = num_hmetrics; checksum = 0; - if( ( table.flags & WOFF2_FLAGS_TRANSFORM ) != WOFF2_FLAGS_TRANSFORM ) + if ( ( table.flags & WOFF2_FLAGS_TRANSFORM ) != WOFF2_FLAGS_TRANSFORM ) { /* Check if `head' is atleast 12 bytes. */ - if( table.Tag == TTAG_head ) + if ( table.Tag == TTAG_head ) { - if( table.src_length < 12 ) + if ( table.src_length < 12 ) return FT_THROW( Invalid_Table ); buf_cursor = transformed_buf + table.src_offset + 8; @@ -1509,42 +1509,44 @@ /* DEBUG - Remove later */ FT_TRACE2(( "Checksum = %08x\n", checksum )); - if( WRITE_SFNT_BUF( transformed_buf + table.src_offset, - table.src_length ) ) + if ( WRITE_SFNT_BUF( transformed_buf + table.src_offset, + table.src_length ) ) return FT_THROW( Invalid_Table ); } else{ /* DEBUG - Remove later */ FT_TRACE2(( "This table has xform.\n" )); - if( table.Tag == TTAG_glyf ) + if ( table.Tag == TTAG_glyf ) { is_glyf_xform = TRUE; table.dst_offset = dest_offset; - if( reconstruct_glyf( stream, &table, &checksum, - loca_table, &loca_checksum, - &sfnt, sfnt_size, &dest_offset, - info, memory ) ) + if ( reconstruct_glyf( stream, &table, &checksum, + loca_table, &loca_checksum, + &sfnt, sfnt_size, &dest_offset, + info, memory ) ) return FT_THROW( Invalid_Table ); FT_TRACE2(("glyf checksum is %08x\n", checksum)); } - else if( table.Tag == TTAG_loca ) + else if ( table.Tag == TTAG_loca ) { checksum = loca_checksum; } - else if( table.Tag == TTAG_hmtx ) + else if ( table.Tag == TTAG_hmtx ) { /* If glyf is not transformed and hmtx is, handle separately. */ - if( !is_glyf_xform ) + if ( !is_glyf_xform ) { - if( get_x_mins(stream, indices, num_tables, info, memory) ) + if ( get_x_mins(stream, indices, num_tables, info, memory) ) return FT_THROW( Invalid_Table ); } table.dst_offset = dest_offset; - if( reconstruct_hmtx( stream, table.src_length, info->num_glyphs, - info->num_hmetrics, info->x_mins, &checksum, - &sfnt, sfnt_size, &dest_offset, memory ) ) + if ( reconstruct_hmtx( stream, table.src_length, + info->num_glyphs, info->num_hmetrics, + info->x_mins, &checksum, + &sfnt, sfnt_size, + &dest_offset, memory ) ) return FT_THROW( Invalid_Table ); } else @@ -1567,7 +1569,7 @@ /* Update checksum. */ font_checksum += compute_ULong_sum( table_entry, 16 ); - if( pad4( &sfnt, sfnt_size, &dest_offset, memory ) ) + if ( pad4( &sfnt, sfnt_size, &dest_offset, memory ) ) goto Fail; /* Sanity check. */ @@ -1603,7 +1605,7 @@ return error; Fail: - if( !error ) + if ( !error ) error = FT_THROW( Invalid_Table ); FT_FREE( table_entry ); @@ -1736,12 +1738,12 @@ for ( nn = 0; nn < woff2.num_tables; nn++ ) { WOFF2_Table table = tables + nn; - if( FT_READ_BYTE( table->FlagByte ) ) + if ( FT_READ_BYTE( table->FlagByte ) ) goto Exit; if ( ( table->FlagByte & 0x3f ) == 0x3f ) { - if( FT_READ_ULONG( table->Tag ) ) + if ( FT_READ_ULONG( table->Tag ) ) goto Exit; } else @@ -1761,16 +1763,16 @@ flags |= xform_version; - if( READ_BASE128( table->dst_length ) ) + if ( READ_BASE128( table->dst_length ) ) goto Exit; table->TransformLength = table->dst_length; if ( ( flags & WOFF2_FLAGS_TRANSFORM ) != 0 ) { - if( READ_BASE128( table->TransformLength ) ) + if ( READ_BASE128( table->TransformLength ) ) goto Exit; - if( table->Tag == TTAG_loca && table->TransformLength ) + if ( table->Tag == TTAG_loca && table->TransformLength ) { FT_ERROR(( "woff_font_open: Invalid loca `transformLength'.\n" )); error = FT_THROW( Invalid_Table ); @@ -1809,7 +1811,7 @@ last_table = indices[woff2.num_tables - 1]; woff2.uncompressed_size = last_table->src_offset + last_table->src_length; - if( woff2.uncompressed_size < last_table->src_offset ) + if ( woff2.uncompressed_size < last_table->src_offset ) { error = FT_THROW( Invalid_Table ); goto Exit; @@ -1823,37 +1825,37 @@ /* Check for and read collection directory. */ woff2.num_fonts = 1; woff2.header_version = 0; - if( woff2.flavor == TTAG_ttcf ){ + if ( woff2.flavor == TTAG_ttcf ){ FT_TRACE2(( "Font is a TTC, reading collection directory.\n" )); - if( FT_READ_ULONG( woff2.header_version ) ) + if ( FT_READ_ULONG( woff2.header_version ) ) goto Exit; /* DEBUG - Remove later */ FT_TRACE2(( "Header version: %lx\n", woff2.header_version )); - if( woff2.header_version != 0x00010000 && - woff2.header_version != 0x00020000 ) + if ( woff2.header_version != 0x00010000 && + woff2.header_version != 0x00020000 ) { error = FT_THROW( Invalid_Table ); goto Exit; } - if( READ_255USHORT( woff2.num_fonts ) ) + if ( READ_255USHORT( woff2.num_fonts ) ) goto Exit; /* DEBUG - Remove later */ FT_TRACE2(( "Number of fonts in TTC: %ld\n", woff2.num_fonts )); - if( FT_NEW_ARRAY( woff2.ttc_fonts, woff2.num_fonts ) ) + if ( FT_NEW_ARRAY( woff2.ttc_fonts, woff2.num_fonts ) ) goto Exit; for ( nn = 0; nn < woff2.num_fonts; nn++ ) { WOFF2_TtcFont ttc_font = woff2.ttc_fonts + nn; - if( READ_255USHORT( ttc_font->num_tables ) ) + if ( READ_255USHORT( ttc_font->num_tables ) ) goto Exit; - if( FT_READ_ULONG( ttc_font->flavor ) ) + if ( FT_READ_ULONG( ttc_font->flavor ) ) goto Exit; - if( FT_NEW_ARRAY( ttc_font->table_indices, ttc_font->num_tables ) ) + if ( FT_NEW_ARRAY( ttc_font->table_indices, ttc_font->num_tables ) ) goto Exit; /* DEBUG - Change to TRACE4 */ FT_TRACE2(( "Number of tables in font %d: %ld\n", @@ -1869,26 +1871,26 @@ FT_UShort table_index; WOFF2_Table table; - if( READ_255USHORT( table_index ) ) + if ( READ_255USHORT( table_index ) ) goto Exit; /* DEBUG - Change to TRACE5 */ FT_TRACE2(("%hu ", table_index)); ttc_font->table_indices[j] = table_index; table = indices[table_index]; - if( table->Tag == TTAG_loca ) + if ( table->Tag == TTAG_loca ) loca_index = table_index; - if( table->Tag == TTAG_glyf ) + if ( table->Tag == TTAG_glyf ) glyf_index = table_index; } /* DEBUG - Change to TRACE5 */ FT_TRACE2(( "\n" )); /* glyf and loca must be consecutive */ - if( glyf_index > 0 || loca_index > 0 ) + if ( glyf_index > 0 || loca_index > 0 ) { - if( glyf_index > loca_index || - loca_index - glyf_index != 1 ) + if ( glyf_index > loca_index || + loca_index - glyf_index != 1 ) { error = FT_THROW( Invalid_Table ); goto Exit; @@ -1904,7 +1906,7 @@ woff2.totalCompressedSize ); /* Few more checks before we start reading the tables. */ - if( file_offset > woff2.length ) + if ( file_offset > woff2.length ) { error = FT_THROW( Invalid_Table ); goto Exit; @@ -1920,9 +1922,9 @@ file_offset = ROUND4(woff2.metaOffset + woff2.metaLength); } - if( woff2.privOffset ) + if ( woff2.privOffset ) { - if( file_offset != woff2.privOffset ) + if ( file_offset != woff2.privOffset ) { error = FT_THROW( Invalid_Table ); goto Exit; @@ -1930,7 +1932,7 @@ file_offset = ROUND4(woff2.privOffset + woff2.privLength); } - if( file_offset != ( ROUND4( woff2.length ) ) ) + if ( file_offset != ( ROUND4( woff2.length ) ) ) { error = FT_THROW( Invalid_Table ); goto Exit; @@ -1942,7 +1944,7 @@ if ( *face_instance_index < 0 ) face_index--; - if( face_index >= woff2.num_fonts ) + if ( face_index >= woff2.num_fonts ) { if ( *face_instance_index >= 0 ) { @@ -1954,13 +1956,13 @@ } /* Only retain tables of the requested face in a TTC. */ - if( woff2.header_version ) + if ( woff2.header_version ) { WOFF2_TtcFont ttc_font = woff2.ttc_fonts + face_index; /* Create a temporary array. */ - if( FT_NEW_ARRAY( temp_indices, - ttc_font->num_tables ) ) + if ( FT_NEW_ARRAY( temp_indices, + ttc_font->num_tables ) ) goto Exit; /* DEBUG - Remove later */ @@ -1969,8 +1971,9 @@ temp_indices[nn] = indices[ttc_font->table_indices[nn]]; /* Resize array to required size. */ - if( FT_RENEW_ARRAY( indices, woff2.num_tables, - ttc_font->num_tables ) ) + if ( FT_RENEW_ARRAY( indices, + woff2.num_tables, + ttc_font->num_tables ) ) goto Exit; for ( nn = 0; nn < ttc_font->num_tables; nn++ ) @@ -2042,7 +2045,7 @@ (FT_Char)( table->Tag ))); } - if( woff2.uncompressed_size < 1 ) + if ( woff2.uncompressed_size < 1 ) { error = FT_THROW( Invalid_Table ); goto Exit; @@ -2056,7 +2059,7 @@ /* Uncompress the stream. */ error = woff2_uncompress( uncompressed_buf, woff2.uncompressed_size, stream->cursor, woff2.totalCompressedSize ); - if( error ) + if ( error ) goto Exit; FT_FRAME_EXIT(); @@ -2064,7 +2067,7 @@ error = reconstruct_font( uncompressed_buf, woff2.uncompressed_size, indices, &woff2, &info, &sfnt, &sfnt_size, memory ); - if( error ) + if ( error ) goto Exit; /* Resize `sfnt' to actual size of sfnt stream. */ @@ -2074,8 +2077,8 @@ FT_TRACE2(( "Trimming sfnt stream from %lu to %lu.\n", sfnt_size, woff2.actual_sfnt_size )); if ( FT_REALLOC( sfnt, - (FT_ULong)( sfnt_size ), - (FT_ULong)( woff2.actual_sfnt_size ) ) ) + (FT_ULong)( sfnt_size ), + (FT_ULong)( woff2.actual_sfnt_size ) ) ) goto Exit; } @@ -2094,7 +2097,7 @@ face->root.face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM; /* Set face_index. */ - if( *face_instance_index < 0 ) + if ( *face_instance_index < 0 ) *face_instance_index = -1; else *face_instance_index = 0; @@ -2108,7 +2111,7 @@ FT_FREE( tables ); FT_FREE( indices ); - if( error ) + if ( error ) { FT_FREE( sfnt ); if ( sfnt_stream )