} else {
                load();
                if (x >= 0) {
                    makeImmediateItem(syms.intType, new Integer(x)).load();
                    code.emitop(iadd);
                } else {
                    makeImmediateItem(syms.intType, new Integer(-x)).load();
                    code.emitop(isub);
                }
                makeStackItem(syms.intType).coerce(typecode);
                store();
            }
        }

        public String toString() {
            return "localItem(type=" + type + "; reg=" + reg + ")";
        }
    }

    /**
      * An item representing a static variable or method.
      */
    class StaticItem extends Item {

        /**
         * The represented symbol.
         */
        Symbol member;

        StaticItem(Symbol member) {
            super(Code.typecode(member.erasure()));
            this.member = member;
        }

        Item load() {
            code.emitop(getstatic, Code.width(typecode));
            code.emit2(pool.put(member));
            return stackItem[typecode];
        }

        Item store() {
            code.emitop(putstatic, -Code.width(typecode));
            code.emit2(pool.put(member));
            return voidItem;
        }

        Item invoke() {
            MethodType mtype = (MethodType) member.erasure();
            int argsize = Code.width(mtype.argtypes);
            int rescode = Code.typecode(mtype.restype);
            int sdiff = Code.width(rescode) - argsize;
            code.emitop(invokestatic, sdiff);
            code.emit2(pool.put(member));
            return stackItem[rescode];
        }

        public String toString() {
            return "static(" + member + ")";
        }
    }

    /**
      * An item representing an instance variable or method.
      */
    class MemberItem extends Item {

        /**
         * The represented symbol.
         */
        Symbol member;

        /**
         * Flag that determines whether or not access is virtual.
         */
        boolean nonvirtual;

        MemberItem(Symbol member, boolean nonvirtual) {
            super(Code.typecode(member.erasure()));
            this.member = member;
            this.nonvirtual = nonvirtual;
        }

        Item load() {
            code.emitop(getfield, Code.width(typecode) - 1);
            code.emit2(pool.put(member));
            return stackItem[typecode];
        }

        Item store() {
            code.emitop(putfield, -Code.width(typecode) - 1);
            code.emit2(pool.put(member));
            return voidItem;
        }

        Item invoke() {
            MethodType mtype = (MethodType) member.externalType();
            int argsize = Code.width(mtype.argtypes);
            int rescode = Code.typecode(mtype.restype);
            int sdiff = Code.width(rescode) - argsize;
            if ((member.owner.flags() & Flags.INTERFACE) != 0) {
                code.emitop(invokeinterface, sdiff - 1);
                code.emit2(pool.put(member));
                code.emit1(argsize + 1);
                code.emit1(0);
            } else if (nonvirtual) {
                code.emitop(invokespecial, sdiff - 1);
                code.emit2(pool.put(member));
            } else {
                code.emitop(invokevirtual, sdiff - 1);
                code.emit2(pool.put(member));
            }
            return stackItem[rescode];
        }

        void duplicate() {
            stackItem[OBJECTcode].duplicate();
        }

        void drop() {
            stackItem[OBJECTcode].drop();
        }

        void stash(int toscode) {
            stackItem[OBJECTcode].stash(toscode);
        }

        int width() {
            return 1;
        }

        public String toString() {
            return "member(" + member + (nonvirtual ? " nonvirtual)" : ")");
        }
    }

    /**
      * An item representing a literal.
      */
    class ImmediateItem extends Item {

        /**
         * The literal's value.
         */
        Object value;

        ImmediateItem(Type type, Object value) {
            super(Code.typecode(type));
            this.value = value;
        }

        private void ldc() {
            int idx = pool.put(value);
            if (typecode == LONGcode || typecode == DOUBLEcode) {
                code.emitop(ldc2w, 2);
                code.emit2(idx);
            } else if (idx <= 255) {
                code.emitop(ldc1, 1);
                code.emit1(idx);
            } else {
                code.emitop(ldc2, 1);
                code.emit2(idx);
            }
        }

        Item load() {
            switch (typecode) {
            case INTcode:

            case BYTEcode:

            case SHORTcode:

            case CHARcode:
                int ival = ((Number) value).intValue();
                if (-1 <= ival && ival <= 5)
                    code.emitop(iconst_0 + ival);
                else if (Byte.MIN_VALUE <= ival && ival <= Byte.MAX_VALUE)
                    code.emitop1(bipush, ival);
                else if (Short.MIN_VALUE <= ival && ival <= Short.MAX_VALUE)
                    code.emitop2(sipush, ival);
                else
                    ldc();
                break;

            case LONGcode:
                long lval = ((Number) value).longValue();
                if (lval == 0 || lval == 1)
                    code.emitop(lconst_0 + (int) lval);
                else
                    ldc();
                break;

            case FLOATcode:
                float fval = ((Number) value).floatValue();
                if (isPosZero(fval) || fval == 1.0 || fval == 2.0)
                    code.emitop(fconst_0 + (int) fval);
                else {
                    ldc();
                }
                break;

            case DOUBLEcode:
                double dval = ((Number) value).doubleValue();
                if (isPosZero(dval) || dval == 1.0)
                    code.emitop(dconst_0 + (int) dval);
                else
                    ldc();
                break;

            case OBJECTcode:
                ldc();
                break;

            default:
                assert false;

            }
            return stackItem[typecode];
        }

        /**
          * Return true iff float number is positive 0.
          */
        private boolean isPosZero(float x) {
            return x == 0.0F && 1.0F / x > 0.0F;
        }

        /**
          * Return true iff double number is positive 0.
          */
        private boolean isPosZero(double x) {
            return x == 0.0 && 1.0 / x > 0.0;
        }

        CondItem mkCond() {
            int ival = ((Number) value).intValue();
            return makeCondItem(ival != 0 ? goto_ : dontgoto);
        }

        Item coerce(int targetcode) {
            if (typecode == targetcode) {
                return this;
            } else {
                switch (targetcode) {
                case INTcode:
                    if (Code.truncate(typecode) == INTcode)
                        return this;
                    else
                        return new ImmediateItem(syms.intType,
                                new Integer(((Number) value).intValue()));

                case LONGcode:
                    return new ImmediateItem(syms.longType,
                            new Long(((Number) value).longValue()));

                case FLOATcode:
                    return new ImmediateItem(syms.floatType,
                            new Float(((Number) value).floatValue()));

                case DOUBLEcode:
                    return new ImmediateItem(syms.doubleType,
                            new Double(((Number) value).doubleValue()));

                case BYTEcode:
                    return new ImmediateItem(syms.byteType,
                            new Integer((byte)((Number) value).intValue()));

                case CHARcode:
                    return new ImmediateItem(syms.charType,
                            new Integer((char)((Number) value).intValue()));

                case SHORTcode:
                    return new ImmediateItem(syms.shortType,
                            new Integer((short)((Number) value).intValue()));

                default:
                    return super.coerce(targetcode);

                }
            }
        }

        public String toString() {
            return "immediate(" + value + ")";
        }
    }

    /**
      * An item representing an assignment expressions.
      */
    class AssignItem extends Item {

        /**
         * The item representing the assignment's left hand side.
         */
        Item lhs;

        AssignItem(Item lhs) {
            super(lhs.typecode);
            this.lhs = lhs;
        }

        Item load() {
            lhs.stash(typecode);
            lhs.store();
            return stackItem[typecode];
        }

        void duplicate() {
            load().duplicate();
        }

        void drop() {
            lhs.store();
        }

        void stash(int toscode) {
            assert false;
        }

        int width() {
            return lhs.width() + Code.width(typecode);
        }

        public String toString() {
            return "assign(lhs = " + lhs + ")";
        }
    }

    /**
      * An item representing a conditional or unconditional jump.
      */
    class CondItem extends Item {

        /**
         * A chain encomassing all jumps that can be taken
         *  if the condition evaluates to true.
         */
        Chain trueJumps;

        /**
         * A chain encomassing all jumps that can be taken
         *  if the condition evaluates to false.
         */
        Chain falseJumps;

        /**
         * The jump's opcode.
         */
        int opcode;
        Tree tree;

        CondItem(int opcode, Chain truejumps, Chain falsejumps) {
            super(BYTEcode);
            this.opcode = opcode;
            this.trueJumps = truejumps;
            this.falseJumps = falsejumps;
        }

        Item load() {
            Chain trueChain = null;
            Chain falseChain = jumpFalse();
            if (trueJumps != null || opcode != dontgoto) {
                code.resolve(trueJumps);
                code.emitop(iconst_1);
                trueChain = code.branch(goto_);
            }
            if (falseChain != null) {
                code.resolve(falseChain);
                code.emitop(iconst_0);
            }
            code.resolve(trueChain);
            return stackItem[typecode];
        }

        void duplicate() {
            load().duplicate();
        }

        void drop() {
            load().drop();
        }

        void stash(int toscode) {
            assert false;
        }

        CondItem mkCond() {
            return this;
        }

        Chain jumpTrue() {
            if (tree == null)
                return code.mergeChains(trueJumps, code.branch(opcode));
            int startpc = code.curPc();
            Chain c = code.mergeChains(trueJumps, code.branch(opcode));
            code.crt.put(tree, CRTable.CRT_BRANCH_TRUE, startpc, code.curPc());
            return c;
        }

        Chain jumpFalse() {
            if (tree == null)
                return code.mergeChains(falseJumps, code.branch(code.negate(opcode)));
            int startpc = code.curPc();
            Chain c = code.mergeChains(falseJumps, code.branch(code.negate(opcode)));
            code.crt.put(tree, CRTable.CRT_BRANCH_FALSE, startpc, code.curPc());
            return c;
        }

        CondItem negate() {
            CondItem c = new CondItem(code.negate(opcode), falseJumps, trueJumps);
            c.tree = tree;
            return c;
        }

        int width() {
            return -code.stackdiff[opcode];
        }

        boolean isTrue() {
            return falseJumps == null && opcode == goto_;
        }

        boolean isFalse() {
            return trueJumps == null && opcode == dontgoto;
        }

        public String toString() {
            return "cond(" + Code.mnem(opcode) + ")";
        }
    }
}