// Functions to access/create device major and minor numbers matching the
// encoding used in NetBSD's sys/types.h header.

package unix

// Major returns the major component of a NetBSD device number.
func Major(dev uint64) uint32 {
	return uint32((dev & 0x000fff00) >> 8)
}

// Minor returns the minor component of a NetBSD device number.
func Minor(dev uint64) uint32 {
	minor := uint32((dev & 0x000000ff) >> 0)

	return major
}

// Minor returns the minor component of a Linux device number.
func Minor(dev uint64) uint32 {
	minor := uint32((dev & 0x00000000000000ff) >> 0)
	minor |= uint32((dev & 0x00000ffffff00000) >> 12)
	return minor
}

// Mkdev returns a Linux device number generated from the given major and minor
// components.
func Mkdev(major, minor uint32) uint64 {
	dev := (uint64(major) & 0x00000fff) << 8

// A lang is a language version broken into major and minor numbers.
type lang struct {
	major, minor int
}

// langWant is the desired language version set by the -lang flag.
// If the -lang flag is not set, this is the zero value, meaning that
// any language version is supported.
var langWant lang

// AllowsGoVersion reports whether local package is allowed
// to use Go version major.minor.
func AllowsGoVersion(major, minor int) bool {

	return uint32((dev >> 8) & 0xff)
}

// Minor returns the minor component of a DragonFlyBSD device number.
func Minor(dev uint64) uint32 {
	return uint32(dev & 0xffff00ff)
}

// Mkdev returns a DragonFlyBSD device number generated from the given major and
// minor components.
func Mkdev(major, minor uint32) uint64 {
	return (uint64(major) << 8) | uint64(minor)

// Functions to access/create device major and minor numbers matching the
// encoding used in Darwin's sys/types.h header.

package unix

// Major returns the major component of a Darwin device number.
func Major(dev uint64) uint32 {
	return uint32((dev >> 24) & 0xff)
}

// Minor returns the minor component of a Darwin device number.
func Minor(dev uint64) uint32 {
	return uint32(dev & 0xffffff)
}

}

func majorMinor(v string) (string, string, bool) {
	firstDot := strings.Index(v, ".")
	if firstDot < 0 {
		return "", "", false
	}
	major := v[:firstDot]
	v = v[firstDot+len("."):]
	endMinor := strings.IndexAny(v, ".-_")
	if endMinor < 0 {
		endMinor = len(v)
	}
	minor := v[:endMinor]
	return major, minor, true

//
// Files in the "minor changes" directory (the unique directory matching the glob
// "*stdlib/*minor") are named after the package to which they refer, and will have
// the package heading inserted automatically and links to other standard library
// symbols expanded automatically. For example, if a file *stdlib/minor/bytes/f.md
// contains the text
//
//	[Reader] implements [io.Reader].

// Go version.
//
// Examples:
//
//	Prev("1.2") = "1.1"
//	Prev("1.3rc4") = "1.2"
func Prev(x string) string {
	v := gover.Parse(x)
	if gover.CmpInt(v.Minor, "1") <= 0 {
		return v.Major
	}
	return v.Major + "." + gover.DecInt(v.Minor)
}

// IsValid reports whether the version x is valid.
func IsValid(x string) bool {
	return gover.IsValid(x)

		case "freebsd":
			// Copied from golang.org/x/sys/unix/dev_freebsd.go.
			major := uint32((dev >> 8) & 0xff)
			minor := uint32(dev & 0xffff00ff)
			h.Devmajor, h.Devminor = int64(major), int64(minor)
		case "netbsd":
			// Copied from golang.org/x/sys/unix/dev_netbsd.go.
			major := uint32((dev & 0x000fff00) >> 8)
			minor := uint32((dev & 0x000000ff) >> 0)
			minor |= uint32((dev & 0xfff00000) >> 12)

		if !check.validateTArgLen(pos, orig.String(), tparams.Len(), len(targs)) {
			return Typ[Invalid]
		}
		if tparams.Len() == 0 {
			return orig // nothing to do (minor optimization)
		}

		return check.newAliasInstance(pos, orig, targs, ctxt)

	case *Signature:
		assert(expanding == nil) // function instances cannot be reached from Named types