OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [gcj/] [javaprims.h] - Blame information for rev 841

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.