mymarkdown

My markdown
git clone https://git.grace.moe/mymarkdown
Log | Files | Refs

main.zig (4761B)

      1 const std = @import("std");
      2 
      3 const mymarkdown = @import("mymarkdown");
      4 const tracy = @import("tracy");
      5 
      6 fn readInput(gpa: std.mem.Allocator, arena: std.mem.Allocator) !std.ArrayList(u8) {
      7     const stdin = std.io.getStdIn();
      8     const tracy_frame = tracy.namedFrame("reading input");
      9     defer tracy_frame.end();
     10     if (stdin.stat()) |stat| {
     11         if (stat.size > 0) {
     12             var al: std.ArrayList(u8) = try .initCapacity(arena, stat.size + mymarkdown.PADDING + 1);
     13             try stdin.reader().readAllArrayList(&al, std.math.maxInt(u32) - mymarkdown.PADDING - 1);
     14             try al.appendNTimes('\n', mymarkdown.PADDING + 1);
     15             return al;
     16         }
     17     } else |_| {}
     18     var al: std.ArrayList(u8) = try .initCapacity(gpa, 4096);
     19     errdefer al.deinit();
     20     try stdin.reader().readAllArrayList(&al, std.math.maxInt(u32) - mymarkdown.PADDING - 1);
     21     try al.appendNTimes('\n', mymarkdown.PADDING + 1);
     22     return al;
     23 }
     24 
     25 var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
     26 
     27 pub fn main() !void {
     28     const gpa, const is_debug = gpa: {
     29         break :gpa switch (@import("builtin").mode) {
     30             .Debug, .ReleaseSafe => .{ debug_allocator.allocator(), true },
     31             .ReleaseFast, .ReleaseSmall => .{ std.heap.smp_allocator, false },
     32         };
     33     };
     34     defer _ = if (is_debug) debug_allocator.deinit();
     35     var arena_instance: std.heap.ArenaAllocator = .init(gpa);
     36     defer arena_instance.deinit();
     37     const arena = arena_instance.allocator();
     38 
     39     const args = try std.process.argsAlloc(arena);
     40 
     41     const bench, //
     42     const run, //
     43     const render, //
     44     const print, //
     45     const iters =
     46         blk: {
     47             var bench = false;
     48             var run = false;
     49             var render = false;
     50             var print = false;
     51             var iters: usize = 8;
     52             for (args) |arg| {
     53                 if (std.mem.eql(u8, arg, "--bench"))
     54                     bench = true;
     55                 if (std.mem.eql(u8, arg, "--run"))
     56                     run = true;
     57                 if (std.mem.eql(u8, arg, "--render"))
     58                     render, run = .{ true, true };
     59                 if (std.mem.eql(u8, arg, "--print"))
     60                     print, run = .{ true, true };
     61                 if (std.mem.startsWith(u8, arg, "--iters="))
     62                     iters = std.fmt.parseInt(
     63                         usize,
     64                         arg[8..],
     65                         0,
     66                     ) catch |err| {
     67                         std.debug.print(
     68                             "Invalid --iters= argument, expected number: {}\n",
     69                             .{err},
     70                         );
     71                         continue;
     72                     };
     73                 if (std.mem.eql(u8, arg, "--wait"))
     74                     std.Thread.sleep(2e9);
     75             }
     76             break :blk .{
     77                 bench,
     78                 run,
     79                 render,
     80                 print,
     81                 iters,
     82             };
     83         };
     84 
     85     var input_arraylist = try readInput(gpa, arena);
     86     defer input_arraylist.deinit();
     87     const input = input_arraylist.items;
     88 
     89     for (0..iters) |_| {
     90         if (bench) {
     91             const ast = blk: {
     92                 const tracy_frame = tracy.namedFrame("parse");
     93                 defer tracy_frame.end();
     94                 break :blk try mymarkdown.parse(
     95                     gpa,
     96                     gpa,
     97                     input,
     98                 );
     99             };
    100             ast.deinit(gpa);
    101         }
    102     }
    103 
    104     if (!bench) {
    105         const ast: mymarkdown.Ast = if (run) blk: {
    106             const tracy_frame = tracy.namedFrame("parse");
    107             defer tracy_frame.end();
    108             break :blk try mymarkdown.parse(
    109                 gpa,
    110                 arena,
    111                 input,
    112             );
    113         } else .empty;
    114 
    115         var render_arraylist: std.ArrayList(u8) = .init(gpa);
    116         defer render_arraylist.deinit();
    117         if (render or print) {
    118             std.debug.print("Rendering\n", .{});
    119             const tracy_frame = tracy.namedFrame("Render");
    120             defer tracy_frame.end();
    121             _ = try ast.renderAst(render_arraylist.writer(), input);
    122         }
    123 
    124         for (0..iters) |_| {
    125             if (render) {
    126                 std.debug.print("Re-rendering\n", .{});
    127                 render_arraylist.clearRetainingCapacity();
    128                 const tracy_frame = tracy.namedFrame("re-render");
    129                 defer tracy_frame.end();
    130                 _ = try ast.renderAst(render_arraylist.writer(), input);
    131             }
    132         }
    133 
    134         if (print) try std.io.getStdOut().writeAll(render_arraylist.items);
    135     }
    136 
    137     if (tracy.enable) {
    138         tracy.frameMarkNamed("waiting for tracy");
    139         std.Thread.sleep(100 * std.time.ns_per_ms);
    140     }
    141 }