Merge pull request #133 from cobalt-language/num-lits-base

Add alternate bases for integer literals

Author: matt-cornell

cobalt-errors/src/error.rs

@@ -49,8 +49,14 @@ pub enum CobaltError<'src> {
         #[label("previously defined here")]
         prev: SourceSpan,
     },
-
-    #[error("unexpected character {ch}")]
+    #[error("invalid character {ch:?} in base-{base} literal")]
+    InvalidCharInLiteral {
+        ch: char,
+        base: u8,
+        #[label]
+        loc: SourceSpan,
+    },
+    #[error("unexpected character {ch:?}")]
     UnexpectedChar {
         #[label]
         loc: SourceSpan,

cobalt-parser/src/lexer/tokenizer.rs

@@ -485,6 +485,74 @@ impl<'src> SourceReader<'src> {
                         span: self.source_span_backward(1),
                     });
                 }
+                // alt. base int. literals
+                '0' => {
+                    let start = self.index;
+
+                    self.next_char();
+                    let (base, alt) = match self.peek() {
+                        Some(&'x') => (16, true),
+                        Some(&'o') => (8, true),
+                        Some(&'b') => (2, true),
+                        _ => (10, false),
+                    };
+                    if alt {
+                        self.next_char();
+                    }
+
+                    // Now pointing to the first digit.
+                    let mut end = self.index;
+                    while let Some(&ch) = self.peek() {
+                        if ch.is_digit(base as _) {
+                            self.next_char();
+                            end += 1;
+                        } else {
+                            if ch.is_ascii_digit() {
+                                errors.push(CobaltError::InvalidCharInLiteral {
+                                    ch,
+                                    base,
+                                    loc: (self.index, 1).into(),
+                                });
+                                while self.peek().map_or(false, char::is_ascii_digit) {
+                                    self.next_char();
+                                }
+                            }
+                            break;
+                        }
+                    }
+
+                    // Now pointing to the last digit before the non-digit.
+
+                    if !alt && self.peek() == Some(&'.') {
+                        self.next_char();
+                        end += 1;
+                    } else {
+                        // Not a float.
+                        tokens.push(Token {
+                            kind: TokenKind::Literal(LiteralToken::Int(&self.source[start..end])),
+                            span: (start..end).into(),
+                        });
+                        continue;
+                    }
+
+                    // Now pointing to the decimal point.
+
+                    while let Some(c) = self.peek() {
+                        if c.is_ascii_digit() {
+                            self.next_char();
+                            end += 1;
+                        } else {
+                            break;
+                        }
+                    }
+
+                    // Now pointing to the last digit of the float.
+
+                    tokens.push(Token {
+                        kind: TokenKind::Literal(LiteralToken::Float(&self.source[start..end])),
+                        span: (start..end).into(),
+                    });
+                }
 
                 // LITERALS.
                 n if n.is_ascii_digit() => {

cobalt-parser/src/parser/expr/literal.rs

@@ -1,8 +1,9 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
 use std::iter::Peekable;
-use std::{borrow::Cow, collections::HashMap, str::CharIndices};
+use std::str::CharIndices;
 
-use cobalt_ast::ast::CharLiteralAST;
-use cobalt_ast::{ast::*, BoxedAST};
+use cobalt_ast::ast::*;
 use cobalt_errors::{CobaltError, SourceSpan};
 
 use crate::{
@@ -41,16 +42,21 @@ impl<'src> Parser<'src> {
 
                 // Now we want to parse the string `s` to an `i128`. If there is a suffix,
                 // we don't want to include this in the string we parse.
+                let parsed_int = match s.as_bytes().get(1) {
+                    Some(&b'x') => i128::from_str_radix(&s[2..], 16),
+                    Some(&b'o') => i128::from_str_radix(&s[2..], 8),
+                    Some(&b'b') => i128::from_str_radix(&s[2..], 2),
+                    _ => s.parse::<i128>(),
+                };
 
-                let parsed_int = s.parse::<i128>();
-                if parsed_int.is_err() {
+                let parsed_int = parsed_int.unwrap_or_else(|_| {
                     errors.push(CobaltError::ExpectedFound {
                         ex: "integer literal",
                         found: Some(s.into()),
                         loc: span,
                     });
-                }
-                let parsed_int = parsed_int.unwrap();
+                    0
+                });
 
                 return Box::new(IntLiteralAST::new(span, parsed_int, suffix));
             }
@@ -69,21 +75,16 @@ impl<'src> Parser<'src> {
 
                 // Now we want to parse the string `s` to an `f64`.
 
-                let parsed_float = s.parse::<f64>();
-                if parsed_float.is_err() {
+                let parsed_float = s.parse::<f64>().unwrap_or_else(|_| {
                     errors.push(CobaltError::ExpectedFound {
                         ex: "float literal",
                         found: Some(s.into()),
                         loc: span,
                     });
-                }
-                let parsed_float = parsed_float.unwrap();
+                    0.0
+                });
 
-                return Box::new(cobalt_ast::ast::FloatLiteralAST::new(
-                    span,
-                    parsed_float,
-                    suffix,
-                ));
+                return Box::new(FloatLiteralAST::new(span, parsed_float, suffix));
             }
 
             TokenKind::Literal(LiteralToken::Char(_)) => {