libjava/gcj/javaprims.h

   1 // javaprims.h - Main external header file for libgcj.  -*- c++ -*-
   2
   3
   4 /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   5    2008, 2009 Free Software Foundation
   6
   7    This file is part of libgcj.
   8
   9 This software is copyrighted work licensed under the terms of the
  10 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
  11 details.  */
  12
  13 #ifndef __JAVAPRIMS_H__
  14 #define __JAVAPRIMS_H__
  15
  16 // Force C++ compiler to use Java-style exceptions.
  17 #pragma GCC java_exceptions
  18
  19 #include <gcj/libgcj-config.h>
  20
  21 // FIXME: this is a hack until we get a proper gcjh.
  22 // It is needed to work around system header files that define TRUE
  23 // and FALSE.
  24 #undef TRUE
  25 #define TRUE TRUE
  26 #undef FALSE
  27 #define FALSE FALSE
  28
  29 // To force selection of correct types that will mangle consistently
  30 // across platforms.
  31 extern "Java"
  32 {
  33   typedef __java_byte jbyte;
  34   typedef __java_short jshort;
  35   typedef __java_int jint;
  36   typedef __java_long jlong;
  37   typedef __java_float jfloat;
  38   typedef __java_double jdouble;
  39   typedef __java_char jchar;
  40   typedef __java_boolean jboolean;
  41   typedef jint jsize;
  42
  43   // The following class declarations are automatically generated by
  44   // the `classes.pl' script.
  45   namespace java
  46   {
  47     namespace io
  48     {
  49       class BufferedInputStream;
  50       class BufferedOutputStream;
  51       class BufferedReader;
  52       class BufferedWriter;
  53       class ByteArrayInputStream;
  54       class ByteArrayOutputStream;
  55       class CharArrayReader;
  56       class CharArrayWriter;
  57       class CharConversionException;
  58       class Closeable;
  59       class DataInput;
  60       class DataInputStream;
  61       class DataOutput;
  62       class DataOutputStream;
  63       class DeleteFileHelper;
  64       class DeleteFileHelper$1;
  65       class EOFException;
  66       class Externalizable;
  67       class File;
  68       class FileDescriptor;
  69       class FileFilter;
  70       class FileInputStream;
  71       class FileNotFoundException;
  72       class FileOutputStream;
  73       class FilePermission;
  74       class FileReader;
  75       class FileWriter;
  76       class FilenameFilter;
  77       class FilterInputStream;
  78       class FilterOutputStream;
  79       class FilterReader;
  80       class FilterWriter;
  81       class Flushable;
  82       class IOException;
  83       class InputStream;
  84       class InputStreamReader;
  85       class InterruptedIOException;
  86       class InvalidClassException;
  87       class InvalidObjectException;
  88       class LineNumberInputStream;
  89       class LineNumberReader;
  90       class NotActiveException;
  91       class NotSerializableException;
  92       class ObjectInput;
  93       class ObjectInputStream;
  94       class ObjectInputStream$1;
  95       class ObjectInputStream$2;
  96       class ObjectInputStream$GetField;
  97       class ObjectInputStream$ValidatorAndPriority;
  98       class ObjectInputValidation;
  99       class ObjectOutput;
 100       class ObjectOutputStream;
 101       class ObjectOutputStream$1;
 102       class ObjectOutputStream$PutField;
 103       class ObjectStreamClass;
 104       class ObjectStreamClass$1;
 105       class ObjectStreamClass$2;
 106       class ObjectStreamClass$InterfaceComparator;
 107       class ObjectStreamClass$MemberComparator;
 108       class ObjectStreamConstants;
 109       class ObjectStreamException;
 110       class ObjectStreamField;
 111       class ObjectStreamField$1;
 112       class OptionalDataException;
 113       class OutputStream;
 114       class OutputStreamWriter;
 115       class PipedInputStream;
 116       class PipedOutputStream;
 117       class PipedReader;
 118       class PipedWriter;
 119       class PrintStream;
 120       class PrintWriter;
 121       class PushbackInputStream;
 122       class PushbackReader;
 123       class RandomAccessFile;
 124       class Reader;
 125       class SequenceInputStream;
 126       class Serializable;
 127       class SerializablePermission;
 128       class StreamCorruptedException;
 129       class StreamTokenizer;
 130       class StringBufferInputStream;
 131       class StringReader;
 132       class StringWriter;
 133       class SyncFailedException;
 134       class UTFDataFormatException;
 135       class UnsupportedEncodingException;
 136       class VMObjectInputStream;
 137       class VMObjectStreamClass;
 138       class WriteAbortedException;
 139       class Writer;
 140     }
 141
 142     namespace lang
 143     {
 144       class AbstractMethodError;
 145       class AbstractStringBuffer;
 146       class Appendable;
 147       class ArithmeticException;
 148       class ArrayIndexOutOfBoundsException;
 149       class ArrayStoreException;
 150       class AssertionError;
 151       class Boolean;
 152       class Byte;
 153       class CharSequence;
 154       class Character;
 155       class Character$Subset;
 156       class Character$UnicodeBlock;
 157       class Character$UnicodeBlock$NameType;
 158       class Class;
 159       class Class$1;
 160       class ClassCastException;
 161       class ClassCircularityError;
 162       class ClassFormatError;
 163       class ClassLoader;
 164       class ClassLoader$AnnotationsKey;
 165       class ClassNotFoundException;
 166       class CloneNotSupportedException;
 167       class Cloneable;
 168       class Comparable;
 169       class Compiler;
 170       class Deprecated;
 171       class Double;
 172       class EcosProcess;
 173       class Enum;
 174       class EnumConstantNotPresentException;
 175       class Error;
 176       class Exception;
 177       class ExceptionInInitializerError;
 178       class Float;
 179       class IllegalAccessError;
 180       class IllegalAccessException;
 181       class IllegalArgumentException;
 182       class IllegalMonitorStateException;
 183       class IllegalStateException;
 184       class IllegalThreadStateException;
 185       class IncompatibleClassChangeError;
 186       class IndexOutOfBoundsException;
 187       class InheritableThreadLocal;
 188       class InstantiationError;
 189       class InstantiationException;
 190       class Integer;
 191       class InternalError;
 192       class InterruptedException;
 193       class Iterable;
 194       class LinkageError;
 195       class Long;
 196       class Math;
 197       class NegativeArraySizeException;
 198       class NoClassDefFoundError;
 199       class NoSuchFieldError;
 200       class NoSuchFieldException;
 201       class NoSuchMethodError;
 202       class NoSuchMethodException;
 203       class NullPointerException;
 204       class Number;
 205       class NumberFormatException;
 206       class Object;
 207       class OutOfMemoryError;
 208       class Override;
 209       class Package;
 210       class PosixProcess;
 211       class PosixProcess$EOFInputStream;
 212       class PosixProcess$ProcessManager;
 213       class Process;
 214       class ProcessBuilder;
 215       class Readable;
 216       class Runnable;
 217       class Runtime;
 218       class RuntimeException;
 219       class RuntimePermission;
 220       class SecurityException;
 221       class SecurityManager;
 222       class SecurityManager$1;
 223       class Short;
 224       class StackOverflowError;
 225       class StackTraceElement;
 226       class StrictMath;
 227       class String;
 228       class String$CaseInsensitiveComparator;
 229       class StringBuffer;
 230       class StringBuilder;
 231       class StringIndexOutOfBoundsException;
 232       class SuppressWarnings;
 233       class System;
 234       class System$EnvironmentCollection;
 235       class System$EnvironmentMap;
 236       class System$EnvironmentSet;
 237       class Thread;
 238       class Thread$State;
 239       class Thread$UncaughtExceptionHandler;
 240       class ThreadDeath;
 241       class ThreadGroup;
 242       class ThreadLocal;
 243       class ThreadLocalMap;
 244       class ThreadLocalMap$Entry;
 245       class Throwable;
 246       class Throwable$StaticData;
 247       class TypeNotPresentException;
 248       class UnknownError;
 249       class UnsatisfiedLinkError;
 250       class UnsupportedClassVersionError;
 251       class UnsupportedOperationException;
 252       class VMClassLoader;
 253       class VMCompiler;
 254       class VMDouble;
 255       class VMFloat;
 256       class VMProcess;
 257       class VMThrowable;
 258       class VerifyError;
 259       class VirtualMachineError;
 260       class Void;
 261       class Win32Process;
 262       class Win32Process$EOFInputStream;
 263       namespace annotation
 264       {
 265         class Annotation;
 266         class AnnotationFormatError;
 267         class AnnotationTypeMismatchException;
 268         class Documented;
 269         class ElementType;
 270         class IncompleteAnnotationException;
 271         class Inherited;
 272         class Retention;
 273         class RetentionPolicy;
 274         class Target;
 275       }
 276
 277       namespace instrument
 278       {
 279         class ClassDefinition;
 280         class ClassFileTransformer;
 281         class IllegalClassFormatException;
 282         class Instrumentation;
 283         class UnmodifiableClassException;
 284       }
 285
 286       namespace management
 287       {
 288         class ClassLoadingMXBean;
 289         class CompilationMXBean;
 290         class GarbageCollectorMXBean;
 291         class LockInfo;
 292         class ManagementFactory;
 293         class ManagementFactory$ManagementInvocationHandler;
 294         class ManagementPermission;
 295         class MemoryMXBean;
 296         class MemoryManagerMXBean;
 297         class MemoryNotificationInfo;
 298         class MemoryPoolMXBean;
 299         class MemoryType;
 300         class MemoryUsage;
 301         class MonitorInfo;
 302         class OperatingSystemMXBean;
 303         class RuntimeMXBean;
 304         class ThreadInfo;
 305         class ThreadMXBean;
 306         class VMManagementFactory;
 307       }
 308
 309       namespace ref
 310       {
 311         class PhantomReference;
 312         class Reference;
 313         class ReferenceQueue;
 314         class SoftReference;
 315         class WeakReference;
 316       }
 317
 318       namespace reflect
 319       {
 320         class AccessibleObject;
 321         class AnnotatedElement;
 322         class Array;
 323         class Constructor;
 324         class Field;
 325         class GenericArrayType;
 326         class GenericDeclaration;
 327         class GenericSignatureFormatError;
 328         class InvocationHandler;
 329         class InvocationTargetException;
 330         class MalformedParameterizedTypeException;
 331         class Member;
 332         class Method;
 333         class Modifier;
 334         class ParameterizedType;
 335         class Proxy;
 336         class Proxy$ClassFactory;
 337         class Proxy$ProxyData;
 338         class Proxy$ProxySignature;
 339         class Proxy$ProxyType;
 340         class ReflectPermission;
 341         class Type;
 342         class TypeVariable;
 343         class UndeclaredThrowableException;
 344         class VMProxy;
 345         class WildcardType;
 346       }
 347     }
 348
 349     namespace util
 350     {
 351       class AbstractCollection;
 352       class AbstractList;
 353       class AbstractList$1;
 354       class AbstractList$2;
 355       class AbstractList$3;
 356       class AbstractList$RandomAccessSubList;
 357       class AbstractList$SubList;
 358       class AbstractMap;
 359       class AbstractMap$1;
 360       class AbstractMap$2;
 361       class AbstractMap$3;
 362       class AbstractMap$4;
 363       class AbstractMap$SimpleEntry;
 364       class AbstractMap$SimpleImmutableEntry;
 365       class AbstractQueue;
 366       class AbstractSequentialList;
 367       class AbstractSet;
 368       class ArrayDeque;
 369       class ArrayDeque$DeqIterator;
 370       class ArrayDeque$DescendingIterator;
 371       class ArrayList;
 372       class Arrays;
 373       class Arrays$ArrayList;
 374       class BitSet;
 375       class Calendar;
 376       class Collection;
 377       class Collections;
 378       class Collections$1;
 379       class Collections$1$SynchronizedMapEntry;
 380       class Collections$2;
 381       class Collections$3;
 382       class Collections$4;
 383       class Collections$5;
 384       class Collections$6;
 385       class Collections$7;
 386       class Collections$8;
 387       class Collections$9;
 388       class Collections$CheckedCollection;
 389       class Collections$CheckedIterator;
 390       class Collections$CheckedList;
 391       class Collections$CheckedListIterator;
 392       class Collections$CheckedMap;
 393       class Collections$CheckedMap$CheckedEntrySet;
 394       class Collections$CheckedRandomAccessList;
 395       class Collections$CheckedSet;
 396       class Collections$CheckedSortedMap;
 397       class Collections$CheckedSortedSet;
 398       class Collections$CopiesList;
 399       class Collections$EmptyList;
 400       class Collections$EmptyMap;
 401       class Collections$EmptySet;
 402       class Collections$LIFOQueue;
 403       class Collections$MapSet;
 404       class Collections$ReverseComparator;
 405       class Collections$SingletonList;
 406       class Collections$SingletonMap;
 407       class Collections$SingletonSet;
 408       class Collections$SynchronizedCollection;
 409       class Collections$SynchronizedIterator;
 410       class Collections$SynchronizedList;
 411       class Collections$SynchronizedListIterator;
 412       class Collections$SynchronizedMap;
 413       class Collections$SynchronizedRandomAccessList;
 414       class Collections$SynchronizedSet;
 415       class Collections$SynchronizedSortedMap;
 416       class Collections$SynchronizedSortedSet;
 417       class Collections$UnmodifiableCollection;
 418       class Collections$UnmodifiableIterator;
 419       class Collections$UnmodifiableList;
 420       class Collections$UnmodifiableListIterator;
 421       class Collections$UnmodifiableMap;
 422       class Collections$UnmodifiableMap$UnmodifiableEntrySet;
 423       class Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableMapEntry;
 424       class Collections$UnmodifiableRandomAccessList;
 425       class Collections$UnmodifiableSet;
 426       class Collections$UnmodifiableSortedMap;
 427       class Collections$UnmodifiableSortedSet;
 428       class Comparator;
 429       class ConcurrentModificationException;
 430       class Currency;
 431       class Date;
 432       class Deque;
 433       class Dictionary;
 434       class DuplicateFormatFlagsException;
 435       class EmptyStackException;
 436       class EnumMap;
 437       class EnumMap$1;
 438       class EnumMap$2;
 439       class EnumMap$3;
 440       class EnumMap$4;
 441       class EnumMap$5;
 442       class EnumMap$6;
 443       class EnumMap$7;
 444       class EnumSet;
 445       class EnumSet$1;
 446       class EnumSet$2;
 447       class Enumeration;
 448       class EventListener;
 449       class EventListenerProxy;
 450       class EventObject;
 451       class FormatFlagsConversionMismatchException;
 452       class Formattable;
 453       class FormattableFlags;
 454       class Formatter;
 455       class Formatter$BigDecimalLayoutForm;
 456       class FormatterClosedException;
 457       class GregorianCalendar;
 458       class HashMap;
 459       class HashMap$1;
 460       class HashMap$2;
 461       class HashMap$3;
 462       class HashMap$HashEntry;
 463       class HashMap$HashIterator;
 464       class HashSet;
 465       class Hashtable;
 466       class Hashtable$1;
 467       class Hashtable$2;
 468       class Hashtable$3;
 469       class Hashtable$EntryEnumerator;
 470       class Hashtable$EntryIterator;
 471       class Hashtable$HashEntry;
 472       class Hashtable$KeyEnumerator;
 473       class Hashtable$KeyIterator;
 474       class Hashtable$ValueEnumerator;
 475       class Hashtable$ValueIterator;
 476       class IdentityHashMap;
 477       class IdentityHashMap$1;
 478       class IdentityHashMap$2;
 479       class IdentityHashMap$3;
 480       class IdentityHashMap$IdentityEntry;
 481       class IdentityHashMap$IdentityIterator;
 482       class IllegalFormatCodePointException;
 483       class IllegalFormatConversionException;
 484       class IllegalFormatException;
 485       class IllegalFormatFlagsException;
 486       class IllegalFormatPrecisionException;
 487       class IllegalFormatWidthException;
 488       class InputMismatchException;
 489       class InvalidPropertiesFormatException;
 490       class Iterator;
 491       class LinkedHashMap;
 492       class LinkedHashMap$1;
 493       class LinkedHashMap$LinkedHashEntry;
 494       class LinkedHashSet;
 495       class LinkedList;
 496       class LinkedList$1;
 497       class LinkedList$Entry;
 498       class LinkedList$LinkedListItr;
 499       class List;
 500       class ListIterator;
 501       class ListResourceBundle;
 502       class Locale;
 503       class Map;
 504       class Map$Entry;
 505       class MissingFormatArgumentException;
 506       class MissingFormatWidthException;
 507       class MissingResourceException;
 508       class NavigableMap;
 509       class NavigableSet;
 510       class NoSuchElementException;
 511       class Observable;
 512       class Observer;
 513       class PriorityQueue;
 514       class PriorityQueue$1;
 515       class Properties;
 516       class PropertyPermission;
 517       class PropertyPermissionCollection;
 518       class PropertyResourceBundle;
 519       class Queue;
 520       class Random;
 521       class RandomAccess;
 522       class ResourceBundle;
 523       class ResourceBundle$1;
 524       class ResourceBundle$BundleKey;
 525       class Scanner;
 526       class ServiceConfigurationError;
 527       class ServiceLoader;
 528       class ServiceLoader$1;
 529       class Set;
 530       class SimpleTimeZone;
 531       class SortedMap;
 532       class SortedSet;
 533       class Stack;
 534       class StringTokenizer;
 535       class TimeZone;
 536       class TimeZone$1;
 537       class Timer;
 538       class Timer$Scheduler;
 539       class Timer$TaskQueue;
 540       class TimerTask;
 541       class TooManyListenersException;
 542       class TreeMap;
 543       class TreeMap$1;
 544       class TreeMap$2;
 545       class TreeMap$3;
 546       class TreeMap$4;
 547       class TreeMap$5;
 548       class TreeMap$6;
 549       class TreeMap$7;
 550       class TreeMap$DescendingMap;
 551       class TreeMap$DescendingSet;
 552       class TreeMap$EntrySet;
 553       class TreeMap$KeySet;
 554       class TreeMap$NavigableEntrySet;
 555       class TreeMap$NavigableKeySet;
 556       class TreeMap$Node;
 557       class TreeMap$SubMap;
 558       class TreeMap$SubMap$EntrySet;
 559       class TreeMap$SubMap$KeySet;
 560       class TreeMap$SubMap$NavigableEntrySet;
 561       class TreeMap$SubMap$NavigableKeySet;
 562       class TreeMap$TreeIterator;
 563       class TreeSet;
 564       class UUID;
 565       class UnknownFormatConversionException;
 566       class UnknownFormatFlagsException;
 567       class VMTimeZone;
 568       class Vector;
 569       class Vector$1;
 570       class WeakHashMap;
 571       class WeakHashMap$1;
 572       class WeakHashMap$2;
 573       class WeakHashMap$WeakBucket;
 574       class WeakHashMap$WeakBucket$WeakEntry;
 575       class WeakHashMap$WeakEntrySet;
 576       namespace concurrent
 577       {
 578         class AbstractExecutorService;
 579         class ArrayBlockingQueue;
 580         class ArrayBlockingQueue$Itr;
 581         class BlockingDeque;
 582         class BlockingQueue;
 583         class BrokenBarrierException;
 584         class Callable;
 585         class CancellationException;
 586         class CompletionService;
 587         class ConcurrentHashMap;
 588         class ConcurrentHashMap$EntryIterator;
 589         class ConcurrentHashMap$EntrySet;
 590         class ConcurrentHashMap$HashEntry;
 591         class ConcurrentHashMap$HashIterator;
 592         class ConcurrentHashMap$KeyIterator;
 593         class ConcurrentHashMap$KeySet;
 594         class ConcurrentHashMap$Segment;
 595         class ConcurrentHashMap$ValueIterator;
 596         class ConcurrentHashMap$Values;
 597         class ConcurrentHashMap$WriteThroughEntry;
 598         class ConcurrentLinkedQueue;
 599         class ConcurrentLinkedQueue$Itr;
 600         class ConcurrentLinkedQueue$Node;
 601         class ConcurrentMap;
 602         class ConcurrentNavigableMap;
 603         class ConcurrentSkipListMap;
 604         class ConcurrentSkipListMap$ComparableUsingComparator;
 605         class ConcurrentSkipListMap$EntryIterator;
 606         class ConcurrentSkipListMap$EntrySet;
 607         class ConcurrentSkipListMap$HeadIndex;
 608         class ConcurrentSkipListMap$Index;
 609         class ConcurrentSkipListMap$Iter;
 610         class ConcurrentSkipListMap$KeyIterator;
 611         class ConcurrentSkipListMap$KeySet;
 612         class ConcurrentSkipListMap$Node;
 613         class ConcurrentSkipListMap$SubMap;
 614         class ConcurrentSkipListMap$SubMap$SubMapEntryIterator;
 615         class ConcurrentSkipListMap$SubMap$SubMapIter;
 616         class ConcurrentSkipListMap$SubMap$SubMapKeyIterator;
 617         class ConcurrentSkipListMap$SubMap$SubMapValueIterator;
 618         class ConcurrentSkipListMap$ValueIterator;
 619         class ConcurrentSkipListMap$Values;
 620         class ConcurrentSkipListSet;
 621         class CopyOnWriteArrayList;
 622         class CopyOnWriteArrayList$1;
 623         class CopyOnWriteArrayList$2;
 624         class CopyOnWriteArrayList$3;
 625         class CopyOnWriteArrayList$RandomAccessSubList;
 626         class CopyOnWriteArrayList$SubList;
 627         class CopyOnWriteArraySet;
 628         class CountDownLatch;
 629         class CountDownLatch$Sync;
 630         class CyclicBarrier;
 631         class CyclicBarrier$Generation;
 632         class DelayQueue;
 633         class DelayQueue$Itr;
 634         class Delayed;
 635         class Exchanger;
 636         class Exchanger$Node;
 637         class Exchanger$Slot;
 638         class ExecutionException;
 639         class Executor;
 640         class ExecutorCompletionService;
 641         class ExecutorCompletionService$QueueingFuture;
 642         class ExecutorService;
 643         class Executors;
 644         class Executors$1;
 645         class Executors$2;
 646         class Executors$3;
 647         class Executors$4;
 648         class Executors$5;
 649         class Executors$6;
 650         class Executors$DefaultThreadFactory;
 651         class Executors$DelegatedExecutorService;
 652         class Executors$DelegatedScheduledExecutorService;
 653         class Executors$FinalizableDelegatedExecutorService;
 654         class Executors$PrivilegedCallable;
 655         class Executors$PrivilegedCallableUsingCurrentClassLoader;
 656         class Executors$PrivilegedThreadFactory;
 657         class Executors$RunnableAdapter;
 658         class Future;
 659         class FutureTask;
 660         class FutureTask$Sync;
 661         class LinkedBlockingDeque;
 662         class LinkedBlockingDeque$AbstractItr;
 663         class LinkedBlockingDeque$DescendingItr;
 664         class LinkedBlockingDeque$Itr;
 665         class LinkedBlockingDeque$Node;
 666         class LinkedBlockingQueue;
 667         class LinkedBlockingQueue$Itr;
 668         class LinkedBlockingQueue$Node;
 669         class PriorityBlockingQueue;
 670         class PriorityBlockingQueue$Itr;
 671         class RejectedExecutionException;
 672         class RejectedExecutionHandler;
 673         class RunnableFuture;
 674         class RunnableScheduledFuture;
 675         class ScheduledExecutorService;
 676         class ScheduledFuture;
 677         class ScheduledThreadPoolExecutor;
 678         class ScheduledThreadPoolExecutor$1;
 679         class ScheduledThreadPoolExecutor$DelayedWorkQueue;
 680         class ScheduledThreadPoolExecutor$ScheduledFutureTask;
 681         class Semaphore;
 682         class Semaphore$FairSync;
 683         class Semaphore$NonfairSync;
 684         class Semaphore$Sync;
 685         class SynchronousQueue;
 686         class SynchronousQueue$EmptyIterator;
 687         class SynchronousQueue$FifoWaitQueue;
 688         class SynchronousQueue$LifoWaitQueue;
 689         class SynchronousQueue$TransferQueue;
 690         class SynchronousQueue$TransferQueue$QNode;
 691         class SynchronousQueue$TransferStack;
 692         class SynchronousQueue$TransferStack$SNode;
 693         class SynchronousQueue$Transferer;
 694         class SynchronousQueue$WaitQueue;
 695         class ThreadFactory;
 696         class ThreadPoolExecutor;
 697         class ThreadPoolExecutor$AbortPolicy;
 698         class ThreadPoolExecutor$CallerRunsPolicy;
 699         class ThreadPoolExecutor$DiscardOldestPolicy;
 700         class ThreadPoolExecutor$DiscardPolicy;
 701         class ThreadPoolExecutor$Worker;
 702         class TimeUnit;
 703         class TimeUnit$1;
 704         class TimeUnit$2;
 705         class TimeUnit$3;
 706         class TimeUnit$4;
 707         class TimeUnit$5;
 708         class TimeUnit$6;
 709         class TimeUnit$7;
 710         class TimeoutException;
 711         namespace atomic
 712         {
 713           class AtomicBoolean;
 714           class AtomicInteger;
 715           class AtomicIntegerArray;
 716           class AtomicIntegerFieldUpdater;
 717           class AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl;
 718           class AtomicLong;
 719           class AtomicLongArray;
 720           class AtomicLongFieldUpdater;
 721           class AtomicLongFieldUpdater$CASUpdater;
 722           class AtomicLongFieldUpdater$LockedUpdater;
 723           class AtomicMarkableReference;
 724           class AtomicMarkableReference$ReferenceBooleanPair;
 725           class AtomicReference;
 726           class AtomicReferenceArray;
 727           class AtomicReferenceFieldUpdater;
 728           class AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl;
 729           class AtomicStampedReference;
 730           class AtomicStampedReference$ReferenceIntegerPair;
 731         }
 732
 733         namespace locks
 734         {
 735           class AbstractOwnableSynchronizer;
 736           class AbstractQueuedLongSynchronizer;
 737           class AbstractQueuedLongSynchronizer$ConditionObject;
 738           class AbstractQueuedLongSynchronizer$Node;
 739           class AbstractQueuedSynchronizer;
 740           class AbstractQueuedSynchronizer$ConditionObject;
 741           class AbstractQueuedSynchronizer$Node;
 742           class Condition;
 743           class Lock;
 744           class LockSupport;
 745           class ReadWriteLock;
 746           class ReentrantLock;
 747           class ReentrantLock$FairSync;
 748           class ReentrantLock$NonfairSync;
 749           class ReentrantLock$Sync;
 750           class ReentrantReadWriteLock;
 751           class ReentrantReadWriteLock$FairSync;
 752           class ReentrantReadWriteLock$NonfairSync;
 753           class ReentrantReadWriteLock$ReadLock;
 754           class ReentrantReadWriteLock$Sync;
 755           class ReentrantReadWriteLock$Sync$HoldCounter;
 756           class ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter;
 757           class ReentrantReadWriteLock$WriteLock;
 758         }
 759       }
 760
 761       namespace jar
 762       {
 763         class Attributes;
 764         class Attributes$Name;
 765         class JarEntry;
 766         class JarException;
 767         class JarFile;
 768         class JarFile$EntryInputStream;
 769         class JarFile$JarEnumeration;
 770         class JarInputStream;
 771         class JarOutputStream;
 772         class Manifest;
 773       }
 774
 775       namespace logging
 776       {
 777         class ConsoleHandler;
 778         class ErrorManager;
 779         class FileHandler;
 780         class FileHandler$ostr;
 781         class Filter;
 782         class Formatter;
 783         class Handler;
 784         class Level;
 785         class LogManager;
 786         class LogManager$1;
 787         class LogRecord;
 788         class Logger;
 789         class Logger$1;
 790         class LoggingMXBean;
 791         class LoggingPermission;
 792         class MemoryHandler;
 793         class SimpleFormatter;
 794         class SocketHandler;
 795         class StreamHandler;
 796         class XMLFormatter;
 797       }
 798
 799       namespace prefs
 800       {
 801         class AbstractPreferences;
 802         class AbstractPreferences$1;
 803         class AbstractPreferences$2;
 804         class BackingStoreException;
 805         class InvalidPreferencesFormatException;
 806         class NodeChangeEvent;
 807         class NodeChangeListener;
 808         class PreferenceChangeEvent;
 809         class PreferenceChangeListener;
 810         class Preferences;
 811         class Preferences$1;
 812         class PreferencesFactory;
 813       }
 814
 815       namespace regex
 816       {
 817         class MatchResult;
 818         class Matcher;
 819         class Pattern;
 820         class PatternSyntaxException;
 821       }
 822
 823       namespace spi
 824       {
 825         class CurrencyNameProvider;
 826         class LocaleNameProvider;
 827         class LocaleServiceProvider;
 828         class TimeZoneNameProvider;
 829       }
 830
 831       namespace zip
 832       {
 833         class Adler32;
 834         class CRC32;
 835         class CheckedInputStream;
 836         class CheckedOutputStream;
 837         class Checksum;
 838         class DataFormatException;
 839         class Deflater;
 840         class DeflaterOutputStream;
 841         class GZIPInputStream;
 842         class GZIPOutputStream;
 843         class Inflater;
 844         class InflaterInputStream;
 845         class ZipConstants;
 846         class ZipEntry;
 847         class ZipException;
 848         class ZipFile;
 849         class ZipFile$1;
 850         class ZipFile$PartialInputStream;
 851         class ZipFile$ZipEntryEnumeration;
 852         class ZipInputStream;
 853         class ZipOutputStream;
 854       }
 855     }
 856   }
 857   // end of output of the `classes.pl' script.
 858 }
 859
 860 typedef struct java::lang::Object* jobject;
 861 typedef class java::lang::Class* jclass;
 862 typedef class java::lang::Throwable* jthrowable;
 863 typedef class java::lang::String* jstring;
 864 struct _Jv_JNIEnv;
 865
 866 typedef struct _Jv_Field *jfieldID;
 867 typedef struct _Jv_Method *jmethodID;
 868
 869 extern "C" jobject _Jv_AllocObject (jclass) __attribute__((__malloc__));
 870 extern "C" jobject _Jv_AllocObjectNoFinalizer (jclass) __attribute__((__malloc__));
 871 extern "C" jobject _Jv_AllocObjectNoInitNoFinalizer (jclass) __attribute__((__malloc__));
 872 #ifdef JV_HASH_SYNCHRONIZATION
 873   extern "C" jobject _Jv_AllocPtrFreeObject (jclass)
 874                             __attribute__((__malloc__));
 875 #else
 876   // Collector still needs to scan sync_info
 877   static inline jobject _Jv_AllocPtrFreeObject (jclass klass)
 878   {
 879     return _Jv_AllocObject(klass);
 880   }
 881 #endif
 882 extern "C" jboolean _Jv_IsInstanceOf(jobject, jclass);
 883 extern "C" jstring _Jv_AllocString(jsize) __attribute__((__malloc__));
 884 extern "C" jstring _Jv_NewString (const jchar*, jsize)
 885   __attribute__((__malloc__));
 886 extern jint _Jv_FormatInt (jchar* bufend, jint num);
 887 extern "C" jchar* _Jv_GetStringChars (jstring str);
 888 extern "C" void _Jv_MonitorEnter (jobject);
 889 extern "C" void _Jv_MonitorExit (jobject);
 890 extern "C" jstring _Jv_NewStringUTF (const char *bytes)
 891   __attribute__((__malloc__));
 892 extern "C" jstring _Jv_NewStringLatin1(const char*, jsize)
 893   __attribute__((__malloc__));
 894 extern "C" jsize _Jv_GetStringUTFLength (jstring);
 895 extern "C" jsize _Jv_GetStringUTFRegion (jstring, jsize, jsize, char *);
 896 extern "C" jint _Jv_hashUtf8String (const char*, int);
 897 extern bool _Jv_is_proxy (void *pc);
 898
 899 struct _Jv_VMOption
 900 {
 901   // a VM initialization option
 902   char* optionString;
 903   // extra information associated with this option
 904   void* extraInfo;
 905 };
 906
 907 struct _Jv_VMInitArgs
 908 {
 909   // for compatibility with JavaVMInitArgs
 910   jint version;
 911
 912   // number of VM initialization options
 913   jint nOptions;
 914
 915   // an array of VM initialization options
 916   struct _Jv_VMOption* options;
 917
 918   // true if the option parser should ignore unrecognized options
 919   jboolean ignoreUnrecognized;
 920 };
 921
 922 extern "C" jint _Jv_CreateJavaVM (struct _Jv_VMInitArgs*);
 923
 924 void
 925 _Jv_ThreadRun (java::lang::Thread* thread);
 926 jint
 927 _Jv_AttachCurrentThread(java::lang::Thread* thread);
 928 extern "C" java::lang::Thread*
 929 _Jv_AttachCurrentThread(jstring name, java::lang::ThreadGroup* group);
 930 extern "C" java::lang::Thread*
 931 _Jv_AttachCurrentThreadAsDaemon(jstring name, java::lang::ThreadGroup* group);
 932 extern "C" jint _Jv_DetachCurrentThread (void);
 933
 934 extern "C" void _Jv_Throw (jthrowable) __attribute__ ((__noreturn__));
 935 extern "C" void* _Jv_Malloc (jsize) __attribute__((__malloc__));
 936 extern "C" void* _Jv_Realloc (void *, jsize);
 937 extern "C" void _Jv_Free (void*);
 938 extern void (*_Jv_RegisterClassHook) (jclass cl);
 939 extern "C" void _Jv_RegisterClassHookDefault (jclass);
 940
 941 typedef unsigned short _Jv_ushort __attribute__((__mode__(__HI__)));
 942 typedef unsigned int _Jv_uint __attribute__((__mode__(__SI__)));
 943 typedef unsigned int _Jv_ulong __attribute__((__mode__(__DI__)));
 944
 945 // The type to use when treating a pointer as an integer.  Similar to
 946 // uintptr_t in C99.
 947 typedef unsigned int _Jv_uintptr_t __attribute__((__mode__(__pointer__)));
 948
 949 class _Jv_Utf8Const
 950 {
 951   _Jv_ushort hash;
 952   _Jv_ushort length;    /* In bytes, of data portion, without final '\0'. */
 953   char data[1];         /* In Utf8 format, with final '\0'. */
 954  public:
 955   /** Return same value of java.lang.String's hashCode. */
 956   jint hash32() { return _Jv_hashUtf8String(data, length); }
 957   /** Return a hash code that has at least 16 bits of information. */
 958   _Jv_ushort hash16 () { return hash; }
 959   /** Return a hash code that has at least 8 bits of information. */
 960   _Jv_ushort hash8 () { return hash; }
 961   /** Length in bytes of the UTF8-encoding. */
 962   _Jv_ushort len () const { return length; }
 963   /** Pointer to the first byte in the NUL-terminated UTF8-encoding. */
 964   char* chars() { return data; }
 965   /** Pointer to the NUL byte that terminated the UTF8-encoding. */
 966   char* limit() { return data+length; }
 967   /** Return the first byte in the UTF8-encoding. */
 968   char first() const { return data[0]; }
 969   /** Create a (non-interned) java.lang.String from this UTF8Const. */
 970   jstring toString() { return _Jv_NewStringUTF(data); }
 971   /** Given an UTF8 string, how many bytes needed for a UTF8Const,
 972       including struct header, and final NUL.  I.e. what to pas to malloc. */
 973   static int space_needed (const char *, int len)
 974   { return sizeof (_Jv_Utf8Const) + len + 1; }
 975   /** Given an allocated _Jv_Utf8Const, copy / fill it in. */
 976   void init (const char *s, int len);
 977   friend jboolean _Jv_equalUtf8Consts (const _Jv_Utf8Const*, const _Jv_Utf8Const *);
 978   friend jboolean _Jv_equal (_Jv_Utf8Const*, jstring, jint);
 979   friend jboolean _Jv_equaln (_Jv_Utf8Const*, jstring, jint);
 980   friend jboolean _Jv_equalUtf8Classnames (const _Jv_Utf8Const*,
 981                                              const _Jv_Utf8Const*);
 982   friend jboolean _Jv_isPrimitiveOrDerived (const _Jv_Utf8Const*);
 983   friend _Jv_Utf8Const *_Jv_makeUtf8Const (const char*, int);
 984   friend _Jv_Utf8Const *_Jv_makeUtf8Const (jstring);
 985   friend jstring _Jv_NewStringUtf8Const (_Jv_Utf8Const*);
 986 };
 987
 988
 989 #endif /* __JAVAPRIMS_H__ */