* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.

import java.util.Iterator;

// Code duplicated in com.sun.tools.classfile.TypeAnnotation.Position

    public enum TypePathEntryKind {

        ARRAY(0),

        INNER_TYPE(1),

        WILDCARD(2),

        TYPE_ARGUMENT(3);

        public final int tag;

        private TypePathEntryKind(int tag) {

            this.tag = tag;

        }

    }

    public static class TypePathEntry {

        /** The fixed number of bytes per TypePathEntry. */

        public static final int bytesPerEntry = 2;

        public final TypePathEntryKind tag;

        public final int arg;

        public static final TypePathEntry ARRAY = new TypePathEntry(TypePathEntryKind.ARRAY);

        public static final TypePathEntry INNER_TYPE = new TypePathEntry(TypePathEntryKind.INNER_TYPE);

        public static final TypePathEntry WILDCARD = new TypePathEntry(TypePathEntryKind.WILDCARD);

        private TypePathEntry(TypePathEntryKind tag) {

            Assert.check(tag == TypePathEntryKind.ARRAY ||

                    tag == TypePathEntryKind.INNER_TYPE ||

                    tag == TypePathEntryKind.WILDCARD,

                    "Invalid TypePathEntryKind: " + tag);

            this.tag = tag;

            this.arg = 0;

        }

        public TypePathEntry(TypePathEntryKind tag, int arg) {

            Assert.check(tag == TypePathEntryKind.TYPE_ARGUMENT,

                    "Invalid TypePathEntryKind: " + tag);

            this.tag = tag;

            this.arg = arg;

        }

        public static TypePathEntry fromBinary(int tag, int arg) {

            Assert.check(arg == 0 || tag == TypePathEntryKind.TYPE_ARGUMENT.tag,

                    "Invalid TypePathEntry tag/arg: " + tag + "/" + arg);

            switch (tag) {

            case 0:

                return ARRAY;

            case 1:

                return INNER_TYPE;

            case 2:

                return WILDCARD;

            case 3:

                return new TypePathEntry(TypePathEntryKind.TYPE_ARGUMENT, arg);

            default:

                Assert.error("Invalid TypePathEntryKind tag: " + tag);

                return null;

            }

        }

        @Override

        public String toString() {

            return tag.toString() +

                    (tag == TypePathEntryKind.TYPE_ARGUMENT ? ("(" + arg + ")") : "");

        }

        @Override

        public boolean equals(Object other) {

            if (! (other instanceof TypePathEntry)) {

                return false;

            }

            TypePathEntry tpe = (TypePathEntry) other;

            return this.tag == tpe.tag && this.arg == tpe.arg;

        }

        @Override

        public int hashCode() {

            return this.tag.hashCode() * 17 + this.arg;

        }

    }

    public List<TypePathEntry> location = List.nil();

    // For class extends, implements, and throws clauses

    // For exception parameters, index into exception table

    public int exception_index = Integer.MIN_VALUE;

    public TypeAnnotationPosition() {}

        // type cast

        case CAST:

        // instanceof

        // new expression

        // local variable

        // resource variable

        case RESOURCE_VARIABLE:

            if (lvarOffset == null) {

                sb.append(", lvarOffset is null!");

                break;

            }

                sb.append("start_pc = ");

        // method receiver

        // type parameter

        // type parameter bound

        // class extends or implements clause

        // throws

        // exception parameter

        case EXCEPTION_PARAMETER:

            sb.append(", exception_index = ");

            sb.append(exception_index);

        // method parameter

        case METHOD_FORMAL_PARAMETER:

        // method/constructor/reference type argument

        case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:

        case METHOD_INVOCATION_TYPE_ARGUMENT:

        case METHOD_REFERENCE_TYPE_ARGUMENT:

        // We don't need to worry about these

        case METHOD_RETURN:

        case FIELD:

            break;

        // lambda formal parameter

        case LAMBDA_FORMAL_PARAMETER:

            // TODO: also needs an offset?

            sb.append(", param_index = ");

            sb.append(parameter_index);

            sb.append(", position UNKNOWN!");

            Assert.error("Unknown target type: " + type);

        if (!location.isEmpty()) {

        return !type.isLocal() || isValidOffset;

    }

    /**

     * Decode the binary representation for a type path and set

     * the {@code location} field.

     *

     * @param list The bytecode representation of the type path.

     */

    public static List<TypePathEntry> getTypePathFromBinary(java.util.List<Integer> list) {

        ListBuffer<TypePathEntry> loc = ListBuffer.lb();

        Iterator<Integer> iter = list.iterator();

        while (iter.hasNext()) {

            Integer fst = iter.next();

            Assert.check(iter.hasNext(), "Could not decode type path: " + list);

            Integer snd = iter.next();

            loc = loc.append(TypePathEntry.fromBinary(fst, snd));

        }

        return loc.toList();

    }

    public static List<Integer> getBinaryFromTypePath(java.util.List<TypePathEntry> locs) {

        ListBuffer<Integer> loc = ListBuffer.lb();

        for (TypePathEntry tpe : locs) {

            loc = loc.append(tpe.tag.tag);

            loc = loc.append(tpe.arg);

        }

        return loc.toList();