    const std = @import("std.zig");
    const tokenizer = @import("zig/tokenizer.zig");
    const fmt = @import("zig/fmt.zig");
    const assert = std.debug.assert;

    pub const Token = tokenizer.Token;
    pub const Tokenizer = tokenizer.Tokenizer;
    pub const fmtId = fmt.fmtId;
    pub const fmtEscapes = fmt.fmtEscapes;
    pub const isValidId = fmt.isValidId;
    pub const parse = @import("zig/parse.zig").parse;
    pub const string_literal = @import("zig/string_literal.zig");
    pub const number_literal = @import("zig/number_literal.zig");
    pub const Ast = @import("zig/Ast.zig");
    pub const system = @import("zig/system.zig");
    pub const CrossTarget = @import("zig/CrossTarget.zig");

    // Character literal parsing

    pub const ParsedCharLiteral = string_literal.ParsedCharLiteral;
    pub const parseCharLiteral = string_literal.parseCharLiteral;
    pub const parseNumberLiteral = number_literal.parseNumberLiteral;

    // Files needed by translate-c.

    pub const c_builtins = @import("zig/c_builtins.zig");
    pub const c_translation = @import("zig/c_translation.zig");

    pub const SrcHash = [16]u8;

    pub fn hashSrc(src: []const u8) SrcHash {
        var out: SrcHash = undefined;
        std.crypto.hash.Blake3.hash(src, &out, .{});
        return out;
    }

    pub fn srcHashEql(a: SrcHash, b: SrcHash) bool {
        return @bitCast(u128, a) == @bitCast(u128, b);
    }

    pub fn hashName(parent_hash: SrcHash, sep: []const u8, name: []const u8) SrcHash {
        var out: SrcHash = undefined;
        var hasher = std.crypto.hash.Blake3.init(.{});
        hasher.update(&parent_hash);
        hasher.update(sep);
        hasher.update(name);
        hasher.final(&out);
        return out;
    }

    pub const Loc = struct {
        line: usize,
        column: usize,
        /// Does not include the trailing newline.
        source_line: []const u8,

        pub fn eql(a: Loc, b: Loc) bool {
            return a.line == b.line and a.column == b.column and std.mem.eql(u8, a.source_line, b.source_line);
        }
    };

    pub fn findLineColumn(source: []const u8, byte_offset: usize) Loc {
        var line: usize = 0;
        var column: usize = 0;
        var line_start: usize = 0;
        var i: usize = 0;
        while (i < byte_offset) : (i += 1) {
            switch (source[i]) {
                '\n' => {
                    line += 1;
                    column = 0;
                    line_start = i + 1;
                },
                else => {
                    column += 1;
                },
            }
        }
        while (i < source.len and source[i] != '\n') {
            i += 1;
        }
        return .{
            .line = line,
            .column = column,
            .source_line = source[line_start..i],
        };
    }

    pub fn lineDelta(source: []const u8, start: usize, end: usize) isize {
        var line: isize = 0;
        if (end >= start) {
            for (source[start..end]) |byte| switch (byte) {
                '\n' => line += 1,
                else => continue,
            };
        } else {
            for (source[end..start]) |byte| switch (byte) {
                '\n' => line -= 1,
                else => continue,
            };
        }
        return line;
    }

    pub const BinNameOptions = struct {
        root_name: []const u8,
        target: std.Target,
        output_mode: std.builtin.OutputMode,
        link_mode: ?std.builtin.LinkMode = null,
        version: ?std.builtin.Version = null,
    };

    /// Returns the standard file system basename of a binary generated by the Zig compiler.
    pub fn binNameAlloc(allocator: std.mem.Allocator, options: BinNameOptions) error{OutOfMemory}![]u8 {
        const root_name = options.root_name;
        const target = options.target;
        switch (target.ofmt) {
            .coff => switch (options.output_mode) {
                .Exe => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, target.exeFileExt() }),
                .Lib => {
                    const suffix = switch (options.link_mode orelse .Static) {
                        .Static => ".lib",
                        .Dynamic => ".dll",
                    };
                    return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, suffix });
                },
                .Obj => return std.fmt.allocPrint(allocator, "{s}.obj", .{root_name}),
            },
            .elf => switch (options.output_mode) {
                .Exe => return allocator.dupe(u8, root_name),
                .Lib => {
                    switch (options.link_mode orelse .Static) {
                        .Static => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{
                            target.libPrefix(), root_name,
                        }),
                        .Dynamic => {
                            if (options.version) |ver| {
                                return std.fmt.allocPrint(allocator, "{s}{s}.so.{d}.{d}.{d}", .{
                                    target.libPrefix(), root_name, ver.major, ver.minor, ver.patch,
                                });
                            } else {
                                return std.fmt.allocPrint(allocator, "{s}{s}.so", .{
                                    target.libPrefix(), root_name,
                                });
                            }
                        },
                    }
                },
                .Obj => return std.fmt.allocPrint(allocator, "{s}.o", .{root_name}),
            },
            .macho => switch (options.output_mode) {
                .Exe => return allocator.dupe(u8, root_name),
                .Lib => {
                    switch (options.link_mode orelse .Static) {
                        .Static => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{
                            target.libPrefix(), root_name,
                        }),
                        .Dynamic => {
                            if (options.version) |ver| {
                                return std.fmt.allocPrint(allocator, "{s}{s}.{d}.{d}.{d}.dylib", .{
                                    target.libPrefix(), root_name, ver.major, ver.minor, ver.patch,
                                });
                            } else {
                                return std.fmt.allocPrint(allocator, "{s}{s}.dylib", .{
                                    target.libPrefix(), root_name,
                                });
                            }
                        },
                    }
                },
                .Obj => return std.fmt.allocPrint(allocator, "{s}.o", .{root_name}),
            },
            .wasm => switch (options.output_mode) {
                .Exe => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, target.exeFileExt() }),
                .Lib => {
                    switch (options.link_mode orelse .Static) {
                        .Static => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{
                            target.libPrefix(), root_name,
                        }),
                        .Dynamic => return std.fmt.allocPrint(allocator, "{s}.wasm", .{root_name}),
                    }
                },
                .Obj => return std.fmt.allocPrint(allocator, "{s}.o", .{root_name}),
            },
            .c => return std.fmt.allocPrint(allocator, "{s}.c", .{root_name}),
            .spirv => return std.fmt.allocPrint(allocator, "{s}.spv", .{root_name}),
            .hex => return std.fmt.allocPrint(allocator, "{s}.ihex", .{root_name}),
            .raw => return std.fmt.allocPrint(allocator, "{s}.bin", .{root_name}),
            .plan9 => switch (options.output_mode) {
                .Exe => return allocator.dupe(u8, root_name),
                .Obj => return std.fmt.allocPrint(allocator, "{s}{s}", .{
                    root_name, target.ofmt.fileExt(target.cpu.arch),
                }),
                .Lib => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{
                    target.libPrefix(), root_name,
                }),
            },
            .nvptx => return std.fmt.allocPrint(allocator, "{s}.ptx", .{root_name}),
            .dxcontainer => @panic("TODO what's the file extension for these?"),
        }
    }

    test {
        @import("std").testing.refAllDecls(@This());
    }