@@ -131,6 +131,8 @@ functions.
131
131
issue = "0" ) ]
132
132
133
133
use i16;
134
+ use mem:: MaybeUninit ;
135
+ use slice;
134
136
pub use self :: decoder:: { decode, DecodableFloat , FullDecoded , Decoded } ;
135
137
136
138
pub mod estimator;
@@ -604,32 +606,35 @@ pub fn to_exact_exp_str<'a, T, F>(mut format_exact: F, v: T,
604
606
/// `[+][0.][0000][2][0000]` with `frac_digits = 10`.
605
607
pub fn to_exact_fixed_str < ' a , T , F > ( mut format_exact : F , v : T ,
606
608
sign : Sign , frac_digits : usize , _upper : bool ,
607
- buf : & ' a mut [ u8 ] , parts : & ' a mut [ Part < ' a > ] ) -> Formatted < ' a >
609
+ buf : & ' a mut [ u8 ] ,
610
+ parts : & ' a mut [ MaybeUninit < Part < ' a > > ] ) -> Formatted < ' a >
608
611
where T : DecodableFloat , F : FnMut ( & Decoded , & mut [ u8 ] , i16 ) -> ( usize , i16 ) {
609
612
assert ! ( parts. len( ) >= 4 ) ;
610
613
611
614
let ( negative, full_decoded) = decode ( v) ;
612
615
let sign = determine_sign ( sign, & full_decoded, negative) ;
616
+ let parts_head = parts. as_mut_ptr ( ) as * mut Part ;
617
+ let parts_len = parts. len ( ) ;
613
618
match full_decoded {
614
- FullDecoded :: Nan => {
615
- parts[ 0 ] = Part :: Copy ( b"NaN" ) ;
616
- Formatted { sign, parts : & parts [ .. 1 ] }
619
+ FullDecoded :: Nan => unsafe {
620
+ parts[ 0 ] . set ( Part :: Copy ( b"NaN" ) ) ;
621
+ Formatted { sign, parts : slice :: from_raw_parts ( parts_head , 1 ) }
617
622
}
618
- FullDecoded :: Infinite => {
619
- parts[ 0 ] = Part :: Copy ( b"inf" ) ;
620
- Formatted { sign, parts : & parts [ .. 1 ] }
623
+ FullDecoded :: Infinite => unsafe {
624
+ parts[ 0 ] . set ( Part :: Copy ( b"inf" ) ) ;
625
+ Formatted { sign, parts : slice :: from_raw_parts ( parts_head , 1 ) }
621
626
}
622
- FullDecoded :: Zero => {
627
+ FullDecoded :: Zero => unsafe {
623
628
if frac_digits > 0 { // [0.][0000]
624
- parts[ 0 ] = Part :: Copy ( b"0." ) ;
625
- parts[ 1 ] = Part :: Zero ( frac_digits) ;
626
- Formatted { sign, parts : & parts [ .. 2 ] }
629
+ parts[ 0 ] . set ( Part :: Copy ( b"0." ) ) ;
630
+ parts[ 1 ] . set ( Part :: Zero ( frac_digits) ) ;
631
+ Formatted { sign, parts : slice :: from_raw_parts ( parts_head , 2 ) }
627
632
} else {
628
- parts[ 0 ] = Part :: Copy ( b"0" ) ;
629
- Formatted { sign, parts : & parts [ .. 1 ] }
633
+ parts[ 0 ] . set ( Part :: Copy ( b"0" ) ) ;
634
+ Formatted { sign, parts : slice :: from_raw_parts ( parts_head , 1 ) }
630
635
}
631
636
}
632
- FullDecoded :: Finite ( ref decoded) => {
637
+ FullDecoded :: Finite ( ref decoded) => unsafe {
633
638
let maxlen = estimate_max_buf_len ( decoded. exp ) ;
634
639
assert ! ( buf. len( ) >= maxlen) ;
635
640
@@ -644,18 +649,22 @@ pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T,
644
649
// only after the final rounding-up; it's a regular case with `exp = limit + 1`.
645
650
debug_assert_eq ! ( len, 0 ) ;
646
651
if frac_digits > 0 { // [0.][0000]
647
- parts[ 0 ] = Part :: Copy ( b"0." ) ;
648
- parts[ 1 ] = Part :: Zero ( frac_digits) ;
649
- Formatted { sign, parts : & parts [ .. 2 ] }
652
+ parts[ 0 ] . set ( Part :: Copy ( b"0." ) ) ;
653
+ parts[ 1 ] . set ( Part :: Zero ( frac_digits) ) ;
654
+ Formatted { sign, parts : slice :: from_raw_parts ( parts_head , 2 ) }
650
655
} else {
651
- parts[ 0 ] = Part :: Copy ( b"0" ) ;
652
- Formatted { sign, parts : & parts [ .. 1 ] }
656
+ parts[ 0 ] . set ( Part :: Copy ( b"0" ) ) ;
657
+ Formatted { sign, parts : slice :: from_raw_parts ( parts_head , 1 ) }
653
658
}
654
659
} else {
655
660
Formatted { sign,
656
- parts : digits_to_dec_str ( & buf[ ..len] , exp, frac_digits, parts) }
661
+ parts : digits_to_dec_str (
662
+ & buf[ ..len] ,
663
+ exp,
664
+ frac_digits,
665
+ slice:: from_raw_parts_mut ( parts_head, parts_len) ,
666
+ ) }
657
667
}
658
668
}
659
669
}
660
670
}
661
-
0 commit comments