import java.nio.file.Files;

enum Profile {

    COMPACT1("compact1", 1),

    COMPACT2("compact2", 2),

    COMPACT3("compact3", 3),

    FULL_JRE("Full JRE", 4);

    final String name;

    final int profile;

    final Set<String> packages;

    final Set<String> proprietaryPkgs;

    Profile(String name, int profile) {

        this.name = name;

        this.profile = profile;

        this.packages = new HashSet<>();

        this.proprietaryPkgs = new HashSet<>();

    }

    @Override

    public String toString() {

        return name;

        return PackageToProfile.map.values().size();

    }

    /**

     * Returns the Profile for the given package name. It returns an empty

     * string if the given package is not in any profile.

     */

    public static Profile getProfile(String pn) {

        Profile profile = PackageToProfile.map.get(pn);

        return (profile != null && profile.packages.contains(pn))

                ? profile : null;

    static class PackageToProfile {

        static Map<String, Profile> map = initProfiles();

        private static Map<String, Profile> initProfiles() {

            try {

                String profilesProps = System.getProperty("jdeps.profiles");

                if (profilesProps != null) {

                    // for testing for JDK development build where ct.sym doesn't exist

                    initProfilesFromProperties(profilesProps);

                } else {

                    Path home = Paths.get(System.getProperty("java.home"));

                    if (home.endsWith("jre")) {

                        home = home.getParent();

                    }

                    Path ctsym = home.resolve("lib").resolve("ct.sym");

                    if (Files.exists(ctsym)) {

                        // parse ct.sym and load information about profiles

                        try (JarFile jf = new JarFile(ctsym.toFile())) {

                            ClassFileReader reader = ClassFileReader.newInstance(ctsym, jf);

                            for (ClassFile cf : reader.getClassFiles()) {

                                findProfile(cf);

                            }

                }

            } catch (IOException | ConstantPoolException e) {

                throw new Error(e);

            }

            HashMap<String,Profile> map = new HashMap<>();

            for (Profile profile : Profile.values()) {

                for (String pn : profile.packages) {

                    if (!map.containsKey(pn)) {

                        // split packages in the JRE: use the smaller compact

                        map.put(pn, profile);

                    }

                }

                for (String pn : profile.proprietaryPkgs) {

                    if (!map.containsKey(pn)) {

                        map.put(pn, profile);

            return map;

        private static final String PROFILE_ANNOTATION = "Ljdk/Profile+Annotation;";

        private static final String PROPRIETARY_ANNOTATION = "Lsun/Proprietary+Annotation;";

        private static Profile findProfile(ClassFile cf) throws ConstantPoolException {

            RuntimeAnnotations_attribute attr = (RuntimeAnnotations_attribute)

                cf.attributes.get(Attribute.RuntimeInvisibleAnnotations);

            int index = 0;

            boolean proprietary = false;

            if (attr != null) {

                for (int i = 0; i < attr.annotations.length; i++) {

                    Annotation ann = attr.annotations[i];

                    String annType = cf.constant_pool.getUTF8Value(ann.type_index);

                    if (PROFILE_ANNOTATION.equals(annType)) {

                        for (int j = 0; j < ann.num_element_value_pairs; j++) {

                            Annotation.element_value_pair pair = ann.element_value_pairs[j];

                            Primitive_element_value ev = (Primitive_element_value) pair.value;

                            CONSTANT_Integer_info info = (CONSTANT_Integer_info)

                                cf.constant_pool.get(ev.const_value_index);

                            index = info.value;

                            break;

                        }

                    } else if (PROPRIETARY_ANNOTATION.equals(annType)) {

                        proprietary = true;

            Profile p = null;  // default

            switch (index) {

                case 1:

                    p = Profile.COMPACT1; break;

                case 2:

                    p = Profile.COMPACT2; break;

                case 3:

                    p = Profile.COMPACT3; break;

                case 4:

                    p = Profile.FULL_JRE; break;

                default:

                    // skip classes with profile=0

                    // Inner classes are not annotated with the profile annotation

                    return null;

            }

            String name = cf.getName();

            int i = name.lastIndexOf('/');

            name = (i > 0) ? name.substring(0, i).replace('/', '.') : "";

            if (proprietary) {

                p.proprietaryPkgs.add(name);

            } else {

                p.packages.add(name);

            }

            return p;

        private static void initProfilesFromProperties(String path) throws IOException {

            Properties props = new Properties();

            try (FileReader reader = new FileReader(path)) {

                props.load(reader);

            for (Profile prof : Profile.values()) {

                int i = prof.profile;

                String key = props.getProperty("profile." + i + ".name");

                if (key == null) {

                    throw new RuntimeException(key + " missing in " + path);

                }

                String n = props.getProperty("profile." + i + ".packages");

                String[] pkgs = n.split("\\s+");

                for (String p : pkgs) {

                    if (p.isEmpty()) continue;

                    prof.packages.add(p);

                }

            }

            if (Profile.getProfileCount() == 0) {

                System.err.println("No profile is present in this JDK");

            for (Profile p : Profile.values()) {

                SortedSet<String> set = new TreeSet<>(p.packages);

                    if (PackageToProfile.map.get(s) == p) {

                        System.out.format("%2d: %-10s  %s%n", p.profile, profileName, s);

                    } else {

                        System.err.format("Split package: %s in %s and %s %n",

                            s, PackageToProfile.map.get(s).name, p.name);

            System.out.format("%s in %s%n", pn, getProfile(pn));