class SyncFailedException;
class UTFDataFormatException;
class UnsupportedEncodingException;
+ class VMObjectInputStream;
class VMObjectStreamClass;
class WriteAbortedException;
class Writer;
class ClassCircularityError;
class ClassFormatError;
class ClassLoader;
+ class ClassLoader$AnnotationsKey;
class ClassNotFoundException;
class CloneNotSupportedException;
class Cloneable;
class Comparable;
class Compiler;
- class ConcreteProcess;
- class ConcreteProcess$EOFInputStream;
- class ConcreteProcess$ProcessManager;
+ class Deprecated;
class Double;
+ class EcosProcess;
class Enum;
class EnumConstantNotPresentException;
class Error;
class NumberFormatException;
class Object;
class OutOfMemoryError;
+ class Override;
class Package;
+ class PosixProcess;
+ class PosixProcess$EOFInputStream;
+ class PosixProcess$ProcessManager;
class Process;
+ class ProcessBuilder;
class Readable;
class Runnable;
class Runtime;
class RuntimeException;
class RuntimePermission;
- class SecurityContext;
class SecurityException;
class SecurityManager;
+ class SecurityManager$1;
class Short;
class StackOverflowError;
class StackTraceElement;
class StringBuffer;
class StringBuilder;
class StringIndexOutOfBoundsException;
+ class SuppressWarnings;
class System;
+ class System$EnvironmentCollection;
+ class System$EnvironmentMap;
+ class System$EnvironmentSet;
class Thread;
+ class Thread$State;
class Thread$UncaughtExceptionHandler;
class ThreadDeath;
class ThreadGroup;
class VMCompiler;
class VMDouble;
class VMFloat;
- class VMSecurityManager;
class VMThrowable;
class VerifyError;
class VirtualMachineError;
class Void;
+ class Win32Process;
namespace annotation
{
class Annotation;
class AnnotationFormatError;
class AnnotationTypeMismatchException;
+ class Documented;
+ class ElementType;
+ class IncompleteAnnotationException;
+ class Inherited;
+ class Retention;
+ class RetentionPolicy;
+ class Target;
}
namespace instrument
class UnmodifiableClassException;
}
+ namespace management
+ {
+ class ClassLoadingMXBean;
+ class CompilationMXBean;
+ class GarbageCollectorMXBean;
+ class ManagementFactory;
+ class ManagementPermission;
+ class MemoryMXBean;
+ class MemoryManagerMXBean;
+ class MemoryNotificationInfo;
+ class MemoryPoolMXBean;
+ class MemoryType;
+ class MemoryUsage;
+ class OperatingSystemMXBean;
+ class RuntimeMXBean;
+ class ThreadInfo;
+ class ThreadMXBean;
+ class VMManagementFactory;
+ }
+
namespace ref
{
class PhantomReference;
class AbstractList;
class AbstractList$1;
class AbstractList$2;
+ class AbstractList$3;
class AbstractList$RandomAccessSubList;
class AbstractList$SubList;
- class AbstractList$SubList$3;
class AbstractMap;
class AbstractMap$1;
- class AbstractMap$1$2;
+ class AbstractMap$2;
class AbstractMap$3;
- class AbstractMap$3$4;
- class AbstractMap$BasicMapEntry;
+ class AbstractMap$4;
+ class AbstractMap$SimpleEntry;
+ class AbstractMap$SimpleImmutableEntry;
+ class AbstractQueue;
class AbstractSequentialList;
class AbstractSet;
+ class ArrayDeque;
+ class ArrayDeque$DeqIterator;
+ class ArrayDeque$DescendingIterator;
class ArrayList;
class Arrays;
class Arrays$ArrayList;
class Collection;
class Collections;
class Collections$1;
+ class Collections$1$SynchronizedMapEntry;
+ class Collections$2;
+ class Collections$3;
+ class Collections$4;
+ class Collections$5;
+ class Collections$6;
+ class Collections$7;
+ class Collections$8;
+ class Collections$9;
+ class Collections$CheckedCollection;
+ class Collections$CheckedIterator;
+ class Collections$CheckedList;
+ class Collections$CheckedListIterator;
+ class Collections$CheckedMap;
+ class Collections$CheckedMap$CheckedEntrySet;
+ class Collections$CheckedRandomAccessList;
+ class Collections$CheckedSet;
+ class Collections$CheckedSortedMap;
+ class Collections$CheckedSortedSet;
class Collections$CopiesList;
class Collections$EmptyList;
class Collections$EmptyMap;
class Collections$ReverseComparator;
class Collections$SingletonList;
class Collections$SingletonMap;
- class Collections$SingletonMap$3;
class Collections$SingletonSet;
- class Collections$SingletonSet$2;
class Collections$SynchronizedCollection;
class Collections$SynchronizedIterator;
class Collections$SynchronizedList;
class Collections$SynchronizedListIterator;
class Collections$SynchronizedMap;
- class Collections$SynchronizedMap$4$SynchronizedMapEntry;
- class Collections$SynchronizedMap$5;
- class Collections$SynchronizedMap$5$6;
class Collections$SynchronizedRandomAccessList;
class Collections$SynchronizedSet;
class Collections$SynchronizedSortedMap;
class Collections$UnmodifiableListIterator;
class Collections$UnmodifiableMap;
class Collections$UnmodifiableMap$UnmodifiableEntrySet;
- class Collections$UnmodifiableMap$UnmodifiableEntrySet$7;
- class Collections$UnmodifiableMap$UnmodifiableEntrySet$7$8;
+ class Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableMapEntry;
class Collections$UnmodifiableRandomAccessList;
class Collections$UnmodifiableSet;
class Collections$UnmodifiableSortedMap;
class ConcurrentModificationException;
class Currency;
class Date;
+ class Deque;
class Dictionary;
+ class DuplicateFormatFlagsException;
class EmptyStackException;
+ class EnumMap;
+ class EnumMap$1;
+ class EnumMap$2;
+ class EnumMap$3;
+ class EnumMap$4;
+ class EnumMap$5;
+ class EnumMap$6;
+ class EnumMap$7;
+ class EnumSet;
+ class EnumSet$1;
class Enumeration;
class EventListener;
class EventListenerProxy;
class EventObject;
+ class FormatFlagsConversionMismatchException;
+ class Formattable;
+ class FormattableFlags;
+ class Formatter;
+ class Formatter$BigDecimalLayoutForm;
+ class FormatterClosedException;
class GregorianCalendar;
class HashMap;
class HashMap$1;
class IdentityHashMap$3;
class IdentityHashMap$IdentityEntry;
class IdentityHashMap$IdentityIterator;
+ class IllegalFormatCodePointException;
+ class IllegalFormatConversionException;
+ class IllegalFormatException;
+ class IllegalFormatFlagsException;
+ class IllegalFormatPrecisionException;
+ class IllegalFormatWidthException;
+ class InputMismatchException;
class InvalidPropertiesFormatException;
class Iterator;
class LinkedHashMap;
class Locale;
class Map;
class Map$Entry;
+ class MissingFormatArgumentException;
+ class MissingFormatWidthException;
class MissingResourceException;
+ class NavigableMap;
+ class NavigableSet;
class NoSuchElementException;
class Observable;
class Observer;
+ class PriorityQueue;
+ class PriorityQueue$1;
class Properties;
class PropertyPermission;
class PropertyPermissionCollection;
class PropertyResourceBundle;
+ class Queue;
class Random;
class RandomAccess;
class ResourceBundle;
+ class ResourceBundle$1;
class ResourceBundle$BundleKey;
class Set;
class SimpleTimeZone;
class TreeMap$1;
class TreeMap$2;
class TreeMap$3;
+ class TreeMap$4;
+ class TreeMap$5;
+ class TreeMap$6;
class TreeMap$Node;
class TreeMap$SubMap;
- class TreeMap$SubMap$4;
- class TreeMap$SubMap$5;
- class TreeMap$SubMap$6;
class TreeMap$TreeIterator;
class TreeSet;
+ class UUID;
+ class UnknownFormatConversionException;
+ class UnknownFormatFlagsException;
class VMTimeZone;
class Vector;
class Vector$1;
class WeakHashMap;
class WeakHashMap$1;
+ class WeakHashMap$2;
class WeakHashMap$WeakBucket;
class WeakHashMap$WeakBucket$WeakEntry;
class WeakHashMap$WeakEntrySet;
- class WeakHashMap$WeakEntrySet$2;
+ namespace concurrent
+ {
+ class AbstractExecutorService;
+ class ArrayBlockingQueue;
+ class ArrayBlockingQueue$Itr;
+ class BlockingDeque;
+ class BlockingQueue;
+ class BrokenBarrierException;
+ class Callable;
+ class CancellationException;
+ class CompletionService;
+ class ConcurrentHashMap;
+ class ConcurrentHashMap$EntryIterator;
+ class ConcurrentHashMap$EntrySet;
+ class ConcurrentHashMap$HashEntry;
+ class ConcurrentHashMap$HashIterator;
+ class ConcurrentHashMap$KeyIterator;
+ class ConcurrentHashMap$KeySet;
+ class ConcurrentHashMap$Segment;
+ class ConcurrentHashMap$ValueIterator;
+ class ConcurrentHashMap$Values;
+ class ConcurrentHashMap$WriteThroughEntry;
+ class ConcurrentLinkedQueue;
+ class ConcurrentLinkedQueue$Itr;
+ class ConcurrentLinkedQueue$Node;
+ class ConcurrentMap;
+ class ConcurrentNavigableMap;
+ class ConcurrentSkipListMap;
+ class ConcurrentSkipListMap$ComparableUsingComparator;
+ class ConcurrentSkipListMap$EntryIterator;
+ class ConcurrentSkipListMap$EntrySet;
+ class ConcurrentSkipListMap$HeadIndex;
+ class ConcurrentSkipListMap$Index;
+ class ConcurrentSkipListMap$Iter;
+ class ConcurrentSkipListMap$KeyIterator;
+ class ConcurrentSkipListMap$KeySet;
+ class ConcurrentSkipListMap$Node;
+ class ConcurrentSkipListMap$SubMap;
+ class ConcurrentSkipListMap$SubMap$SubMapEntryIterator;
+ class ConcurrentSkipListMap$SubMap$SubMapIter;
+ class ConcurrentSkipListMap$SubMap$SubMapKeyIterator;
+ class ConcurrentSkipListMap$SubMap$SubMapValueIterator;
+ class ConcurrentSkipListMap$ValueIterator;
+ class ConcurrentSkipListMap$Values;
+ class ConcurrentSkipListSet;
+ class CopyOnWriteArrayList;
+ class CopyOnWriteArraySet;
+ class CountDownLatch;
+ class CountDownLatch$Sync;
+ class CyclicBarrier;
+ class CyclicBarrier$Generation;
+ class DelayQueue;
+ class DelayQueue$Itr;
+ class Delayed;
+ class Exchanger;
+ class Exchanger$Node;
+ class Exchanger$Slot;
+ class ExecutionException;
+ class Executor;
+ class ExecutorCompletionService;
+ class ExecutorCompletionService$QueueingFuture;
+ class ExecutorService;
+ class Executors;
+ class Executors$1;
+ class Executors$2;
+ class Executors$3;
+ class Executors$4;
+ class Executors$5;
+ class Executors$6;
+ class Executors$DefaultThreadFactory;
+ class Executors$DelegatedExecutorService;
+ class Executors$DelegatedScheduledExecutorService;
+ class Executors$FinalizableDelegatedExecutorService;
+ class Executors$PrivilegedCallable;
+ class Executors$PrivilegedCallableUsingCurrentClassLoader;
+ class Executors$PrivilegedThreadFactory;
+ class Executors$RunnableAdapter;
+ class Future;
+ class FutureTask;
+ class FutureTask$Sync;
+ class LinkedBlockingDeque;
+ class LinkedBlockingDeque$AbstractItr;
+ class LinkedBlockingDeque$DescendingItr;
+ class LinkedBlockingDeque$Itr;
+ class LinkedBlockingDeque$Node;
+ class LinkedBlockingQueue;
+ class LinkedBlockingQueue$Itr;
+ class LinkedBlockingQueue$Node;
+ class PriorityBlockingQueue;
+ class PriorityBlockingQueue$Itr;
+ class RejectedExecutionException;
+ class RejectedExecutionHandler;
+ class RunnableFuture;
+ class RunnableScheduledFuture;
+ class ScheduledExecutorService;
+ class ScheduledFuture;
+ class ScheduledThreadPoolExecutor;
+ class ScheduledThreadPoolExecutor$1;
+ class ScheduledThreadPoolExecutor$DelayedWorkQueue;
+ class ScheduledThreadPoolExecutor$ScheduledFutureTask;
+ class Semaphore;
+ class Semaphore$FairSync;
+ class Semaphore$NonfairSync;
+ class Semaphore$Sync;
+ class SynchronousQueue;
+ class SynchronousQueue$EmptyIterator;
+ class SynchronousQueue$FifoWaitQueue;
+ class SynchronousQueue$LifoWaitQueue;
+ class SynchronousQueue$TransferQueue;
+ class SynchronousQueue$TransferQueue$QNode;
+ class SynchronousQueue$TransferStack;
+ class SynchronousQueue$TransferStack$SNode;
+ class SynchronousQueue$Transferer;
+ class SynchronousQueue$WaitQueue;
+ class ThreadFactory;
+ class ThreadPoolExecutor;
+ class ThreadPoolExecutor$AbortPolicy;
+ class ThreadPoolExecutor$CallerRunsPolicy;
+ class ThreadPoolExecutor$DiscardOldestPolicy;
+ class ThreadPoolExecutor$DiscardPolicy;
+ class ThreadPoolExecutor$Worker;
+ class TimeUnit;
+ class TimeUnit$1;
+ class TimeUnit$2;
+ class TimeUnit$3;
+ class TimeUnit$4;
+ class TimeUnit$5;
+ class TimeUnit$6;
+ class TimeUnit$7;
+ class TimeoutException;
+ namespace atomic
+ {
+ class AtomicBoolean;
+ class AtomicInteger;
+ class AtomicIntegerArray;
+ class AtomicIntegerFieldUpdater;
+ class AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl;
+ class AtomicLong;
+ class AtomicLongArray;
+ class AtomicLongFieldUpdater;
+ class AtomicLongFieldUpdater$CASUpdater;
+ class AtomicLongFieldUpdater$LockedUpdater;
+ class AtomicMarkableReference;
+ class AtomicMarkableReference$ReferenceBooleanPair;
+ class AtomicReference;
+ class AtomicReferenceArray;
+ class AtomicReferenceFieldUpdater;
+ class AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl;
+ class AtomicStampedReference;
+ class AtomicStampedReference$ReferenceIntegerPair;
+ }
+
+ namespace locks
+ {
+ class AbstractOwnableSynchronizer;
+ class AbstractQueuedLongSynchronizer;
+ class AbstractQueuedLongSynchronizer$ConditionObject;
+ class AbstractQueuedLongSynchronizer$Node;
+ class AbstractQueuedSynchronizer;
+ class AbstractQueuedSynchronizer$ConditionObject;
+ class AbstractQueuedSynchronizer$Node;
+ class Condition;
+ class Lock;
+ class LockSupport;
+ class ReadWriteLock;
+ class ReentrantLock;
+ class ReentrantLock$FairSync;
+ class ReentrantLock$NonfairSync;
+ class ReentrantLock$Sync;
+ class ReentrantReadWriteLock;
+ class ReentrantReadWriteLock$FairSync;
+ class ReentrantReadWriteLock$NonfairSync;
+ class ReentrantReadWriteLock$ReadLock;
+ class ReentrantReadWriteLock$Sync;
+ class ReentrantReadWriteLock$Sync$HoldCounter;
+ class ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter;
+ class ReentrantReadWriteLock$WriteLock;
+ }
+ }
+
namespace jar
{
class Attributes;
class Handler;
class Level;
class LogManager;
+ class LogManager$1;
class LogRecord;
class Logger;
class Logger$1;
+ class LoggingMXBean;
class LoggingPermission;
class MemoryHandler;
class SimpleFormatter;
extern "C" jsize _Jv_GetStringUTFLength (jstring);
extern "C" jsize _Jv_GetStringUTFRegion (jstring, jsize, jsize, char *);
extern "C" jint _Jv_hashUtf8String (const char*, int);
+extern bool _Jv_is_proxy (void *pc);
struct _Jv_VMOption
{
OSDN Git Service
