src/libcore/fmt/num.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Integer and floating-point number formatting
  12
  13 // FIXME: #6220 Implement floating point formatting
  14
  15 #![allow(unsigned_negation)]
  16
  17 use fmt;
  18 use iter::IteratorExt;
  19 use num::{Int, cast};
  20 use slice::SliceExt;
  21 use str;
  22
  23 /// A type that represents a specific radix
  24 #[doc(hidden)]
  25 trait GenericRadix {
  26     /// The number of digits.
  27     fn base(&self) -> u8;
  28
  29     /// A radix-specific prefix string.
  30     fn prefix(&self) -> &'static str { "" }
  31
  32     /// Converts an integer to corresponding radix digit.
  33     fn digit(&self, x: u8) -> u8;
  34
  35     /// Format an integer using the radix using a formatter.
  36     fn fmt_int<T: Int>(&self, mut x: T, f: &mut fmt::Formatter) -> fmt::Result {
  37         // The radix can be as low as 2, so we need a buffer of at least 64
  38         // characters for a base 2 number.
  39         let zero = Int::zero();
  40         let is_positive = x >= zero;
  41         let mut buf = [0u8; 64];
  42         let mut curr = buf.len();
  43         let base = cast(self.base()).unwrap();
  44         if is_positive {
  45             // Accumulate each digit of the number from the least significant
  46             // to the most significant figure.
  47             for byte in buf.iter_mut().rev() {
  48                 let n = x % base;                         // Get the current place value.
  49                 x = x / base;                             // Deaccumulate the number.
  50                 *byte = self.digit(cast(n).unwrap());     // Store the digit in the buffer.
  51                 curr -= 1;
  52                 if x == zero { break };                   // No more digits left to accumulate.
  53             }
  54         } else {
  55             // Do the same as above, but accounting for two's complement.
  56             for byte in buf.iter_mut().rev() {
  57                 let n = zero - (x % base);                // Get the current place value.
  58                 x = x / base;                             // Deaccumulate the number.
  59                 *byte = self.digit(cast(n).unwrap());     // Store the digit in the buffer.
  60                 curr -= 1;
  61                 if x == zero { break };                   // No more digits left to accumulate.
  62             }
  63         }
  64         let buf = unsafe { str::from_utf8_unchecked(buf[curr..]) };
  65         f.pad_integral(is_positive, self.prefix(), buf)
  66     }
  67 }
  68
  69 /// A binary (base 2) radix
  70 #[derive(Clone, PartialEq)]
  71 struct Binary;
  72
  73 /// An octal (base 8) radix
  74 #[derive(Clone, PartialEq)]
  75 struct Octal;
  76
  77 /// A decimal (base 10) radix
  78 #[derive(Clone, PartialEq)]
  79 struct Decimal;
  80
  81 /// A hexadecimal (base 16) radix, formatted with lower-case characters
  82 #[derive(Clone, PartialEq)]
  83 struct LowerHex;
  84
  85 /// A hexadecimal (base 16) radix, formatted with upper-case characters
  86 #[derive(Clone, PartialEq)]
  87 pub struct UpperHex;
  88
  89 macro_rules! radix {
  90     ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
  91         impl GenericRadix for $T {
  92             fn base(&self) -> u8 { $base }
  93             fn prefix(&self) -> &'static str { $prefix }
  94             fn digit(&self, x: u8) -> u8 {
  95                 match x {
  96                     $($x => $conv,)+
  97                     x => panic!("number not in the range 0..{}: {}", self.base() - 1, x),
  98                 }
  99             }
 100         }
 101     }
 102 }
 103
 104 radix! { Binary,    2, "0b", x @  0 ...  2 => b'0' + x }
 105 radix! { Octal,     8, "0o", x @  0 ...  7 => b'0' + x }
 106 radix! { Decimal,  10, "",   x @  0 ...  9 => b'0' + x }
 107 radix! { LowerHex, 16, "0x", x @  0 ...  9 => b'0' + x,
 108                              x @ 10 ... 15 => b'a' + (x - 10) }
 109 radix! { UpperHex, 16, "0x", x @  0 ...  9 => b'0' + x,
 110                              x @ 10 ... 15 => b'A' + (x - 10) }
 111
 112 /// A radix with in the range of `2..36`.
 113 #[derive(Clone, Copy, PartialEq)]
 114 #[unstable = "may be renamed or move to a different module"]
 115 pub struct Radix {
 116     base: u8,
 117 }
 118
 119 impl Radix {
 120     fn new(base: u8) -> Radix {
 121         assert!(2 <= base && base <= 36, "the base must be in the range of 2..36: {}", base);
 122         Radix { base: base }
 123     }
 124 }
 125
 126 impl GenericRadix for Radix {
 127     fn base(&self) -> u8 { self.base }
 128     fn digit(&self, x: u8) -> u8 {
 129         match x {
 130             x @  0 ... 9 => b'0' + x,
 131             x if x < self.base() => b'a' + (x - 10),
 132             x => panic!("number not in the range 0..{}: {}", self.base() - 1, x),
 133         }
 134     }
 135 }
 136
 137 /// A helper type for formatting radixes.
 138 #[unstable = "may be renamed or move to a different module"]
 139 #[derive(Copy)]
 140 pub struct RadixFmt<T, R>(T, R);
 141
 142 /// Constructs a radix formatter in the range of `2..36`.
 143 ///
 144 /// # Example
 145 ///
 146 /// ```
 147 /// use std::fmt::radix;
 148 /// assert_eq!(format!("{}", radix(55i, 36)), "1j".to_string());
 149 /// ```
 150 #[unstable = "may be renamed or move to a different module"]
 151 pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
 152     RadixFmt(x, Radix::new(base))
 153 }
 154
 155 macro_rules! radix_fmt {
 156     ($T:ty as $U:ty, $fmt:ident) => {
 157         impl fmt::Show for RadixFmt<$T, Radix> {
 158             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 159                 match *self { RadixFmt(ref x, radix) => radix.$fmt(*x as $U, f) }
 160             }
 161         }
 162     }
 163 }
 164 macro_rules! int_base {
 165     ($Trait:ident for $T:ident as $U:ident -> $Radix:ident) => {
 166         impl fmt::$Trait for $T {
 167             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 168                 $Radix.fmt_int(*self as $U, f)
 169             }
 170         }
 171     }
 172 }
 173 macro_rules! integer {
 174     ($Int:ident, $Uint:ident) => {
 175         int_base! { Show     for $Int as $Int   -> Decimal }
 176         int_base! { Binary   for $Int as $Uint  -> Binary }
 177         int_base! { Octal    for $Int as $Uint  -> Octal }
 178         int_base! { LowerHex for $Int as $Uint  -> LowerHex }
 179         int_base! { UpperHex for $Int as $Uint  -> UpperHex }
 180         radix_fmt! { $Int as $Int, fmt_int }
 181
 182         int_base! { Show     for $Uint as $Uint -> Decimal }
 183         int_base! { Binary   for $Uint as $Uint -> Binary }
 184         int_base! { Octal    for $Uint as $Uint -> Octal }
 185         int_base! { LowerHex for $Uint as $Uint -> LowerHex }
 186         int_base! { UpperHex for $Uint as $Uint -> UpperHex }
 187         radix_fmt! { $Uint as $Uint, fmt_int }
 188     }
 189 }
 190 integer! { int, uint }
 191 integer! { i8, u8 }
 192 integer! { i16, u16 }
 193 integer! { i32, u32 }
 194 integer! { i64, u64 }