402 lines
13 KiB
Zig
402 lines
13 KiB
Zig
const std = @import("std");
|
|
|
|
pub fn main() !void {
|
|
try execute(std.io.getStdOut().writer(), @embedFile("./test.tmp.html"), .{
|
|
.community = .{ .name = "abcd" },
|
|
.foo = [_][]const u8{ "5", "4", "3", "2", "1" },
|
|
.baz = [_][]const []const u8{
|
|
&.{ "5", "4", "3", "2", "1" },
|
|
&.{ "5", "4", "3", "2", "1" },
|
|
},
|
|
});
|
|
}
|
|
|
|
pub fn execute(writer: anytype, comptime template: []const u8, args: anytype) !void {
|
|
@setEvalBranchQuota(@intCast(u32, template.len * 6));
|
|
const tmpl = comptime parseTemplate(TokenIter{ .text = template }, .root);
|
|
try executeTemplate(writer, tmpl.item, args, .{});
|
|
}
|
|
|
|
fn executeTemplate(writer: anytype, comptime items: []const TemplateItem, args: anytype, captures: anytype) !void {
|
|
inline for (items) |it| switch (it) {
|
|
.text => |text| try writer.writeAll(text),
|
|
.statement => |stmt| try executeStatement(writer, stmt, args, captures),
|
|
};
|
|
}
|
|
|
|
fn executeStatement(writer: anytype, comptime stmt: Statement, args: anytype, captures: anytype) !void {
|
|
switch (stmt) {
|
|
.expression => |expr| {
|
|
const val = evaluateExpression(expr, args, captures);
|
|
try print(writer, val);
|
|
},
|
|
.for_loop => |loop| {
|
|
const iterable = evaluateExpression(loop.iterable, args, captures);
|
|
const subtemplate = loop.subtemplate;
|
|
for (iterable) |v| {
|
|
try executeTemplate(
|
|
writer,
|
|
subtemplate,
|
|
args,
|
|
addCapture(captures, loop.capture, v),
|
|
);
|
|
}
|
|
},
|
|
else => @compileError("TODO"),
|
|
}
|
|
}
|
|
|
|
fn print(writer: anytype, arg: anytype) !void {
|
|
if (comptime std.meta.trait.isZigString(@TypeOf(arg))) return writer.writeAll(arg);
|
|
@compileLog(@TypeOf(arg));
|
|
|
|
@compileError("TODO");
|
|
}
|
|
|
|
fn Deref(comptime T: type, comptime names: []const []const u8) type {
|
|
if (names.len == 0) return T;
|
|
|
|
// Compiler segfaults when I use std.meta to get this info so we search it manually
|
|
const field = for (@typeInfo(T).Struct.fields) |f| {
|
|
if (std.mem.eql(u8, f.name, names[0])) break f;
|
|
} else @compileError("Unknown field " ++ names[0] ++ " in type " ++ @typeName(T));
|
|
|
|
return Deref(field.field_type, names[1..]);
|
|
}
|
|
|
|
fn deref(arg: anytype, comptime names: []const []const u8) Deref(@TypeOf(arg), names) {
|
|
if (names.len == 0) return arg;
|
|
return deref(@field(arg, names[0]), names[1..]);
|
|
}
|
|
|
|
fn EvaluateExpression(comptime expression: Expression, comptime Args: type, comptime Captures: type) type {
|
|
return switch (expression) {
|
|
.arg_deref => |names| Deref(Args, names),
|
|
.capture_deref => |names| Deref(Captures, names),
|
|
};
|
|
}
|
|
|
|
fn evaluateExpression(
|
|
comptime expression: Expression,
|
|
args: anytype,
|
|
captures: anytype,
|
|
) EvaluateExpression(expression, @TypeOf(args), @TypeOf(captures)) {
|
|
return switch (expression) {
|
|
.arg_deref => |names| deref(args, names),
|
|
.capture_deref => |names| deref(captures, names),
|
|
};
|
|
}
|
|
|
|
fn AddCapture(comptime Root: type, comptime name: []const u8, comptime Val: type) type {
|
|
var fields = std.meta.fields(Root) ++ [_]std.builtin.Type.StructField{.{
|
|
.name = name,
|
|
.field_type = Val,
|
|
.default_value = null,
|
|
.is_comptime = false,
|
|
.alignment = @alignOf(Val),
|
|
}};
|
|
|
|
return @Type(.{ .Struct = .{
|
|
.layout = .Auto,
|
|
.fields = fields,
|
|
.decls = &.{},
|
|
.is_tuple = false,
|
|
} });
|
|
}
|
|
|
|
fn addCapture(root: anytype, comptime name: []const u8, val: anytype) AddCapture(@TypeOf(root), name, @TypeOf(val)) {
|
|
var result = std.mem.zeroInit(AddCapture(@TypeOf(root), name, @TypeOf(val)), root);
|
|
@field(result, name) = val;
|
|
return result;
|
|
}
|
|
|
|
const TemplateType = enum {
|
|
root,
|
|
subtemplate,
|
|
};
|
|
|
|
fn parseTemplate(comptime tokens: TokenIter, comptime template_type: TemplateType) ParseResult([]const TemplateItem) {
|
|
comptime {
|
|
var iter = tokens;
|
|
var items: []const TemplateItem = &.{};
|
|
var current_text: []const u8 = "";
|
|
|
|
parse_loop: while (iter.next()) |token| {
|
|
switch (token) {
|
|
.whitespace, .text => |text| current_text = current_text ++ text,
|
|
.open_bracket => {
|
|
const next = iter.peek() orelse @compileError("Unexpected end of template");
|
|
if (next == .open_bracket) {
|
|
current_text = current_text ++ "{";
|
|
_ = iter.next();
|
|
} else {
|
|
if (current_text.len != 0) {
|
|
items = items ++ [_]TemplateItem{.{ .text = current_text }};
|
|
current_text = "";
|
|
}
|
|
const result = parseExpressionOrStatement(iter, true);
|
|
iter = result.new_iter;
|
|
if (result.item == .end_for) {
|
|
if (template_type == .subtemplate) break :parse_loop else @compileError("Unexpected end statement");
|
|
}
|
|
items = items ++ [_]TemplateItem{.{ .statement = result.item }};
|
|
}
|
|
},
|
|
.close_bracket => {
|
|
const next = iter.next() orelse @compileError("Unexpected end of template");
|
|
if (next == .close_bracket) current_text = current_text ++ "}" else @compileError("Unpaired close bracket, did you mean \"}}\"?");
|
|
},
|
|
.period => current_text = current_text ++ ".",
|
|
.pound => current_text = current_text ++ "#",
|
|
.pipe => current_text = current_text ++ "|",
|
|
.dollar => current_text = current_text ++ "$",
|
|
}
|
|
}
|
|
|
|
if (current_text.len != 0) {
|
|
items = items ++ [_]TemplateItem{.{ .text = current_text }};
|
|
}
|
|
|
|
return .{
|
|
.new_iter = iter,
|
|
.item = items,
|
|
};
|
|
}
|
|
}
|
|
|
|
fn parseExpressionOrStatement(
|
|
comptime tokens: TokenIter,
|
|
comptime as_statement: bool,
|
|
) ParseResult(if (as_statement) Statement else Expression) {
|
|
comptime {
|
|
var iter = tokens;
|
|
var stmt: Statement = while (iter.next()) |token| switch (token) {
|
|
.whitespace => {},
|
|
.pound => {
|
|
if (!as_statement) @compileError("Unexpected Token");
|
|
const next = iter.next() orelse @compileError("Unexpected end of template");
|
|
if (next != .text) @compileError("Expected keyword following '#' character");
|
|
const text = next.text;
|
|
const keyword = std.meta.stringToEnum(Keyword, text) orelse @compileError("Unknown keyword: " ++ text);
|
|
|
|
switch (keyword) {
|
|
.end_for => break .{ .end_for = {} },
|
|
.@"for" => {
|
|
const result = parseForLoop(iter);
|
|
// statemnt already finished so just return
|
|
return .{
|
|
.new_iter = result.new_iter,
|
|
.item = .{ .for_loop = result.item },
|
|
};
|
|
},
|
|
|
|
//else => @compileError("TODO"),
|
|
}
|
|
},
|
|
.period => {
|
|
const names = parseDeref(iter);
|
|
iter = names.new_iter;
|
|
break .{ .expression = .{ .arg_deref = names.item } };
|
|
},
|
|
.dollar => {
|
|
const names = parseDeref(iter);
|
|
iter = names.new_iter;
|
|
break .{ .expression = .{ .capture_deref = names.item } };
|
|
},
|
|
else => if (as_statement) @compileError("TODO") else break,
|
|
};
|
|
|
|
if (as_statement) {
|
|
// search for end of statement
|
|
while (iter.next()) |token| switch (token) {
|
|
.whitespace => {},
|
|
.close_bracket => return .{
|
|
.new_iter = iter,
|
|
.item = stmt,
|
|
},
|
|
else => {
|
|
@compileLog(iter.row);
|
|
@compileError("TODO" ++ @tagName(token));
|
|
},
|
|
};
|
|
|
|
@compileError("Unexpected end of template");
|
|
} else return .{ .new_iter = iter, .item = stmt.expression };
|
|
}
|
|
}
|
|
|
|
fn skipWhitespace(comptime tokens: TokenIter) TokenIter {
|
|
comptime {
|
|
var iter = tokens;
|
|
while (iter.peek()) |token| switch (token) {
|
|
.whitespace => _ = iter.next(),
|
|
else => break,
|
|
};
|
|
|
|
return iter;
|
|
}
|
|
}
|
|
|
|
fn endStatement(comptime tokens: TokenIter) TokenIter {
|
|
comptime {
|
|
var iter = skipWhitespace(tokens);
|
|
|
|
const token = iter.next() orelse @compileError("Unexpected end of template");
|
|
if (token != .close_bracket) @compileError("Unexpected token");
|
|
return iter;
|
|
}
|
|
}
|
|
|
|
fn parseForLoop(comptime tokens: TokenIter) ParseResult(ForLoop) {
|
|
comptime {
|
|
const iterable = parseExpressionOrStatement(tokens, false);
|
|
var iter = iterable.new_iter;
|
|
|
|
iter = skipWhitespace(iter);
|
|
{
|
|
const token = iter.next() orelse @compileError("Unexpected end of template");
|
|
if (token != .pipe) @compileError("Unexpected token");
|
|
}
|
|
{
|
|
const token = iter.next() orelse @compileError("Unexpected end of template");
|
|
if (token != .dollar) @compileError("Unexpected token");
|
|
}
|
|
const capture = blk: {
|
|
const token = iter.next() orelse @compileError("Unexpected end of template");
|
|
if (token != .text) @compileError("Unexpected token");
|
|
break :blk token.text;
|
|
};
|
|
{
|
|
const token = iter.next() orelse @compileError("Unexpected end of template");
|
|
if (token != .pipe) @compileError("Unexpected token");
|
|
}
|
|
iter = endStatement(iter);
|
|
|
|
const subtemplate = parseTemplate(iter, .subtemplate);
|
|
|
|
return .{ .new_iter = subtemplate.new_iter, .item = .{ .iterable = iterable.item, .subtemplate = subtemplate.item, .capture = capture } };
|
|
}
|
|
}
|
|
|
|
fn parseDeref(comptime tokens: TokenIter) ParseResult([]const []const u8) {
|
|
comptime {
|
|
var iter = tokens;
|
|
var fields: []const []const u8 = &.{};
|
|
var wants = .text;
|
|
while (iter.peek()) |token| {
|
|
switch (token) {
|
|
.whitespace => {},
|
|
.text => |text| {
|
|
if (wants != .text) @compileError("Unexpected token \"" ++ text ++ "\"");
|
|
fields = fields ++ [1][]const u8{text};
|
|
wants = .period;
|
|
},
|
|
.period => {
|
|
if (wants != .period) @compileError("Unexpected token \".\"");
|
|
wants = .text;
|
|
},
|
|
else => if (wants == .period) return .{
|
|
.new_iter = iter,
|
|
.item = fields,
|
|
} else @compileError("Unexpected token"),
|
|
}
|
|
_ = iter.next();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn ParseResult(comptime T: type) type {
|
|
return struct {
|
|
new_iter: TokenIter,
|
|
item: T,
|
|
};
|
|
}
|
|
|
|
const TemplateItem = union(enum) {
|
|
text: []const u8,
|
|
statement: Statement,
|
|
};
|
|
|
|
const Expression = union(enum) {
|
|
arg_deref: []const []const u8,
|
|
capture_deref: []const []const u8,
|
|
};
|
|
|
|
const ForLoop = struct {
|
|
subtemplate: []const TemplateItem,
|
|
iterable: Expression,
|
|
capture: []const u8,
|
|
};
|
|
|
|
const Statement = union(enum) {
|
|
expression: Expression,
|
|
for_loop: ForLoop,
|
|
end_for: void,
|
|
};
|
|
|
|
const Keyword = enum {
|
|
@"for",
|
|
end_for,
|
|
};
|
|
|
|
const Token = union(enum) {
|
|
text: []const u8,
|
|
open_bracket: void,
|
|
close_bracket: void,
|
|
period: void,
|
|
whitespace: []const u8,
|
|
pound: void,
|
|
pipe: void,
|
|
dollar: void,
|
|
};
|
|
|
|
const TokenIter = struct {
|
|
start: usize = 0,
|
|
text: []const u8,
|
|
peeked_token: ?Token = null,
|
|
|
|
row: usize = 0,
|
|
|
|
fn next(self: *TokenIter) ?Token {
|
|
if (self.peeked_token) |token| {
|
|
self.peeked_token = null;
|
|
return token;
|
|
}
|
|
|
|
const remaining = self.text[self.start..];
|
|
if (remaining.len == 0) return null;
|
|
|
|
const ch = remaining[0];
|
|
self.start += 1;
|
|
switch (ch) {
|
|
'{' => return .{ .open_bracket = {} },
|
|
'}' => return .{ .close_bracket = {} },
|
|
'.' => return .{ .period = {} },
|
|
'#' => return .{ .pound = {} },
|
|
'|' => return .{ .pipe = {} },
|
|
'$' => return .{ .dollar = {} },
|
|
' ', '\t', '\n', '\r' => {
|
|
var idx: usize = 0;
|
|
while (idx < remaining.len and std.mem.indexOfScalar(u8, " \t\n\r", remaining[idx]) != null) : (idx += 1) {}
|
|
const newline_count = std.mem.count(u8, remaining[0..idx], "\n");
|
|
self.row += newline_count;
|
|
|
|
self.start += idx - 1;
|
|
return .{ .whitespace = remaining[0..idx] };
|
|
},
|
|
else => {
|
|
var idx: usize = 0;
|
|
while (idx < remaining.len and std.mem.indexOfScalar(u8, "{}.#|$ \t\n\r", remaining[idx]) == null) : (idx += 1) {}
|
|
|
|
self.start += idx - 1;
|
|
return .{ .text = remaining[0..idx] };
|
|
},
|
|
}
|
|
}
|
|
|
|
fn peek(self: *TokenIter) ?Token {
|
|
const token = self.next();
|
|
self.peeked_token = token;
|
|
return token;
|
|
}
|
|
};
|