// javaprims.h - Main external header file for libgcj. -*- c++ -*-
-/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
+
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Free Software Foundation
This file is part of libgcj.
#ifndef __JAVAPRIMS_H__
#define __JAVAPRIMS_H__
+// Force C++ compiler to use Java-style exceptions.
+#pragma GCC java_exceptions
+
+#include <gcj/libgcj-config.h>
+
// FIXME: this is a hack until we get a proper gcjh.
// It is needed to work around system header files that define TRUE
// and FALSE.
{
namespace io
{
- class BlockDataException;
class BufferedInputStream;
class BufferedOutputStream;
class BufferedReader;
class CharArrayReader;
class CharArrayWriter;
class CharConversionException;
+ class Closeable;
class DataInput;
class DataInputStream;
class DataOutput;
class DataOutputStream;
+ class DeleteFileHelper;
+ class DeleteFileHelper$1;
class EOFException;
class Externalizable;
class File;
class FileDescriptor;
+ class FileFilter;
class FileInputStream;
class FileNotFoundException;
class FileOutputStream;
+ class FilePermission;
class FileReader;
class FileWriter;
class FilenameFilter;
class FilterOutputStream;
class FilterReader;
class FilterWriter;
+ class Flushable;
class IOException;
class InputStream;
class InputStreamReader;
- class InterfaceComparator;
class InterruptedIOException;
class InvalidClassException;
class InvalidObjectException;
class LineNumberInputStream;
class LineNumberReader;
- class MemberComparator;
class NotActiveException;
class NotSerializableException;
class ObjectInput;
class ObjectInputStream;
+ class ObjectInputStream$1;
+ class ObjectInputStream$2;
class ObjectInputStream$GetField;
+ class ObjectInputStream$ValidatorAndPriority;
class ObjectInputValidation;
class ObjectOutput;
class ObjectOutputStream;
+ class ObjectOutputStream$1;
class ObjectOutputStream$PutField;
class ObjectStreamClass;
+ class ObjectStreamClass$1;
+ class ObjectStreamClass$2;
+ class ObjectStreamClass$InterfaceComparator;
+ class ObjectStreamClass$MemberComparator;
class ObjectStreamConstants;
class ObjectStreamException;
class ObjectStreamField;
+ class ObjectStreamField$1;
class OptionalDataException;
class OutputStream;
class OutputStreamWriter;
class PushbackReader;
class RandomAccessFile;
class Reader;
- class Replaceable;
- class Resolvable;
class SequenceInputStream;
class Serializable;
class SerializablePermission;
class SyncFailedException;
class UTFDataFormatException;
class UnsupportedEncodingException;
- class ValidatorAndPriority;
+ class VMObjectInputStream;
+ class VMObjectStreamClass;
class WriteAbortedException;
class Writer;
- };
+ }
namespace lang
{
class AbstractMethodError;
+ class Appendable;
class ArithmeticException;
class ArrayIndexOutOfBoundsException;
class ArrayStoreException;
+ class AssertionError;
class Boolean;
class Byte;
- class CPlusPlusDemangler;
+ class CharSequence;
class Character;
+ class Character$Subset;
+ class Character$UnicodeBlock;
class Class;
class ClassCastException;
class ClassCircularityError;
class ClassFormatError;
class ClassLoader;
+ class ClassLoader$AnnotationsKey;
class ClassNotFoundException;
class CloneNotSupportedException;
class Cloneable;
class Comparable;
class Compiler;
- class ConcreteProcess;
+ class Deprecated;
class Double;
+ class EcosProcess;
+ class Enum;
+ class EnumConstantNotPresentException;
class Error;
class Exception;
class ExceptionInInitializerError;
class IllegalThreadStateException;
class IncompatibleClassChangeError;
class IndexOutOfBoundsException;
+ class InheritableThreadLocal;
class InstantiationError;
class InstantiationException;
class Integer;
class InternalError;
class InterruptedException;
+ class Iterable;
class LinkageError;
class Long;
class Math;
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 SecurityException;
class SecurityManager;
+ class SecurityManager$1;
class Short;
class StackOverflowError;
+ class StackTraceElement;
+ class StrictMath;
class String;
+ class String$CaseInsensitiveComparator;
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 ThreadLocal;
class Throwable;
+ class Throwable$StaticData;
+ class TypeNotPresentException;
class UnknownError;
class UnsatisfiedLinkError;
+ class UnsupportedClassVersionError;
class UnsupportedOperationException;
+ class VMClassLoader;
+ class VMCompiler;
+ class VMDouble;
+ class VMFloat;
+ 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 ClassDefinition;
+ class ClassFileTransformer;
+ class IllegalClassFormatException;
+ class Instrumentation;
+ 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 Reference;
+ class ReferenceQueue;
+ class SoftReference;
+ class WeakReference;
+ }
+
namespace reflect
{
class AccessibleObject;
+ class AnnotatedElement;
class Array;
class Constructor;
class Field;
+ class GenericArrayType;
+ class GenericDeclaration;
+ class GenericSignatureFormatError;
+ class InvocationHandler;
class InvocationTargetException;
+ class MalformedParameterizedTypeException;
class Member;
class Method;
class Modifier;
- };
- };
+ class ParameterizedType;
+ class Proxy;
+ class Proxy$ClassFactory;
+ class Proxy$ProxyData;
+ class Proxy$ProxySignature;
+ class Proxy$ProxyType;
+ class ReflectPermission;
+ class Type;
+ class TypeVariable;
+ class UndeclaredThrowableException;
+ class VMProxy;
+ class WildcardType;
+ }
+ }
namespace util
{
class AbstractCollection;
class AbstractList;
+ class AbstractList$1;
+ class AbstractList$2;
+ class AbstractList$3;
+ class AbstractList$RandomAccessSubList;
class AbstractList$SubList;
+ class AbstractMap;
+ class AbstractMap$1;
+ class AbstractMap$2;
+ class AbstractMap$3;
+ 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$ListImpl;
+ class Arrays$ArrayList;
class BitSet;
class Calendar;
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$EmptySet;
+ class Collections$ReverseComparator;
+ class Collections$SingletonList;
+ class Collections$SingletonMap;
+ class Collections$SingletonSet;
+ class Collections$SynchronizedCollection;
+ class Collections$SynchronizedIterator;
+ class Collections$SynchronizedList;
+ class Collections$SynchronizedListIterator;
+ class Collections$SynchronizedMap;
+ class Collections$SynchronizedRandomAccessList;
+ class Collections$SynchronizedSet;
+ class Collections$SynchronizedSortedMap;
+ class Collections$SynchronizedSortedSet;
+ class Collections$UnmodifiableCollection;
+ class Collections$UnmodifiableIterator;
+ class Collections$UnmodifiableList;
+ class Collections$UnmodifiableListIterator;
+ class Collections$UnmodifiableMap;
+ class Collections$UnmodifiableMap$UnmodifiableEntrySet;
+ class Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableMapEntry;
+ class Collections$UnmodifiableRandomAccessList;
+ class Collections$UnmodifiableSet;
+ class Collections$UnmodifiableSortedMap;
+ class Collections$UnmodifiableSortedSet;
class Comparator;
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 HashMap$2;
+ class HashMap$3;
+ class HashMap$HashEntry;
+ class HashMap$HashIterator;
+ class HashSet;
class Hashtable;
- class HashtableEntry;
- class HashtableEnumeration;
+ class Hashtable$1;
+ class Hashtable$2;
+ class Hashtable$3;
+ class Hashtable$EntryEnumerator;
+ class Hashtable$EntryIterator;
+ class Hashtable$HashEntry;
+ class Hashtable$KeyEnumerator;
+ class Hashtable$KeyIterator;
+ class Hashtable$ValueEnumerator;
+ class Hashtable$ValueIterator;
+ class IdentityHashMap;
+ class IdentityHashMap$1;
+ class IdentityHashMap$2;
+ 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 LinkedHashMap$1;
+ class LinkedHashMap$LinkedHashEntry;
+ class LinkedHashSet;
+ class LinkedList;
+ class LinkedList$Entry;
+ class LinkedList$LinkedListItr;
class List;
class ListIterator;
class ListResourceBundle;
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 SortedMap;
+ class SortedSet;
class Stack;
class StringTokenizer;
class TimeZone;
+ class TimeZone$1;
+ class Timer;
+ class Timer$Scheduler;
+ class Timer$TaskQueue;
+ class TimerTask;
class TooManyListenersException;
+ class TreeMap;
+ 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$TreeIterator;
+ class TreeSet;
+ class UUID;
+ class UnknownFormatConversionException;
+ class UnknownFormatFlagsException;
+ class VMTimeZone;
class Vector;
- class VectorEnumeration;
+ class Vector$1;
+ class WeakHashMap;
+ class WeakHashMap$1;
+ class WeakHashMap$2;
+ class WeakHashMap$WeakBucket;
+ class WeakHashMap$WeakBucket$WeakEntry;
+ class WeakHashMap$WeakEntrySet;
+ 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 Attributes$Name;
class JarEntry;
+ class JarException;
class JarFile;
+ class JarFile$EntryInputStream;
+ class JarFile$JarEnumeration;
class JarInputStream;
- };
+ class JarOutputStream;
+ class Manifest;
+ }
+
+ namespace logging
+ {
+ class ConsoleHandler;
+ class ErrorManager;
+ class FileHandler;
+ class FileHandler$ostr;
+ class Filter;
+ class Formatter;
+ class Handler;
+ class Level;
+ class LogManager;
+ class LogManager$1;
+ class LogRecord;
+ class Logger;
+ class Logger$1;
+ class LoggingMXBean;
+ class LoggingPermission;
+ class MemoryHandler;
+ class SimpleFormatter;
+ class SocketHandler;
+ class StreamHandler;
+ class XMLFormatter;
+ }
+
+ namespace prefs
+ {
+ class AbstractPreferences;
+ class AbstractPreferences$1;
+ class AbstractPreferences$2;
+ class BackingStoreException;
+ class InvalidPreferencesFormatException;
+ class NodeChangeEvent;
+ class NodeChangeListener;
+ class PreferenceChangeEvent;
+ class PreferenceChangeListener;
+ class Preferences;
+ class Preferences$1;
+ class PreferencesFactory;
+ }
+
+ namespace regex
+ {
+ class MatchResult;
+ class Matcher;
+ class Pattern;
+ class PatternSyntaxException;
+ }
namespace zip
{
class InflaterInputStream;
class ZipConstants;
class ZipEntry;
- class ZipEnumeration;
class ZipException;
class ZipFile;
+ class ZipFile$1;
+ class ZipFile$PartialInputStream;
+ class ZipFile$ZipEntryEnumeration;
class ZipInputStream;
class ZipOutputStream;
- };
- };
- };
-};
-
+ }
+ }
+ }
+}
+
typedef struct java::lang::Object* jobject;
typedef class java::lang::Class* jclass;
typedef class java::lang::Throwable* jthrowable;
typedef struct _Jv_Field *jfieldID;
typedef struct _Jv_Method *jmethodID;
-extern "C" jobject _Jv_AllocObject (jclass, jint) __attribute__((__malloc__));
+extern "C" jobject _Jv_AllocObject (jclass) __attribute__((__malloc__));
+extern "C" jobject _Jv_AllocObjectNoFinalizer (jclass) __attribute__((__malloc__));
+extern "C" jobject _Jv_AllocObjectNoInitNoFinalizer (jclass) __attribute__((__malloc__));
+#ifdef JV_HASH_SYNCHRONIZATION
+ extern "C" jobject _Jv_AllocPtrFreeObject (jclass)
+ __attribute__((__malloc__));
+#else
+ // Collector still needs to scan sync_info
+ static inline jobject _Jv_AllocPtrFreeObject (jclass klass)
+ {
+ return _Jv_AllocObject(klass);
+ }
+#endif
extern "C" jboolean _Jv_IsInstanceOf(jobject, jclass);
extern "C" jstring _Jv_AllocString(jsize) __attribute__((__malloc__));
extern "C" jstring _Jv_NewString (const jchar*, jsize)
__attribute__((__malloc__));
+extern jint _Jv_FormatInt (jchar* bufend, jint num);
extern "C" jchar* _Jv_GetStringChars (jstring str);
-extern "C" jint _Jv_MonitorEnter (jobject);
-extern "C" jint _Jv_MonitorExit (jobject);
+extern "C" void _Jv_MonitorEnter (jobject);
+extern "C" void _Jv_MonitorExit (jobject);
+extern "C" jstring _Jv_NewStringUTF (const char *bytes)
+ __attribute__((__malloc__));
extern "C" jstring _Jv_NewStringLatin1(const char*, jsize)
__attribute__((__malloc__));
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
+{
+ // a VM initialization option
+ char* optionString;
+ // extra information associated with this option
+ void* extraInfo;
+};
+
+struct _Jv_VMInitArgs
+{
+ // for compatibility with JavaVMInitArgs
+ jint version;
+
+ // number of VM initialization options
+ jint nOptions;
+
+ // an array of VM initialization options
+ struct _Jv_VMOption* options;
+
+ // true if the option parser should ignore unrecognized options
+ jboolean ignoreUnrecognized;
+};
-extern "C" void _Jv_Throw (void *) __attribute__ ((__noreturn__));
-extern "C" void _Jv_Sjlj_Throw (void *) __attribute__ ((__noreturn__));
+extern jint _Jv_CreateJavaVM (struct _Jv_VMInitArgs*);
+
+void
+_Jv_ThreadRun (java::lang::Thread* thread);
+jint
+_Jv_AttachCurrentThread(java::lang::Thread* thread);
+extern "C" java::lang::Thread*
+_Jv_AttachCurrentThread(jstring name, java::lang::ThreadGroup* group);
+extern "C" java::lang::Thread*
+_Jv_AttachCurrentThreadAsDaemon(jstring name, java::lang::ThreadGroup* group);
+extern "C" jint _Jv_DetachCurrentThread (void);
+
+extern "C" void _Jv_Throw (jthrowable) __attribute__ ((__noreturn__));
extern "C" void* _Jv_Malloc (jsize) __attribute__((__malloc__));
extern "C" void* _Jv_Realloc (void *, jsize);
extern "C" void _Jv_Free (void*);
+extern void (*_Jv_RegisterClassHook) (jclass cl);
+extern "C" void _Jv_RegisterClassHookDefault (jclass);
typedef unsigned short _Jv_ushort __attribute__((__mode__(__HI__)));
typedef unsigned int _Jv_uint __attribute__((__mode__(__SI__)));
+typedef unsigned int _Jv_ulong __attribute__((__mode__(__DI__)));
-struct _Jv_Utf8Const
+// The type to use when treating a pointer as an integer. Similar to
+// uintptr_t in C99.
+typedef unsigned int _Jv_uintptr_t __attribute__((__mode__(__pointer__)));
+
+class _Jv_Utf8Const
{
_Jv_ushort hash;
_Jv_ushort length; /* In bytes, of data portion, without final '\0'. */
char data[1]; /* In Utf8 format, with final '\0'. */
+ public:
+ /** Return same value of java.lang.String's hashCode. */
+ jint hash32() { return _Jv_hashUtf8String(data, length); }
+ /** Return a hash code that has at least 16 bits of information. */
+ _Jv_ushort hash16 () { return hash; }
+ /** Return a hash code that has at least 8 bits of information. */
+ _Jv_ushort hash8 () { return hash; }
+ /** Length in bytes of the UTF8-encoding. */
+ _Jv_ushort len () const { return length; }
+ /** Pointer to the first byte in the NUL-terminated UTF8-encoding. */
+ char* chars() { return data; }
+ /** Pointer to the NUL byte that terminated the UTF8-encoding. */
+ char* limit() { return data+length; }
+ /** Return the first byte in the UTF8-encoding. */
+ char first() const { return data[0]; }
+ /** Create a (non-interned) java.lang.String from this UTF8Const. */
+ jstring toString() { return _Jv_NewStringUTF(data); }
+ /** Given an UTF8 string, how many bytes needed for a UTF8Const,
+ including struct header, and final NUL. I.e. what to pas to malloc. */
+ static int space_needed (const char *, int len)
+ { return sizeof (_Jv_Utf8Const) + len + 1; }
+ /** Given an allocated _Jv_Utf8Const, copy / fill it in. */
+ void init (const char *s, int len);
+ friend jboolean _Jv_equalUtf8Consts (const _Jv_Utf8Const*, const _Jv_Utf8Const *);
+ friend jboolean _Jv_equal (_Jv_Utf8Const*, jstring, jint);
+ friend jboolean _Jv_equaln (_Jv_Utf8Const*, jstring, jint);
+ friend jboolean _Jv_equalUtf8Classnames (const _Jv_Utf8Const*,
+ const _Jv_Utf8Const*);
+ friend jboolean _Jv_isPrimitiveOrDerived (const _Jv_Utf8Const*);
+ friend _Jv_Utf8Const *_Jv_makeUtf8Const (const char*, int);
+ friend _Jv_Utf8Const *_Jv_makeUtf8Const (jstring);
+ friend jstring _Jv_NewStringUtf8Const (_Jv_Utf8Const*);
};
+
#endif /* __JAVAPRIMS_H__ */
OSDN Git Service
