2022-11-16 03:10:16 +00:00
|
|
|
const std = @import("std");
|
|
|
|
|
|
|
|
pub fn main() !void {
|
|
|
|
try execute(std.io.getStdOut().writer(), @embedFile("./test.tmp.html"), .{ .community = .{ .name = "abcd" } });
|
|
|
|
}
|
|
|
|
|
2022-11-16 06:07:45 +00:00
|
|
|
const logging = false;
|
|
|
|
|
2022-11-16 03:10:16 +00:00
|
|
|
pub fn execute(writer: anytype, comptime template: []const u8, args: anytype) !void {
|
|
|
|
@setEvalBranchQuota(@intCast(u32, template.len * 6));
|
|
|
|
comptime var iter = TokenIter{ .text = template };
|
|
|
|
inline while (comptime iter.next()) |token| {
|
2022-11-16 06:07:45 +00:00
|
|
|
if (logging) @compileLog(token);
|
2022-11-16 03:10:16 +00:00
|
|
|
switch (token) {
|
2022-11-16 06:07:45 +00:00
|
|
|
.text => |text| try writer.writeAll(text),
|
|
|
|
.open_bracket => {
|
|
|
|
const next = comptime iter.peek() orelse @compileError("Unexpected end of template");
|
|
|
|
if (next == .open_bracket) {
|
2022-11-16 03:10:16 +00:00
|
|
|
try writer.writeByte('{');
|
2022-11-16 06:07:45 +00:00
|
|
|
_ = comptime iter.next();
|
|
|
|
} else {
|
|
|
|
const result = comptime parseStatement(iter);
|
|
|
|
try executeStatement(writer, result.statement, args);
|
|
|
|
iter = result.new_iter;
|
|
|
|
}
|
2022-11-16 03:10:16 +00:00
|
|
|
},
|
2022-11-16 06:07:45 +00:00
|
|
|
.close_bracket => {
|
|
|
|
const next = comptime iter.next() orelse @compileError("Unexpected end of template");
|
|
|
|
if (comptime next == .close_bracket) try writer.writeByte('}') else @compileError("Unpaired close bracket, did you mean \"}}\"?");
|
2022-11-16 03:10:16 +00:00
|
|
|
},
|
2022-11-16 06:07:45 +00:00
|
|
|
.whitespace => |wsp| try writer.writeAll(wsp),
|
|
|
|
.period => try writer.writeByte('.'),
|
|
|
|
.pound => try writer.writeByte('#'),
|
2022-11-16 03:10:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-16 06:07:45 +00:00
|
|
|
fn executeStatement(writer: anytype, comptime stmt: Statement, args: anytype) !void {
|
|
|
|
switch (stmt) {
|
|
|
|
.expression => |expr| switch (expr) {
|
|
|
|
.arg_deref => |fields| try argDeref(writer, fields, args),
|
|
|
|
},
|
|
|
|
else => @compileError("TODO"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn argDeref(writer: anytype, comptime names: []const []const u8, arg: anytype) !void {
|
|
|
|
if (names.len == 0) {
|
|
|
|
const T = @TypeOf(arg);
|
|
|
|
if (comptime std.meta.trait.isZigString(T)) return writer.writeAll(arg);
|
|
|
|
return std.fmt.format(writer, "{any}", .{arg});
|
|
|
|
}
|
|
|
|
|
|
|
|
return argDeref(writer, names[1..], @field(arg, names[0]));
|
|
|
|
}
|
|
|
|
|
|
|
|
fn parseStatement(comptime tokens: TokenIter) StatementResult {
|
|
|
|
comptime {
|
|
|
|
var iter = tokens;
|
|
|
|
while (iter.next()) |token| switch (token) {
|
|
|
|
.whitespace => {},
|
|
|
|
.pound => {
|
|
|
|
const next = iter.next() orelse @compileError("Unexpected end of template");
|
|
|
|
if (logging) @compileLog("keyword", next);
|
|
|
|
if (next != .text) @compileError("Expected keyword following '#' character");
|
|
|
|
const text = next.text;
|
|
|
|
const keyword = std.meta.stringToEnum(Keyword, text) orelse @compileError("Unknown keyword: " ++ text);
|
|
|
|
|
|
|
|
_ = keyword;
|
|
|
|
@panic("todo");
|
|
|
|
},
|
|
|
|
.period => {
|
|
|
|
const expr = parseArgDeref(iter);
|
|
|
|
iter = expr.new_iter;
|
|
|
|
while (iter.next()) |it| switch (it) {
|
|
|
|
.whitespace => {},
|
|
|
|
.close_bracket => break,
|
|
|
|
else => @compileError("TODO"),
|
|
|
|
};
|
|
|
|
return .{ .new_iter = iter, .statement = .{
|
|
|
|
.expression = expr.expression,
|
|
|
|
} };
|
2022-11-16 03:10:16 +00:00
|
|
|
},
|
2022-11-16 06:07:45 +00:00
|
|
|
else => @compileError(""),
|
|
|
|
};
|
|
|
|
|
|
|
|
@compileError("Unexpected end of template");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn parseArgDeref(comptime tokens: TokenIter) ExpressionResult {
|
|
|
|
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,
|
|
|
|
.expression = .{ .arg_deref = fields },
|
|
|
|
} else @compileError("Unexpected token"),
|
|
|
|
}
|
|
|
|
_ = iter.next();
|
2022-11-16 03:10:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-16 06:07:45 +00:00
|
|
|
const Expression = union(enum) {
|
|
|
|
arg_deref: []const []const u8,
|
|
|
|
};
|
|
|
|
|
|
|
|
const ExpressionResult = struct {
|
|
|
|
new_iter: TokenIter,
|
|
|
|
expression: Expression,
|
|
|
|
};
|
|
|
|
|
|
|
|
const Statement = union(enum) {
|
|
|
|
expression: Expression,
|
|
|
|
for_loop: struct {
|
|
|
|
subtemplate: []const u8,
|
|
|
|
indexable: Expression,
|
|
|
|
iteration_capture: []const u8,
|
|
|
|
index_capture: ?[]const u8,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
const StatementResult = struct {
|
|
|
|
new_iter: TokenIter,
|
|
|
|
statement: Statement,
|
|
|
|
};
|
|
|
|
|
2022-11-16 03:10:16 +00:00
|
|
|
const State = enum {
|
|
|
|
text,
|
|
|
|
text_close_bracket,
|
|
|
|
template_start,
|
|
|
|
template,
|
|
|
|
};
|
|
|
|
|
2022-11-16 06:07:45 +00:00
|
|
|
const Keyword = enum {
|
|
|
|
@"for",
|
|
|
|
};
|
|
|
|
|
2022-11-16 03:10:16 +00:00
|
|
|
const Token = union(enum) {
|
|
|
|
text: []const u8,
|
|
|
|
open_bracket: void,
|
|
|
|
close_bracket: void,
|
|
|
|
period: void,
|
|
|
|
whitespace: []const u8,
|
2022-11-16 06:07:45 +00:00
|
|
|
pound: void,
|
2022-11-16 03:10:16 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
const TokenIter = struct {
|
|
|
|
start: usize = 0,
|
|
|
|
text: []const u8,
|
|
|
|
peeked_token: ?Token = null,
|
|
|
|
|
|
|
|
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 = {} },
|
2022-11-16 06:07:45 +00:00
|
|
|
'#' => return .{ .pound = {} },
|
2022-11-16 03:10:16 +00:00
|
|
|
' ', '\t', '\n', '\r' => {
|
|
|
|
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 .{ .whitespace = remaining[0..idx] };
|
|
|
|
},
|
|
|
|
else => {
|
|
|
|
var idx: usize = 0;
|
2022-11-16 06:07:45 +00:00
|
|
|
while (idx < remaining.len and std.mem.indexOfScalar(u8, "{}.# \t\n\r", remaining[idx]) == null) : (idx += 1) {}
|
2022-11-16 03:10:16 +00:00
|
|
|
|
|
|
|
self.start += idx - 1;
|
|
|
|
return .{ .text = remaining[0..idx] };
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn peek(self: *TokenIter) ?Token {
|
|
|
|
const token = self.next();
|
|
|
|
self.peeked_token = token;
|
|
|
|
return token;
|
|
|
|
}
|
|
|
|
};
|