Support multi-line output

zig/sdl/hello_sdl.zig

    defer c.TTF_CloseFont(font);
    c.SDL_Log("Using font %s", font_file.ptr);
    const screen = c.SDL_CreateWindow("hello fonts", c.SDL_WINDOWPOS_CENTERED, c.SDL_WINDOWPOS_CENTERED, 600, 100, c.SDL_WINDOW_BORDERLESS) orelse {
        c.SDL_Log("Unable to create window: %s", c.SDL_GetError());
        return error.SDLInitializationFailed;
    };
    defer c.SDL_DestroyWindow(screen);
    var surface = c.SDL_GetWindowSurface(screen);
    // assume monospace font
    var glyph_width: c_int = 0;
    if (c.TTF_GlyphMetrics(font, 'g', null, null, null, null, &glyph_width) != 0) {
    }
    var glyph_height = c.TTF_FontLineSkip(font);
    var msg = "howdy there, enby! 🐘                                          ".*;
    const window_width = glyph_width * 100;
    const window_height = glyph_height * 20;
    const screen = c.SDL_CreateWindow("hello fonts", c.SDL_WINDOWPOS_CENTERED, c.SDL_WINDOWPOS_CENTERED, window_width, window_height, c.SDL_WINDOW_BORDERLESS) orelse {
        c.SDL_Log("Unable to create window: %s", c.SDL_GetError());
        return error.SDLInitializationFailed;
    };
    defer c.SDL_DestroyWindow(screen);
    const renderer = c.SDL_CreateRenderer(screen, -1, c.SDL_RENDERER_ACCELERATED);
    var msg = "                                                                                                    ".*;
    var pos: usize = 0;
    var max_chars = std.math.min(@divTrunc(@intCast(usize, surface.*.w), @intCast(usize, glyph_width)), msg.len);
    var max_chars = std.math.min(@divTrunc(@intCast(usize, window_width), @intCast(usize, glyph_width)), msg.len);
    var result: ?[*:0]u8 = null;
    result = "";
    var result: []const u8 = "";
    const keyboardState = c.SDL_GetKeyboardState(null);
            }
        }
        _ = c.SDL_RenderClear(renderer);
        // thanks to https://stackoverflow.com/questions/22886500/how-to-render-text-in-sdl2 for some actually useful code here
        const white: c.SDL_Color = c.SDL_Color{ .r = 255, .g = 255, .b = 255, .a = 255 };
        const black: c.SDL_Color = c.SDL_Color{ .r = 0, .g = 0, .b = 0, .a = 255 };
        // Shaded vs Solid gives a nicer output, with solid the output
        // was squiggly and not aligned with a baseline.
        const text = c.TTF_RenderUTF8_Shaded(font, &msg, white, black);
        _ = c.SDL_BlitSurface(text, null, surface, null);
        const result_text = c.TTF_RenderUTF8_Shaded(font, result, white, black);
        _ = c.SDL_BlitSurface(result_text, null, surface, &c.SDL_Rect{ .x = 0, .y = glyph_height, .w = surface.*.w, .h = surface.*.h - glyph_height });
        const texture = c.SDL_CreateTextureFromSurface(renderer, text);
        c.SDL_FreeSurface(text);
        _ = c.SDL_RenderCopy(renderer, texture, null, &c.SDL_Rect{ .x = 0, .y = 0, .w = window_width, .h = glyph_height });
        var i: c_int = 1;
        var lines = std.mem.split(result, "\n");
        var line = lines.next();
        while (line != null) {
            const line_c = try gpa.dupeZ(u8, line.?);
            const result_text = c.TTF_RenderUTF8_Shaded(font, line_c, white, black);
            gpa.free(line_c);
            const result_texture = c.SDL_CreateTextureFromSurface(renderer, result_text);
            _ = c.SDL_RenderCopy(renderer, result_texture, null, &c.SDL_Rect{ .x = 0, .y = i * glyph_height, .w = @intCast(c_int, line.?.len) * glyph_width, .h = glyph_height });
            c.SDL_FreeSurface(result_text);
            c.SDL_DestroyTexture(result_texture);
            i += 1;
            line = lines.next();
        }
        _ = c.SDL_UpdateWindowSurface(screen);
        _ = c.SDL_RenderPresent(renderer);
        c.SDL_Delay(16);
    }
}
fn runCommand(raw_cmd: []const u8, allocator: *std.mem.Allocator) !?[*:0]u8 {
fn runCommand(raw_cmd: []const u8, allocator: *std.mem.Allocator) ![]const u8 {
    const cmd = std.mem.trim(u8, std.mem.sliceTo(raw_cmd, 0), &std.ascii.spaces);
    const argv = if (std.mem.startsWith(u8, cmd, "go "))
        &[_][]const u8{ "go", "doc", cmd[3..] }
        std.debug.print("'{s}' ", .{arg});
    }
    const result = try std.ChildProcess.exec(.{ .allocator = allocator, .argv = argv });
    const buf = try allocator.allocSentinel(u8, 100, 0);
    std.mem.copy(u8, buf, result.stdout[0..std.math.min(100, result.stdout.len)]);
    var i: usize = result.stdout.len;
    while (i < buf.len) : (i += 1) {
        buf[i] = ' ';
    }
    buf[buf.len - 1] = 0;
    std.debug.print("stderr: '{s}'\n", .{result.stderr});
    defer {
        allocator.free(result.stdout);
        // FIXME: allocator.free(result.stdout);
        allocator.free(result.stderr);
    }
    return buf;
    return result.stdout;
}
// tests