123 lines
4.4 KiB
Zig
123 lines
4.4 KiB
Zig
const std = @import("std");
|
|
const ink = @import("ink");
|
|
const fatal = std.process.fatal;
|
|
|
|
var stdin_buffer: [4096]u8 align(std.heap.page_size_min) = undefined;
|
|
var stdout_buffer: [4096]u8 align(std.heap.page_size_min) = undefined;
|
|
var stderr_buffer: [4096]u8 align(std.heap.page_size_min) = undefined;
|
|
var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
|
|
const max_src_size = std.math.maxInt(u32);
|
|
|
|
pub fn main() !void {
|
|
const gpa = debug_allocator.allocator();
|
|
defer _ = debug_allocator.deinit();
|
|
|
|
var arena_allocator = std.heap.ArenaAllocator.init(gpa);
|
|
defer arena_allocator.deinit();
|
|
|
|
const arena = arena_allocator.allocator();
|
|
const args = try std.process.argsAlloc(gpa);
|
|
defer std.process.argsFree(gpa, args);
|
|
|
|
if (args.len < 2) {
|
|
fatal("Not enough arguments!", .{});
|
|
}
|
|
return mainArgs(gpa, arena, args);
|
|
}
|
|
|
|
fn mainArgs(
|
|
gpa: std.mem.Allocator,
|
|
arena: std.mem.Allocator,
|
|
args_list: []const [:0]const u8,
|
|
) !void {
|
|
var source_path: ?[]const u8 = null;
|
|
var arg_index: usize = 1;
|
|
var compile_only: bool = false;
|
|
var dump_ast: bool = false;
|
|
var use_stdin: bool = false;
|
|
var use_color: bool = false;
|
|
|
|
while (arg_index < args_list.len) : (arg_index += 1) {
|
|
const arg = args_list[arg_index];
|
|
if (std.mem.startsWith(u8, arg, "-")) {
|
|
if (std.mem.eql(u8, arg, "--stdin")) {
|
|
use_stdin = true;
|
|
} else if (std.mem.eql(u8, arg, "--compile-only")) {
|
|
compile_only = true;
|
|
} else if (std.mem.eql(u8, arg, "--dump-ast")) {
|
|
dump_ast = true;
|
|
} else if (std.mem.eql(u8, arg, "--use-color")) {
|
|
use_color = true;
|
|
} else {
|
|
fatal("invalid parameter: '{s}'", .{arg});
|
|
}
|
|
} else if (source_path == null) {
|
|
source_path = arg;
|
|
} else {
|
|
fatal("invalid positional argument: '{s}'", .{arg});
|
|
}
|
|
}
|
|
|
|
const filename = source_path orelse "<STDIN>";
|
|
const source_bytes: [:0]const u8 = s: {
|
|
var f = if (source_path) |p| file: {
|
|
break :file std.fs.cwd().openFile(p, .{}) catch |err| {
|
|
fatal("unable to open file '{s}': {s}", .{ p, @errorName(err) });
|
|
};
|
|
} else std.fs.File.stdin();
|
|
defer if (source_path != null) f.close();
|
|
|
|
var file_reader: std.fs.File.Reader = f.reader(&stdin_buffer);
|
|
break :s readSourceFile(arena, &file_reader) catch |err| {
|
|
fatal("unable to load file '{s}': {s}", .{ filename, @errorName(err) });
|
|
};
|
|
};
|
|
|
|
const stdout = std.fs.File.stdout();
|
|
var stdout_writer = stdout.writer(&stdout_buffer);
|
|
|
|
const stderr = std.fs.File.stderr();
|
|
var stderr_writer = stderr.writer(&stderr_buffer);
|
|
|
|
var story = try ink.Story.loadFromString(gpa, source_bytes, .{
|
|
.stderr_writer = &stderr_writer.interface,
|
|
.dump_writer = &stdout_writer.interface,
|
|
.use_color = use_color,
|
|
});
|
|
defer story.deinit();
|
|
}
|
|
|
|
fn readSourceFile(gpa: std.mem.Allocator, file_reader: *std.fs.File.Reader) ![:0]u8 {
|
|
var buffer: std.ArrayListUnmanaged(u8) = .empty;
|
|
defer buffer.deinit(gpa);
|
|
|
|
if (file_reader.getSize()) |size| {
|
|
const casted_size = std.math.cast(u32, size) orelse return error.StreamTooLong;
|
|
try buffer.ensureTotalCapacityPrecise(gpa, casted_size + 1);
|
|
} else |_| {}
|
|
|
|
try file_reader.interface.appendRemaining(gpa, &buffer, .limited(max_src_size));
|
|
|
|
const unsupported_boms = [_][]const u8{
|
|
"\xff\xfe\x00\x00", // UTF-32 little endian
|
|
"\xfe\xff\x00\x00", // UTF-32 big endian
|
|
"\xfe\xff", // UTF-16 big endian
|
|
};
|
|
for (unsupported_boms) |bom| {
|
|
if (std.mem.startsWith(u8, buffer.items, bom)) {
|
|
return error.UnsupportedEncoding;
|
|
}
|
|
}
|
|
if (std.mem.startsWith(u8, buffer.items, "\xff\xfe")) {
|
|
if (buffer.items.len % 2 != 0) {
|
|
return error.InvalidEncoding;
|
|
}
|
|
return std.unicode.utf16LeToUtf8AllocZ(gpa, @ptrCast(@alignCast(buffer.items))) catch |err| switch (err) {
|
|
error.DanglingSurrogateHalf => error.UnsupportedEncoding,
|
|
error.ExpectedSecondSurrogateHalf => error.UnsupportedEncoding,
|
|
error.UnexpectedSecondSurrogateHalf => error.UnsupportedEncoding,
|
|
else => |e| return e,
|
|
};
|
|
}
|
|
return buffer.toOwnedSliceSentinel(gpa, 0);
|
|
}
|