zahl

scan.zig (5471B)

---

 const std = @import("std");
 const v = @import("value.zig");
 const symintern = @import("symintern.zig");
 
 const ascii = std.ascii;
 
 const readlog = std.log.scoped(.read);
 
 inline fn ueql(left: []const u8, right: []const u8) bool {
     return std.mem.eql(u8, left, right);
 }
 
 pub const Reader = struct {
     const Self = @This();
 
     const Token = union(enum) {
         number: v.Int,
         symbol: []const u8,
         oparen,
         cparen,
         eof,
     };
 
     input: []const u8,
     curpos: usize,
     curtok: Token,
     all: std.mem.Allocator,
 
     pub fn init(input: []const u8, all: std.mem.Allocator, err_offset: *?usize) !Self {
         var self: Self = .{
             .input = input,
             .curpos = 0,
             .curtok = undefined,
             .all = all,
         };
 
         try self.nextTok(err_offset);
 
         return self;
     }
 
     fn skipWhitespaceComment(self: *Self) void {
         while (self.curpos < self.input.len and
             (ascii.isWhitespace(self.input[self.curpos]) or
             self.input[self.curpos] == ';')) : (self.curpos += 1)
         {
             readlog.debug("Skip over offset {} char '{c}'", .{self.curpos, self.input[self.curpos]});
             // skip comments
             if (self.input[self.curpos] == ';') {
                 const endcomment = std.mem.indexOfScalar(u8, self.input[self.curpos..], '\n') orelse {
                     self.curpos = self.input.len;
                     break;
                 };
                 self.curpos += endcomment - 1;
             }
         }
     }
 
     fn isSymChar(char: u8) bool {
         return !ascii.isWhitespace(char) and switch (char) {
             '(', ')', ';' => false,
             else => true,
         };
     }
 
     pub inline fn peekTok(self: *const Reader) Token {
         return self.curtok;
     }
 
     pub fn nextTok(self: *Reader, err_offset: *?usize) !void {
         self.skipWhitespaceComment();
         if (self.curpos >= self.input.len) {
             self.curtok = .eof;
             return;
         }
 
         errdefer if (err_offset.* == null) {
             err_offset.* = self.curpos;
         };
 
         self.curtok = switch (self.input[self.curpos]) {
             inline '(', ')' => |val| onechar: {
                 self.curpos += 1;
                 break :onechar switch (val) {
                     '(' => .oparen,
                     ')' => .cparen,
                     else => @compileError("Unreachable")
                 };
             },
             '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' => .{ .number = try self.tokInt(err_offset) },
             else => sym: {
                 var offset = self.curpos;
                 while (offset < self.input.len and isSymChar(self.input[offset])) : (offset += 1) {}
 
                 // Check to avoid infinite loop
                 std.debug.assert(offset > self.curpos);
                 const tok = .{ .symbol = self.input[self.curpos..offset] };
                 self.curpos = offset;
                 break :sym tok;
             },
         };
         readlog.debug("Curtok: {}", .{self.curtok});
     }
 
     fn tokInt(self: *Self, err_offset: *?usize) !v.Int {
         var offset = self.curpos;
         errdefer err_offset.* = offset;
 
         // TODO: hex/binary...
         while (offset < self.input.len and ascii.isDigit(self.input[offset])) : (offset += 1) {}
 
         var ret = try v.Int.init(self.all);
         try ret.setString(10, self.input[self.curpos..offset]);
 
         self.curpos = offset;
 
         return ret;
     }
 
     // Reader functions
     pub fn readValue(self: *Self, err_offset: *?usize) !*v.Value {
         errdefer if (err_offset.* == null) {
             err_offset.* = self.curpos;
         };
 
         switch (self.peekTok()) {
             .oparen => {
                 readlog.debug("Start parse list", .{});
                 var acc = std.ArrayList(*v.Value).init(self.all);
                 defer acc.deinit();
                 errdefer {
                     for (acc.items) |val| {
                         val.unref();
                     }
                 }
 
                 try self.nextTok(err_offset);
                 while (self.peekTok() != .cparen) {
                     if (self.peekTok() == .eof) {
                         return error.Eof;
                     }
 
                     try acc.append(try self.readValue(err_offset));
                 }
                 // Consume the closing parenthesis
                 try self.nextTok(err_offset);
 
                 return v.Value.newList(self.all, try acc.toOwnedSlice());
             },
             .number => |num| {
                 try self.nextTok(err_offset);
                 return v.Value.newInt(self.all, num);
             },
             .symbol => |sym| {
                 try self.nextTok(err_offset);
 
                 inline for (comptime std.enums.values(v.Special)) |tag| {
                     if (ueql(sym, @tagName(tag))) {
                         return v.Value.newSpecial(self.all, tag);
                     }
                 }
 
                 return if (ueql(sym, "nil"))
                     v.Value.newNil(self.all)
                 else if (ueql(sym, "true"))
                     v.Value.newBool(self.all, true)
                 else if (ueql(sym, "false"))
                     v.Value.newBool(self.all, false)
                 else
                     v.Value.newSymbol(self.all, try symintern.intern(sym));
             },
             .cparen, .eof => return error.Eof
         }
     }
 };