src/main.zig

@@ -16,7 +16,7 @@ fn run(allocator: *Allocator, data: []u8) !void {
     var scanner = scanners.Scanner.init(allocator, data);
 
     while (true) {
-        var tok_opt = scanner.nextToken() catch |err| {
+        var tok = scanner.nextToken() catch |err| {
             try stdout.print(
                 "error at '{}': {}\n",
                 scanner.currentLexeme(),
@@ -25,12 +25,9 @@ fn run(allocator: *Allocator, data: []u8) !void {
 
             return Result.CompileError;
         };
-
-        if (tok_opt) |tok| {
         if (tok.ttype == .EOF) break;
         try stdout.print("{x}\n", tok);
     }
-    }
 
     return Result.Ok;
 }

src/scanner.zig

@@ -148,13 +148,12 @@ pub const Scanner = struct {
 
     fn peek(self: *Scanner) u8 {
         if (self.isAtEnd()) return 0;
-        if (self.current == 0) return 0;
+        return self.source[self.current];
-        return self.source[self.current - 1];
     }
 
     fn peekNext(self: *Scanner) u8 {
         if (self.current + 1 >= self.source.len) return 0;
-        return self.source[self.current];
+        return self.source[self.current + 1];
     }
 
     fn skipWhitespace(self: *Scanner) void {
@@ -174,40 +173,15 @@ pub const Scanner = struct {
         }
     }
 
-    /// Consume a number.
+    pub fn nextToken(self: *Scanner) !Token {
-    /// Returns either an Integer or a Float token. Proper typing
-    /// of the number (i32 i64 u32 u64 f32 f64) are for the parser.
-    fn doNumber(self: *Scanner) Token {
-        var ttype = TokenType.Integer;
-
-        while (isDigit(self.peek())) {
-            _ = self.advance();
-        }
-
-        // check if its a number like 12.34, where the '.' character
-        // exists and the one next to it is a digit.
-        if (self.peek() == '.' and isDigit(self.peekNext())) {
-            ttype = TokenType.Float;
-
-            _ = self.advance();
-            while (isDigit(self.peek())) {
-                _ = self.advance();
-            }
-        }
-
-        return self.makeToken(ttype);
-    }
-
-    pub fn nextToken(self: *Scanner) !?Token {
         self.skipWhitespace();
         self.start = self.current;
 
         if (self.isAtEnd()) return self.makeToken(TokenType.EOF);
 
         var c = self.advance();
-        if (isDigit(c)) return self.doNumber();
 
-        var token: ?Token = switch (c) {
+        var token = switch (c) {
             '(' => self.makeToken(.LeftParen),
             ')' => self.makeToken(.RightParen),
             '{' => self.makeToken(.LeftBrace),
@@ -223,10 +197,6 @@ pub const Scanner = struct {
             '?' => self.makeToken(.QuestionMark),
             '$' => self.makeToken(.DollarSign),
 
-            '-' => self.makeToken(.Minus),
-            '+' => self.makeToken(.Plus),
-            '*' => self.makeToken(.Star),
-
             '!' => self.makeMatchToken('=', .BangEqual, .Bang),
             '=' => self.makeMatchToken('=', .EqualEqual, .Equal),
 
@@ -245,18 +215,6 @@ pub const Scanner = struct {
             },
             '>' => self.makeMatchToken('=', .GreaterEqual, .Greater),
 
-            '/' => blk: {
-                if (self.peekNext() == '/') {
-                    while (self.peek() != '\n' and !self.isAtEnd()) {
-                        _ = self.advance();
-                    }
-
-                    break :blk null;
-                } else {
-                    break :blk self.makeToken(.Slash);
-                }
-            },
-
             else => return ScannerError.Unexpected,
         };