Java InternalException类代码示例

import com.sun.jdi.InternalException; //导入依赖的package包/类
@Override
public boolean isInstanceOf(String className) {
    List<ReferenceType> classTypes;
    try {
        classTypes = VirtualMachineWrapper.classesByName(MirrorWrapper.virtualMachine(classType), className);
    } catch (InternalExceptionWrapper | VMDisconnectedExceptionWrapper ex) {
        return false;
    }
    for (ReferenceType rt : classTypes) {
        try {
            if (EvaluatorVisitor.instanceOf(classType, rt)) {
                return true;
            }
        } catch (VMDisconnectedException vmdex) {
            return false;
        } catch (InternalException iex) {
            // procceed
        }
    }
    return false;
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
void writeLocation(Location location) {
    ReferenceTypeImpl refType = (ReferenceTypeImpl)location.declaringType();
    byte tag;
    if (refType instanceof ClassType) {
        tag = JDWP.TypeTag.CLASS;
    } else if (refType instanceof InterfaceType) {
        // It's possible to have executable code in an interface
        tag = JDWP.TypeTag.INTERFACE;
    } else {
        throw new InternalException("Invalid Location");
    }
    writeByte(tag);
    writeClassRef(refType.ref());
    writeMethodRef(((MethodImpl)location.method()).ref());
    writeLong(location.codeIndex());
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
public void resume() {
    switch (suspendPolicy()) {
        case EventRequest.SUSPEND_ALL:
            vm.resume();
            break;
        case EventRequest.SUSPEND_EVENT_THREAD:
            ThreadReference thread = eventThread();
            if (thread == null) {
                throw new InternalException("Inconsistent suspend policy");
            }
            thread.resume();
            break;
        case EventRequest.SUSPEND_NONE:
            // Do nothing
            break;
        default:
            throw new InternalException("Invalid suspend policy");
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
ValueImpl convertForAssignmentTo(ValueContainer destination)
    throws InvalidTypeException
{
    /*
     * TO DO: Centralize JNI signature knowledge
     */
    if (destination.signature().length() > 1) {
        throw new InvalidTypeException("Can't assign primitive value to object");
    }

    if ((destination.signature().charAt(0) == 'Z') &&
        (type().signature().charAt(0) != 'Z')) {
        throw new InvalidTypeException("Can't assign non-boolean value to a boolean");
    }

    if ((destination.signature().charAt(0) != 'Z') &&
        (type().signature().charAt(0) == 'Z')) {
        throw new InvalidTypeException("Can't assign boolean value to an non-boolean");
    }

    if ("void".equals(destination.typeName())) {
        throw new InvalidTypeException("Can't assign primitive value to a void");
    }

    try {
        PrimitiveTypeImpl primitiveType = (PrimitiveTypeImpl)destination.type();
        return (ValueImpl)(primitiveType.convert(this));
    } catch (ClassNotLoadedException e) {
        throw new InternalException("Signature and type inconsistent for: " +
                                    destination.typeName());
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
synchronized void removeObjectMirror(ObjectReferenceImpl object) {
    // Handle any queue elements that are not strongly reachable
    processQueue();

    SoftObjectReference ref = objectsByID.remove(object.ref());
    if (ref != null) {
        batchForDispose(ref);
    } else {
        /*
         * If there's a live ObjectReference about, it better be part
         * of the cache.
         */
        throw new InternalException("ObjectReference " + object.ref() +
                                    " not found in object cache");
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
public Object clone() {
    try {
        return super.clone();
    } catch (CloneNotSupportedException e) {
        // Object should always support clone
        throw new InternalException();
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
public String getEventText(Pair<Breakpoint, Event> descriptor) {
  String text = "";
  final Event event = descriptor.getSecond();
  final Breakpoint breakpoint = descriptor.getFirst();
  if (event instanceof LocatableEvent) {
    if (breakpoint instanceof LineBreakpoint && !((LineBreakpoint)breakpoint).isVisible()) {
      text = DebuggerBundle.message("status.stopped.at.cursor");
    }
    else {
      try {
        text = breakpoint != null? breakpoint.getEventMessage(((LocatableEvent)event)) : DebuggerBundle.message("status.generic.breakpoint.reached");
      }
      catch (InternalException e) {
        text = DebuggerBundle.message("status.generic.breakpoint.reached");
      }
    }
  }
  else if (event instanceof VMStartEvent) {
    text = DebuggerBundle.message("status.process.started");
  }
  else if (event instanceof VMDeathEvent) {
    text = DebuggerBundle.message("status.process.terminated");
  }
  else if (event instanceof VMDisconnectEvent) {
    final RemoteConnection connection = getConnection();
    final String addressDisplayName = DebuggerBundle.getAddressDisplayName(connection);
    final String transportName = DebuggerBundle.getTransportName(connection);
    text = DebuggerBundle.message("status.disconnected", addressDisplayName, transportName);
  }
  return text;
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
public Object clone() {
    try {
        return super.clone();
    } catch (CloneNotSupportedException e) {
        // Object should always support clone
        throw (InternalException) new InternalException().initCause(e);
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
public boolean threadResumable(ThreadAction action) {
    synchronized (vm.state()) {
        if (isValid) {
            isValid = false;
            return false;   /* remove this stack frame as a listener */
        } else {
            throw new InternalException(
                              "Invalid stack frame thread listener");
        }
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
public boolean isArgument() {
    try {
        MethodImpl method = (MethodImpl)scopeStart.method();
        return (slot < method.argSlotCount());
    } catch (AbsentInformationException e) {
        // If this variable object exists, there shouldn't be absent info
        throw new InternalException();
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
void waitForReply() throws JDWPException {
    if (!isCommitted) {
        throw new InternalException("waitForReply without send");
    }

    vm.waitForTargetReply(pkt);

    if (pkt.errorCode != Packet.ReplyNoError) {
        throw new JDWPException(pkt.errorCode);
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
void writeString(String string) {
    try {
        byte[] stringBytes = string.getBytes("UTF8");
        writeInt(stringBytes.length);
        writeByteArray(stringBytes);
    } catch (java.io.UnsupportedEncodingException e) {
        throw new InternalException("Cannot convert string to UTF8 bytes");
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
RuntimeException toJDIException() {
    switch (errorCode) {
        case JDWP.Error.INVALID_OBJECT:
            return new ObjectCollectedException();
        case JDWP.Error.INVALID_MODULE:
            return new InvalidModuleException();
        case JDWP.Error.VM_DEAD:
            return new VMDisconnectedException();
        case JDWP.Error.OUT_OF_MEMORY:
            return new VMOutOfMemoryException();
        case JDWP.Error.CLASS_NOT_PREPARED:
            return new ClassNotPreparedException();
        case JDWP.Error.INVALID_FRAMEID:
        case JDWP.Error.NOT_CURRENT_FRAME:
            return new InvalidStackFrameException();
        case JDWP.Error.NOT_IMPLEMENTED:
            return new UnsupportedOperationException();
        case JDWP.Error.INVALID_INDEX:
        case JDWP.Error.INVALID_LENGTH:
            return new IndexOutOfBoundsException();
        case JDWP.Error.TYPE_MISMATCH:
            return new InconsistentDebugInfoException();
        case JDWP.Error.INVALID_THREAD:
            return new IllegalThreadStateException();
        default:
            return new InternalException("Unexpected JDWP Error: " + errorCode, errorCode);
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
/**
 * Constructor for special events like VM disconnected
 */
EventSetImpl(VirtualMachine aVm, byte eventCmd) {
    this(aVm, null);
    suspendPolicy = JDWP.SuspendPolicy.NONE;
    switch (eventCmd) {
        case JDWP.EventKind.VM_DISCONNECTED:
            addEvent(new VMDisconnectEventImpl());
            break;

        default:
            throw new InternalException("Bad singleton event code");
    }
}
 

import com.sun.jdi.InternalException; //导入依赖的package包/类
/**
 * Private version of frames() allows "-1" to specify all
 * remaining frames.
 */
synchronized private List<StackFrame> privateFrames(int start, int length)
                          throws IncompatibleThreadStateException  {

    // Lock must be held while creating stack frames so if that two threads
    // do this at the same time, one won't clobber the subset created by the other.
    LocalCache snapshot = localCache;
    try {
        if (snapshot.frames == null || !isSubrange(snapshot, start, length)) {
            JDWP.ThreadReference.Frames.Frame[] jdwpFrames
                = JDWP.ThreadReference.Frames.
                process(vm, this, start, length).frames;
            int count = jdwpFrames.length;
            snapshot.frames = new ArrayList<>(count);

            for (int i = 0; i<count; i++) {
                if (jdwpFrames[i].location == null) {
                    throw new InternalException("Invalid frame location");
                }
                StackFrame frame = new StackFrameImpl(vm, this,
                                                      jdwpFrames[i].frameID,
                                                      jdwpFrames[i].location);
                // Add to the frame list
                snapshot.frames.add(frame);
            }
            snapshot.framesStart = start;
            snapshot.framesLength = length;
            return Collections.unmodifiableList(snapshot.frames);
        } else {
            int fromIndex = start - snapshot.framesStart;
            int toIndex;
            if (length == -1) {
                toIndex = snapshot.frames.size() - fromIndex;
            } else {
                toIndex = fromIndex + length;
            }
            return Collections.unmodifiableList(snapshot.frames.subList(fromIndex, toIndex));
        }
    } catch (JDWPException exc) {
        switch (exc.errorCode()) {
        case JDWP.Error.THREAD_NOT_SUSPENDED:
        case JDWP.Error.INVALID_THREAD:   /* zombie */
            throw new IncompatibleThreadStateException();
        default:
            throw exc.toJDIException();
        }
    }
}