Straighten out the NumberBuilder so it works

Also fix the Number lexing :D

src/lexer/mod.rs

@@ -10,6 +10,7 @@ mod str;
 
 use self::char::Lexable;
 use self::number::NumberBuilder;
+use self::number::Radix;
 use self::str::CharAt;
 use self::str::RelativeIndexable;
 use self::token::Lex;
@@ -192,7 +193,6 @@ impl Lexer {
             self.advance();
         }
         else if c.is_dot() {
-            self.number_builder.extend_decimal_value(c);
             self.state = State::NumberDecimal;
             self.advance();
         }
@@ -206,7 +206,7 @@ impl Lexer {
     }
 
     fn state_number_decimal(&mut self, c: char, token: &mut Option<Token>) {
-        if c.is_digit(self.number_builder.radix_value()) {
+        if c.is_digit(Radix::Dec.value()) {
             self.number_builder.extend_decimal_value(c);
             self.advance();
         }

src/lexer/number.rs

@@ -54,7 +54,7 @@ impl NumberBuilder {
 
     pub fn extend_value<'a>(&'a mut self, digit: char) -> &'a mut Self {
         if let Some(place) = NumberBuilder::place_value(digit) {
-            self.value = self.radix.value() * self.value + place;
+            self.value = self.radix.float_value() * self.value + place;
         }
         else {
             // TODO: Indicate an error.
@@ -71,17 +71,13 @@ impl NumberBuilder {
 
     pub fn resolve(&self) -> Number {
         // TODO: Convert fields to Number type.
-        let value = if self.point == 0 {
-            self.value
-        } else {
-            self.value / 10u32.pow(self.point) as f64
-        };
+        let value = if self.point > 0 { self.value / 10u32.pow(self.point) as f64 } else { self.value };
         let value = if self.sign == Sign::Neg { value * -1.0 } else { value };
         Number { value: value }
     }
 
     pub fn radix_value(&self) -> u32 {
-        self.radix.value() as u32
+        self.radix.value()
     }
 
     fn place_value(digit: char) -> Option<f64> {
@@ -95,14 +91,18 @@ impl NumberBuilder {
 }
 
 impl Radix {
-    fn value(&self) -> f64 {
+    pub fn value(&self) -> u32 {
         match *self {
-            Radix::Bin => 2.0,
-            Radix::Oct => 8.0,
-            Radix::Dec => 10.0,
-            Radix::Hex => 16.0,
+            Radix::Bin => 2,
+            Radix::Oct => 8,
+            Radix::Dec => 10,
+            Radix::Hex => 16,
         }
     }
+
+    pub fn float_value(&self) -> f64 {
+        self.value() as f64
+    }
 }