var data = {lines:[
{"lineNum":"    1","line":"const builtin = @import(\"builtin\");"},
{"lineNum":"    2","line":"const std = @import(\"std.zig\");"},
{"lineNum":"    3","line":"const os = std.os;"},
{"lineNum":"    4","line":"const mem = std.mem;"},
{"lineNum":"    5","line":"const base64 = std.base64;"},
{"lineNum":"    6","line":"const crypto = std.crypto;"},
{"lineNum":"    7","line":"const Allocator = std.mem.Allocator;"},
{"lineNum":"    8","line":"const assert = std.debug.assert;"},
{"lineNum":"    9","line":"const math = std.math;"},
{"lineNum":"   10","line":""},
{"lineNum":"   11","line":"const is_darwin = std.Target.current.os.tag.isDarwin();"},
{"lineNum":"   12","line":""},
{"lineNum":"   13","line":"pub const path = @import(\"fs/path.zig\");"},
{"lineNum":"   14","line":"pub const File = @import(\"fs/file.zig\").File;"},
{"lineNum":"   15","line":"pub const wasi = @import(\"fs/wasi.zig\");"},
{"lineNum":"   16","line":""},
{"lineNum":"   17","line":"// TODO audit these APIs with respect to Dir and absolute paths"},
{"lineNum":"   18","line":""},
{"lineNum":"   19","line":"pub const symLink = os.symlink;"},
{"lineNum":"   20","line":"pub const symLinkZ = os.symlinkZ;"},
{"lineNum":"   21","line":"pub const symLinkC = @compileError(\"deprecated: renamed to symlinkZ\");"},
{"lineNum":"   22","line":"pub const rename = os.rename;"},
{"lineNum":"   23","line":"pub const renameZ = os.renameZ;"},
{"lineNum":"   24","line":"pub const renameC = @compileError(\"deprecated: renamed to renameZ\");"},
{"lineNum":"   25","line":"pub const renameW = os.renameW;"},
{"lineNum":"   26","line":"pub const realpath = os.realpath;"},
{"lineNum":"   27","line":"pub const realpathZ = os.realpathZ;"},
{"lineNum":"   28","line":"pub const realpathC = @compileError(\"deprecated: renamed to realpathZ\");"},
{"lineNum":"   29","line":"pub const realpathW = os.realpathW;"},
{"lineNum":"   30","line":""},
{"lineNum":"   31","line":"pub const getAppDataDir = @import(\"fs/get_app_data_dir.zig\").getAppDataDir;"},
{"lineNum":"   32","line":"pub const GetAppDataDirError = @import(\"fs/get_app_data_dir.zig\").GetAppDataDirError;"},
{"lineNum":"   33","line":""},
{"lineNum":"   34","line":"pub const Watch = @import(\"fs/watch.zig\").Watch;"},
{"lineNum":"   35","line":""},
{"lineNum":"   36","line":"/// This represents the maximum size of a UTF-8 encoded file path."},
{"lineNum":"   37","line":"/// All file system operations which return a path are guaranteed to"},
{"lineNum":"   38","line":"/// fit into a UTF-8 encoded array of this length."},
{"lineNum":"   39","line":"/// The byte count includes room for a null sentinel byte."},
{"lineNum":"   40","line":"pub const MAX_PATH_BYTES = switch (builtin.os.tag) {"},
{"lineNum":"   41","line":"    .linux, .macosx, .ios, .freebsd, .netbsd, .dragonfly => os.PATH_MAX,"},
{"lineNum":"   42","line":"    // Each UTF-16LE character may be expanded to 3 UTF-8 bytes."},
{"lineNum":"   43","line":"    // If it would require 4 UTF-8 bytes, then there would be a surrogate"},
{"lineNum":"   44","line":"    // pair in the UTF-16LE, and we (over)account 3 bytes for it that way."},
{"lineNum":"   45","line":"    // +1 for the null byte at the end, which can be encoded in 1 byte."},
{"lineNum":"   46","line":"    .windows => os.windows.PATH_MAX_WIDE * 3 + 1,"},
{"lineNum":"   47","line":"    // TODO work out what a reasonable value we should use here"},
{"lineNum":"   48","line":"    .wasi => 4096,"},
{"lineNum":"   49","line":"    else => @compileError(\"Unsupported OS\"),"},
{"lineNum":"   50","line":"};"},
{"lineNum":"   51","line":""},
{"lineNum":"   52","line":"/// Base64, replacing the standard `+/` with `-_` so that it can be used in a file name on any filesystem."},
{"lineNum":"   53","line":"pub const base64_encoder = base64.Base64Encoder.init("},
{"lineNum":"   54","line":"    \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\","},
{"lineNum":"   55","line":"    base64.standard_pad_char,"},
{"lineNum":"   56","line":");"},
{"lineNum":"   57","line":""},
{"lineNum":"   58","line":"/// Whether or not async file system syscalls need a dedicated thread because the operating"},
{"lineNum":"   59","line":"/// system does not support non-blocking I/O on the file system."},
{"lineNum":"   60","line":"pub const need_async_thread = std.io.is_async and switch (builtin.os.tag) {"},
{"lineNum":"   61","line":"    .windows, .other => false,"},
{"lineNum":"   62","line":"    else => true,"},
{"lineNum":"   63","line":"};"},
{"lineNum":"   64","line":""},
{"lineNum":"   65","line":"/// TODO remove the allocator requirement from this API"},
{"lineNum":"   66","line":"pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path: []const u8) !void {"},
{"lineNum":"   67","line":"    if (symLink(existing_path, new_path)) {"},
{"lineNum":"   68","line":"        return;"},
{"lineNum":"   69","line":"    } else |err| switch (err) {"},
{"lineNum":"   70","line":"        error.PathAlreadyExists => {},"},
{"lineNum":"   71","line":"        else => return err, // TODO zig should know this set does not include PathAlreadyExists"},
{"lineNum":"   72","line":"    }"},
{"lineNum":"   73","line":""},
{"lineNum":"   74","line":"    const dirname = path.dirname(new_path) orelse \".\";"},
{"lineNum":"   75","line":""},
{"lineNum":"   76","line":"    var rand_buf: [AtomicFile.RANDOM_BYTES]u8 = undefined;"},
{"lineNum":"   77","line":"    const tmp_path = try allocator.alloc(u8, dirname.len + 1 + base64.Base64Encoder.calcSize(rand_buf.len));"},
{"lineNum":"   78","line":"    defer allocator.free(tmp_path);"},
{"lineNum":"   79","line":"    mem.copy(u8, tmp_path[0..], dirname);"},
{"lineNum":"   80","line":"    tmp_path[dirname.len] = path.sep;"},
{"lineNum":"   81","line":"    while (true) {"},
{"lineNum":"   82","line":"        try crypto.randomBytes(rand_buf[0..]);"},
{"lineNum":"   83","line":"        base64_encoder.encode(tmp_path[dirname.len + 1 ..], &rand_buf);"},
{"lineNum":"   84","line":""},
{"lineNum":"   85","line":"        if (symLink(existing_path, tmp_path)) {"},
{"lineNum":"   86","line":"            return rename(tmp_path, new_path);"},
{"lineNum":"   87","line":"        } else |err| switch (err) {"},
{"lineNum":"   88","line":"            error.PathAlreadyExists => continue,"},
{"lineNum":"   89","line":"            else => return err, // TODO zig should know this set does not include PathAlreadyExists"},
{"lineNum":"   90","line":"        }"},
{"lineNum":"   91","line":"    }"},
{"lineNum":"   92","line":"}"},
{"lineNum":"   93","line":""},
{"lineNum":"   94","line":"pub const PrevStatus = enum {"},
{"lineNum":"   95","line":"    stale,"},
{"lineNum":"   96","line":"    fresh,"},
{"lineNum":"   97","line":"};"},
{"lineNum":"   98","line":""},
{"lineNum":"   99","line":"pub const CopyFileOptions = struct {"},
{"lineNum":"  100","line":"    /// When this is `null` the mode is copied from the source file."},
{"lineNum":"  101","line":"    override_mode: ?File.Mode = null,"},
{"lineNum":"  102","line":"};"},
{"lineNum":"  103","line":""},
{"lineNum":"  104","line":"/// Same as `Dir.updateFile`, except asserts that both `source_path` and `dest_path`"},
{"lineNum":"  105","line":"/// are absolute. See `Dir.updateFile` for a function that operates on both"},
{"lineNum":"  106","line":"/// absolute and relative paths."},
{"lineNum":"  107","line":"pub fn updateFileAbsolute(","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  108","line":"    source_path: []const u8,"},
{"lineNum":"  109","line":"    dest_path: []const u8,"},
{"lineNum":"  110","line":"    args: CopyFileOptions,"},
{"lineNum":"  111","line":") !PrevStatus {"},
{"lineNum":"  112","line":"    assert(path.isAbsolute(source_path));","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  113","line":"    assert(path.isAbsolute(dest_path));","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  114","line":"    const my_cwd = cwd();","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  115","line":"    return Dir.updateFile(my_cwd, source_path, my_cwd, dest_path, args);","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  116","line":"}"},
{"lineNum":"  117","line":""},
{"lineNum":"  118","line":"/// Same as `Dir.copyFile`, except asserts that both `source_path` and `dest_path`"},
{"lineNum":"  119","line":"/// are absolute. See `Dir.copyFile` for a function that operates on both"},
{"lineNum":"  120","line":"/// absolute and relative paths."},
{"lineNum":"  121","line":"pub fn copyFileAbsolute(source_path: []const u8, dest_path: []const u8, args: CopyFileOptions) !void {","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  122","line":"    assert(path.isAbsolute(source_path));","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  123","line":"    assert(path.isAbsolute(dest_path));","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  124","line":"    const my_cwd = cwd();","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  125","line":"    return Dir.copyFile(my_cwd, source_path, my_cwd, dest_path, args);","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  126","line":"}"},
{"lineNum":"  127","line":""},
{"lineNum":"  128","line":"/// TODO update this API to avoid a getrandom syscall for every operation."},
{"lineNum":"  129","line":"pub const AtomicFile = struct {"},
{"lineNum":"  130","line":"    file: File,"},
{"lineNum":"  131","line":"    // TODO either replace this with rand_buf or use []u16 on Windows"},
{"lineNum":"  132","line":"    tmp_path_buf: [TMP_PATH_LEN:0]u8,"},
{"lineNum":"  133","line":"    dest_basename: []const u8,"},
{"lineNum":"  134","line":"    file_open: bool,"},
{"lineNum":"  135","line":"    file_exists: bool,"},
{"lineNum":"  136","line":"    close_dir_on_deinit: bool,"},
{"lineNum":"  137","line":"    dir: Dir,"},
{"lineNum":"  138","line":""},
{"lineNum":"  139","line":"    const InitError = File.OpenError;"},
{"lineNum":"  140","line":""},
{"lineNum":"  141","line":"    const RANDOM_BYTES = 12;"},
{"lineNum":"  142","line":"    const TMP_PATH_LEN = base64.Base64Encoder.calcSize(RANDOM_BYTES);"},
{"lineNum":"  143","line":""},
{"lineNum":"  144","line":"    /// Note that the `Dir.atomicFile` API may be more handy than this lower-level function."},
{"lineNum":"  145","line":"    pub fn init(","class":"lineCov","hits":"1","order":"14842","possible_hits":"1",},
{"lineNum":"  146","line":"        dest_basename: []const u8,"},
{"lineNum":"  147","line":"        mode: File.Mode,"},
{"lineNum":"  148","line":"        dir: Dir,"},
{"lineNum":"  149","line":"        close_dir_on_deinit: bool,"},
{"lineNum":"  150","line":"    ) InitError!AtomicFile {"},
{"lineNum":"  151","line":"        var rand_buf: [RANDOM_BYTES]u8 = undefined;","class":"lineCov","hits":"1","order":"14843","possible_hits":"1",},
{"lineNum":"  152","line":"        var tmp_path_buf: [TMP_PATH_LEN:0]u8 = undefined;","class":"lineCov","hits":"1","order":"14844","possible_hits":"1",},
{"lineNum":"  153","line":"        // TODO: should be able to use TMP_PATH_LEN here."},
{"lineNum":"  154","line":"        tmp_path_buf[base64.Base64Encoder.calcSize(RANDOM_BYTES)] = 0;","class":"linePartCov","hits":"1","order":"14845","possible_hits":"2",},
{"lineNum":"  155","line":""},
{"lineNum":"  156","line":"        while (true) {","class":"lineCov","hits":"2","order":"14846","possible_hits":"2",},
{"lineNum":"  157","line":"            try crypto.randomBytes(rand_buf[0..]);","class":"linePartCov","hits":"1","order":"14847","possible_hits":"2",},
{"lineNum":"  158","line":"            base64_encoder.encode(&tmp_path_buf, &rand_buf);","class":"lineCov","hits":"1","order":"14848","possible_hits":"1",},
{"lineNum":"  159","line":""},
{"lineNum":"  160","line":"            const file = dir.createFile(","class":"lineCov","hits":"1","order":"14851","possible_hits":"1",},
{"lineNum":"  161","line":"                &tmp_path_buf,","class":"lineCov","hits":"1","order":"14849","possible_hits":"1",},
{"lineNum":"  162","line":"                .{ .mode = mode, .exclusive = true },","class":"lineCov","hits":"1","order":"14850","possible_hits":"1",},
{"lineNum":"  163","line":"            ) catch |err| switch (err) {","class":"lineCov","hits":"2","order":"14852","possible_hits":"2",},
{"lineNum":"  164","line":"                error.PathAlreadyExists => continue,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  165","line":"                else => |e| return e,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  166","line":"            };"},
{"lineNum":"  167","line":""},
{"lineNum":"  168","line":"            return AtomicFile{","class":"lineCov","hits":"2","order":"14853","possible_hits":"2",},
{"lineNum":"  169","line":"                .file = file,","class":"lineCov","hits":"1","order":"14854","possible_hits":"1",},
{"lineNum":"  170","line":"                .tmp_path_buf = tmp_path_buf,","class":"lineCov","hits":"1","order":"14855","possible_hits":"1",},
{"lineNum":"  171","line":"                .dest_basename = dest_basename,","class":"lineCov","hits":"1","order":"14856","possible_hits":"1",},
{"lineNum":"  172","line":"                .file_open = true,","class":"lineCov","hits":"1","order":"14857","possible_hits":"1",},
{"lineNum":"  173","line":"                .file_exists = true,","class":"lineCov","hits":"1","order":"14858","possible_hits":"1",},
{"lineNum":"  174","line":"                .close_dir_on_deinit = close_dir_on_deinit,","class":"lineCov","hits":"1","order":"14859","possible_hits":"1",},
{"lineNum":"  175","line":"                .dir = dir,","class":"lineCov","hits":"1","order":"14860","possible_hits":"1",},
{"lineNum":"  176","line":"            };"},
{"lineNum":"  177","line":"        }"},
{"lineNum":"  178","line":"    }"},
{"lineNum":"  179","line":""},
{"lineNum":"  180","line":"    /// always call deinit, even after successful finish()"},
{"lineNum":"  181","line":"    pub fn deinit(self: *AtomicFile) void {","class":"lineCov","hits":"2","order":"14887","possible_hits":"2",},
{"lineNum":"  182","line":"        if (self.file_open) {","class":"linePartCov","hits":"1","order":"14888","possible_hits":"2",},
{"lineNum":"  183","line":"            self.file.close();","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  184","line":"            self.file_open = false;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  185","line":"        }"},
{"lineNum":"  186","line":"        if (self.file_exists) {","class":"linePartCov","hits":"1","order":"14889","possible_hits":"2",},
{"lineNum":"  187","line":"            self.dir.deleteFile(&self.tmp_path_buf) catch {};","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  188","line":"            self.file_exists = false;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  189","line":"        }"},
{"lineNum":"  190","line":"        if (self.close_dir_on_deinit) {","class":"linePartCov","hits":"1","order":"14890","possible_hits":"2",},
{"lineNum":"  191","line":"            self.dir.close();","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  192","line":"        }"},
{"lineNum":"  193","line":"        self.* = undefined;","class":"lineCov","hits":"1","order":"14891","possible_hits":"1",},
{"lineNum":"  194","line":"    }"},
{"lineNum":"  195","line":""},
{"lineNum":"  196","line":"    pub fn finish(self: *AtomicFile) !void {","class":"lineCov","hits":"2","order":"14866","possible_hits":"2",},
{"lineNum":"  197","line":"        assert(self.file_exists);","class":"lineCov","hits":"1","order":"14867","possible_hits":"1",},
{"lineNum":"  198","line":"        if (self.file_open) {","class":"lineCov","hits":"2","order":"14868","possible_hits":"2",},
{"lineNum":"  199","line":"            self.file.close();","class":"lineCov","hits":"1","order":"14869","possible_hits":"1",},
{"lineNum":"  200","line":"            self.file_open = false;","class":"lineCov","hits":"1","order":"14870","possible_hits":"1",},
{"lineNum":"  201","line":"        }"},
{"lineNum":"  202","line":"        try os.renameat(self.dir.fd, self.tmp_path_buf[0..], self.dir.fd, self.dest_basename);","class":"linePartCov","hits":"1","order":"14871","possible_hits":"2",},
{"lineNum":"  203","line":"        self.file_exists = false;","class":"lineCov","hits":"1","order":"14885","possible_hits":"1",},
{"lineNum":"  204","line":"    }"},
{"lineNum":"  205","line":"};"},
{"lineNum":"  206","line":""},
{"lineNum":"  207","line":"const default_new_dir_mode = 0o755;"},
{"lineNum":"  208","line":""},
{"lineNum":"  209","line":"/// Create a new directory, based on an absolute path."},
{"lineNum":"  210","line":"/// Asserts that the path is absolute. See `Dir.makeDir` for a function that operates"},
{"lineNum":"  211","line":"/// on both absolute and relative paths."},
{"lineNum":"  212","line":"pub fn makeDirAbsolute(absolute_path: []const u8) !void {","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  213","line":"    assert(path.isAbsolute(absolute_path));","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  214","line":"    return os.mkdir(absolute_path, default_new_dir_mode);","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  215","line":"}"},
{"lineNum":"  216","line":""},
{"lineNum":"  217","line":"/// Same as `makeDirAbsolute` except the parameter is a null-terminated UTF8-encoded string."},
{"lineNum":"  218","line":"pub fn makeDirAbsoluteZ(absolute_path_z: [*:0]const u8) !void {","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  219","line":"    assert(path.isAbsoluteZ(absolute_path_z));","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  220","line":"    return os.mkdirZ(absolute_path_z, default_new_dir_mode);","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  221","line":"}"},
{"lineNum":"  222","line":""},
{"lineNum":"  223","line":"/// Same as `makeDirAbsolute` except the parameter is a null-terminated WTF-16 encoded string."},
{"lineNum":"  224","line":"pub fn makeDirAbsoluteW(absolute_path_w: [*:0]const u16) !void {"},
{"lineNum":"  225","line":"    assert(path.isAbsoluteWindowsW(absolute_path_w));"},
{"lineNum":"  226","line":"    const handle = try os.windows.CreateDirectoryW(null, absolute_path_w, null);"},
{"lineNum":"  227","line":"    os.windows.CloseHandle(handle);"},
{"lineNum":"  228","line":"}"},
{"lineNum":"  229","line":""},
{"lineNum":"  230","line":"pub const deleteDir = @compileError(\"deprecated; use dir.deleteDir or deleteDirAbsolute\");"},
{"lineNum":"  231","line":"pub const deleteDirC = @compileError(\"deprecated; use dir.deleteDirZ or deleteDirAbsoluteZ\");"},
{"lineNum":"  232","line":"pub const deleteDirW = @compileError(\"deprecated; use dir.deleteDirW or deleteDirAbsoluteW\");"},
{"lineNum":"  233","line":""},
{"lineNum":"  234","line":"/// Same as `Dir.deleteDir` except the path is absolute."},
{"lineNum":"  235","line":"pub fn deleteDirAbsolute(dir_path: []const u8) !void {"},
{"lineNum":"  236","line":"    assert(path.isAbsolute(dir_path));"},
{"lineNum":"  237","line":"    return os.rmdir(dir_path);"},
{"lineNum":"  238","line":"}"},
{"lineNum":"  239","line":""},
{"lineNum":"  240","line":"/// Same as `deleteDirAbsolute` except the path parameter is null-terminated."},
{"lineNum":"  241","line":"pub fn deleteDirAbsoluteZ(dir_path: [*:0]const u8) !void {"},
{"lineNum":"  242","line":"    assert(path.isAbsoluteZ(dir_path));"},
{"lineNum":"  243","line":"    return os.rmdirZ(dir_path);"},
{"lineNum":"  244","line":"}"},
{"lineNum":"  245","line":""},
{"lineNum":"  246","line":"/// Same as `deleteDirAbsolute` except the path parameter is WTF-16 and target OS is assumed Windows."},
{"lineNum":"  247","line":"pub fn deleteDirAbsoluteW(dir_path: [*:0]const u16) !void {"},
{"lineNum":"  248","line":"    assert(path.isAbsoluteWindowsW(dir_path));"},
{"lineNum":"  249","line":"    return os.rmdirW(dir_path);"},
{"lineNum":"  250","line":"}"},
{"lineNum":"  251","line":""},
{"lineNum":"  252","line":"pub const Dir = struct {"},
{"lineNum":"  253","line":"    fd: os.fd_t,"},
{"lineNum":"  254","line":""},
{"lineNum":"  255","line":"    pub const Entry = struct {"},
{"lineNum":"  256","line":"        name: []const u8,"},
{"lineNum":"  257","line":"        kind: Kind,"},
{"lineNum":"  258","line":""},
{"lineNum":"  259","line":"        pub const Kind = enum {"},
{"lineNum":"  260","line":"            BlockDevice,"},
{"lineNum":"  261","line":"            CharacterDevice,"},
{"lineNum":"  262","line":"            Directory,"},
{"lineNum":"  263","line":"            NamedPipe,"},
{"lineNum":"  264","line":"            SymLink,"},
{"lineNum":"  265","line":"            File,"},
{"lineNum":"  266","line":"            UnixDomainSocket,"},
{"lineNum":"  267","line":"            Whiteout,"},
{"lineNum":"  268","line":"            Unknown,"},
{"lineNum":"  269","line":"        };"},
{"lineNum":"  270","line":"    };"},
{"lineNum":"  271","line":""},
{"lineNum":"  272","line":"    const IteratorError = error{AccessDenied} || os.UnexpectedError;"},
{"lineNum":"  273","line":""},
{"lineNum":"  274","line":"    pub const Iterator = switch (builtin.os.tag) {"},
{"lineNum":"  275","line":"        .macosx, .ios, .freebsd, .netbsd, .dragonfly => struct {"},
{"lineNum":"  276","line":"            dir: Dir,"},
{"lineNum":"  277","line":"            seek: i64,"},
{"lineNum":"  278","line":"            buf: [8192]u8, // TODO align(@alignOf(os.dirent)),"},
{"lineNum":"  279","line":"            index: usize,"},
{"lineNum":"  280","line":"            end_index: usize,"},
{"lineNum":"  281","line":""},
{"lineNum":"  282","line":"            const Self = @This();"},
{"lineNum":"  283","line":""},
{"lineNum":"  284","line":"            pub const Error = IteratorError;"},
{"lineNum":"  285","line":""},
{"lineNum":"  286","line":"            /// Memory such as file names referenced in this returned entry becomes invalid"},
{"lineNum":"  287","line":"            /// with subsequent calls to `next`, as well as when this `Dir` is deinitialized."},
{"lineNum":"  288","line":"            pub fn next(self: *Self) Error!?Entry {"},
{"lineNum":"  289","line":"                switch (builtin.os.tag) {"},
{"lineNum":"  290","line":"                    .macosx, .ios => return self.nextDarwin(),"},
{"lineNum":"  291","line":"                    .freebsd, .netbsd, .dragonfly => return self.nextBsd(),"},
{"lineNum":"  292","line":"                    else => @compileError(\"unimplemented\"),"},
{"lineNum":"  293","line":"                }"},
{"lineNum":"  294","line":"            }"},
{"lineNum":"  295","line":""},
{"lineNum":"  296","line":"            fn nextDarwin(self: *Self) !?Entry {"},
{"lineNum":"  297","line":"                start_over: while (true) {"},
{"lineNum":"  298","line":"                    if (self.index >= self.end_index) {"},
{"lineNum":"  299","line":"                        const rc = os.system.__getdirentries64("},
{"lineNum":"  300","line":"                            self.dir.fd,"},
{"lineNum":"  301","line":"                            &self.buf,"},
{"lineNum":"  302","line":"                            self.buf.len,"},
{"lineNum":"  303","line":"                            &self.seek,"},
{"lineNum":"  304","line":"                        );"},
{"lineNum":"  305","line":"                        if (rc == 0) return null;"},
{"lineNum":"  306","line":"                        if (rc < 0) {"},
{"lineNum":"  307","line":"                            switch (os.errno(rc)) {"},
{"lineNum":"  308","line":"                                os.EBADF => unreachable, // Dir is invalid or was opened without iteration ability"},
{"lineNum":"  309","line":"                                os.EFAULT => unreachable,"},
{"lineNum":"  310","line":"                                os.ENOTDIR => unreachable,"},
{"lineNum":"  311","line":"                                os.EINVAL => unreachable,"},
{"lineNum":"  312","line":"                                else => |err| return os.unexpectedErrno(err),"},
{"lineNum":"  313","line":"                            }"},
{"lineNum":"  314","line":"                        }"},
{"lineNum":"  315","line":"                        self.index = 0;"},
{"lineNum":"  316","line":"                        self.end_index = @intCast(usize, rc);"},
{"lineNum":"  317","line":"                    }"},
{"lineNum":"  318","line":"                    const darwin_entry = @ptrCast(*align(1) os.dirent, &self.buf[self.index]);"},
{"lineNum":"  319","line":"                    const next_index = self.index + darwin_entry.reclen();"},
{"lineNum":"  320","line":"                    self.index = next_index;"},
{"lineNum":"  321","line":""},
{"lineNum":"  322","line":"                    const name = @ptrCast([*]u8, &darwin_entry.d_name)[0..darwin_entry.d_namlen];"},
{"lineNum":"  323","line":""},
{"lineNum":"  324","line":"                    if (mem.eql(u8, name, \".\") or mem.eql(u8, name, \"..\")) {"},
{"lineNum":"  325","line":"                        continue :start_over;"},
{"lineNum":"  326","line":"                    }"},
{"lineNum":"  327","line":""},
{"lineNum":"  328","line":"                    const entry_kind = switch (darwin_entry.d_type) {"},
{"lineNum":"  329","line":"                        os.DT_BLK => Entry.Kind.BlockDevice,"},
{"lineNum":"  330","line":"                        os.DT_CHR => Entry.Kind.CharacterDevice,"},
{"lineNum":"  331","line":"                        os.DT_DIR => Entry.Kind.Directory,"},
{"lineNum":"  332","line":"                        os.DT_FIFO => Entry.Kind.NamedPipe,"},
{"lineNum":"  333","line":"                        os.DT_LNK => Entry.Kind.SymLink,"},
{"lineNum":"  334","line":"                        os.DT_REG => Entry.Kind.File,"},
{"lineNum":"  335","line":"                        os.DT_SOCK => Entry.Kind.UnixDomainSocket,"},
{"lineNum":"  336","line":"                        os.DT_WHT => Entry.Kind.Whiteout,"},
{"lineNum":"  337","line":"                        else => Entry.Kind.Unknown,"},
{"lineNum":"  338","line":"                    };"},
{"lineNum":"  339","line":"                    return Entry{"},
{"lineNum":"  340","line":"                        .name = name,"},
{"lineNum":"  341","line":"                        .kind = entry_kind,"},
{"lineNum":"  342","line":"                    };"},
{"lineNum":"  343","line":"                }"},
{"lineNum":"  344","line":"            }"},
{"lineNum":"  345","line":""},
{"lineNum":"  346","line":"            fn nextBsd(self: *Self) !?Entry {"},
{"lineNum":"  347","line":"                start_over: while (true) {"},
{"lineNum":"  348","line":"                    if (self.index >= self.end_index) {"},
{"lineNum":"  349","line":"                        const rc = if (builtin.os.tag == .netbsd)"},
{"lineNum":"  350","line":"                            os.system.__getdents30(self.dir.fd, &self.buf, self.buf.len)"},
{"lineNum":"  351","line":"                        else"},
{"lineNum":"  352","line":"                            os.system.getdents(self.dir.fd, &self.buf, self.buf.len);"},
{"lineNum":"  353","line":"                        switch (os.errno(rc)) {"},
{"lineNum":"  354","line":"                            0 => {},"},
{"lineNum":"  355","line":"                            os.EBADF => unreachable, // Dir is invalid or was opened without iteration ability"},
{"lineNum":"  356","line":"                            os.EFAULT => unreachable,"},
{"lineNum":"  357","line":"                            os.ENOTDIR => unreachable,"},
{"lineNum":"  358","line":"                            os.EINVAL => unreachable,"},
{"lineNum":"  359","line":"                            else => |err| return os.unexpectedErrno(err),"},
{"lineNum":"  360","line":"                        }"},
{"lineNum":"  361","line":"                        if (rc == 0) return null;"},
{"lineNum":"  362","line":"                        self.index = 0;"},
{"lineNum":"  363","line":"                        self.end_index = @intCast(usize, rc);"},
{"lineNum":"  364","line":"                    }"},
{"lineNum":"  365","line":"                    const freebsd_entry = @ptrCast(*align(1) os.dirent, &self.buf[self.index]);"},
{"lineNum":"  366","line":"                    const next_index = self.index + freebsd_entry.reclen();"},
{"lineNum":"  367","line":"                    self.index = next_index;"},
{"lineNum":"  368","line":""},
{"lineNum":"  369","line":"                    const name = @ptrCast([*]u8, &freebsd_entry.d_name)[0..freebsd_entry.d_namlen];"},
{"lineNum":"  370","line":""},
{"lineNum":"  371","line":"                    if (mem.eql(u8, name, \".\") or mem.eql(u8, name, \"..\")) {"},
{"lineNum":"  372","line":"                        continue :start_over;"},
{"lineNum":"  373","line":"                    }"},
{"lineNum":"  374","line":""},
{"lineNum":"  375","line":"                    const entry_kind = switch (freebsd_entry.d_type) {"},
{"lineNum":"  376","line":"                        os.DT_BLK => Entry.Kind.BlockDevice,"},
{"lineNum":"  377","line":"                        os.DT_CHR => Entry.Kind.CharacterDevice,"},
{"lineNum":"  378","line":"                        os.DT_DIR => Entry.Kind.Directory,"},
{"lineNum":"  379","line":"                        os.DT_FIFO => Entry.Kind.NamedPipe,"},
{"lineNum":"  380","line":"                        os.DT_LNK => Entry.Kind.SymLink,"},
{"lineNum":"  381","line":"                        os.DT_REG => Entry.Kind.File,"},
{"lineNum":"  382","line":"                        os.DT_SOCK => Entry.Kind.UnixDomainSocket,"},
{"lineNum":"  383","line":"                        os.DT_WHT => Entry.Kind.Whiteout,"},
{"lineNum":"  384","line":"                        else => Entry.Kind.Unknown,"},
{"lineNum":"  385","line":"                    };"},
{"lineNum":"  386","line":"                    return Entry{"},
{"lineNum":"  387","line":"                        .name = name,"},
{"lineNum":"  388","line":"                        .kind = entry_kind,"},
{"lineNum":"  389","line":"                    };"},
{"lineNum":"  390","line":"                }"},
{"lineNum":"  391","line":"            }"},
{"lineNum":"  392","line":"        },"},
{"lineNum":"  393","line":"        .linux => struct {"},
{"lineNum":"  394","line":"            dir: Dir,"},
{"lineNum":"  395","line":"            buf: [8192]u8, // TODO align(@alignOf(os.dirent64)),"},
{"lineNum":"  396","line":"            index: usize,"},
{"lineNum":"  397","line":"            end_index: usize,"},
{"lineNum":"  398","line":""},
{"lineNum":"  399","line":"            const Self = @This();"},
{"lineNum":"  400","line":""},
{"lineNum":"  401","line":"            pub const Error = IteratorError;"},
{"lineNum":"  402","line":""},
{"lineNum":"  403","line":"            /// Memory such as file names referenced in this returned entry becomes invalid"},
{"lineNum":"  404","line":"            /// with subsequent calls to `next`, as well as when this `Dir` is deinitialized."},
{"lineNum":"  405","line":"            pub fn next(self: *Self) Error!?Entry {","class":"lineCov","hits":"1","order":"14469","possible_hits":"1",},
{"lineNum":"  406","line":"                start_over: while (true) {","class":"lineCov","hits":"1","order":"14470","possible_hits":"1",},
{"lineNum":"  407","line":"                    if (self.index >= self.end_index) {","class":"lineCov","hits":"2","order":"14471","possible_hits":"2",},
{"lineNum":"  408","line":"                        const rc = os.linux.getdents64(self.dir.fd, &self.buf, self.buf.len);","class":"lineCov","hits":"1","order":"14472","possible_hits":"1",},
{"lineNum":"  409","line":"                        switch (os.linux.getErrno(rc)) {","class":"lineCov","hits":"2","order":"14478","possible_hits":"2",},
{"lineNum":"  410","line":"                            0 => {},"},
{"lineNum":"  411","line":"                            os.EBADF => unreachable, // Dir is invalid or was opened without iteration ability","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  412","line":"                            os.EFAULT => unreachable,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  413","line":"                            os.ENOTDIR => unreachable,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  414","line":"                            os.EINVAL => unreachable,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  415","line":"                            else => |err| return os.unexpectedErrno(err),","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  416","line":"                        }"},
{"lineNum":"  417","line":"                        if (rc == 0) return null;","class":"lineCov","hits":"1","order":"14479","possible_hits":"1",},
{"lineNum":"  418","line":"                        self.index = 0;","class":"lineCov","hits":"1","order":"14480","possible_hits":"1",},
{"lineNum":"  419","line":"                        self.end_index = rc;","class":"lineCov","hits":"1","order":"14481","possible_hits":"1",},
{"lineNum":"  420","line":"                    }"},
{"lineNum":"  421","line":"                    const linux_entry = @ptrCast(*align(1) os.dirent64, &self.buf[self.index]);","class":"linePartCov","hits":"1","order":"14482","possible_hits":"2",},
{"lineNum":"  422","line":"                    const next_index = self.index + linux_entry.reclen();","class":"lineCov","hits":"1","order":"14483","possible_hits":"1",},
{"lineNum":"  423","line":"                    self.index = next_index;","class":"lineCov","hits":"1","order":"14486","possible_hits":"1",},
{"lineNum":"  424","line":""},
{"lineNum":"  425","line":"                    const name = mem.spanZ(@ptrCast([*:0]u8, &linux_entry.d_name));","class":"lineCov","hits":"1","order":"14487","possible_hits":"1",},
{"lineNum":"  426","line":""},
{"lineNum":"  427","line":"                    // skip . and .. entries"},
{"lineNum":"  428","line":"                    if (mem.eql(u8, name, \".\") or mem.eql(u8, name, \"..\")) {","class":"lineCov","hits":"3","order":"14488","possible_hits":"3",},
{"lineNum":"  429","line":"                        continue :start_over;","class":"lineCov","hits":"1","order":"14489","possible_hits":"1",},
{"lineNum":"  430","line":"                    }"},
{"lineNum":"  431","line":""},
{"lineNum":"  432","line":"                    const entry_kind = switch (linux_entry.d_type) {","class":"linePartCov","hits":"3","order":"14657","possible_hits":"8",},
{"lineNum":"  433","line":"                        os.DT_BLK => Entry.Kind.BlockDevice,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  434","line":"                        os.DT_CHR => Entry.Kind.CharacterDevice,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  435","line":"                        os.DT_DIR => Entry.Kind.Directory,","class":"lineCov","hits":"1","order":"14658","possible_hits":"1",},
{"lineNum":"  436","line":"                        os.DT_FIFO => Entry.Kind.NamedPipe,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  437","line":"                        os.DT_LNK => Entry.Kind.SymLink,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  438","line":"                        os.DT_REG => Entry.Kind.File,","class":"lineCov","hits":"1","order":"14671","possible_hits":"1",},
{"lineNum":"  439","line":"                        os.DT_SOCK => Entry.Kind.UnixDomainSocket,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  440","line":"                        else => Entry.Kind.Unknown,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  441","line":"                    };"},
{"lineNum":"  442","line":"                    return Entry{","class":"lineCov","hits":"2","order":"14659","possible_hits":"2",},
{"lineNum":"  443","line":"                        .name = name,","class":"lineCov","hits":"1","order":"14660","possible_hits":"1",},
{"lineNum":"  444","line":"                        .kind = entry_kind,","class":"lineCov","hits":"1","order":"14661","possible_hits":"1",},
{"lineNum":"  445","line":"                    };"},
{"lineNum":"  446","line":"                }"},
{"lineNum":"  447","line":"            }"},
{"lineNum":"  448","line":"        },"},
{"lineNum":"  449","line":"        .windows => struct {"},
{"lineNum":"  450","line":"            dir: Dir,"},
{"lineNum":"  451","line":"            buf: [8192]u8 align(@alignOf(os.windows.FILE_BOTH_DIR_INFORMATION)),"},
{"lineNum":"  452","line":"            index: usize,"},
{"lineNum":"  453","line":"            end_index: usize,"},
{"lineNum":"  454","line":"            first: bool,"},
{"lineNum":"  455","line":"            name_data: [256]u8,"},
{"lineNum":"  456","line":""},
{"lineNum":"  457","line":"            const Self = @This();"},
{"lineNum":"  458","line":""},
{"lineNum":"  459","line":"            pub const Error = IteratorError;"},
{"lineNum":"  460","line":""},
{"lineNum":"  461","line":"            pub fn next(self: *Self) Error!?Entry {"},
{"lineNum":"  462","line":"                start_over: while (true) {"},
{"lineNum":"  463","line":"                    const w = os.windows;"},
{"lineNum":"  464","line":"                    if (self.index >= self.end_index) {"},
{"lineNum":"  465","line":"                        var io: w.IO_STATUS_BLOCK = undefined;"},
{"lineNum":"  466","line":"                        const rc = w.ntdll.NtQueryDirectoryFile("},
{"lineNum":"  467","line":"                            self.dir.fd,"},
{"lineNum":"  468","line":"                            null,"},
{"lineNum":"  469","line":"                            null,"},
{"lineNum":"  470","line":"                            null,"},
{"lineNum":"  471","line":"                            &io,"},
{"lineNum":"  472","line":"                            &self.buf,"},
{"lineNum":"  473","line":"                            self.buf.len,"},
{"lineNum":"  474","line":"                            .FileBothDirectoryInformation,"},
{"lineNum":"  475","line":"                            w.FALSE,"},
{"lineNum":"  476","line":"                            null,"},
{"lineNum":"  477","line":"                            if (self.first) @as(w.BOOLEAN, w.TRUE) else @as(w.BOOLEAN, w.FALSE),"},
{"lineNum":"  478","line":"                        );"},
{"lineNum":"  479","line":"                        self.first = false;"},
{"lineNum":"  480","line":"                        if (io.Information == 0) return null;"},
{"lineNum":"  481","line":"                        self.index = 0;"},
{"lineNum":"  482","line":"                        self.end_index = io.Information;"},
{"lineNum":"  483","line":"                        switch (rc) {"},
{"lineNum":"  484","line":"                            .SUCCESS => {},"},
{"lineNum":"  485","line":"                            .ACCESS_DENIED => return error.AccessDenied, // Double-check that the Dir was opened with iteration ability"},
{"lineNum":"  486","line":""},
{"lineNum":"  487","line":"                            else => return w.unexpectedStatus(rc),"},
{"lineNum":"  488","line":"                        }"},
{"lineNum":"  489","line":"                    }"},
{"lineNum":"  490","line":""},
{"lineNum":"  491","line":"                    const aligned_ptr = @alignCast(@alignOf(w.FILE_BOTH_DIR_INFORMATION), &self.buf[self.index]);"},
{"lineNum":"  492","line":"                    const dir_info = @ptrCast(*w.FILE_BOTH_DIR_INFORMATION, aligned_ptr);"},
{"lineNum":"  493","line":"                    if (dir_info.NextEntryOffset != 0) {"},
{"lineNum":"  494","line":"                        self.index += dir_info.NextEntryOffset;"},
{"lineNum":"  495","line":"                    } else {"},
{"lineNum":"  496","line":"                        self.index = self.buf.len;"},
{"lineNum":"  497","line":"                    }"},
{"lineNum":"  498","line":""},
{"lineNum":"  499","line":"                    const name_utf16le = @ptrCast([*]u16, &dir_info.FileName)[0 .. dir_info.FileNameLength / 2];"},
{"lineNum":"  500","line":""},
{"lineNum":"  501","line":"                    if (mem.eql(u16, name_utf16le, &[_]u16{\'.\'}) or mem.eql(u16, name_utf16le, &[_]u16{ \'.\', \'.\' }))"},
{"lineNum":"  502","line":"                        continue;"},
{"lineNum":"  503","line":"                    // Trust that Windows gives us valid UTF-16LE"},
{"lineNum":"  504","line":"                    const name_utf8_len = std.unicode.utf16leToUtf8(self.name_data[0..], name_utf16le) catch unreachable;"},
{"lineNum":"  505","line":"                    const name_utf8 = self.name_data[0..name_utf8_len];"},
{"lineNum":"  506","line":"                    const kind = blk: {"},
{"lineNum":"  507","line":"                        const attrs = dir_info.FileAttributes;"},
{"lineNum":"  508","line":"                        if (attrs & w.FILE_ATTRIBUTE_DIRECTORY != 0) break :blk Entry.Kind.Directory;"},
{"lineNum":"  509","line":"                        if (attrs & w.FILE_ATTRIBUTE_REPARSE_POINT != 0) break :blk Entry.Kind.SymLink;"},
{"lineNum":"  510","line":"                        break :blk Entry.Kind.File;"},
{"lineNum":"  511","line":"                    };"},
{"lineNum":"  512","line":"                    return Entry{"},
{"lineNum":"  513","line":"                        .name = name_utf8,"},
{"lineNum":"  514","line":"                        .kind = kind,"},
{"lineNum":"  515","line":"                    };"},
{"lineNum":"  516","line":"                }"},
{"lineNum":"  517","line":"            }"},
{"lineNum":"  518","line":"        },"},
{"lineNum":"  519","line":"        .wasi => struct {"},
{"lineNum":"  520","line":"            dir: Dir,"},
{"lineNum":"  521","line":"            buf: [8192]u8, // TODO align(@alignOf(os.wasi.dirent_t)),"},
{"lineNum":"  522","line":"            cookie: u64,"},
{"lineNum":"  523","line":"            index: usize,"},
{"lineNum":"  524","line":"            end_index: usize,"},
{"lineNum":"  525","line":""},
{"lineNum":"  526","line":"            const Self = @This();"},
{"lineNum":"  527","line":""},
{"lineNum":"  528","line":"            pub const Error = IteratorError;"},
{"lineNum":"  529","line":""},
{"lineNum":"  530","line":"            /// Memory such as file names referenced in this returned entry becomes invalid"},
{"lineNum":"  531","line":"            /// with subsequent calls to `next`, as well as when this `Dir` is deinitialized."},
{"lineNum":"  532","line":"            pub fn next(self: *Self) Error!?Entry {"},
{"lineNum":"  533","line":"                const w = os.wasi;"},
{"lineNum":"  534","line":"                start_over: while (true) {"},
{"lineNum":"  535","line":"                    if (self.index >= self.end_index) {"},
{"lineNum":"  536","line":"                        var bufused: usize = undefined;"},
{"lineNum":"  537","line":"                        switch (w.fd_readdir(self.dir.fd, &self.buf, self.buf.len, self.cookie, &bufused)) {"},
{"lineNum":"  538","line":"                            w.ESUCCESS => {},"},
{"lineNum":"  539","line":"                            w.EBADF => unreachable, // Dir is invalid or was opened without iteration ability"},
{"lineNum":"  540","line":"                            w.EFAULT => unreachable,"},
{"lineNum":"  541","line":"                            w.ENOTDIR => unreachable,"},
{"lineNum":"  542","line":"                            w.EINVAL => unreachable,"},
{"lineNum":"  543","line":"                            else => |err| return os.unexpectedErrno(err),"},
{"lineNum":"  544","line":"                        }"},
{"lineNum":"  545","line":"                        if (bufused == 0) return null;"},
{"lineNum":"  546","line":"                        self.index = 0;"},
{"lineNum":"  547","line":"                        self.end_index = bufused;"},
{"lineNum":"  548","line":"                    }"},
{"lineNum":"  549","line":"                    const entry = @ptrCast(*align(1) os.wasi.dirent_t, &self.buf[self.index]);"},
{"lineNum":"  550","line":"                    const entry_size = @sizeOf(os.wasi.dirent_t);"},
{"lineNum":"  551","line":"                    const name_index = self.index + entry_size;"},
{"lineNum":"  552","line":"                    const name = mem.span(self.buf[name_index .. name_index + entry.d_namlen]);"},
{"lineNum":"  553","line":""},
{"lineNum":"  554","line":"                    const next_index = name_index + entry.d_namlen;"},
{"lineNum":"  555","line":"                    self.index = next_index;"},
{"lineNum":"  556","line":"                    self.cookie = entry.d_next;"},
{"lineNum":"  557","line":""},
{"lineNum":"  558","line":"                    // skip . and .. entries"},
{"lineNum":"  559","line":"                    if (mem.eql(u8, name, \".\") or mem.eql(u8, name, \"..\")) {"},
{"lineNum":"  560","line":"                        continue :start_over;"},
{"lineNum":"  561","line":"                    }"},
{"lineNum":"  562","line":""},
{"lineNum":"  563","line":"                    const entry_kind = switch (entry.d_type) {"},
{"lineNum":"  564","line":"                        wasi.FILETYPE_BLOCK_DEVICE => Entry.Kind.BlockDevice,"},
{"lineNum":"  565","line":"                        wasi.FILETYPE_CHARACTER_DEVICE => Entry.Kind.CharacterDevice,"},
{"lineNum":"  566","line":"                        wasi.FILETYPE_DIRECTORY => Entry.Kind.Directory,"},
{"lineNum":"  567","line":"                        wasi.FILETYPE_SYMBOLIC_LINK => Entry.Kind.SymLink,"},
{"lineNum":"  568","line":"                        wasi.FILETYPE_REGULAR_FILE => Entry.Kind.File,"},
{"lineNum":"  569","line":"                        wasi.FILETYPE_SOCKET_STREAM, wasi.FILETYPE_SOCKET_DGRAM => Entry.Kind.UnixDomainSocket,"},
{"lineNum":"  570","line":"                        else => Entry.Kind.Unknown,"},
{"lineNum":"  571","line":"                    };"},
{"lineNum":"  572","line":"                    return Entry{"},
{"lineNum":"  573","line":"                        .name = name,"},
{"lineNum":"  574","line":"                        .kind = entry_kind,"},
{"lineNum":"  575","line":"                    };"},
{"lineNum":"  576","line":"                }"},
{"lineNum":"  577","line":"            }"},
{"lineNum":"  578","line":"        },"},
{"lineNum":"  579","line":"        else => @compileError(\"unimplemented\"),"},
{"lineNum":"  580","line":"    };"},
{"lineNum":"  581","line":""},
{"lineNum":"  582","line":"    pub fn iterate(self: Dir) Iterator {","class":"lineCov","hits":"2","order":"14462","possible_hits":"2",},
{"lineNum":"  583","line":"        switch (builtin.os.tag) {"},
{"lineNum":"  584","line":"            .macosx, .ios, .freebsd, .netbsd, .dragonfly => return Iterator{"},
{"lineNum":"  585","line":"                .dir = self,"},
{"lineNum":"  586","line":"                .seek = 0,"},
{"lineNum":"  587","line":"                .index = 0,"},
{"lineNum":"  588","line":"                .end_index = 0,"},
{"lineNum":"  589","line":"                .buf = undefined,"},
{"lineNum":"  590","line":"            },"},
{"lineNum":"  591","line":"            .linux => return Iterator{","class":"lineCov","hits":"1","order":"14467","possible_hits":"1",},
{"lineNum":"  592","line":"                .dir = self,","class":"lineCov","hits":"1","order":"14463","possible_hits":"1",},
{"lineNum":"  593","line":"                .index = 0,","class":"lineCov","hits":"1","order":"14464","possible_hits":"1",},
{"lineNum":"  594","line":"                .end_index = 0,","class":"lineCov","hits":"1","order":"14465","possible_hits":"1",},
{"lineNum":"  595","line":"                .buf = undefined,","class":"lineCov","hits":"1","order":"14466","possible_hits":"1",},
{"lineNum":"  596","line":"            },"},
{"lineNum":"  597","line":"            .windows => return Iterator{"},
{"lineNum":"  598","line":"                .dir = self,"},
{"lineNum":"  599","line":"                .index = 0,"},
{"lineNum":"  600","line":"                .end_index = 0,"},
{"lineNum":"  601","line":"                .first = true,"},
{"lineNum":"  602","line":"                .buf = undefined,"},
{"lineNum":"  603","line":"                .name_data = undefined,"},
{"lineNum":"  604","line":"            },"},
{"lineNum":"  605","line":"            .wasi => return Iterator{"},
{"lineNum":"  606","line":"                .dir = self,"},
{"lineNum":"  607","line":"                .cookie = os.wasi.DIRCOOKIE_START,"},
{"lineNum":"  608","line":"                .index = 0,"},
{"lineNum":"  609","line":"                .end_index = 0,"},
{"lineNum":"  610","line":"                .buf = undefined,"},
{"lineNum":"  611","line":"            },"},
{"lineNum":"  612","line":"            else => @compileError(\"unimplemented\"),"},
{"lineNum":"  613","line":"        }"},
{"lineNum":"  614","line":"    }"},
{"lineNum":"  615","line":""},
{"lineNum":"  616","line":"    pub const OpenError = error{"},
{"lineNum":"  617","line":"        FileNotFound,"},
{"lineNum":"  618","line":"        NotDir,"},
{"lineNum":"  619","line":"        AccessDenied,"},
{"lineNum":"  620","line":"        SymLinkLoop,"},
{"lineNum":"  621","line":"        ProcessFdQuotaExceeded,"},
{"lineNum":"  622","line":"        NameTooLong,"},
{"lineNum":"  623","line":"        SystemFdQuotaExceeded,"},
{"lineNum":"  624","line":"        NoDevice,"},
{"lineNum":"  625","line":"        SystemResources,"},
{"lineNum":"  626","line":"        InvalidUtf8,"},
{"lineNum":"  627","line":"        BadPathName,"},
{"lineNum":"  628","line":"        DeviceBusy,"},
{"lineNum":"  629","line":"    } || os.UnexpectedError;"},
{"lineNum":"  630","line":""},
{"lineNum":"  631","line":"    pub fn close(self: *Dir) void {","class":"lineCov","hits":"2","order":"14359","possible_hits":"2",},
{"lineNum":"  632","line":"        if (need_async_thread) {"},
{"lineNum":"  633","line":"            std.event.Loop.instance.?.close(self.fd);"},
{"lineNum":"  634","line":"        } else {"},
{"lineNum":"  635","line":"            os.close(self.fd);","class":"lineCov","hits":"1","order":"14360","possible_hits":"1",},
{"lineNum":"  636","line":"        }"},
{"lineNum":"  637","line":"        self.* = undefined;","class":"lineCov","hits":"1","order":"14361","possible_hits":"1",},
{"lineNum":"  638","line":"    }"},
{"lineNum":"  639","line":""},
{"lineNum":"  640","line":"    /// Opens a file for reading or writing, without attempting to create a new file."},
{"lineNum":"  641","line":"    /// To create a new file, see `createFile`."},
{"lineNum":"  642","line":"    /// Call `File.close` to release the resource."},
{"lineNum":"  643","line":"    /// Asserts that the path parameter has no null bytes."},
{"lineNum":"  644","line":"    pub fn openFile(self: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {","class":"lineCov","hits":"1","order":"14392","possible_hits":"1",},
{"lineNum":"  645","line":"        if (builtin.os.tag == .windows) {"},
{"lineNum":"  646","line":"            const path_w = try os.windows.sliceToPrefixedFileW(sub_path);"},
{"lineNum":"  647","line":"            return self.openFileW(path_w.span(), flags);"},
{"lineNum":"  648","line":"        }"},
{"lineNum":"  649","line":"        if (builtin.os.tag == .wasi) {"},
{"lineNum":"  650","line":"            return self.openFileWasi(sub_path, flags);"},
{"lineNum":"  651","line":"        }"},
{"lineNum":"  652","line":"        const path_c = try os.toPosixPath(sub_path);","class":"lineCov","hits":"1","order":"14393","possible_hits":"1",},
{"lineNum":"  653","line":"        return self.openFileZ(&path_c, flags);","class":"lineCov","hits":"1","order":"14394","possible_hits":"1",},
{"lineNum":"  654","line":"    }"},
{"lineNum":"  655","line":""},
{"lineNum":"  656","line":"    /// Save as `openFile` but WASI only."},
{"lineNum":"  657","line":"    pub fn openFileWasi(self: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {"},
{"lineNum":"  658","line":"        const w = os.wasi;"},
{"lineNum":"  659","line":"        var fdflags: w.fdflags_t = 0x0;"},
{"lineNum":"  660","line":"        var base: w.rights_t = 0x0;"},
{"lineNum":"  661","line":"        if (flags.read) {"},
{"lineNum":"  662","line":"            base |= w.RIGHT_FD_READ | w.RIGHT_FD_TELL | w.RIGHT_FD_SEEK | w.RIGHT_FD_FILESTAT_GET;"},
{"lineNum":"  663","line":"        }"},
{"lineNum":"  664","line":"        if (flags.write) {"},
{"lineNum":"  665","line":"            fdflags |= w.FDFLAG_APPEND;"},
{"lineNum":"  666","line":"            base |= w.RIGHT_FD_WRITE |"},
{"lineNum":"  667","line":"                w.RIGHT_FD_TELL |"},
{"lineNum":"  668","line":"                w.RIGHT_FD_SEEK |"},
{"lineNum":"  669","line":"                w.RIGHT_FD_DATASYNC |"},
{"lineNum":"  670","line":"                w.RIGHT_FD_FDSTAT_SET_FLAGS |"},
{"lineNum":"  671","line":"                w.RIGHT_FD_SYNC |"},
{"lineNum":"  672","line":"                w.RIGHT_FD_ALLOCATE |"},
{"lineNum":"  673","line":"                w.RIGHT_FD_ADVISE |"},
{"lineNum":"  674","line":"                w.RIGHT_FD_FILESTAT_SET_TIMES |"},
{"lineNum":"  675","line":"                w.RIGHT_FD_FILESTAT_SET_SIZE;"},
{"lineNum":"  676","line":"        }"},
{"lineNum":"  677","line":"        const fd = try os.openatWasi(self.fd, sub_path, 0x0, fdflags, base, 0x0);"},
{"lineNum":"  678","line":"        return File{ .handle = fd };"},
{"lineNum":"  679","line":"    }"},
{"lineNum":"  680","line":""},
{"lineNum":"  681","line":"    pub const openFileC = @compileError(\"deprecated: renamed to openFileZ\");"},
{"lineNum":"  682","line":""},
{"lineNum":"  683","line":"    /// Same as `openFile` but the path parameter is null-terminated."},
{"lineNum":"  684","line":"    pub fn openFileZ(self: Dir, sub_path: [*:0]const u8, flags: File.OpenFlags) File.OpenError!File {","class":"lineCov","hits":"1","order":"13684","possible_hits":"1",},
{"lineNum":"  685","line":"        if (builtin.os.tag == .windows) {"},
{"lineNum":"  686","line":"            const path_w = try os.windows.cStrToPrefixedFileW(sub_path);"},
{"lineNum":"  687","line":"            return self.openFileW(path_w.span(), flags);"},
{"lineNum":"  688","line":"        }"},
{"lineNum":"  689","line":""},
{"lineNum":"  690","line":"        // Use the O_ locking flags if the os supports them"},
{"lineNum":"  691","line":"        // (Or if it\'s darwin, as darwin\'s `open` doesn\'t support the O_SYNC flag)"},
{"lineNum":"  692","line":"        const has_flock_open_flags = @hasDecl(os, \"O_EXLOCK\") and !is_darwin;"},
{"lineNum":"  693","line":"        const nonblocking_lock_flag = if (has_flock_open_flags and flags.lock_nonblocking)"},
{"lineNum":"  694","line":"            os.O_NONBLOCK | os.O_SYNC"},
{"lineNum":"  695","line":"        else"},
{"lineNum":"  696","line":"            @as(u32, 0);"},
{"lineNum":"  697","line":"        const lock_flag: u32 = if (has_flock_open_flags) switch (flags.lock) {"},
{"lineNum":"  698","line":"            .None => @as(u32, 0),"},
{"lineNum":"  699","line":"            .Shared => os.O_SHLOCK | nonblocking_lock_flag,"},
{"lineNum":"  700","line":"            .Exclusive => os.O_EXLOCK | nonblocking_lock_flag,"},
{"lineNum":"  701","line":"        } else 0;"},
{"lineNum":"  702","line":""},
{"lineNum":"  703","line":"        const O_LARGEFILE = if (@hasDecl(os, \"O_LARGEFILE\")) os.O_LARGEFILE else 0;"},
{"lineNum":"  704","line":"        const os_flags = lock_flag | O_LARGEFILE | os.O_CLOEXEC | if (flags.write and flags.read)","class":"linePartCov","hits":"2","order":"13685","possible_hits":"3",},
{"lineNum":"  705","line":"            @as(u32, os.O_RDWR)","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  706","line":"        else if (flags.write)","class":"linePartCov","hits":"2","order":"13686","possible_hits":"3",},
{"lineNum":"  707","line":"            @as(u32, os.O_WRONLY)","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  708","line":"        else"},
{"lineNum":"  709","line":"            @as(u32, os.O_RDONLY);","class":"lineCov","hits":"1","order":"13687","possible_hits":"1",},
{"lineNum":"  710","line":"        const fd = if (flags.intended_io_mode != .blocking)"},
{"lineNum":"  711","line":"            try std.event.Loop.instance.?.openatZ(self.fd, sub_path, os_flags, 0)"},
{"lineNum":"  712","line":"        else"},
{"lineNum":"  713","line":"            try os.openatZ(self.fd, sub_path, os_flags, 0);","class":"lineCov","hits":"1","order":"13688","possible_hits":"1",},
{"lineNum":"  714","line":""},
{"lineNum":"  715","line":"        if (!has_flock_open_flags and flags.lock != .None) {","class":"linePartCov","hits":"1","order":"13696","possible_hits":"2",},
{"lineNum":"  716","line":"            // TODO: integrate async I/O"},
{"lineNum":"  717","line":"            const lock_nonblocking = if (flags.lock_nonblocking) os.LOCK_NB else @as(i32, 0);","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  718","line":"            try os.flock(fd, switch (flags.lock) {","class":"lineNoCov","hits":"0","possible_hits":"3",},
{"lineNum":"  719","line":"                .None => unreachable,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  720","line":"                .Shared => os.LOCK_SH | lock_nonblocking,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  721","line":"                .Exclusive => os.LOCK_EX | lock_nonblocking,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  722","line":"            });"},
{"lineNum":"  723","line":"        }"},
{"lineNum":"  724","line":""},
{"lineNum":"  725","line":"        return File{","class":"lineCov","hits":"2","order":"13697","possible_hits":"2",},
{"lineNum":"  726","line":"            .handle = fd,","class":"lineCov","hits":"1","order":"13698","possible_hits":"1",},
{"lineNum":"  727","line":"            .capable_io_mode = .blocking,"},
{"lineNum":"  728","line":"            .intended_io_mode = flags.intended_io_mode,"},
{"lineNum":"  729","line":"        };"},
{"lineNum":"  730","line":"    }"},
{"lineNum":"  731","line":""},
{"lineNum":"  732","line":"    /// Same as `openFile` but Windows-only and the path parameter is"},
{"lineNum":"  733","line":"    /// [WTF-16](https://simonsapin.github.io/wtf-8/#potentially-ill-formed-utf-16) encoded."},
{"lineNum":"  734","line":"    pub fn openFileW(self: Dir, sub_path_w: []const u16, flags: File.OpenFlags) File.OpenError!File {"},
{"lineNum":"  735","line":"        const w = os.windows;"},
{"lineNum":"  736","line":"        return @as(File, .{"},
{"lineNum":"  737","line":"            .handle = try os.windows.OpenFile(sub_path_w, .{"},
{"lineNum":"  738","line":"                .dir = self.fd,"},
{"lineNum":"  739","line":"                .access_mask = w.SYNCHRONIZE |"},
{"lineNum":"  740","line":"                    (if (flags.read) @as(u32, w.GENERIC_READ) else 0) |"},
{"lineNum":"  741","line":"                    (if (flags.write) @as(u32, w.GENERIC_WRITE) else 0),"},
{"lineNum":"  742","line":"                .share_access = switch (flags.lock) {"},
{"lineNum":"  743","line":"                    .None => w.FILE_SHARE_WRITE | w.FILE_SHARE_READ | w.FILE_SHARE_DELETE,"},
{"lineNum":"  744","line":"                    .Shared => w.FILE_SHARE_READ | w.FILE_SHARE_DELETE,"},
{"lineNum":"  745","line":"                    .Exclusive => w.FILE_SHARE_DELETE,"},
{"lineNum":"  746","line":"                },"},
{"lineNum":"  747","line":"                .share_access_nonblocking = flags.lock_nonblocking,"},
{"lineNum":"  748","line":"                .creation = w.FILE_OPEN,"},
{"lineNum":"  749","line":"                .io_mode = flags.intended_io_mode,"},
{"lineNum":"  750","line":"            }),"},
{"lineNum":"  751","line":"            .capable_io_mode = std.io.default_mode,"},
{"lineNum":"  752","line":"            .intended_io_mode = flags.intended_io_mode,"},
{"lineNum":"  753","line":"        });"},
{"lineNum":"  754","line":"    }"},
{"lineNum":"  755","line":""},
{"lineNum":"  756","line":"    /// Creates, opens, or overwrites a file with write access."},
{"lineNum":"  757","line":"    /// Call `File.close` on the result when done."},
{"lineNum":"  758","line":"    /// Asserts that the path parameter has no null bytes."},
{"lineNum":"  759","line":"    pub fn createFile(self: Dir, sub_path: []const u8, flags: File.CreateFlags) File.OpenError!File {","class":"lineCov","hits":"1","order":"13714","possible_hits":"1",},
{"lineNum":"  760","line":"        if (builtin.os.tag == .windows) {"},
{"lineNum":"  761","line":"            const path_w = try os.windows.sliceToPrefixedFileW(sub_path);"},
{"lineNum":"  762","line":"            return self.createFileW(path_w.span(), flags);"},
{"lineNum":"  763","line":"        }"},
{"lineNum":"  764","line":"        if (builtin.os.tag == .wasi) {"},
{"lineNum":"  765","line":"            return self.createFileWasi(sub_path, flags);"},
{"lineNum":"  766","line":"        }"},
{"lineNum":"  767","line":"        const path_c = try os.toPosixPath(sub_path);","class":"lineCov","hits":"1","order":"13715","possible_hits":"1",},
{"lineNum":"  768","line":"        return self.createFileZ(&path_c, flags);","class":"lineCov","hits":"1","order":"13716","possible_hits":"1",},
{"lineNum":"  769","line":"    }"},
{"lineNum":"  770","line":""},
{"lineNum":"  771","line":"    pub const createFileC = @compileError(\"deprecated: renamed to createFileZ\");"},
{"lineNum":"  772","line":""},
{"lineNum":"  773","line":"    /// Same as `createFile` but WASI only."},
{"lineNum":"  774","line":"    pub fn createFileWasi(self: Dir, sub_path: []const u8, flags: File.CreateFlags) File.OpenError!File {"},
{"lineNum":"  775","line":"        const w = os.wasi;"},
{"lineNum":"  776","line":"        var oflags = w.O_CREAT;"},
{"lineNum":"  777","line":"        var base: w.rights_t = w.RIGHT_FD_WRITE |"},
{"lineNum":"  778","line":"            w.RIGHT_FD_DATASYNC |"},
{"lineNum":"  779","line":"            w.RIGHT_FD_SEEK |"},
{"lineNum":"  780","line":"            w.RIGHT_FD_TELL |"},
{"lineNum":"  781","line":"            w.RIGHT_FD_FDSTAT_SET_FLAGS |"},
{"lineNum":"  782","line":"            w.RIGHT_FD_SYNC |"},
{"lineNum":"  783","line":"            w.RIGHT_FD_ALLOCATE |"},
{"lineNum":"  784","line":"            w.RIGHT_FD_ADVISE |"},
{"lineNum":"  785","line":"            w.RIGHT_FD_FILESTAT_SET_TIMES |"},
{"lineNum":"  786","line":"            w.RIGHT_FD_FILESTAT_SET_SIZE |"},
{"lineNum":"  787","line":"            w.RIGHT_FD_FILESTAT_GET;"},
{"lineNum":"  788","line":"        if (flags.read) {"},
{"lineNum":"  789","line":"            base |= w.RIGHT_FD_READ;"},
{"lineNum":"  790","line":"        }"},
{"lineNum":"  791","line":"        if (flags.truncate) {"},
{"lineNum":"  792","line":"            oflags |= w.O_TRUNC;"},
{"lineNum":"  793","line":"        }"},
{"lineNum":"  794","line":"        if (flags.exclusive) {"},
{"lineNum":"  795","line":"            oflags |= w.O_EXCL;"},
{"lineNum":"  796","line":"        }"},
{"lineNum":"  797","line":"        const fd = try os.openatWasi(self.fd, sub_path, oflags, 0x0, base, 0x0);"},
{"lineNum":"  798","line":"        return File{ .handle = fd };"},
{"lineNum":"  799","line":"    }"},
{"lineNum":"  800","line":""},
{"lineNum":"  801","line":"    /// Same as `createFile` but the path parameter is null-terminated."},
{"lineNum":"  802","line":"    pub fn createFileZ(self: Dir, sub_path_c: [*:0]const u8, flags: File.CreateFlags) File.OpenError!File {","class":"lineCov","hits":"1","order":"13717","possible_hits":"1",},
{"lineNum":"  803","line":"        if (builtin.os.tag == .windows) {"},
{"lineNum":"  804","line":"            const path_w = try os.windows.cStrToPrefixedFileW(sub_path_c);"},
{"lineNum":"  805","line":"            return self.createFileW(path_w.span(), flags);"},
{"lineNum":"  806","line":"        }"},
{"lineNum":"  807","line":""},
{"lineNum":"  808","line":"        // Use the O_ locking flags if the os supports them"},
{"lineNum":"  809","line":"        // (Or if it\'s darwin, as darwin\'s `open` doesn\'t support the O_SYNC flag)"},
{"lineNum":"  810","line":"        const has_flock_open_flags = @hasDecl(os, \"O_EXLOCK\") and !is_darwin;"},
{"lineNum":"  811","line":"        const nonblocking_lock_flag: u32 = if (has_flock_open_flags and flags.lock_nonblocking)"},
{"lineNum":"  812","line":"            os.O_NONBLOCK | os.O_SYNC"},
{"lineNum":"  813","line":"        else"},
{"lineNum":"  814","line":"            0;"},
{"lineNum":"  815","line":"        const lock_flag: u32 = if (has_flock_open_flags) switch (flags.lock) {"},
{"lineNum":"  816","line":"            .None => @as(u32, 0),"},
{"lineNum":"  817","line":"            .Shared => os.O_SHLOCK,"},
{"lineNum":"  818","line":"            .Exclusive => os.O_EXLOCK,"},
{"lineNum":"  819","line":"        } else 0;"},
{"lineNum":"  820","line":""},
{"lineNum":"  821","line":"        const O_LARGEFILE = if (@hasDecl(os, \"O_LARGEFILE\")) os.O_LARGEFILE else 0;"},
{"lineNum":"  822","line":"        const os_flags = lock_flag | O_LARGEFILE | os.O_CREAT | os.O_CLOEXEC |","class":"lineCov","hits":"1","order":"13719","possible_hits":"1",},
{"lineNum":"  823","line":"            (if (flags.truncate) @as(u32, os.O_TRUNC) else 0) |","class":"lineCov","hits":"2","order":"13718","possible_hits":"2",},
{"lineNum":"  824","line":"            (if (flags.read) @as(u32, os.O_RDWR) else os.O_WRONLY) |","class":"lineCov","hits":"2","order":"13720","possible_hits":"2",},
{"lineNum":"  825","line":"            (if (flags.exclusive) @as(u32, os.O_EXCL) else 0);","class":"lineCov","hits":"1","order":"13721","possible_hits":"1",},
{"lineNum":"  826","line":"        const fd = if (flags.intended_io_mode != .blocking)"},
{"lineNum":"  827","line":"            try std.event.Loop.instance.?.openatZ(self.fd, sub_path_c, os_flags, flags.mode)"},
{"lineNum":"  828","line":"        else"},
{"lineNum":"  829","line":"            try os.openatZ(self.fd, sub_path_c, os_flags, flags.mode);","class":"lineCov","hits":"1","order":"13722","possible_hits":"1",},
{"lineNum":"  830","line":""},
{"lineNum":"  831","line":"        if (!has_flock_open_flags and flags.lock != .None) {","class":"lineCov","hits":"2","order":"13723","possible_hits":"2",},
{"lineNum":"  832","line":"            // TODO: integrate async I/O"},
{"lineNum":"  833","line":"            const lock_nonblocking = if (flags.lock_nonblocking) os.LOCK_NB else @as(i32, 0);","class":"lineCov","hits":"1","order":"13724","possible_hits":"1",},
{"lineNum":"  834","line":"            try os.flock(fd, switch (flags.lock) {","class":"linePartCov","hits":"2","order":"13725","possible_hits":"3",},
{"lineNum":"  835","line":"                .None => unreachable,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  836","line":"                .Shared => os.LOCK_SH | lock_nonblocking,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  837","line":"                .Exclusive => os.LOCK_EX | lock_nonblocking,","class":"lineCov","hits":"1","order":"13726","possible_hits":"1",},
{"lineNum":"  838","line":"            });"},
{"lineNum":"  839","line":"        }"},
{"lineNum":"  840","line":""},
{"lineNum":"  841","line":"        return File{","class":"lineCov","hits":"2","order":"13734","possible_hits":"2",},
{"lineNum":"  842","line":"            .handle = fd,","class":"lineCov","hits":"1","order":"13735","possible_hits":"1",},
{"lineNum":"  843","line":"            .capable_io_mode = .blocking,"},
{"lineNum":"  844","line":"            .intended_io_mode = flags.intended_io_mode,"},
{"lineNum":"  845","line":"        };"},
{"lineNum":"  846","line":"    }"},
{"lineNum":"  847","line":""},
{"lineNum":"  848","line":"    /// Same as `createFile` but Windows-only and the path parameter is"},
{"lineNum":"  849","line":"    /// [WTF-16](https://simonsapin.github.io/wtf-8/#potentially-ill-formed-utf-16) encoded."},
{"lineNum":"  850","line":"    pub fn createFileW(self: Dir, sub_path_w: []const u16, flags: File.CreateFlags) File.OpenError!File {"},
{"lineNum":"  851","line":"        const w = os.windows;"},
{"lineNum":"  852","line":"        const read_flag = if (flags.read) @as(u32, w.GENERIC_READ) else 0;"},
{"lineNum":"  853","line":"        return @as(File, .{"},
{"lineNum":"  854","line":"            .handle = try os.windows.OpenFile(sub_path_w, .{"},
{"lineNum":"  855","line":"                .dir = self.fd,"},
{"lineNum":"  856","line":"                .access_mask = w.SYNCHRONIZE | w.GENERIC_WRITE | read_flag,"},
{"lineNum":"  857","line":"                .share_access = switch (flags.lock) {"},
{"lineNum":"  858","line":"                    .None => w.FILE_SHARE_WRITE | w.FILE_SHARE_READ | w.FILE_SHARE_DELETE,"},
{"lineNum":"  859","line":"                    .Shared => w.FILE_SHARE_READ | w.FILE_SHARE_DELETE,"},
{"lineNum":"  860","line":"                    .Exclusive => w.FILE_SHARE_DELETE,"},
{"lineNum":"  861","line":"                },"},
{"lineNum":"  862","line":"                .share_access_nonblocking = flags.lock_nonblocking,"},
{"lineNum":"  863","line":"                .creation = if (flags.exclusive)"},
{"lineNum":"  864","line":"                    @as(u32, w.FILE_CREATE)"},
{"lineNum":"  865","line":"                else if (flags.truncate)"},
{"lineNum":"  866","line":"                    @as(u32, w.FILE_OVERWRITE_IF)"},
{"lineNum":"  867","line":"                else"},
{"lineNum":"  868","line":"                    @as(u32, w.FILE_OPEN_IF),"},
{"lineNum":"  869","line":"                .io_mode = flags.intended_io_mode,"},
{"lineNum":"  870","line":"            }),"},
{"lineNum":"  871","line":"            .capable_io_mode = std.io.default_mode,"},
{"lineNum":"  872","line":"            .intended_io_mode = flags.intended_io_mode,"},
{"lineNum":"  873","line":"        });"},
{"lineNum":"  874","line":"    }"},
{"lineNum":"  875","line":""},
{"lineNum":"  876","line":"    pub const openRead = @compileError(\"deprecated in favor of openFile\");"},
{"lineNum":"  877","line":"    pub const openReadC = @compileError(\"deprecated in favor of openFileZ\");"},
{"lineNum":"  878","line":"    pub const openReadW = @compileError(\"deprecated in favor of openFileW\");"},
{"lineNum":"  879","line":""},
{"lineNum":"  880","line":"    pub fn makeDir(self: Dir, sub_path: []const u8) !void {","class":"lineCov","hits":"2","order":"14329","possible_hits":"2",},
{"lineNum":"  881","line":"        try os.mkdirat(self.fd, sub_path, default_new_dir_mode);","class":"lineCov","hits":"1","order":"14330","possible_hits":"1",},
{"lineNum":"  882","line":"    }"},
{"lineNum":"  883","line":""},
{"lineNum":"  884","line":"    pub fn makeDirZ(self: Dir, sub_path: [*:0]const u8) !void {"},
{"lineNum":"  885","line":"        try os.mkdiratZ(self.fd, sub_path, default_new_dir_mode);"},
{"lineNum":"  886","line":"    }"},
{"lineNum":"  887","line":""},
{"lineNum":"  888","line":"    pub fn makeDirW(self: Dir, sub_path: [*:0]const u16) !void {"},
{"lineNum":"  889","line":"        const handle = try os.windows.CreateDirectoryW(self.fd, sub_path, null);"},
{"lineNum":"  890","line":"        os.windows.CloseHandle(handle);"},
{"lineNum":"  891","line":"    }"},
{"lineNum":"  892","line":""},
{"lineNum":"  893","line":"    /// Calls makeDir recursively to make an entire path. Returns success if the path"},
{"lineNum":"  894","line":"    /// already exists and is a directory."},
{"lineNum":"  895","line":"    /// This function is not atomic, and if it returns an error, the file system may"},
{"lineNum":"  896","line":"    /// have been modified regardless."},
{"lineNum":"  897","line":"    pub fn makePath(self: Dir, sub_path: []const u8) !void {","class":"lineCov","hits":"1","order":"14325","possible_hits":"1",},
{"lineNum":"  898","line":"        var end_index: usize = sub_path.len;","class":"lineCov","hits":"1","order":"14326","possible_hits":"1",},
{"lineNum":"  899","line":"        while (true) {","class":"lineCov","hits":"2","order":"14327","possible_hits":"2",},
{"lineNum":"  900","line":"            self.makeDir(sub_path[0..end_index]) catch |err| switch (err) {","class":"linePartCov","hits":"1","order":"14328","possible_hits":"3",},
{"lineNum":"  901","line":"                error.PathAlreadyExists => {"},
{"lineNum":"  902","line":"                    // TODO stat the file and return an error if it\'s not a directory"},
{"lineNum":"  903","line":"                    // this is important because otherwise a dangling symlink"},
{"lineNum":"  904","line":"                    // could cause an infinite loop"},
{"lineNum":"  905","line":"                    if (end_index == sub_path.len) return;","class":"lineCov","hits":"1","order":"14339","possible_hits":"1",},
{"lineNum":"  906","line":"                },"},
{"lineNum":"  907","line":"                error.FileNotFound => {"},
{"lineNum":"  908","line":"                    if (end_index == 0) return err;","class":"lineCov","hits":"1","order":"14640","possible_hits":"1",},
{"lineNum":"  909","line":"                    // march end_index backward until next path component"},
{"lineNum":"  910","line":"                    while (true) {","class":"lineCov","hits":"2","order":"14641","possible_hits":"2",},
{"lineNum":"  911","line":"                        end_index -= 1;","class":"linePartCov","hits":"1","order":"14642","possible_hits":"2",},
{"lineNum":"  912","line":"                        if (path.isSep(sub_path[end_index])) break;","class":"lineCov","hits":"2","order":"14643","possible_hits":"2",},
{"lineNum":"  913","line":"                    }"},
{"lineNum":"  914","line":"                    continue;","class":"lineCov","hits":"1","order":"14646","possible_hits":"1",},
{"lineNum":"  915","line":"                },"},
{"lineNum":"  916","line":"                else => return err,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  917","line":"            };"},
{"lineNum":"  918","line":"            if (end_index == sub_path.len) return;","class":"lineCov","hits":"1","order":"14354","possible_hits":"1",},
{"lineNum":"  919","line":"            // march end_index forward until next path component"},
{"lineNum":"  920","line":"            while (true) {","class":"lineCov","hits":"2","order":"14647","possible_hits":"2",},
{"lineNum":"  921","line":"                end_index += 1;","class":"linePartCov","hits":"1","order":"14648","possible_hits":"2",},
{"lineNum":"  922","line":"                if (end_index == sub_path.len or path.isSep(sub_path[end_index])) break;","class":"lineCov","hits":"2","order":"14649","possible_hits":"2",},
{"lineNum":"  923","line":"            }"},
{"lineNum":"  924","line":"        }"},
{"lineNum":"  925","line":"    }"},
{"lineNum":"  926","line":""},
{"lineNum":"  927","line":"    /// This function performs `makePath`, followed by `openDir`."},
{"lineNum":"  928","line":"    /// If supported by the OS, this operation is atomic. It is not atomic on"},
{"lineNum":"  929","line":"    /// all operating systems."},
{"lineNum":"  930","line":"    pub fn makeOpenPath(self: Dir, sub_path: []const u8, open_dir_options: OpenDirOptions) !Dir {","class":"lineCov","hits":"1","order":"14323","possible_hits":"1",},
{"lineNum":"  931","line":"        // TODO improve this implementation on Windows; we can avoid 1 call to NtClose"},
{"lineNum":"  932","line":"        try self.makePath(sub_path);","class":"lineCov","hits":"1","order":"14324","possible_hits":"1",},
{"lineNum":"  933","line":"        return self.openDir(sub_path, open_dir_options);","class":"lineCov","hits":"1","order":"14340","possible_hits":"1",},
{"lineNum":"  934","line":"    }"},
{"lineNum":"  935","line":""},
{"lineNum":"  936","line":"    /// Changes the current working directory to the open directory handle."},
{"lineNum":"  937","line":"    /// This modifies global state and can have surprising effects in multi-"},
{"lineNum":"  938","line":"    /// threaded applications. Most applications and especially libraries should"},
{"lineNum":"  939","line":"    /// not call this function as a general rule, however it can have use cases"},
{"lineNum":"  940","line":"    /// in, for example, implementing a shell, or child process execution."},
{"lineNum":"  941","line":"    /// Not all targets support this. For example, WASI does not have the concept"},
{"lineNum":"  942","line":"    /// of a current working directory."},
{"lineNum":"  943","line":"    pub fn setAsCwd(self: Dir) !void {"},
{"lineNum":"  944","line":"        if (builtin.os.tag == .wasi) {"},
{"lineNum":"  945","line":"            @compileError(\"changing cwd is not currently possible in WASI\");"},
{"lineNum":"  946","line":"        }"},
{"lineNum":"  947","line":"        try os.fchdir(self.fd);"},
{"lineNum":"  948","line":"    }"},
{"lineNum":"  949","line":""},
{"lineNum":"  950","line":"    pub const OpenDirOptions = struct {"},
{"lineNum":"  951","line":"        /// `true` means the opened directory can be used as the `Dir` parameter"},
{"lineNum":"  952","line":"        /// for functions which operate based on an open directory handle. When `false`,"},
{"lineNum":"  953","line":"        /// such operations are Illegal Behavior."},
{"lineNum":"  954","line":"        access_sub_paths: bool = true,"},
{"lineNum":"  955","line":""},
{"lineNum":"  956","line":"        /// `true` means the opened directory can be scanned for the files and sub-directories"},
{"lineNum":"  957","line":"        /// of the result. It means the `iterate` function can be called."},
{"lineNum":"  958","line":"        iterate: bool = false,"},
{"lineNum":"  959","line":"    };"},
{"lineNum":"  960","line":""},
{"lineNum":"  961","line":"    /// Opens a directory at the given path. The directory is a system resource that remains"},
{"lineNum":"  962","line":"    /// open until `close` is called on the result."},
{"lineNum":"  963","line":"    ///"},
{"lineNum":"  964","line":"    /// Asserts that the path parameter has no null bytes."},
{"lineNum":"  965","line":"    pub fn openDir(self: Dir, sub_path: []const u8, args: OpenDirOptions) OpenError!Dir {","class":"lineCov","hits":"1","order":"14341","possible_hits":"1",},
{"lineNum":"  966","line":"        if (builtin.os.tag == .windows) {"},
{"lineNum":"  967","line":"            const sub_path_w = try os.windows.sliceToPrefixedFileW(sub_path);"},
{"lineNum":"  968","line":"            return self.openDirW(sub_path_w.span().ptr, args);"},
{"lineNum":"  969","line":"        } else if (builtin.os.tag == .wasi) {"},
{"lineNum":"  970","line":"            return self.openDirWasi(sub_path, args);"},
{"lineNum":"  971","line":"        } else {"},
{"lineNum":"  972","line":"            const sub_path_c = try os.toPosixPath(sub_path);","class":"lineCov","hits":"1","order":"14342","possible_hits":"1",},
{"lineNum":"  973","line":"            return self.openDirZ(&sub_path_c, args);","class":"lineCov","hits":"1","order":"14343","possible_hits":"1",},
{"lineNum":"  974","line":"        }"},
{"lineNum":"  975","line":"    }"},
{"lineNum":"  976","line":""},
{"lineNum":"  977","line":"    pub const openDirC = @compileError(\"deprecated: renamed to openDirZ\");"},
{"lineNum":"  978","line":""},
{"lineNum":"  979","line":"    /// Same as `openDir` except only WASI."},
{"lineNum":"  980","line":"    pub fn openDirWasi(self: Dir, sub_path: []const u8, args: OpenDirOptions) OpenError!Dir {"},
{"lineNum":"  981","line":"        const w = os.wasi;"},
{"lineNum":"  982","line":"        var base: w.rights_t = w.RIGHT_FD_FILESTAT_GET | w.RIGHT_FD_FDSTAT_SET_FLAGS | w.RIGHT_FD_FILESTAT_SET_TIMES;"},
{"lineNum":"  983","line":"        if (args.iterate) {"},
{"lineNum":"  984","line":"            base |= w.RIGHT_FD_READDIR;"},
{"lineNum":"  985","line":"        }"},
{"lineNum":"  986","line":"        if (args.access_sub_paths) {"},
{"lineNum":"  987","line":"            base |= w.RIGHT_PATH_CREATE_DIRECTORY |"},
{"lineNum":"  988","line":"                w.RIGHT_PATH_CREATE_FILE |"},
{"lineNum":"  989","line":"                w.RIGHT_PATH_LINK_SOURCE |"},
{"lineNum":"  990","line":"                w.RIGHT_PATH_LINK_TARGET |"},
{"lineNum":"  991","line":"                w.RIGHT_PATH_OPEN |"},
{"lineNum":"  992","line":"                w.RIGHT_PATH_READLINK |"},
{"lineNum":"  993","line":"                w.RIGHT_PATH_RENAME_SOURCE |"},
{"lineNum":"  994","line":"                w.RIGHT_PATH_RENAME_TARGET |"},
{"lineNum":"  995","line":"                w.RIGHT_PATH_FILESTAT_GET |"},
{"lineNum":"  996","line":"                w.RIGHT_PATH_FILESTAT_SET_SIZE |"},
{"lineNum":"  997","line":"                w.RIGHT_PATH_FILESTAT_SET_TIMES |"},
{"lineNum":"  998","line":"                w.RIGHT_PATH_SYMLINK |"},
{"lineNum":"  999","line":"                w.RIGHT_PATH_REMOVE_DIRECTORY |"},
{"lineNum":" 1000","line":"                w.RIGHT_PATH_UNLINK_FILE;"},
{"lineNum":" 1001","line":"        }"},
{"lineNum":" 1002","line":"        // TODO do we really need all the rights here?"},
{"lineNum":" 1003","line":"        const inheriting: w.rights_t = w.RIGHT_ALL ^ w.RIGHT_SOCK_SHUTDOWN;"},
{"lineNum":" 1004","line":""},
{"lineNum":" 1005","line":"        const result = os.openatWasi(self.fd, sub_path, w.O_DIRECTORY, 0x0, base, inheriting);"},
{"lineNum":" 1006","line":"        const fd = result catch |err| switch (err) {"},
{"lineNum":" 1007","line":"            error.FileTooBig => unreachable, // can\'t happen for directories"},
{"lineNum":" 1008","line":"            error.IsDir => unreachable, // we\'re providing O_DIRECTORY"},
{"lineNum":" 1009","line":"            error.NoSpaceLeft => unreachable, // not providing O_CREAT"},
{"lineNum":" 1010","line":"            error.PathAlreadyExists => unreachable, // not providing O_CREAT"},
{"lineNum":" 1011","line":"            error.FileLocksNotSupported => unreachable, // locking folders is not supported"},
{"lineNum":" 1012","line":"            else => |e| return e,"},
{"lineNum":" 1013","line":"        };"},
{"lineNum":" 1014","line":"        return Dir{ .fd = fd };"},
{"lineNum":" 1015","line":"    }"},
{"lineNum":" 1016","line":""},
{"lineNum":" 1017","line":"    /// Same as `openDir` except the parameter is null-terminated."},
{"lineNum":" 1018","line":"    pub fn openDirZ(self: Dir, sub_path_c: [*:0]const u8, args: OpenDirOptions) OpenError!Dir {","class":"lineCov","hits":"1","order":"14344","possible_hits":"1",},
{"lineNum":" 1019","line":"        if (builtin.os.tag == .windows) {"},
{"lineNum":" 1020","line":"            const sub_path_w = try os.windows.cStrToPrefixedFileW(sub_path_c);"},
{"lineNum":" 1021","line":"            return self.openDirW(sub_path_w.span().ptr, args);"},
{"lineNum":" 1022","line":"        } else if (!args.iterate) {","class":"lineCov","hits":"1","order":"14345","possible_hits":"1",},
{"lineNum":" 1023","line":"            const O_PATH = if (@hasDecl(os, \"O_PATH\")) os.O_PATH else 0;"},
{"lineNum":" 1024","line":"            return self.openDirFlagsZ(sub_path_c, os.O_DIRECTORY | os.O_RDONLY | os.O_CLOEXEC | O_PATH);","class":"lineCov","hits":"1","order":"14346","possible_hits":"1",},
{"lineNum":" 1025","line":"        } else {"},
{"lineNum":" 1026","line":"            return self.openDirFlagsZ(sub_path_c, os.O_DIRECTORY | os.O_RDONLY | os.O_CLOEXEC);","class":"lineCov","hits":"1","order":"14456","possible_hits":"1",},
{"lineNum":" 1027","line":"        }"},
{"lineNum":" 1028","line":"    }"},
{"lineNum":" 1029","line":""},
{"lineNum":" 1030","line":"    /// Same as `openDir` except the path parameter is WTF-16 encoded, NT-prefixed."},
{"lineNum":" 1031","line":"    /// This function asserts the target OS is Windows."},
{"lineNum":" 1032","line":"    pub fn openDirW(self: Dir, sub_path_w: [*:0]const u16, args: OpenDirOptions) OpenError!Dir {"},
{"lineNum":" 1033","line":"        const w = os.windows;"},
{"lineNum":" 1034","line":"        // TODO remove some of these flags if args.access_sub_paths is false"},
{"lineNum":" 1035","line":"        const base_flags = w.STANDARD_RIGHTS_READ | w.FILE_READ_ATTRIBUTES | w.FILE_READ_EA |"},
{"lineNum":" 1036","line":"            w.SYNCHRONIZE | w.FILE_TRAVERSE;"},
{"lineNum":" 1037","line":"        const flags: u32 = if (args.iterate) base_flags | w.FILE_LIST_DIRECTORY else base_flags;"},
{"lineNum":" 1038","line":"        return self.openDirAccessMaskW(sub_path_w, flags);"},
{"lineNum":" 1039","line":"    }"},
{"lineNum":" 1040","line":""},
{"lineNum":" 1041","line":"    /// `flags` must contain `os.O_DIRECTORY`."},
{"lineNum":" 1042","line":"    fn openDirFlagsZ(self: Dir, sub_path_c: [*:0]const u8, flags: u32) OpenError!Dir {","class":"lineCov","hits":"1","order":"14347","possible_hits":"1",},
{"lineNum":" 1043","line":"        const result = if (need_async_thread)"},
{"lineNum":" 1044","line":"            std.event.Loop.instance.?.openatZ(self.fd, sub_path_c, flags, 0)"},
{"lineNum":" 1045","line":"        else"},
{"lineNum":" 1046","line":"            os.openatZ(self.fd, sub_path_c, flags, 0);","class":"lineCov","hits":"1","order":"14348","possible_hits":"1",},
{"lineNum":" 1047","line":"        const fd = result catch |err| switch (err) {","class":"lineCov","hits":"2","order":"14349","possible_hits":"2",},
{"lineNum":" 1048","line":"            error.FileTooBig => unreachable, // can\'t happen for directories","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1049","line":"            error.IsDir => unreachable, // we\'re providing O_DIRECTORY","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1050","line":"            error.NoSpaceLeft => unreachable, // not providing O_CREAT","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1051","line":"            error.PathAlreadyExists => unreachable, // not providing O_CREAT","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1052","line":"            error.FileLocksNotSupported => unreachable, // locking folders is not supported","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1053","line":"            else => |e| return e,","class":"lineCov","hits":"1","order":"14677","possible_hits":"1",},
{"lineNum":" 1054","line":"        };"},
{"lineNum":" 1055","line":"        return Dir{ .fd = fd };","class":"lineCov","hits":"1","order":"14350","possible_hits":"1",},
{"lineNum":" 1056","line":"    }"},
{"lineNum":" 1057","line":""},
{"lineNum":" 1058","line":"    fn openDirAccessMaskW(self: Dir, sub_path_w: [*:0]const u16, access_mask: u32) OpenError!Dir {"},
{"lineNum":" 1059","line":"        const w = os.windows;"},
{"lineNum":" 1060","line":""},
{"lineNum":" 1061","line":"        var result = Dir{"},
{"lineNum":" 1062","line":"            .fd = undefined,"},
{"lineNum":" 1063","line":"        };"},
{"lineNum":" 1064","line":""},
{"lineNum":" 1065","line":"        const path_len_bytes = @intCast(u16, mem.lenZ(sub_path_w) * 2);"},
{"lineNum":" 1066","line":"        var nt_name = w.UNICODE_STRING{"},
{"lineNum":" 1067","line":"            .Length = path_len_bytes,"},
{"lineNum":" 1068","line":"            .MaximumLength = path_len_bytes,"},
{"lineNum":" 1069","line":"            .Buffer = @intToPtr([*]u16, @ptrToInt(sub_path_w)),"},
{"lineNum":" 1070","line":"        };"},
{"lineNum":" 1071","line":"        var attr = w.OBJECT_ATTRIBUTES{"},
{"lineNum":" 1072","line":"            .Length = @sizeOf(w.OBJECT_ATTRIBUTES),"},
{"lineNum":" 1073","line":"            .RootDirectory = if (path.isAbsoluteWindowsW(sub_path_w)) null else self.fd,"},
{"lineNum":" 1074","line":"            .Attributes = 0, // Note we do not use OBJ_CASE_INSENSITIVE here."},
{"lineNum":" 1075","line":"            .ObjectName = &nt_name,"},
{"lineNum":" 1076","line":"            .SecurityDescriptor = null,"},
{"lineNum":" 1077","line":"            .SecurityQualityOfService = null,"},
{"lineNum":" 1078","line":"        };"},
{"lineNum":" 1079","line":"        if (sub_path_w[0] == \'.\' and sub_path_w[1] == 0) {"},
{"lineNum":" 1080","line":"            // Windows does not recognize this, but it does work with empty string."},
{"lineNum":" 1081","line":"            nt_name.Length = 0;"},
{"lineNum":" 1082","line":"        }"},
{"lineNum":" 1083","line":"        if (sub_path_w[0] == \'.\' and sub_path_w[1] == \'.\' and sub_path_w[2] == 0) {"},
{"lineNum":" 1084","line":"            // If you\'re looking to contribute to zig and fix this, see here for an example of how to"},
{"lineNum":" 1085","line":"            // implement this: https://git.midipix.org/ntapi/tree/src/fs/ntapi_tt_open_physical_parent_directory.c"},
{"lineNum":" 1086","line":"            @panic(\"TODO opening \'..\' with a relative directory handle is not yet implemented on Windows\");"},
{"lineNum":" 1087","line":"        }"},
{"lineNum":" 1088","line":"        var io: w.IO_STATUS_BLOCK = undefined;"},
{"lineNum":" 1089","line":"        const rc = w.ntdll.NtCreateFile("},
{"lineNum":" 1090","line":"            &result.fd,"},
{"lineNum":" 1091","line":"            access_mask,"},
{"lineNum":" 1092","line":"            &attr,"},
{"lineNum":" 1093","line":"            &io,"},
{"lineNum":" 1094","line":"            null,"},
{"lineNum":" 1095","line":"            0,"},
{"lineNum":" 1096","line":"            w.FILE_SHARE_READ | w.FILE_SHARE_WRITE,"},
{"lineNum":" 1097","line":"            w.FILE_OPEN,"},
{"lineNum":" 1098","line":"            w.FILE_DIRECTORY_FILE | w.FILE_SYNCHRONOUS_IO_NONALERT | w.FILE_OPEN_FOR_BACKUP_INTENT,"},
{"lineNum":" 1099","line":"            null,"},
{"lineNum":" 1100","line":"            0,"},
{"lineNum":" 1101","line":"        );"},
{"lineNum":" 1102","line":"        switch (rc) {"},
{"lineNum":" 1103","line":"            .SUCCESS => return result,"},
{"lineNum":" 1104","line":"            .OBJECT_NAME_INVALID => unreachable,"},
{"lineNum":" 1105","line":"            .OBJECT_NAME_NOT_FOUND => return error.FileNotFound,"},
{"lineNum":" 1106","line":"            .OBJECT_PATH_NOT_FOUND => return error.FileNotFound,"},
{"lineNum":" 1107","line":"            .INVALID_PARAMETER => unreachable,"},
{"lineNum":" 1108","line":"            else => return w.unexpectedStatus(rc),"},
{"lineNum":" 1109","line":"        }"},
{"lineNum":" 1110","line":"    }"},
{"lineNum":" 1111","line":""},
{"lineNum":" 1112","line":"    pub const DeleteFileError = os.UnlinkError;"},
{"lineNum":" 1113","line":""},
{"lineNum":" 1114","line":"    /// Delete a file name and possibly the file it refers to, based on an open directory handle."},
{"lineNum":" 1115","line":"    /// Asserts that the path parameter has no null bytes."},
{"lineNum":" 1116","line":"    pub fn deleteFile(self: Dir, sub_path: []const u8) DeleteFileError!void {","class":"lineCov","hits":"2","order":"13740","possible_hits":"2",},
{"lineNum":" 1117","line":"        os.unlinkat(self.fd, sub_path, 0) catch |err| switch (err) {","class":"lineCov","hits":"2","order":"13741","possible_hits":"2",},
{"lineNum":" 1118","line":"            error.DirNotEmpty => unreachable, // not passing AT_REMOVEDIR","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1119","line":"            else => |e| return e,","class":"lineCov","hits":"1","order":"14453","possible_hits":"1",},
{"lineNum":" 1120","line":"        };"},
{"lineNum":" 1121","line":"    }"},
{"lineNum":" 1122","line":""},
{"lineNum":" 1123","line":"    pub const deleteFileC = @compileError(\"deprecated: renamed to deleteFileZ\");"},
{"lineNum":" 1124","line":""},
{"lineNum":" 1125","line":"    /// Same as `deleteFile` except the parameter is null-terminated."},
{"lineNum":" 1126","line":"    pub fn deleteFileZ(self: Dir, sub_path_c: [*:0]const u8) DeleteFileError!void {"},
{"lineNum":" 1127","line":"        os.unlinkatZ(self.fd, sub_path_c, 0) catch |err| switch (err) {"},
{"lineNum":" 1128","line":"            error.DirNotEmpty => unreachable, // not passing AT_REMOVEDIR"},
{"lineNum":" 1129","line":"            else => |e| return e,"},
{"lineNum":" 1130","line":"        };"},
{"lineNum":" 1131","line":"    }"},
{"lineNum":" 1132","line":""},
{"lineNum":" 1133","line":"    /// Same as `deleteFile` except the parameter is WTF-16 encoded."},
{"lineNum":" 1134","line":"    pub fn deleteFileW(self: Dir, sub_path_w: [*:0]const u16) DeleteFileError!void {"},
{"lineNum":" 1135","line":"        os.unlinkatW(self.fd, sub_path_w, 0) catch |err| switch (err) {"},
{"lineNum":" 1136","line":"            error.DirNotEmpty => unreachable, // not passing AT_REMOVEDIR"},
{"lineNum":" 1137","line":"            else => |e| return e,"},
{"lineNum":" 1138","line":"        };"},
{"lineNum":" 1139","line":"    }"},
{"lineNum":" 1140","line":""},
{"lineNum":" 1141","line":"    pub const DeleteDirError = error{"},
{"lineNum":" 1142","line":"        DirNotEmpty,"},
{"lineNum":" 1143","line":"        FileNotFound,"},
{"lineNum":" 1144","line":"        AccessDenied,"},
{"lineNum":" 1145","line":"        FileBusy,"},
{"lineNum":" 1146","line":"        FileSystem,"},
{"lineNum":" 1147","line":"        SymLinkLoop,"},
{"lineNum":" 1148","line":"        NameTooLong,"},
{"lineNum":" 1149","line":"        NotDir,"},
{"lineNum":" 1150","line":"        SystemResources,"},
{"lineNum":" 1151","line":"        ReadOnlyFileSystem,"},
{"lineNum":" 1152","line":"        InvalidUtf8,"},
{"lineNum":" 1153","line":"        BadPathName,"},
{"lineNum":" 1154","line":"        Unexpected,"},
{"lineNum":" 1155","line":"    };"},
{"lineNum":" 1156","line":""},
{"lineNum":" 1157","line":"    /// Returns `error.DirNotEmpty` if the directory is not empty."},
{"lineNum":" 1158","line":"    /// To delete a directory recursively, see `deleteTree`."},
{"lineNum":" 1159","line":"    /// Asserts that the path parameter has no null bytes."},
{"lineNum":" 1160","line":"    pub fn deleteDir(self: Dir, sub_path: []const u8) DeleteDirError!void {","class":"lineCov","hits":"1","order":"14494","possible_hits":"1",},
{"lineNum":" 1161","line":"        if (builtin.os.tag == .windows) {"},
{"lineNum":" 1162","line":"            const sub_path_w = try os.windows.sliceToPrefixedFileW(sub_path);"},
{"lineNum":" 1163","line":"            return self.deleteDirW(sub_path_w.span().ptr);"},
{"lineNum":" 1164","line":"        } else if (builtin.os.tag == .wasi) {"},
{"lineNum":" 1165","line":"            os.unlinkat(self.fd, sub_path, os.AT_REMOVEDIR) catch |err| switch (err) {"},
{"lineNum":" 1166","line":"                error.IsDir => unreachable, // not possible since we pass AT_REMOVEDIR"},
{"lineNum":" 1167","line":"                else => |e| return e,"},
{"lineNum":" 1168","line":"            };"},
{"lineNum":" 1169","line":"        } else {"},
{"lineNum":" 1170","line":"            const sub_path_c = try os.toPosixPath(sub_path);","class":"lineCov","hits":"1","order":"14495","possible_hits":"1",},
{"lineNum":" 1171","line":"            return self.deleteDirZ(&sub_path_c);","class":"lineCov","hits":"1","order":"14496","possible_hits":"1",},
{"lineNum":" 1172","line":"        }"},
{"lineNum":" 1173","line":"    }"},
{"lineNum":" 1174","line":""},
{"lineNum":" 1175","line":"    /// Same as `deleteDir` except the parameter is null-terminated."},
{"lineNum":" 1176","line":"    pub fn deleteDirZ(self: Dir, sub_path_c: [*:0]const u8) DeleteDirError!void {","class":"lineCov","hits":"2","order":"14497","possible_hits":"2",},
{"lineNum":" 1177","line":"        os.unlinkatZ(self.fd, sub_path_c, os.AT_REMOVEDIR) catch |err| switch (err) {","class":"lineCov","hits":"2","order":"14498","possible_hits":"2",},
{"lineNum":" 1178","line":"            error.IsDir => unreachable, // not possible since we pass AT_REMOVEDIR","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1179","line":"            else => |e| return e,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1180","line":"        };"},
{"lineNum":" 1181","line":"    }"},
{"lineNum":" 1182","line":""},
{"lineNum":" 1183","line":"    /// Same as `deleteDir` except the parameter is UTF16LE, NT prefixed."},
{"lineNum":" 1184","line":"    /// This function is Windows-only."},
{"lineNum":" 1185","line":"    pub fn deleteDirW(self: Dir, sub_path_w: [*:0]const u16) DeleteDirError!void {"},
{"lineNum":" 1186","line":"        os.unlinkatW(self.fd, sub_path_w, os.AT_REMOVEDIR) catch |err| switch (err) {"},
{"lineNum":" 1187","line":"            error.IsDir => unreachable, // not possible since we pass AT_REMOVEDIR"},
{"lineNum":" 1188","line":"            else => |e| return e,"},
{"lineNum":" 1189","line":"        };"},
{"lineNum":" 1190","line":"    }"},
{"lineNum":" 1191","line":""},
{"lineNum":" 1192","line":"    /// Read value of a symbolic link."},
{"lineNum":" 1193","line":"    /// The return value is a slice of `buffer`, from index `0`."},
{"lineNum":" 1194","line":"    /// Asserts that the path parameter has no null bytes."},
{"lineNum":" 1195","line":"    pub fn readLink(self: Dir, sub_path: []const u8, buffer: *[MAX_PATH_BYTES]u8) ![]u8 {"},
{"lineNum":" 1196","line":"        const sub_path_c = try os.toPosixPath(sub_path);"},
{"lineNum":" 1197","line":"        return self.readLinkZ(&sub_path_c, buffer);"},
{"lineNum":" 1198","line":"    }"},
{"lineNum":" 1199","line":""},
{"lineNum":" 1200","line":"    pub const readLinkC = @compileError(\"deprecated: renamed to readLinkZ\");"},
{"lineNum":" 1201","line":""},
{"lineNum":" 1202","line":"    /// Same as `readLink`, except the `pathname` parameter is null-terminated."},
{"lineNum":" 1203","line":"    pub fn readLinkZ(self: Dir, sub_path_c: [*:0]const u8, buffer: *[MAX_PATH_BYTES]u8) ![]u8 {"},
{"lineNum":" 1204","line":"        return os.readlinkatZ(self.fd, sub_path_c, buffer);"},
{"lineNum":" 1205","line":"    }"},
{"lineNum":" 1206","line":""},
{"lineNum":" 1207","line":"    /// On success, caller owns returned buffer."},
{"lineNum":" 1208","line":"    /// If the file is larger than `max_bytes`, returns `error.FileTooBig`."},
{"lineNum":" 1209","line":"    pub fn readFileAlloc(self: Dir, allocator: *mem.Allocator, file_path: []const u8, max_bytes: usize) ![]u8 {","class":"lineCov","hits":"1","order":"14904","possible_hits":"1",},
{"lineNum":" 1210","line":"        return self.readFileAllocOptions(allocator, file_path, max_bytes, @alignOf(u8), null);","class":"lineCov","hits":"1","order":"14905","possible_hits":"1",},
{"lineNum":" 1211","line":"    }"},
{"lineNum":" 1212","line":""},
{"lineNum":" 1213","line":"    /// On success, caller owns returned buffer."},
{"lineNum":" 1214","line":"    /// If the file is larger than `max_bytes`, returns `error.FileTooBig`."},
{"lineNum":" 1215","line":"    /// Allows specifying alignment and a sentinel value."},
{"lineNum":" 1216","line":"    pub fn readFileAllocOptions(","class":"lineCov","hits":"1","order":"14906","possible_hits":"1",},
{"lineNum":" 1217","line":"        self: Dir,"},
{"lineNum":" 1218","line":"        allocator: *mem.Allocator,"},
{"lineNum":" 1219","line":"        file_path: []const u8,"},
{"lineNum":" 1220","line":"        max_bytes: usize,"},
{"lineNum":" 1221","line":"        comptime alignment: u29,"},
{"lineNum":" 1222","line":"        comptime optional_sentinel: ?u8,"},
{"lineNum":" 1223","line":"    ) !(if (optional_sentinel) |s| [:s]align(alignment) u8 else []align(alignment) u8) {"},
{"lineNum":" 1224","line":"        var file = try self.openFile(file_path, .{});","class":"lineCov","hits":"1","order":"14907","possible_hits":"1",},
{"lineNum":" 1225","line":"        defer file.close();","class":"linePartCov","hits":"1","order":"14914","possible_hits":"5",},
{"lineNum":" 1226","line":""},
{"lineNum":" 1227","line":"        const size = math.cast(usize, try file.getEndPos()) catch math.maxInt(usize);","class":"linePartCov","hits":"1","order":"14908","possible_hits":"2",},
{"lineNum":" 1228","line":"        if (size > max_bytes) return error.FileTooBig;","class":"linePartCov","hits":"1","order":"14909","possible_hits":"2",},
{"lineNum":" 1229","line":""},
{"lineNum":" 1230","line":"        const buf = try allocator.allocWithOptions(u8, size, alignment, optional_sentinel);","class":"linePartCov","hits":"1","order":"14910","possible_hits":"2",},
{"lineNum":" 1231","line":"        errdefer allocator.free(buf);","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1232","line":""},
{"lineNum":" 1233","line":"        try file.inStream().readNoEof(buf);","class":"linePartCov","hits":"1","order":"14912","possible_hits":"2",},
{"lineNum":" 1234","line":"        return buf;","class":"lineCov","hits":"2","order":"14913","possible_hits":"2",},
{"lineNum":" 1235","line":"    }"},
{"lineNum":" 1236","line":""},
{"lineNum":" 1237","line":"    pub const DeleteTreeError = error{"},
{"lineNum":" 1238","line":"        AccessDenied,"},
{"lineNum":" 1239","line":"        FileTooBig,"},
{"lineNum":" 1240","line":"        SymLinkLoop,"},
{"lineNum":" 1241","line":"        ProcessFdQuotaExceeded,"},
{"lineNum":" 1242","line":"        NameTooLong,"},
{"lineNum":" 1243","line":"        SystemFdQuotaExceeded,"},
{"lineNum":" 1244","line":"        NoDevice,"},
{"lineNum":" 1245","line":"        SystemResources,"},
{"lineNum":" 1246","line":"        ReadOnlyFileSystem,"},
{"lineNum":" 1247","line":"        FileSystem,"},
{"lineNum":" 1248","line":"        FileBusy,"},
{"lineNum":" 1249","line":"        DeviceBusy,"},
{"lineNum":" 1250","line":""},
{"lineNum":" 1251","line":"        /// One of the path components was not a directory."},
{"lineNum":" 1252","line":"        /// This error is unreachable if `sub_path` does not contain a path separator."},
{"lineNum":" 1253","line":"        NotDir,"},
{"lineNum":" 1254","line":""},
{"lineNum":" 1255","line":"        /// On Windows, file paths must be valid Unicode."},
{"lineNum":" 1256","line":"        InvalidUtf8,"},
{"lineNum":" 1257","line":""},
{"lineNum":" 1258","line":"        /// On Windows, file paths cannot contain these characters:"},
{"lineNum":" 1259","line":"        /// \'/\', \'*\', \'?\', \'\"\', \'<\', \'>\', \'|\'"},
{"lineNum":" 1260","line":"        BadPathName,"},
{"lineNum":" 1261","line":"    } || os.UnexpectedError;"},
{"lineNum":" 1262","line":""},
{"lineNum":" 1263","line":"    /// Whether `full_path` describes a symlink, file, or directory, this function"},
{"lineNum":" 1264","line":"    /// removes it. If it cannot be removed because it is a non-empty directory,"},
{"lineNum":" 1265","line":"    /// this function recursively removes its entries and then tries again."},
{"lineNum":" 1266","line":"    /// This operation is not atomic on most file systems."},
{"lineNum":" 1267","line":"    pub fn deleteTree(self: Dir, sub_path: []const u8) DeleteTreeError!void {","class":"lineCov","hits":"1","order":"14448","possible_hits":"1",},
{"lineNum":" 1268","line":"        start_over: while (true) {","class":"lineCov","hits":"1","order":"14449","possible_hits":"1",},
{"lineNum":" 1269","line":"            var got_access_denied = false;","class":"lineCov","hits":"1","order":"14450","possible_hits":"1",},
{"lineNum":" 1270","line":"            // First, try deleting the item as a file. This way we don\'t follow sym links."},
{"lineNum":" 1271","line":"            if (self.deleteFile(sub_path)) {","class":"lineCov","hits":"3","order":"14451","possible_hits":"3",},
{"lineNum":" 1272","line":"                return;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1273","line":"            } else |err| switch (err) {","class":"linePartCov","hits":"1","order":"14454","possible_hits":"2",},
{"lineNum":" 1274","line":"                error.FileNotFound => return,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1275","line":"                error.IsDir => {},"},
{"lineNum":" 1276","line":"                error.AccessDenied => got_access_denied = true,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1277","line":""},
{"lineNum":" 1278","line":"                error.InvalidUtf8,"},
{"lineNum":" 1279","line":"                error.SymLinkLoop,"},
{"lineNum":" 1280","line":"                error.NameTooLong,"},
{"lineNum":" 1281","line":"                error.SystemResources,"},
{"lineNum":" 1282","line":"                error.ReadOnlyFileSystem,"},
{"lineNum":" 1283","line":"                error.NotDir,"},
{"lineNum":" 1284","line":"                error.FileSystem,"},
{"lineNum":" 1285","line":"                error.FileBusy,"},
{"lineNum":" 1286","line":"                error.BadPathName,"},
{"lineNum":" 1287","line":"                error.Unexpected,"},
{"lineNum":" 1288","line":"                => |e| return e,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1289","line":"            }"},
{"lineNum":" 1290","line":"            var dir = self.openDir(sub_path, .{ .iterate = true }) catch |err| switch (err) {","class":"linePartCov","hits":"1","order":"14455","possible_hits":"2",},
{"lineNum":" 1291","line":"                error.NotDir => {"},
{"lineNum":" 1292","line":"                    if (got_access_denied) {","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1293","line":"                        return error.AccessDenied;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1294","line":"                    }"},
{"lineNum":" 1295","line":"                    continue :start_over;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1296","line":"                },"},
{"lineNum":" 1297","line":"                error.FileNotFound => {"},
{"lineNum":" 1298","line":"                    // That\'s fine, we were trying to remove this directory anyway."},
{"lineNum":" 1299","line":"                    continue :start_over;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1300","line":"                },"},
{"lineNum":" 1301","line":""},
{"lineNum":" 1302","line":"                error.AccessDenied,"},
{"lineNum":" 1303","line":"                error.SymLinkLoop,"},
{"lineNum":" 1304","line":"                error.ProcessFdQuotaExceeded,"},
{"lineNum":" 1305","line":"                error.NameTooLong,"},
{"lineNum":" 1306","line":"                error.SystemFdQuotaExceeded,"},
{"lineNum":" 1307","line":"                error.NoDevice,"},
{"lineNum":" 1308","line":"                error.SystemResources,"},
{"lineNum":" 1309","line":"                error.Unexpected,"},
{"lineNum":" 1310","line":"                error.InvalidUtf8,"},
{"lineNum":" 1311","line":"                error.BadPathName,"},
{"lineNum":" 1312","line":"                error.DeviceBusy,"},
{"lineNum":" 1313","line":"                => |e| return e,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1314","line":"            };"},
{"lineNum":" 1315","line":"            var cleanup_dir_parent: ?Dir = null;","class":"lineCov","hits":"1","order":"14457","possible_hits":"1",},
{"lineNum":" 1316","line":"            defer if (cleanup_dir_parent) |*d| d.close();","class":"linePartCov","hits":"2","order":"14501","possible_hits":"11",},
{"lineNum":" 1317","line":""},
{"lineNum":" 1318","line":"            var cleanup_dir = true;","class":"lineCov","hits":"1","order":"14458","possible_hits":"1",},
{"lineNum":" 1319","line":"            defer if (cleanup_dir) dir.close();","class":"linePartCov","hits":"2","order":"14500","possible_hits":"11",},
{"lineNum":" 1320","line":""},
{"lineNum":" 1321","line":"            var dir_name_buf: [MAX_PATH_BYTES]u8 = undefined;","class":"lineCov","hits":"2","order":"14459","possible_hits":"2",},
{"lineNum":" 1322","line":"            var dir_name: []const u8 = sub_path;","class":"lineCov","hits":"1","order":"14460","possible_hits":"1",},
{"lineNum":" 1323","line":""},
{"lineNum":" 1324","line":"            // Here we must avoid recursion, in order to provide O(1) memory guarantee of this function."},
{"lineNum":" 1325","line":"            // Go through each entry and if it is not a directory, delete it. If it is a directory,"},
{"lineNum":" 1326","line":"            // open it, and close the original directory. Repeat. Then start the entire operation over."},
{"lineNum":" 1327","line":""},
{"lineNum":" 1328","line":"            scan_dir: while (true) {"},
{"lineNum":" 1329","line":"                var dir_it = dir.iterate();","class":"lineCov","hits":"1","order":"14461","possible_hits":"1",},
{"lineNum":" 1330","line":"                while (try dir_it.next()) |entry| {","class":"linePartCov","hits":"1","order":"14468","possible_hits":"2",},
{"lineNum":" 1331","line":"                    if (dir.deleteFile(entry.name)) {","class":"lineCov","hits":"3","order":"14662","possible_hits":"3",},
{"lineNum":" 1332","line":"                        continue;","class":"lineCov","hits":"1","order":"14672","possible_hits":"1",},
{"lineNum":" 1333","line":"                    } else |err| switch (err) {","class":"linePartCov","hits":"1","order":"14663","possible_hits":"2",},
{"lineNum":" 1334","line":"                        error.FileNotFound => continue,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1335","line":""},
{"lineNum":" 1336","line":"                        // Impossible because we do not pass any path separators."},
{"lineNum":" 1337","line":"                        error.NotDir => unreachable,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1338","line":""},
{"lineNum":" 1339","line":"                        error.IsDir => {},"},
{"lineNum":" 1340","line":"                        error.AccessDenied => got_access_denied = true,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1341","line":""},
{"lineNum":" 1342","line":"                        error.InvalidUtf8,"},
{"lineNum":" 1343","line":"                        error.SymLinkLoop,"},
{"lineNum":" 1344","line":"                        error.NameTooLong,"},
{"lineNum":" 1345","line":"                        error.SystemResources,"},
{"lineNum":" 1346","line":"                        error.ReadOnlyFileSystem,"},
{"lineNum":" 1347","line":"                        error.FileSystem,"},
{"lineNum":" 1348","line":"                        error.FileBusy,"},
{"lineNum":" 1349","line":"                        error.BadPathName,"},
{"lineNum":" 1350","line":"                        error.Unexpected,"},
{"lineNum":" 1351","line":"                        => |e| return e,","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1352","line":"                    }"},
{"lineNum":" 1353","line":""},
{"lineNum":" 1354","line":"                    const new_dir = dir.openDir(entry.name, .{ .iterate = true }) catch |err| switch (err) {","class":"linePartCov","hits":"1","order":"14664","possible_hits":"2",},
{"lineNum":" 1355","line":"                        error.NotDir => {"},
{"lineNum":" 1356","line":"                            if (got_access_denied) {","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1357","line":"                                return error.AccessDenied;","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1358","line":"                            }"},
{"lineNum":" 1359","line":"                            continue :scan_dir;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1360","line":"                        },"},
{"lineNum":" 1361","line":"                        error.FileNotFound => {"},
{"lineNum":" 1362","line":"                            // That\'s fine, we were trying to remove this directory anyway."},
{"lineNum":" 1363","line":"                            continue :scan_dir;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1364","line":"                        },"},
{"lineNum":" 1365","line":""},
{"lineNum":" 1366","line":"                        error.AccessDenied,"},
{"lineNum":" 1367","line":"                        error.SymLinkLoop,"},
{"lineNum":" 1368","line":"                        error.ProcessFdQuotaExceeded,"},
{"lineNum":" 1369","line":"                        error.NameTooLong,"},
{"lineNum":" 1370","line":"                        error.SystemFdQuotaExceeded,"},
{"lineNum":" 1371","line":"                        error.NoDevice,"},
{"lineNum":" 1372","line":"                        error.SystemResources,"},
{"lineNum":" 1373","line":"                        error.Unexpected,"},
{"lineNum":" 1374","line":"                        error.InvalidUtf8,"},
{"lineNum":" 1375","line":"                        error.BadPathName,"},
{"lineNum":" 1376","line":"                        error.DeviceBusy,"},
{"lineNum":" 1377","line":"                        => |e| return e,","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1378","line":"                    };"},
{"lineNum":" 1379","line":"                    if (cleanup_dir_parent) |*d| d.close();","class":"lineCov","hits":"1","order":"14665","possible_hits":"1",},
{"lineNum":" 1380","line":"                    cleanup_dir_parent = dir;","class":"lineCov","hits":"1","order":"14666","possible_hits":"1",},
{"lineNum":" 1381","line":"                    dir = new_dir;","class":"lineCov","hits":"1","order":"14667","possible_hits":"1",},
{"lineNum":" 1382","line":"                    mem.copy(u8, &dir_name_buf, entry.name);","class":"lineCov","hits":"2","order":"14668","possible_hits":"2",},
{"lineNum":" 1383","line":"                    dir_name = dir_name_buf[0..entry.name.len];","class":"linePartCov","hits":"1","order":"14669","possible_hits":"2",},
{"lineNum":" 1384","line":"                    continue :scan_dir;","class":"lineCov","hits":"1","order":"14670","possible_hits":"1",},
{"lineNum":" 1385","line":"                }"},
{"lineNum":" 1386","line":"                // Reached the end of the directory entries, which means we successfully deleted all of them."},
{"lineNum":" 1387","line":"                // Now to remove the directory itself."},
{"lineNum":" 1388","line":"                dir.close();","class":"lineCov","hits":"1","order":"14490","possible_hits":"1",},
{"lineNum":" 1389","line":"                cleanup_dir = false;","class":"lineCov","hits":"1","order":"14491","possible_hits":"1",},
{"lineNum":" 1390","line":""},
{"lineNum":" 1391","line":"                if (cleanup_dir_parent) |d| {","class":"lineCov","hits":"1","order":"14492","possible_hits":"1",},
{"lineNum":" 1392","line":"                    d.deleteDir(dir_name) catch |err| switch (err) {","class":"lineCov","hits":"2","order":"14673","possible_hits":"2",},
{"lineNum":" 1393","line":"                        // These two things can happen due to file system race conditions."},
{"lineNum":" 1394","line":"                        error.FileNotFound, error.DirNotEmpty => continue :start_over,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1395","line":"                        else => |e| return e,","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1396","line":"                    };"},
{"lineNum":" 1397","line":"                    continue :start_over;","class":"lineCov","hits":"1","order":"14674","possible_hits":"1",},
{"lineNum":" 1398","line":"                } else {"},
{"lineNum":" 1399","line":"                    self.deleteDir(sub_path) catch |err| switch (err) {","class":"lineCov","hits":"2","order":"14493","possible_hits":"2",},
{"lineNum":" 1400","line":"                        error.FileNotFound => return,","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1401","line":"                        error.DirNotEmpty => continue :start_over,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1402","line":"                        else => |e| return e,","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1403","line":"                    };"},
{"lineNum":" 1404","line":"                    return;","class":"lineCov","hits":"2","order":"14499","possible_hits":"2",},
{"lineNum":" 1405","line":"                }"},
{"lineNum":" 1406","line":"            }"},
{"lineNum":" 1407","line":"        }"},
{"lineNum":" 1408","line":"    }"},
{"lineNum":" 1409","line":""},
{"lineNum":" 1410","line":"    /// Writes content to the file system, creating a new file if it does not exist, truncating"},
{"lineNum":" 1411","line":"    /// if it already exists."},
{"lineNum":" 1412","line":"    pub fn writeFile(self: Dir, sub_path: []const u8, data: []const u8) !void {","class":"lineCov","hits":"3","order":"14651","possible_hits":"3",},
{"lineNum":" 1413","line":"        var file = try self.createFile(sub_path, .{});","class":"lineCov","hits":"1","order":"14652","possible_hits":"1",},
{"lineNum":" 1414","line":"        defer file.close();","class":"linePartCov","hits":"1","order":"14654","possible_hits":"2",},
{"lineNum":" 1415","line":"        try file.writeAll(data);","class":"linePartCov","hits":"1","order":"14653","possible_hits":"2",},
{"lineNum":" 1416","line":"    }"},
{"lineNum":" 1417","line":""},
{"lineNum":" 1418","line":"    pub const AccessError = os.AccessError;"},
{"lineNum":" 1419","line":""},
{"lineNum":" 1420","line":"    /// Test accessing `path`."},
{"lineNum":" 1421","line":"    /// `path` is UTF8-encoded."},
{"lineNum":" 1422","line":"    /// Be careful of Time-Of-Check-Time-Of-Use race conditions when using this function."},
{"lineNum":" 1423","line":"    /// For example, instead of testing if a file exists and then opening it, just"},
{"lineNum":" 1424","line":"    /// open it and handle the error for file not found."},
{"lineNum":" 1425","line":"    pub fn access(self: Dir, sub_path: []const u8, flags: File.OpenFlags) AccessError!void {","class":"lineCov","hits":"1","order":"14684","possible_hits":"1",},
{"lineNum":" 1426","line":"        if (builtin.os.tag == .windows) {"},
{"lineNum":" 1427","line":"            const sub_path_w = try os.windows.sliceToPrefixedFileW(sub_path);"},
{"lineNum":" 1428","line":"            return self.accessW(sub_path_w.span().ptr, flags);"},
{"lineNum":" 1429","line":"        }"},
{"lineNum":" 1430","line":"        const path_c = try os.toPosixPath(sub_path);","class":"lineCov","hits":"1","order":"14685","possible_hits":"1",},
{"lineNum":" 1431","line":"        return self.accessZ(&path_c, flags);","class":"lineCov","hits":"1","order":"14686","possible_hits":"1",},
{"lineNum":" 1432","line":"    }"},
{"lineNum":" 1433","line":""},
{"lineNum":" 1434","line":"    /// Same as `access` except the path parameter is null-terminated."},
{"lineNum":" 1435","line":"    pub fn accessZ(self: Dir, sub_path: [*:0]const u8, flags: File.OpenFlags) AccessError!void {","class":"lineCov","hits":"1","order":"14687","possible_hits":"1",},
{"lineNum":" 1436","line":"        if (builtin.os.tag == .windows) {"},
{"lineNum":" 1437","line":"            const sub_path_w = try os.windows.cStrToPrefixedFileW(sub_path);"},
{"lineNum":" 1438","line":"            return self.accessW(sub_path_w.span().ptr, flags);"},
{"lineNum":" 1439","line":"        }"},
{"lineNum":" 1440","line":"        const os_mode = if (flags.write and flags.read)","class":"linePartCov","hits":"1","order":"14688","possible_hits":"2",},
{"lineNum":" 1441","line":"            @as(u32, os.R_OK | os.W_OK)","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1442","line":"        else if (flags.write)","class":"linePartCov","hits":"2","order":"14689","possible_hits":"3",},
{"lineNum":" 1443","line":"            @as(u32, os.W_OK)","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1444","line":"        else"},
{"lineNum":" 1445","line":"            @as(u32, os.F_OK);","class":"lineCov","hits":"1","order":"14690","possible_hits":"1",},
{"lineNum":" 1446","line":"        const result = if (need_async_thread and flags.intended_io_mode != .blocking)"},
{"lineNum":" 1447","line":"            std.event.Loop.instance.?.faccessatZ(self.fd, sub_path, os_mode, 0)"},
{"lineNum":" 1448","line":"        else"},
{"lineNum":" 1449","line":"            os.faccessatZ(self.fd, sub_path, os_mode, 0);","class":"lineCov","hits":"1","order":"14691","possible_hits":"1",},
{"lineNum":" 1450","line":"        return result;","class":"lineCov","hits":"1","order":"14697","possible_hits":"1",},
{"lineNum":" 1451","line":"    }"},
{"lineNum":" 1452","line":""},
{"lineNum":" 1453","line":"    /// Same as `access` except asserts the target OS is Windows and the path parameter is"},
{"lineNum":" 1454","line":"    /// * WTF-16 encoded"},
{"lineNum":" 1455","line":"    /// * null-terminated"},
{"lineNum":" 1456","line":"    /// * NtDll prefixed"},
{"lineNum":" 1457","line":"    /// TODO currently this ignores `flags`."},
{"lineNum":" 1458","line":"    pub fn accessW(self: Dir, sub_path_w: [*:0]const u16, flags: File.OpenFlags) AccessError!void {"},
{"lineNum":" 1459","line":"        return os.faccessatW(self.fd, sub_path_w, 0, 0);"},
{"lineNum":" 1460","line":"    }"},
{"lineNum":" 1461","line":""},
{"lineNum":" 1462","line":"    /// Check the file size, mtime, and mode of `source_path` and `dest_path`. If they are equal, does nothing."},
{"lineNum":" 1463","line":"    /// Otherwise, atomically copies `source_path` to `dest_path`. The destination file gains the mtime,"},
{"lineNum":" 1464","line":"    /// atime, and mode of the source file so that the next call to `updateFile` will not need a copy."},
{"lineNum":" 1465","line":"    /// Returns the previous status of the file before updating."},
{"lineNum":" 1466","line":"    /// If any of the directories do not exist for dest_path, they are created."},
{"lineNum":" 1467","line":"    pub fn updateFile(","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1468","line":"        source_dir: Dir,"},
{"lineNum":" 1469","line":"        source_path: []const u8,"},
{"lineNum":" 1470","line":"        dest_dir: Dir,"},
{"lineNum":" 1471","line":"        dest_path: []const u8,"},
{"lineNum":" 1472","line":"        options: CopyFileOptions,"},
{"lineNum":" 1473","line":"    ) !PrevStatus {"},
{"lineNum":" 1474","line":"        var src_file = try source_dir.openFile(source_path, .{});","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1475","line":"        defer src_file.close();","class":"lineNoCov","hits":"0","possible_hits":"10",},
{"lineNum":" 1476","line":""},
{"lineNum":" 1477","line":"        const src_stat = try src_file.stat();","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1478","line":"        const actual_mode = options.override_mode orelse src_stat.mode;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1479","line":"        check_dest_stat: {","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1480","line":"            const dest_stat = blk: {"},
{"lineNum":" 1481","line":"                var dest_file = dest_dir.openFile(dest_path, .{}) catch |err| switch (err) {","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1482","line":"                    error.FileNotFound => break :check_dest_stat,","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1483","line":"                    else => |e| return e,","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1484","line":"                };"},
{"lineNum":" 1485","line":"                defer dest_file.close();","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1486","line":""},
{"lineNum":" 1487","line":"                break :blk try dest_file.stat();","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1488","line":"            };"},
{"lineNum":" 1489","line":""},
{"lineNum":" 1490","line":"            if (src_stat.size == dest_stat.size and","class":"lineNoCov","hits":"0","possible_hits":"3",},
{"lineNum":" 1491","line":"                src_stat.mtime == dest_stat.mtime and","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1492","line":"                actual_mode == dest_stat.mode)","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1493","line":"            {"},
{"lineNum":" 1494","line":"                return PrevStatus.fresh;","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1495","line":"            }"},
{"lineNum":" 1496","line":"        }"},
{"lineNum":" 1497","line":""},
{"lineNum":" 1498","line":"        if (path.dirname(dest_path)) |dirname| {","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1499","line":"            try dest_dir.makePath(dirname);","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1500","line":"        }"},
{"lineNum":" 1501","line":""},
{"lineNum":" 1502","line":"        var atomic_file = try dest_dir.atomicFile(dest_path, .{ .mode = actual_mode });","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1503","line":"        defer atomic_file.deinit();","class":"lineNoCov","hits":"0","possible_hits":"4",},
{"lineNum":" 1504","line":""},
{"lineNum":" 1505","line":"        try atomic_file.file.writeFileAll(src_file, .{ .in_len = src_stat.size });","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1506","line":"        try atomic_file.file.updateTimes(src_stat.atime, src_stat.mtime);","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1507","line":"        try atomic_file.finish();","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1508","line":"        return PrevStatus.stale;","class":"lineNoCov","hits":"0","possible_hits":"2",},
{"lineNum":" 1509","line":"    }"},
{"lineNum":" 1510","line":""},
{"lineNum":" 1511","line":"    /// Guaranteed to be atomic."},
{"lineNum":" 1512","line":"    /// On Linux, until https://patchwork.kernel.org/patch/9636735/ is merged and readily available,"},
{"lineNum":" 1513","line":"    /// there is a possibility of power loss or application termination leaving temporary files present"},
{"lineNum":" 1514","line":"    /// in the same directory as dest_path."},
{"lineNum":" 1515","line":"    pub fn copyFile(","class":"lineCov","hits":"1","order":"14829","possible_hits":"1",},
{"lineNum":" 1516","line":"        source_dir: Dir,"},
{"lineNum":" 1517","line":"        source_path: []const u8,"},
{"lineNum":" 1518","line":"        dest_dir: Dir,"},
{"lineNum":" 1519","line":"        dest_path: []const u8,"},
{"lineNum":" 1520","line":"        options: CopyFileOptions,"},
{"lineNum":" 1521","line":"    ) !void {"},
{"lineNum":" 1522","line":"        var in_file = try source_dir.openFile(source_path, .{});","class":"lineCov","hits":"1","order":"14830","possible_hits":"1",},
{"lineNum":" 1523","line":"        defer in_file.close();","class":"linePartCov","hits":"1","order":"14892","possible_hits":"5",},
{"lineNum":" 1524","line":""},
{"lineNum":" 1525","line":"        var size: ?u64 = null;","class":"lineCov","hits":"1","order":"14831","possible_hits":"1",},
{"lineNum":" 1526","line":"        const mode = options.override_mode orelse blk: {","class":"lineCov","hits":"2","order":"14832","possible_hits":"2",},
{"lineNum":" 1527","line":"            const stat = try in_file.stat();","class":"linePartCov","hits":"1","order":"14833","possible_hits":"2",},
{"lineNum":" 1528","line":"            size = stat.size;","class":"lineCov","hits":"1","order":"14834","possible_hits":"1",},
{"lineNum":" 1529","line":"            break :blk stat.mode;","class":"lineCov","hits":"1","order":"14835","possible_hits":"1",},
{"lineNum":" 1530","line":"        };"},
{"lineNum":" 1531","line":""},
{"lineNum":" 1532","line":"        var atomic_file = try dest_dir.atomicFile(dest_path, .{ .mode = mode });","class":"linePartCov","hits":"1","order":"14836","possible_hits":"2",},
{"lineNum":" 1533","line":"        defer atomic_file.deinit();","class":"linePartCov","hits":"1","order":"14886","possible_hits":"3",},
{"lineNum":" 1534","line":""},
{"lineNum":" 1535","line":"        try atomic_file.file.writeFileAll(in_file, .{ .in_len = size });","class":"linePartCov","hits":"1","order":"14861","possible_hits":"2",},
{"lineNum":" 1536","line":"        return atomic_file.finish();","class":"linePartCov","hits":"2","order":"14865","possible_hits":"3",},
{"lineNum":" 1537","line":"    }"},
{"lineNum":" 1538","line":""},
{"lineNum":" 1539","line":"    pub const AtomicFileOptions = struct {"},
{"lineNum":" 1540","line":"        mode: File.Mode = File.default_mode,"},
{"lineNum":" 1541","line":"    };"},
{"lineNum":" 1542","line":""},
{"lineNum":" 1543","line":"    /// Directly access the `.file` field, and then call `AtomicFile.finish`"},
{"lineNum":" 1544","line":"    /// to atomically replace `dest_path` with contents."},
{"lineNum":" 1545","line":"    /// Always call `AtomicFile.deinit` to clean up, regardless of whether `AtomicFile.finish` succeeded."},
{"lineNum":" 1546","line":"    /// `dest_path` must remain valid until `AtomicFile.deinit` is called."},
{"lineNum":" 1547","line":"    pub fn atomicFile(self: Dir, dest_path: []const u8, options: AtomicFileOptions) !AtomicFile {","class":"lineCov","hits":"1","order":"14837","possible_hits":"1",},
{"lineNum":" 1548","line":"        if (path.dirname(dest_path)) |dirname| {","class":"lineCov","hits":"1","order":"14838","possible_hits":"1",},
{"lineNum":" 1549","line":"            const dir = try self.openDir(dirname, .{});","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1550","line":"            return AtomicFile.init(path.basename(dest_path), options.mode, dir, true);","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1551","line":"        } else {"},
{"lineNum":" 1552","line":"            return AtomicFile.init(dest_path, options.mode, self, false);","class":"lineCov","hits":"1","order":"14841","possible_hits":"1",},
{"lineNum":" 1553","line":"        }"},
{"lineNum":" 1554","line":"    }"},
{"lineNum":" 1555","line":"};"},
{"lineNum":" 1556","line":""},
{"lineNum":" 1557","line":"/// Returns an handle to the current working directory. It is not opened with iteration capability."},
{"lineNum":" 1558","line":"/// Closing the returned `Dir` is checked illegal behavior. Iterating over the result is illegal behavior."},
{"lineNum":" 1559","line":"/// On POSIX targets, this function is comptime-callable."},
{"lineNum":" 1560","line":"pub fn cwd() Dir {","class":"lineCov","hits":"1","order":"13682","possible_hits":"1",},
{"lineNum":" 1561","line":"    if (builtin.os.tag == .windows) {"},
{"lineNum":" 1562","line":"        return Dir{ .fd = os.windows.peb().ProcessParameters.CurrentDirectory.Handle };"},
{"lineNum":" 1563","line":"    } else if (builtin.os.tag == .wasi) {"},
{"lineNum":" 1564","line":"        @compileError(\"WASI doesn\'t have a concept of cwd(); use std.fs.wasi.PreopenList to get available Dir handles instead\");"},
{"lineNum":" 1565","line":"    } else {"},
{"lineNum":" 1566","line":"        return Dir{ .fd = os.AT_FDCWD };","class":"lineCov","hits":"1","order":"13683","possible_hits":"1",},
{"lineNum":" 1567","line":"    }"},
{"lineNum":" 1568","line":"}"},
{"lineNum":" 1569","line":""},
{"lineNum":" 1570","line":"/// Opens a file for reading or writing, without attempting to create a new file, based on an absolute path."},
{"lineNum":" 1571","line":"/// Call `File.close` to release the resource."},
{"lineNum":" 1572","line":"/// Asserts that the path is absolute. See `Dir.openFile` for a function that"},
{"lineNum":" 1573","line":"/// operates on both absolute and relative paths."},
{"lineNum":" 1574","line":"/// Asserts that the path parameter has no null bytes. See `openFileAbsoluteC` for a function"},
{"lineNum":" 1575","line":"/// that accepts a null-terminated path."},
{"lineNum":" 1576","line":"pub fn openFileAbsolute(absolute_path: []const u8, flags: File.OpenFlags) File.OpenError!File {"},
{"lineNum":" 1577","line":"    assert(path.isAbsolute(absolute_path));"},
{"lineNum":" 1578","line":"    return cwd().openFile(absolute_path, flags);"},
{"lineNum":" 1579","line":"}"},
{"lineNum":" 1580","line":""},
{"lineNum":" 1581","line":"pub const openFileAbsoluteC = @compileError(\"deprecated: renamed to openFileAbsoluteZ\");"},
{"lineNum":" 1582","line":""},
{"lineNum":" 1583","line":"/// Same as `openFileAbsolute` but the path parameter is null-terminated."},
{"lineNum":" 1584","line":"pub fn openFileAbsoluteZ(absolute_path_c: [*:0]const u8, flags: File.OpenFlags) File.OpenError!File {","class":"lineCov","hits":"1","order":"13675","possible_hits":"1",},
{"lineNum":" 1585","line":"    assert(path.isAbsoluteZ(absolute_path_c));","class":"lineCov","hits":"1","order":"13676","possible_hits":"1",},
{"lineNum":" 1586","line":"    return cwd().openFileZ(absolute_path_c, flags);","class":"lineCov","hits":"1","order":"13681","possible_hits":"1",},
{"lineNum":" 1587","line":"}"},
{"lineNum":" 1588","line":""},
{"lineNum":" 1589","line":"/// Same as `openFileAbsolute` but the path parameter is WTF-16 encoded."},
{"lineNum":" 1590","line":"pub fn openFileAbsoluteW(absolute_path_w: []const u16, flags: File.OpenFlags) File.OpenError!File {"},
{"lineNum":" 1591","line":"    assert(path.isAbsoluteWindowsWTF16(absolute_path_w));"},
{"lineNum":" 1592","line":"    return cwd().openFileW(absolute_path_w, flags);"},
{"lineNum":" 1593","line":"}"},
{"lineNum":" 1594","line":""},
{"lineNum":" 1595","line":"/// Creates, opens, or overwrites a file with write access, based on an absolute path."},
{"lineNum":" 1596","line":"/// Call `File.close` to release the resource."},
{"lineNum":" 1597","line":"/// Asserts that the path is absolute. See `Dir.createFile` for a function that"},
{"lineNum":" 1598","line":"/// operates on both absolute and relative paths."},
{"lineNum":" 1599","line":"/// Asserts that the path parameter has no null bytes. See `createFileAbsoluteC` for a function"},
{"lineNum":" 1600","line":"/// that accepts a null-terminated path."},
{"lineNum":" 1601","line":"pub fn createFileAbsolute(absolute_path: []const u8, flags: File.CreateFlags) File.OpenError!File {","class":"lineCov","hits":"1","order":"13785","possible_hits":"1",},
{"lineNum":" 1602","line":"    assert(path.isAbsolute(absolute_path));","class":"lineCov","hits":"1","order":"13786","possible_hits":"1",},
{"lineNum":" 1603","line":"    return cwd().createFile(absolute_path, flags);","class":"lineCov","hits":"1","order":"13789","possible_hits":"1",},
{"lineNum":" 1604","line":"}"},
{"lineNum":" 1605","line":""},
{"lineNum":" 1606","line":"pub const createFileAbsoluteC = @compileError(\"deprecated: renamed to createFileAbsoluteZ\");"},
{"lineNum":" 1607","line":""},
{"lineNum":" 1608","line":"/// Same as `createFileAbsolute` but the path parameter is null-terminated."},
{"lineNum":" 1609","line":"pub fn createFileAbsoluteZ(absolute_path_c: [*:0]const u8, flags: File.CreateFlags) File.OpenError!File {"},
{"lineNum":" 1610","line":"    assert(path.isAbsoluteZ(absolute_path_c));"},
{"lineNum":" 1611","line":"    return cwd().createFileZ(absolute_path_c, flags);"},
{"lineNum":" 1612","line":"}"},
{"lineNum":" 1613","line":""},
{"lineNum":" 1614","line":"/// Same as `createFileAbsolute` but the path parameter is WTF-16 encoded."},
{"lineNum":" 1615","line":"pub fn createFileAbsoluteW(absolute_path_w: [*:0]const u16, flags: File.CreateFlags) File.OpenError!File {"},
{"lineNum":" 1616","line":"    assert(path.isAbsoluteWindowsW(absolute_path_w));"},
{"lineNum":" 1617","line":"    return cwd().createFileW(absolute_path_w, flags);"},
{"lineNum":" 1618","line":"}"},
{"lineNum":" 1619","line":""},
{"lineNum":" 1620","line":"/// Delete a file name and possibly the file it refers to, based on an absolute path."},
{"lineNum":" 1621","line":"/// Asserts that the path is absolute. See `Dir.deleteFile` for a function that"},
{"lineNum":" 1622","line":"/// operates on both absolute and relative paths."},
{"lineNum":" 1623","line":"/// Asserts that the path parameter has no null bytes."},
{"lineNum":" 1624","line":"pub fn deleteFileAbsolute(absolute_path: []const u8) Dir.DeleteFileError!void {","class":"lineCov","hits":"1","order":"13794","possible_hits":"1",},
{"lineNum":" 1625","line":"    assert(path.isAbsolute(absolute_path));","class":"lineCov","hits":"1","order":"13795","possible_hits":"1",},
{"lineNum":" 1626","line":"    return cwd().deleteFile(absolute_path);","class":"lineCov","hits":"1","order":"13796","possible_hits":"1",},
{"lineNum":" 1627","line":"}"},
{"lineNum":" 1628","line":""},
{"lineNum":" 1629","line":"pub const deleteFileAbsoluteC = @compileError(\"deprecated: renamed to deleteFileAbsoluteZ\");"},
{"lineNum":" 1630","line":""},
{"lineNum":" 1631","line":"/// Same as `deleteFileAbsolute` except the parameter is null-terminated."},
{"lineNum":" 1632","line":"pub fn deleteFileAbsoluteZ(absolute_path_c: [*:0]const u8) Dir.DeleteFileError!void {"},
{"lineNum":" 1633","line":"    assert(path.isAbsoluteZ(absolute_path_c));"},
{"lineNum":" 1634","line":"    return cwd().deleteFileZ(absolute_path_c);"},
{"lineNum":" 1635","line":"}"},
{"lineNum":" 1636","line":""},
{"lineNum":" 1637","line":"/// Same as `deleteFileAbsolute` except the parameter is WTF-16 encoded."},
{"lineNum":" 1638","line":"pub fn deleteFileAbsoluteW(absolute_path_w: [*:0]const u16) Dir.DeleteFileError!void {"},
{"lineNum":" 1639","line":"    assert(path.isAbsoluteWindowsW(absolute_path_w));"},
{"lineNum":" 1640","line":"    return cwd().deleteFileW(absolute_path_w);"},
{"lineNum":" 1641","line":"}"},
{"lineNum":" 1642","line":""},
{"lineNum":" 1643","line":"/// Removes a symlink, file, or directory."},
{"lineNum":" 1644","line":"/// This is equivalent to `Dir.deleteTree` with the base directory."},
{"lineNum":" 1645","line":"/// Asserts that the path is absolute. See `Dir.deleteTree` for a function that"},
{"lineNum":" 1646","line":"/// operates on both absolute and relative paths."},
{"lineNum":" 1647","line":"/// Asserts that the path parameter has no null bytes."},
{"lineNum":" 1648","line":"pub fn deleteTreeAbsolute(absolute_path: []const u8) !void {"},
{"lineNum":" 1649","line":"    assert(path.isAbsolute(absolute_path));"},
{"lineNum":" 1650","line":"    const dirname = path.dirname(absolute_path) orelse return error{"},
{"lineNum":" 1651","line":"        /// Attempt to remove the root file system path."},
{"lineNum":" 1652","line":"        /// This error is unreachable if `absolute_path` is relative."},
{"lineNum":" 1653","line":"        CannotDeleteRootDirectory,"},
{"lineNum":" 1654","line":"    }.CannotDeleteRootDirectory;"},
{"lineNum":" 1655","line":""},
{"lineNum":" 1656","line":"    var dir = try cwd().openDir(dirname, .{});"},
{"lineNum":" 1657","line":"    defer dir.close();"},
{"lineNum":" 1658","line":""},
{"lineNum":" 1659","line":"    return dir.deleteTree(path.basename(absolute_path));"},
{"lineNum":" 1660","line":"}"},
{"lineNum":" 1661","line":""},
{"lineNum":" 1662","line":"/// Same as `Dir.readLink`, except it asserts the path is absolute."},
{"lineNum":" 1663","line":"pub fn readLinkAbsolute(pathname: []const u8, buffer: *[MAX_PATH_BYTES]u8) ![]u8 {"},
{"lineNum":" 1664","line":"    assert(path.isAbsolute(pathname));"},
{"lineNum":" 1665","line":"    return os.readlink(pathname, buffer);"},
{"lineNum":" 1666","line":"}"},
{"lineNum":" 1667","line":""},
{"lineNum":" 1668","line":"/// Same as `readLink`, except the path parameter is null-terminated."},
{"lineNum":" 1669","line":"pub fn readLinkAbsoluteZ(pathname_c: [*]const u8, buffer: *[MAX_PATH_BYTES]u8) ![]u8 {"},
{"lineNum":" 1670","line":"    assert(path.isAbsoluteZ(pathname_c));"},
{"lineNum":" 1671","line":"    return os.readlinkZ(pathname_c, buffer);"},
{"lineNum":" 1672","line":"}"},
{"lineNum":" 1673","line":""},
{"lineNum":" 1674","line":"pub const readLink = @compileError(\"deprecated; use Dir.readLink or readLinkAbsolute\");"},
{"lineNum":" 1675","line":"pub const readLinkC = @compileError(\"deprecated; use Dir.readLinkZ or readLinkAbsoluteZ\");"},
{"lineNum":" 1676","line":""},
{"lineNum":" 1677","line":"pub const Walker = struct {"},
{"lineNum":" 1678","line":"    stack: std.ArrayList(StackItem),"},
{"lineNum":" 1679","line":"    name_buffer: std.ArrayList(u8),"},
{"lineNum":" 1680","line":""},
{"lineNum":" 1681","line":"    pub const Entry = struct {"},
{"lineNum":" 1682","line":"        /// The containing directory. This can be used to operate directly on `basename`"},
{"lineNum":" 1683","line":"        /// rather than `path`, avoiding `error.NameTooLong` for deeply nested paths."},
{"lineNum":" 1684","line":"        /// The directory remains open until `next` or `deinit` is called."},
{"lineNum":" 1685","line":"        dir: Dir,"},
{"lineNum":" 1686","line":"        /// TODO make this null terminated for API convenience"},
{"lineNum":" 1687","line":"        basename: []const u8,"},
{"lineNum":" 1688","line":""},
{"lineNum":" 1689","line":"        path: []const u8,"},
{"lineNum":" 1690","line":"        kind: Dir.Entry.Kind,"},
{"lineNum":" 1691","line":"    };"},
{"lineNum":" 1692","line":""},
{"lineNum":" 1693","line":"    const StackItem = struct {"},
{"lineNum":" 1694","line":"        dir_it: Dir.Iterator,"},
{"lineNum":" 1695","line":"        dirname_len: usize,"},
{"lineNum":" 1696","line":"    };"},
{"lineNum":" 1697","line":""},
{"lineNum":" 1698","line":"    /// After each call to this function, and on deinit(), the memory returned"},
{"lineNum":" 1699","line":"    /// from this function becomes invalid. A copy must be made in order to keep"},
{"lineNum":" 1700","line":"    /// a reference to the path."},
{"lineNum":" 1701","line":"    pub fn next(self: *Walker) !?Entry {"},
{"lineNum":" 1702","line":"        while (true) {"},
{"lineNum":" 1703","line":"            if (self.stack.items.len == 0) return null;"},
{"lineNum":" 1704","line":"            // `top` becomes invalid after appending to `self.stack`."},
{"lineNum":" 1705","line":"            const top = &self.stack.span()[self.stack.items.len - 1];"},
{"lineNum":" 1706","line":"            const dirname_len = top.dirname_len;"},
{"lineNum":" 1707","line":"            if (try top.dir_it.next()) |base| {"},
{"lineNum":" 1708","line":"                self.name_buffer.shrink(dirname_len);"},
{"lineNum":" 1709","line":"                try self.name_buffer.append(path.sep);"},
{"lineNum":" 1710","line":"                try self.name_buffer.appendSlice(base.name);"},
{"lineNum":" 1711","line":"                if (base.kind == .Directory) {"},
{"lineNum":" 1712","line":"                    var new_dir = top.dir_it.dir.openDir(base.name, .{ .iterate = true }) catch |err| switch (err) {"},
{"lineNum":" 1713","line":"                        error.NameTooLong => unreachable, // no path sep in base.name"},
{"lineNum":" 1714","line":"                        else => |e| return e,"},
{"lineNum":" 1715","line":"                    };"},
{"lineNum":" 1716","line":"                    {"},
{"lineNum":" 1717","line":"                        errdefer new_dir.close();"},
{"lineNum":" 1718","line":"                        try self.stack.append(StackItem{"},
{"lineNum":" 1719","line":"                            .dir_it = new_dir.iterate(),"},
{"lineNum":" 1720","line":"                            .dirname_len = self.name_buffer.items.len,"},
{"lineNum":" 1721","line":"                        });"},
{"lineNum":" 1722","line":"                    }"},
{"lineNum":" 1723","line":"                }"},
{"lineNum":" 1724","line":"                return Entry{"},
{"lineNum":" 1725","line":"                    .dir = top.dir_it.dir,"},
{"lineNum":" 1726","line":"                    .basename = self.name_buffer.span()[dirname_len + 1 ..],"},
{"lineNum":" 1727","line":"                    .path = self.name_buffer.span(),"},
{"lineNum":" 1728","line":"                    .kind = base.kind,"},
{"lineNum":" 1729","line":"                };"},
{"lineNum":" 1730","line":"            } else {"},
{"lineNum":" 1731","line":"                self.stack.pop().dir_it.dir.close();"},
{"lineNum":" 1732","line":"            }"},
{"lineNum":" 1733","line":"        }"},
{"lineNum":" 1734","line":"    }"},
{"lineNum":" 1735","line":""},
{"lineNum":" 1736","line":"    pub fn deinit(self: *Walker) void {"},
{"lineNum":" 1737","line":"        while (self.stack.popOrNull()) |*item| item.dir_it.dir.close();"},
{"lineNum":" 1738","line":"        self.stack.deinit();"},
{"lineNum":" 1739","line":"        self.name_buffer.deinit();"},
{"lineNum":" 1740","line":"    }"},
{"lineNum":" 1741","line":"};"},
{"lineNum":" 1742","line":""},
{"lineNum":" 1743","line":"/// Recursively iterates over a directory."},
{"lineNum":" 1744","line":"/// Must call `Walker.deinit` when done."},
{"lineNum":" 1745","line":"/// `dir_path` must not end in a path separator."},
{"lineNum":" 1746","line":"/// The order of returned file system entries is undefined."},
{"lineNum":" 1747","line":"pub fn walkPath(allocator: *Allocator, dir_path: []const u8) !Walker {"},
{"lineNum":" 1748","line":"    assert(!mem.endsWith(u8, dir_path, path.sep_str));"},
{"lineNum":" 1749","line":""},
{"lineNum":" 1750","line":"    var dir = try cwd().openDir(dir_path, .{ .iterate = true });"},
{"lineNum":" 1751","line":"    errdefer dir.close();"},
{"lineNum":" 1752","line":""},
{"lineNum":" 1753","line":"    var name_buffer = std.ArrayList(u8).init(allocator);"},
{"lineNum":" 1754","line":"    errdefer name_buffer.deinit();"},
{"lineNum":" 1755","line":""},
{"lineNum":" 1756","line":"    try name_buffer.appendSlice(dir_path);"},
{"lineNum":" 1757","line":""},
{"lineNum":" 1758","line":"    var walker = Walker{"},
{"lineNum":" 1759","line":"        .stack = std.ArrayList(Walker.StackItem).init(allocator),"},
{"lineNum":" 1760","line":"        .name_buffer = name_buffer,"},
{"lineNum":" 1761","line":"    };"},
{"lineNum":" 1762","line":""},
{"lineNum":" 1763","line":"    try walker.stack.append(Walker.StackItem{"},
{"lineNum":" 1764","line":"        .dir_it = dir.iterate(),"},
{"lineNum":" 1765","line":"        .dirname_len = dir_path.len,"},
{"lineNum":" 1766","line":"    });"},
{"lineNum":" 1767","line":""},
{"lineNum":" 1768","line":"    return walker;"},
{"lineNum":" 1769","line":"}"},
{"lineNum":" 1770","line":""},
{"lineNum":" 1771","line":"pub const OpenSelfExeError = os.OpenError || os.windows.CreateFileError || SelfExePathError || os.FlockError;"},
{"lineNum":" 1772","line":""},
{"lineNum":" 1773","line":"pub fn openSelfExe() OpenSelfExeError!File {","class":"lineCov","hits":"1","order":"13673","possible_hits":"1",},
{"lineNum":" 1774","line":"    if (builtin.os.tag == .linux) {"},
{"lineNum":" 1775","line":"        return openFileAbsoluteZ(\"/proc/self/exe\", .{});","class":"lineCov","hits":"1","order":"13674","possible_hits":"1",},
{"lineNum":" 1776","line":"    }"},
{"lineNum":" 1777","line":"    if (builtin.os.tag == .windows) {"},
{"lineNum":" 1778","line":"        const wide_slice = selfExePathW();"},
{"lineNum":" 1779","line":"        const prefixed_path_w = try os.windows.wToPrefixedFileW(wide_slice);"},
{"lineNum":" 1780","line":"        return cwd().openFileW(prefixed_path_w.span(), .{});"},
{"lineNum":" 1781","line":"    }"},
{"lineNum":" 1782","line":"    var buf: [MAX_PATH_BYTES]u8 = undefined;"},
{"lineNum":" 1783","line":"    const self_exe_path = try selfExePath(&buf);"},
{"lineNum":" 1784","line":"    buf[self_exe_path.len] = 0;"},
{"lineNum":" 1785","line":"    return openFileAbsoluteZ(buf[0..self_exe_path.len :0].ptr, .{});"},
{"lineNum":" 1786","line":"}"},
{"lineNum":" 1787","line":""},
{"lineNum":" 1788","line":"pub const SelfExePathError = os.ReadLinkError || os.SysCtlError;"},
{"lineNum":" 1789","line":""},
{"lineNum":" 1790","line":"/// `selfExePath` except allocates the result on the heap."},
{"lineNum":" 1791","line":"/// Caller owns returned memory."},
{"lineNum":" 1792","line":"pub fn selfExePathAlloc(allocator: *Allocator) ![]u8 {"},
{"lineNum":" 1793","line":"    var buf: [MAX_PATH_BYTES]u8 = undefined;"},
{"lineNum":" 1794","line":"    return mem.dupe(allocator, u8, try selfExePath(&buf));"},
{"lineNum":" 1795","line":"}"},
{"lineNum":" 1796","line":""},
{"lineNum":" 1797","line":"/// Get the path to the current executable."},
{"lineNum":" 1798","line":"/// If you only need the directory, use selfExeDirPath."},
{"lineNum":" 1799","line":"/// If you only want an open file handle, use openSelfExe."},
{"lineNum":" 1800","line":"/// This function may return an error if the current executable"},
{"lineNum":" 1801","line":"/// was deleted after spawning."},
{"lineNum":" 1802","line":"/// Returned value is a slice of out_buffer."},
{"lineNum":" 1803","line":"///"},
{"lineNum":" 1804","line":"/// On Linux, depends on procfs being mounted. If the currently executing binary has"},
{"lineNum":" 1805","line":"/// been deleted, the file path looks something like `/a/b/c/exe (deleted)`."},
{"lineNum":" 1806","line":"/// TODO make the return type of this a null terminated pointer"},
{"lineNum":" 1807","line":"pub fn selfExePath(out_buffer: *[MAX_PATH_BYTES]u8) SelfExePathError![]u8 {","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1808","line":"    if (is_darwin) {"},
{"lineNum":" 1809","line":"        var u32_len: u32 = out_buffer.len;"},
{"lineNum":" 1810","line":"        const rc = std.c._NSGetExecutablePath(out_buffer, &u32_len);"},
{"lineNum":" 1811","line":"        if (rc != 0) return error.NameTooLong;"},
{"lineNum":" 1812","line":"        return mem.spanZ(@ptrCast([*:0]u8, out_buffer));"},
{"lineNum":" 1813","line":"    }"},
{"lineNum":" 1814","line":"    switch (builtin.os.tag) {"},
{"lineNum":" 1815","line":"        .linux => return os.readlinkZ(\"/proc/self/exe\", out_buffer),","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1816","line":"        .freebsd, .dragonfly => {"},
{"lineNum":" 1817","line":"            var mib = [4]c_int{ os.CTL_KERN, os.KERN_PROC, os.KERN_PROC_PATHNAME, -1 };"},
{"lineNum":" 1818","line":"            var out_len: usize = out_buffer.len;"},
{"lineNum":" 1819","line":"            try os.sysctl(&mib, out_buffer, &out_len, null, 0);"},
{"lineNum":" 1820","line":"            // TODO could this slice from 0 to out_len instead?"},
{"lineNum":" 1821","line":"            return mem.spanZ(@ptrCast([*:0]u8, out_buffer));"},
{"lineNum":" 1822","line":"        },"},
{"lineNum":" 1823","line":"        .netbsd => {"},
{"lineNum":" 1824","line":"            var mib = [4]c_int{ os.CTL_KERN, os.KERN_PROC_ARGS, -1, os.KERN_PROC_PATHNAME };"},
{"lineNum":" 1825","line":"            var out_len: usize = out_buffer.len;"},
{"lineNum":" 1826","line":"            try os.sysctl(&mib, out_buffer, &out_len, null, 0);"},
{"lineNum":" 1827","line":"            // TODO could this slice from 0 to out_len instead?"},
{"lineNum":" 1828","line":"            return mem.spanZ(@ptrCast([*:0]u8, out_buffer));"},
{"lineNum":" 1829","line":"        },"},
{"lineNum":" 1830","line":"        .windows => {"},
{"lineNum":" 1831","line":"            const utf16le_slice = selfExePathW();"},
{"lineNum":" 1832","line":"            // Trust that Windows gives us valid UTF-16LE."},
{"lineNum":" 1833","line":"            const end_index = std.unicode.utf16leToUtf8(out_buffer, utf16le_slice) catch unreachable;"},
{"lineNum":" 1834","line":"            return out_buffer[0..end_index];"},
{"lineNum":" 1835","line":"        },"},
{"lineNum":" 1836","line":"        else => @compileError(\"std.fs.selfExePath not supported for this target\"),"},
{"lineNum":" 1837","line":"    }"},
{"lineNum":" 1838","line":"}"},
{"lineNum":" 1839","line":""},
{"lineNum":" 1840","line":"/// The result is UTF16LE-encoded."},
{"lineNum":" 1841","line":"pub fn selfExePathW() [:0]const u16 {"},
{"lineNum":" 1842","line":"    const image_path_name = &os.windows.peb().ProcessParameters.ImagePathName;"},
{"lineNum":" 1843","line":"    return mem.spanZ(@ptrCast([*:0]const u16, image_path_name.Buffer));"},
{"lineNum":" 1844","line":"}"},
{"lineNum":" 1845","line":""},
{"lineNum":" 1846","line":"/// `selfExeDirPath` except allocates the result on the heap."},
{"lineNum":" 1847","line":"/// Caller owns returned memory."},
{"lineNum":" 1848","line":"pub fn selfExeDirPathAlloc(allocator: *Allocator) ![]u8 {"},
{"lineNum":" 1849","line":"    var buf: [MAX_PATH_BYTES]u8 = undefined;"},
{"lineNum":" 1850","line":"    return mem.dupe(allocator, u8, try selfExeDirPath(&buf));"},
{"lineNum":" 1851","line":"}"},
{"lineNum":" 1852","line":""},
{"lineNum":" 1853","line":"/// Get the directory path that contains the current executable."},
{"lineNum":" 1854","line":"/// Returned value is a slice of out_buffer."},
{"lineNum":" 1855","line":"pub fn selfExeDirPath(out_buffer: *[MAX_PATH_BYTES]u8) SelfExePathError![]const u8 {"},
{"lineNum":" 1856","line":"    const self_exe_path = try selfExePath(out_buffer);"},
{"lineNum":" 1857","line":"    // Assume that the OS APIs return absolute paths, and therefore dirname"},
{"lineNum":" 1858","line":"    // will not return null."},
{"lineNum":" 1859","line":"    return path.dirname(self_exe_path).?;"},
{"lineNum":" 1860","line":"}"},
{"lineNum":" 1861","line":""},
{"lineNum":" 1862","line":"/// `realpath`, except caller must free the returned memory."},
{"lineNum":" 1863","line":"/// TODO integrate with `Dir`"},
{"lineNum":" 1864","line":"pub fn realpathAlloc(allocator: *Allocator, pathname: []const u8) ![]u8 {","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1865","line":"    var buf: [MAX_PATH_BYTES]u8 = undefined;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1866","line":"    return mem.dupe(allocator, u8, try os.realpath(pathname, &buf));","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":" 1867","line":"}"},
{"lineNum":" 1868","line":""},
{"lineNum":" 1869","line":"test \"\" {","class":"lineCov","hits":"2","order":"2435","possible_hits":"2",},
{"lineNum":" 1870","line":"    if (builtin.os.tag != .wasi) {"},
{"lineNum":" 1871","line":"        _ = makeDirAbsolute;"},
{"lineNum":" 1872","line":"        _ = makeDirAbsoluteZ;"},
{"lineNum":" 1873","line":"        _ = copyFileAbsolute;"},
{"lineNum":" 1874","line":"        _ = updateFileAbsolute;"},
{"lineNum":" 1875","line":"    }"},
{"lineNum":" 1876","line":"    _ = Dir.copyFile;"},
{"lineNum":" 1877","line":"    _ = @import(\"fs/test.zig\");"},
{"lineNum":" 1878","line":"    _ = @import(\"fs/path.zig\");"},
{"lineNum":" 1879","line":"    _ = @import(\"fs/file.zig\");"},
{"lineNum":" 1880","line":"    _ = @import(\"fs/get_app_data_dir.zig\");"},
{"lineNum":" 1881","line":"    _ = @import(\"fs/watch.zig\");"},
{"lineNum":" 1882","line":"}"},
]};
var percent_low = 25;var percent_high = 75;
var header = { "command" : "test", "date" : "2020-05-19 01:29:25", "instrumented" : 316, "covered" : 208,};
var merged_data = [];