ArchiveMemberHeader

pub const ArchiveMemberHeader = extern struct

File

Code

pub const ArchiveMemberHeader = extern struct {
    /// Left-justified '/' terminated member name
    name: [16]u8,
    /// Left-justified ASCII decimal: seconds since January 1st, 1970
    date: [12]u8,
    /// Left-justified ASCII decimal: user id
    user_id: [6]u8,
    /// Left-justified ASCII decimal: group id
    group_id: [6]u8,
    /// Left-justified ASCII octal: file mode
    file_mode: [8]u8,
    /// Left-justified ASCII decimal: size of the member following this header,
    /// not including the size of this header.
    size: [10]u8,
    /// The literal string '`\n'
    end_of_header: [2]u8,

    /// Extracts the name of the member by either reading it directly from
    /// the header, or by finding it inside the longnames member, if provided.
    pub fn parseName(
        self: *const ArchiveMemberHeader,
        opt_longnames: ?[]const u8,
    ) ![]const u8 {
        const trim = std.mem.trimEnd(u8, &self.name, &.{' '});

        if (trim.len == 0) return error.BadName;
        return if (trim[0] == '/') name: {
            if (trim.len == 1 or
                trim.len == 2 and trim[1] == '/')
                break :name trim;

            const offset = std.fmt.parseUnsigned(u50, trim[1..], 10) catch
                return error.BadName;

            if (opt_longnames) |longnames| {
                if (offset >= longnames.len) return error.BadName;
                break :name std.mem.sliceTo(longnames[@intCast(offset)..], 0);
            } else return error.NoLongNames;
        } else if (trim[trim.len - 1] == '/')
            trim[0 .. trim.len - 1]
        else
            return error.BadName;
    }

    fn parseField(field: []const u8, T: type, base: u8) !T {
        if (std.mem.allEqual(u8, field, ' ')) return 0;
        if (field[0] == '-')
            return @bitCast(try std.fmt.parseInt(
                @Int(.signed, @typeInfo(T).int.bits),
                std.mem.trimEnd(u8, field, &.{' '}),
                base,
            ));

        return std.fmt.parseUnsigned(T, std.mem.trimEnd(u8, field, &.{' '}), base);
    }

    pub fn parseDate(self: *const ArchiveMemberHeader) !u40 {
        return parseField(&self.date, u40, 10);
    }

    pub fn parseUserId(self: *const ArchiveMemberHeader) !u20 {
        return parseField(&self.user_id, u20, 10);
    }

    pub fn parseGroupId(self: *const ArchiveMemberHeader) !u20 {
        return parseField(&self.group_id, u20, 10);
    }

    pub fn parseFileMode(self: *const ArchiveMemberHeader) !u20 {
        return parseField(&self.group_id, u20, 8);
    }

    pub fn parseSize(self: *const ArchiveMemberHeader) !u34 {
        return parseField(&self.size, u34, 10);
    }

    pub const Kind = enum {
        first_linker,
        second_linker,
        longnames,
        coff,
        import,
    };
}