Harshavardhana <******@****.***> 1624037668 -0700

    public String name, scope;
    public int hexCode;
    int srcHashCode; /* srcHashCode must be set by name resolution
                      * routines before entry into addressCache
                      */

    Name() {
    }
    public Name( String name, int hexCode, String scope ) {
        if( name.length() > 15 ) {
            name = name.substring( 0, 15 );
        }

			res[i] = Name(i + 1)
		}
		return res
	default:
		return []Name{name}
	}
}

// Mask returns the type as mask.
// Compound "All" types are expanded.
func (name Name) Mask() uint64 {
	if name < objectSingleTypesEnd {
		return 1 << (name - 1)
	}
	var mask uint64
	for _, n := range name.Expand() {
		mask |= 1 << (n - 1)
	}
	return mask
}

        }
        this.name = name.toUpperCase();
        this.hexCode = hexCode;
        this.scope = scope != null && scope.length() > 0 ? scope : cfg.getNetbiosScope();
        this.srcHashCode = 0;
    }


    /**
     * @param cfg
     * @param name
     */
    public Name ( Configuration cfg, NetbiosName name ) {
        this.config = cfg;
        this.name = name.getName();

	for _, test := range []struct {
		name string
		h    *Header
	}{{
		name: "name too long",
		h:    &Header{Name: strings.Repeat("a", maxSpecialFileSize)},
	}, {
		name: "linkname too long",
		h:    &Header{Linkname: strings.Repeat("a", maxSpecialFileSize)},
	}, {
		name: "uname too long",
		h:    &Header{Uname: strings.Repeat("a", maxSpecialFileSize)},
	}, {
		name: "gname too long",

	tw := NewWriter(&buf)
	const name = "/foo"
	tw.WriteHeader(&Header{
		Name: name,
	})
	tw.Close()
	tr := NewReader(&buf)
	h, err := tr.Next()
	if err != nil {
		t.Fatalf("tr.Next with tarinsecurepath=1: got err %v, want nil", err)
	}
	if h.Name != name {
		t.Fatalf("tr.Next with tarinsecurepath=1: got name %q, want %q", h.Name, name)
	}

// Passing an instance of this to [FileInfoHeader] permits the caller
// to avoid a system-dependent name lookup by specifying the Uname and Gname directly.
type FileInfoNames interface {
	fs.FileInfo
	// Uname should give a user name.
	Uname() (string, error)
	// Gname should give a group name.
	Gname() (string, error)
}

// isHeaderOnlyType checks if the given type flag is of the type that has no

		if err != nil {
			t.Error(err)
			continue
		}
		if strings.Contains(fi.Name(), "/") {
			t.Errorf("FileInfo of %q contains slash: %q", v.h.Name, fi.Name())
		}
		name := path.Base(v.h.Name)
		if fi.IsDir() {
			name += "/"
		}
		if got, want := h2.Name, name; got != want {
			t.Errorf("i=%d: Name: got %v, want %v", i, got, want)
		}
		if got, want := h2.Size, v.h.Size; got != want {

		if u, ok := userMap.Load(h.Uid); ok {
			h.Uname = u.(string)
		} else if u, err := user.LookupId(strconv.Itoa(h.Uid)); err == nil {
			h.Uname = u.Username
			userMap.Store(h.Uid, h.Uname)
		}
		if g, ok := groupMap.Load(h.Gid); ok {
			h.Gname = g.(string)
		} else if g, err := user.LookupGroupId(strconv.Itoa(h.Gid)); err == nil {
			h.Gname = g.Name
			groupMap.Store(h.Gid, h.Gname)
		}
	}
	h.AccessTime = statAtime(sys)

#!/usr/bin/env bash
#

_init() {

	shopt -s extglob

	## Minimum required versions for build dependencies
	GIT_VERSION="1.0"
	GO_VERSION="1.16"
	OSX_VERSION="10.8"
	KNAME=$(uname -s)
	ARCH=$(uname -m)
	case "${KNAME}" in
	SunOS)
		ARCH=$(isainfo -k)
		;;
	esac
}

## FIXME:
## In OSX, 'readlink -f' option does not exist, hence
## we have our own readlink -f behavior here.