tessellation

build.zig

@@ -109,4 +109,24 @@ pub fn build(b: *std.Build) void {
     });
     const run_tests = b.addRunArtifact(tests);
     test_step.dependOn(&run_tests.step);
+
+    // fssc - the foundation simple shader compiler
+    const compiler_exe = b.addExecutable(.{
+        .name = "fssc",
+        .root_source_file = b.path("src/compiler.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    b.installArtifact(compiler_exe);
+
+    const fssc_cmd = b.addRunArtifact(compiler_exe);
+
+    fssc_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| {
+        fssc_cmd.addArgs(args);
+    }
+
+    const fssc_step = b.step("fssc", "Compile a shder");
+    fssc_step.dependOn(&fssc_cmd.step);
 }

src/compiler.zig

@@ -0,0 +1,16 @@
+pub fn main() !void {
+    std.debug.print("Starting compiler.\n", .{});
+
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+
+    const c: *Compiler = try Compiler.init(gpa.allocator());
+    defer c.deinit();
+
+    try c.run();
+
+    std.debug.print("Compiler finished.\n", .{});
+}
+
+const std = @import("std");
+const Compiler = @import("compiler/Compiler.zig");

src/compiler/Args.zig

@@ -0,0 +1,89 @@
+parsed: struct {
+    source_file: ?[]const u8 = null,
+    output_path: ?[]const u8 = null,
+    file_name: ?[]const u8 = null,
+    arg_ctx: arg_context = .none,
+} = .{},
+source_file: []const u8 = undefined,
+output_path: []const u8 = undefined,
+file_name: []const u8 = undefined,
+process_args: std.process.ArgIterator = undefined,
+
+const Args = @This();
+
+const ValidationErrorSourceInvalid: []const u8 = "invalid --source file path";
+const ValidationErrorOutputInvalid: []const u8 = "invalid --output path";
+const ValidationErrorNameInvalid: []const u8 = "invalid out file --name";
+
+pub const ArgsError = error{
+    ValidationErrorSourceInvalid,
+    ValidationErrorOutputInvalid,
+    ValidationErrorNameInvalid,
+};
+
+const arg_context = enum {
+    none,
+    source_file,
+    output_path,
+    file_name,
+};
+
+pub fn init(allocator: std.mem.Allocator) !*Args {
+    var process_args: std.process.ArgIterator = try std.process.argsWithAllocator(allocator);
+    errdefer process_args.deinit();
+    const args: *Args = try allocator.create(Args);
+    args.* = .{
+        .process_args = process_args,
+    };
+    return args;
+}
+
+pub fn deinit(self: *Args, allocator: std.mem.Allocator) void {
+    self.process_args.deinit();
+    allocator.destroy(self);
+}
+
+pub fn parse(self: *Args, _: std.mem.Allocator) !void {
+    while (self.process_args.next()) |pa| self.handle_arg(pa);
+}
+
+pub fn validate(self: *Args) ArgsError!void {
+    self.source_file = self.parsed.source_file orelse return ArgsError.ValidationErrorSourceInvalid;
+    self.output_path = self.parsed.output_path orelse return ArgsError.ValidationErrorOutputInvalid;
+    self.file_name = self.parsed.file_name orelse return ArgsError.ValidationErrorSourceInvalid;
+}
+
+pub fn debug(self: *Args) void {
+    std.debug.print("args: \n", .{});
+    std.debug.print("\t--source {s}\n", .{self.source_file});
+    std.debug.print("\t--output {s}\n", .{self.output_path});
+    std.debug.print("\t--name: {s}\n", .{self.file_name});
+}
+
+fn handle_arg(self: *Args, pa: [:0]const u8) void {
+    switch (self.parsed.arg_ctx) {
+        .none => {
+            if (std.mem.eql(u8, "--source", pa)) {
+                self.parsed.arg_ctx = .source_file;
+            } else if (std.mem.eql(u8, "--output", pa)) {
+                self.parsed.arg_ctx = .output_path;
+            } else if (std.mem.eql(u8, "--name", pa)) {
+                self.parsed.arg_ctx = .file_name;
+            }
+        },
+        .source_file => {
+            self.parsed.source_file = pa;
+            self.parsed.arg_ctx = .none;
+        },
+        .output_path => {
+            self.parsed.output_path = pa;
+            self.parsed.arg_ctx = .none;
+        },
+        .file_name => {
+            self.parsed.file_name = pa;
+            self.parsed.arg_ctx = .none;
+        },
+    }
+}
+
+const std = @import("std");

src/compiler/Compiler.zig

@@ -0,0 +1,97 @@
+allocator: std.mem.Allocator,
+ctx: Ctx,
+
+const Compiler = @This();
+
+const CompilerError = error{
+    NoOutputError,
+};
+
+var cwd_buf: [1000]u8 = undefined;
+
+pub const Ctx = struct {
+    cwd: []const u8,
+    args: *Args,
+};
+
+pub fn init(allocator: std.mem.Allocator) !*Compiler {
+    const c: *Compiler = try allocator.create(Compiler);
+    errdefer allocator.destroy(c);
+
+    const cwd = try std.fs.cwd().realpath(".", &cwd_buf);
+    c.* = .{
+        .allocator = allocator,
+        .ctx = .{
+            .cwd = cwd,
+            .args = Args.init(allocator) catch |err| std.debug.panic("{any}\n", .{err}),
+        },
+    };
+    return c;
+}
+
+pub fn run(self: *Compiler) !void {
+    self.ctx.args.parse(self.allocator) catch |err| std.debug.panic("{any}\n", .{err});
+    self.ctx.args.validate() catch |err| std.debug.panic("{any}\n", .{err});
+    self.ctx.args.debug();
+
+    const source_file: *File = try File.init(self.allocator, self.ctx, self.ctx.args.source_file);
+    defer source_file.deinit(self.allocator);
+    try source_file.read(self.allocator);
+    if (source_file.bytes) |bytes| std.debug.print("numbytes: {d}\n", .{bytes.len});
+
+    var parser: *Parser = try Parser.init(self.allocator, source_file);
+    defer parser.deinit(self.allocator);
+
+    try parser.parse(self.allocator);
+
+    parser.debug();
+
+    var inc = try Includer.init(self.allocator, source_file, self.ctx, parser);
+    defer inc.deinit(self.allocator);
+
+    try inc.fetch(self.allocator, self.ctx);
+    try inc.include(self.allocator);
+    try inc.output_file.write(self.allocator);
+}
+
+// Caller owns returned bytes.
+pub fn runWithBytes(
+    allocator: std.mem.Allocator,
+    in: []const u8,
+) ![]u8 {
+    var args: Compiler.Args = .{
+        .source_file = "sourc.glsl",
+        .output_path = "out",
+        .file_name = "shader.out.glsl",
+    };
+    const ctx: Compiler.Ctx = .{
+        .cwd = std.fs.cwd().realpath(".", &cwd_buf) catch @panic("no cwd"),
+        .args = &args,
+    };
+    const source_file: *File = try File.initWithEmbed(allocator, in);
+    defer source_file.deinit(allocator);
+
+    var parser: *Parser = try Parser.init(allocator, source_file);
+    defer parser.deinit(allocator);
+
+    try parser.parse(allocator);
+
+    var inc = try Includer.init(allocator, source_file, ctx, parser);
+    defer inc.deinit(allocator);
+
+    try inc.fetch(allocator, ctx);
+    try inc.include(allocator);
+    const bytes = inc.output_file.bytes orelse return CompilerError.NoOutputError;
+    return try allocator.dupe(u8, bytes);
+}
+
+pub fn deinit(self: *Compiler) void {
+    self.ctx.args.deinit(self.allocator);
+    self.allocator.destroy(self);
+}
+
+const std = @import("std");
+pub const Args = @import("Args.zig");
+const File = @import("File.zig");
+const Parser = @import("Parser.zig");
+const Includer = @import("Includer.zig");

src/compiler/File.zig

@@ -0,0 +1,61 @@
+path: []const u8 = undefined,
+absolute_path: ?[]const u8 = null,
+bytes: ?[]const u8 = null,
+owned: bool = true,
+ctx: Compiler.Ctx = undefined,
+
+const File = @This();
+
+const FileError = error{
+    NoBytesToWriteError,
+    NoPathError,
+};
+
+const max_bytes = 4096 << 12;
+
+pub fn init(allocator: std.mem.Allocator, ctx: Compiler.Ctx, path: []const u8) !*File {
+    const f: *File = try allocator.create(File);
+    errdefer allocator.destroy(f);
+
+    const full_source_path = try std.fs.path.join(allocator, &[_][]const u8{ ctx.cwd, path });
+
+    f.* = .{
+        .path = path,
+        .absolute_path = full_source_path,
+        .ctx = ctx,
+    };
+    return f;
+}
+
+pub fn initWithEmbed(allocator: std.mem.Allocator, bytes: []const u8) !*File {
+    const f: *File = try allocator.create(File);
+    errdefer allocator.destroy(f);
+
+    f.* = .{
+        .bytes = bytes,
+        .owned = false,
+    };
+    return f;
+}
+
+pub fn read(self: *File, allocator: std.mem.Allocator) !void {
+    const absolute_path = self.absolute_path orelse return FileError.NoPathError;
+    const fs = try std.fs.openFileAbsolute(absolute_path, .{});
+    self.bytes = try fs.readToEndAlloc(allocator, max_bytes);
+}
+
+pub fn write(self: *File, _: std.mem.Allocator) !void {
+    const absolute_path = self.absolute_path orelse return FileError.NoPathError;
+    const bytes = self.bytes orelse return FileError.NoBytesToWriteError;
+    const fs = try std.fs.createFileAbsolute(absolute_path, .{});
+    try fs.writeAll(bytes);
+}
+
+pub fn deinit(self: *File, allocator: std.mem.Allocator) void {
+    if (self.absolute_path) |absolute_path| allocator.free(absolute_path);
+    if (self.owned) if (self.bytes) |b| allocator.free(b);
+    allocator.destroy(self);
+}
+
+const std = @import("std");
+const Compiler = @import("Compiler.zig");