This is the mail archive of the gcc-bugs@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

libgcj/6554: cni compiler bug



>Number:         6554
>Category:       libgcj
>Synopsis:       Java cni bug finding class$
>Confidential:   no
>Severity:       serious
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          ice-on-legal-code
>Submitter-Id:   net
>Arrival-Date:   Fri May 03 15:16:01 PDT 2002
>Closed-Date:
>Last-Modified:
>Originator:     Chris Inacio
>Release:        3.1 20020430 (prerelease)
>Organization:
Spinnaker Networks
>Environment:
System: Linux wayne 2.4.2-2 #1 Sun Apr 8 20:41:30 EDT 2001 i686 unknown
Architecture: i686

	
host: i686-pc-linux-gnu
build: i686-pc-linux-gnu
target: i686-pc-linux-gnu
configured with: ../gcc/configure --host=i686-pc-linux-gnu --prefix=/spin/awk/compilers/gcc-3.1-hol --enable-shared --enable-threads=posix --enable-languages=c,c++,java --enable-version-specific-runtime-libs
>Description:
/tmp/tesla.cc: In member function `virtual JArray<java::lang::String*>* 
   com::spinnakernet::bogus::here::bigClass::getPortAttr(__java_int)':
/tmp/tesla.cc:15: can't find class$
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://www.gnu.org/software/gcc/bugs.html> for instructions.
>How-To-Repeat:
# 1 "/tmp/tesla.cc"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "/tmp/tesla.cc"
# 1 "/usr/local/include/gcj/cni.h" 1 3
# 16 "/usr/local/include/gcj/cni.h" 3
# 1 "/usr/local/include/java/lang/Object.h" 1 3
# 14 "/usr/local/include/java/lang/Object.h" 3
#pragma interface

# 1 "/usr/local/include/gcj/javaprims.h" 1 3
# 15 "/usr/local/include/gcj/javaprims.h" 3
#pragma GCC java_exceptions
# 27 "/usr/local/include/gcj/javaprims.h" 3
extern "Java"
{
  typedef __java_byte jbyte;
  typedef __java_short jshort;
  typedef __java_int jint;
  typedef __java_long jlong;
  typedef __java_float jfloat;
  typedef __java_double jdouble;
  typedef __java_char jchar;
  typedef __java_boolean jboolean;
  typedef jint jsize;



  namespace java
  {
    namespace io
    {
      class BufferedInputStream;
      class BufferedOutputStream;
      class BufferedReader;
      class BufferedWriter;
      class ByteArrayInputStream;
      class ByteArrayOutputStream;
      class CharArrayReader;
      class CharArrayWriter;
      class CharConversionException;
      class DataInput;
      class DataInputStream;
      class DataOutput;
      class DataOutputStream;
      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 FilterInputStream;
      class FilterOutputStream;
      class FilterReader;
      class FilterWriter;
      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$GetField;
      class ObjectInputValidation;
      class ObjectOutput;
      class ObjectOutputStream;
      class ObjectOutputStream$PutField;
      class ObjectStreamClass;
      class ObjectStreamConstants;
      class ObjectStreamException;
      class ObjectStreamField;
      class OptionalDataException;
      class OutputStream;
      class OutputStreamWriter;
      class PipedInputStream;
      class PipedOutputStream;
      class PipedReader;
      class PipedWriter;
      class PrintStream;
      class PrintWriter;
      class PushbackInputStream;
      class PushbackReader;
      class RandomAccessFile;
      class Reader;
      class SequenceInputStream;
      class Serializable;
      class SerializablePermission;
      class StreamCorruptedException;
      class StreamTokenizer;
      class StringBufferInputStream;
      class StringReader;
      class StringWriter;
      class SyncFailedException;
      class UTFDataFormatException;
      class UnsupportedEncodingException;
      class ValidatorAndPriority;
      class WriteAbortedException;
      class Writer;
    };

    namespace lang
    {
      class AbstractMethodError;
      class ArithmeticException;
      class ArrayIndexOutOfBoundsException;
      class ArrayStoreException;
      class Boolean;
      class Byte;
      class CPlusPlusDemangler;
      class Character;
      class Character$Subset;
      class Character$UnicodeBlock;
      class Class;
      class ClassCastException;
      class ClassCircularityError;
      class ClassFormatError;
      class ClassLoader;
      class ClassNotFoundException;
      class CloneNotSupportedException;
      class Cloneable;
      class Comparable;
      class Compiler;
      class ConcreteProcess;
      class Double;
      class Error;
      class Exception;
      class ExceptionInInitializerError;
      class Float;
      class IllegalAccessError;
      class IllegalAccessException;
      class IllegalArgumentException;
      class IllegalMonitorStateException;
      class IllegalStateException;
      class IllegalThreadStateException;
      class IncompatibleClassChangeError;
      class IndexOutOfBoundsException;
      class InstantiationError;
      class InstantiationException;
      class Integer;
      class InternalError;
      class InterruptedException;
      class LinkageError;
      class Long;
      class Math;
      class NegativeArraySizeException;
      class NoClassDefFoundError;
      class NoSuchFieldError;
      class NoSuchFieldException;
      class NoSuchMethodError;
      class NoSuchMethodException;
      class NullPointerException;
      class Number;
      class NumberFormatException;
      class Object;
      class OutOfMemoryError;
      class Process;
      class Runnable;
      class Runtime;
      class RuntimeException;
      class RuntimePermission;
      class SecurityException;
      class SecurityManager;
      class Short;
      class StackOverflowError;
      class String;
      class StringBuffer;
      class StringIndexOutOfBoundsException;
      class System;
      class Thread;
      class ThreadDeath;
      class ThreadGroup;
      class Throwable;
      class UnknownError;
      class UnsatisfiedLinkError;
      class UnsupportedOperationException;
      class VerifyError;
      class VirtualMachineError;
      class Void;
      namespace ref
      {
        class PhantomReference;
        class Reference;
        class ReferenceQueue;
        class SoftReference;
        class WeakReference;
      };

      namespace reflect
      {
        class AccessibleObject;
        class Array;
        class Constructor;
        class Field;
        class InvocationTargetException;
        class Member;
        class Method;
        class Modifier;
        class ReflectPermission;
      };
    };

    namespace util
    {
      class AbstractCollection;
      class AbstractList;
      class AbstractList$AbstractListItr;
      class AbstractMap;
      class AbstractSequentialList;
      class AbstractSet;
      class ArrayList;
      class Arrays;
      class Arrays$ListImpl;
      class BasicMapEntry;
      class BitSet;
      class Calendar;
      class Collection;
      class Collections;
      class Collections$ReverseComparator;
      class Collections$SynchronizedCollection;
      class Collections$SynchronizedIterator;
      class Collections$SynchronizedList;
      class Collections$SynchronizedListIterator;
      class Collections$SynchronizedMap;
      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$UnmodifiableSet;
      class Collections$UnmodifiableSortedMap;
      class Collections$UnmodifiableSortedSet;
      class Comparator;
      class ConcurrentModificationException;
      class Date;
      class Dictionary;
      class EmptyStackException;
      class Enumeration;
      class EventListener;
      class EventObject;
      class GregorianCalendar;
      class HashMap;
      class HashMap$Entry;
      class HashMap$HashIterator;
      class HashSet;
      class Hashtable;
      class Hashtable$Entry;
      class Hashtable$Enumerator;
      class Hashtable$HashIterator;
      class Iterator;
      class LinkedList;
      class LinkedList$Entry;
      class LinkedList$LinkedListItr;
      class List;
      class ListIterator;
      class ListResourceBundle;
      class Locale;
      class Map;
      class Map$Entry;
      class MissingResourceException;
      class NoSuchElementException;
      class Observable;
      class Observer;
      class Properties;
      class PropertyPermission;
      class PropertyResourceBundle;
      class Random;
      class ResourceBundle;
      class Set;
      class SimpleTimeZone;
      class SortedMap;
      class SortedSet;
      class Stack;
      class StringTokenizer;
      class SubList;
      class TimeZone;
      class Timer;
      class Timer$Scheduler;
      class Timer$TaskQueue;
      class TimerTask;
      class TooManyListenersException;
      class TreeMap;
      class TreeMap$Node;
      class TreeMap$SubMap;
      class TreeMap$TreeIterator;
      class TreeMap$VerifyResult;
      class TreeSet;
      class Vector;
      class WeakHashMap;
      class WeakHashMap$Entry;
      class WeakHashMap$WeakBucket;
      class WeakHashMap$WeakEntrySet;
      namespace jar
      {
        class Attributes;
        class Attributes$Name;
        class JarEntry;
        class JarException;
        class JarFile;
        class JarFile$JarEnumeration;
        class JarInputStream;
        class JarOutputStream;
        class Manifest;
      };

      namespace zip
      {
        class Adler32;
        class CRC32;
        class CheckedInputStream;
        class CheckedOutputStream;
        class Checksum;
        class DataFormatException;
        class Deflater;
        class DeflaterOutputStream;
        class GZIPInputStream;
        class GZIPOutputStream;
        class Inflater;
        class InflaterInputStream;
        class ZipConstants;
        class ZipEntry;
        class ZipEnumeration;
        class ZipException;
        class ZipFile;
        class ZipInputStream;
        class ZipOutputStream;
      };
    };
  };
};

typedef struct java::lang::Object* jobject;
typedef class java::lang::Class* jclass;
typedef class java::lang::Throwable* jthrowable;
typedef class java::lang::String* jstring;
struct _Jv_JNIEnv;

typedef struct _Jv_Field *jfieldID;
typedef struct _Jv_Method *jmethodID;

extern "C" jobject _Jv_AllocObject (jclass, jint) __attribute__((__malloc__));
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 "C" jchar* _Jv_GetStringChars (jstring str);
extern "C" jint _Jv_MonitorEnter (jobject);
extern "C" jint _Jv_MonitorExit (jobject);
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" 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*);

typedef unsigned short _Jv_ushort __attribute__((__mode__(__HI__)));
typedef unsigned int _Jv_uint __attribute__((__mode__(__SI__)));

struct _Jv_Utf8Const
{
  _Jv_ushort hash;
  _Jv_ushort length;
  char data[1];
};
# 17 "/usr/local/include/java/lang/Object.h" 2 3



struct _JvObjectPrefix
{
protected:

  virtual void nacd_1 (void) {};
  virtual void nacd_2 (void) {};
};

class java::lang::Object : public _JvObjectPrefix
{
protected:
  virtual void finalize (void);
public:

  jclass getClass (void);
  virtual jint hashCode (void);
  void notify (void);
  void notifyAll (void);
  void wait (jlong timeout, jint nanos);
  virtual jboolean equals (jobject obj);
  Object (void);
  virtual jstring toString (void);
  void wait (void);
  void wait (jlong timeout);

  friend jint _Jv_MonitorEnter (jobject obj);
  friend jint _Jv_MonitorExit (jobject obj);
  friend void _Jv_InitializeSyncMutex (void);
  friend void _Jv_FinalizeObject (jobject obj);
# 57 "/usr/local/include/java/lang/Object.h" 3
  static java::lang::Class class$;

protected:
  virtual jobject clone (void);

private:



  jobject sync_info;


  void sync_init (void);
};
# 17 "/usr/local/include/gcj/cni.h" 2 3
# 1 "/usr/local/include/java/lang/Class.h" 1 3
# 15 "/usr/local/include/java/lang/Class.h" 3
#pragma interface

# 1 "/home/spin_test/awk/compilers/gcc-3.1-hol/lib/gcc-lib/i686-pc-linux-gnu/3.1/include/stddef.h" 1 3
# 147 "/home/spin_test/awk/compilers/gcc-3.1-hol/lib/gcc-lib/i686-pc-linux-gnu/3.1/include/stddef.h" 3
typedef int ptrdiff_t;
# 201 "/home/spin_test/awk/compilers/gcc-3.1-hol/lib/gcc-lib/i686-pc-linux-gnu/3.1/include/stddef.h" 3
typedef unsigned int size_t;
# 18 "/usr/local/include/java/lang/Class.h" 2 3

# 1 "/usr/local/include/java/lang/String.h" 1 3





#pragma interface


# 1 "/usr/local/include/gcj/array.h" 1 3
# 16 "/usr/local/include/gcj/array.h" 3
extern "Java" {

class __JArray : public java::lang::Object
{
protected:



  __JArray () : length (0)
  {
  }
public:
  const jsize length;
  friend jsize JvGetArrayLength (__JArray*);
};

template<class T>
class JArray : public __JArray
{
  T data[0];
public:
  friend T* elements<>(JArray<T>& x);
  friend T* elements<>(JArray<T>* x);


};

template<class T>
inline T* elements(JArray<T>& x) { return x.data; }
template<class T>
inline T* elements(JArray<T>* x) { return x->data; }

};


typedef __JArray *jarray;
typedef JArray<jobject> *jobjectArray;
typedef JArray<jboolean> *jbooleanArray;
typedef JArray<jbyte> *jbyteArray;
typedef JArray<jchar> *jcharArray;
typedef JArray<jshort> *jshortArray;
typedef JArray<jint> *jintArray;
typedef JArray<jlong> *jlongArray;
typedef JArray<jfloat> *jfloatArray;
typedef JArray<jdouble> *jdoubleArray;
typedef JArray<jstring> *jstringArray;

extern java::lang::Class _Jv_byteClass, _Jv_shortClass, _Jv_intClass,
  _Jv_longClass, _Jv_booleanClass, _Jv_charClass, _Jv_floatClass,
  _Jv_doubleClass, _Jv_voidClass;


extern "C" jobjectArray _Jv_NewObjectArray(jsize length, jclass, jobject init);
extern "C" jobject _Jv_NewPrimArray (jclass eltype, jint count);

extern inline jobjectArray
JvNewObjectArray (jsize length, jclass cls, jobject init)
{
  return _Jv_NewObjectArray (length, cls, init);
}

extern inline jcharArray
JvNewCharArray (jint length)
{
  return (jcharArray) _Jv_NewPrimArray ((& _Jv_charClass), length);
}

extern inline jbooleanArray
JvNewBooleanArray (jint length)
{
  return (jbooleanArray) _Jv_NewPrimArray ((& _Jv_booleanClass), length);
}

extern inline jbyteArray
JvNewByteArray (jint length)
{
  return (jbyteArray) _Jv_NewPrimArray ((& _Jv_byteClass), length);
}

extern inline jshortArray
JvNewShortArray (jint length)
{
  return (jshortArray) _Jv_NewPrimArray ((& _Jv_shortClass), length);
}

extern inline jintArray
JvNewIntArray (jint length)
{
  return (jintArray) _Jv_NewPrimArray ((& _Jv_intClass), length);
}

extern inline jlongArray
JvNewLongArray (jint length)
{
  return (jlongArray) _Jv_NewPrimArray ((& _Jv_longClass), length);
}

extern inline jfloatArray
JvNewFloatArray (jint length)
{
  return (jfloatArray) _Jv_NewPrimArray ((& _Jv_floatClass), length);
}

extern inline jdoubleArray
JvNewDoubleArray (jint length)
{
  return (jdoubleArray) _Jv_NewPrimArray ((& _Jv_doubleClass), length);
}


extern "C" jstringArray JvConvertArgv(int argc, const char **argv);

inline jsize JvGetArrayLength (jarray array) { return array->length; }
# 10 "/usr/local/include/java/lang/String.h" 2 3

class ::java::lang::String : public ::java::lang::Object
{
public:
  String ();
  String (::java::lang::String *);
  String (::java::lang::StringBuffer *);
  String (jcharArray);
  String (jcharArray, jint, jint);
  String (jbyteArray);
  String (jbyteArray, jint, jint);
  String (jbyteArray, ::java::lang::String *);
  String (jbyteArray, jint, jint, ::java::lang::String *);
  static ::java::lang::String *copyValueOf (jcharArray);
  static ::java::lang::String *copyValueOf (jcharArray, jint, jint);
  String (jbyteArray, jint);
  String (jbyteArray, jint, jint, jint);
  ::java::lang::String *toString () { return this; }
  jboolean equals (::java::lang::Object *);
  jint hashCode ();
  jint length () { return count; }
  jchar charAt (jint);
  void getChars (jint, jint, jcharArray, jint);
  jbyteArray getBytes ();
  jbyteArray getBytes (::java::lang::String *);
  void getBytes (jint, jint, jbyteArray, jint);
  jcharArray toCharArray ();
  jboolean equalsIgnoreCase (::java::lang::String *);
  jint compareTo (::java::lang::String *);
  jint compareTo (::java::lang::Object *);
  jint compareToIgnoreCase (::java::lang::String *);
  jboolean regionMatches (jint, ::java::lang::String *, jint, jint);
  jboolean regionMatches (jboolean, jint, ::java::lang::String *, jint, jint);
  jboolean startsWith (::java::lang::String *);
  jboolean startsWith (::java::lang::String *, jint);
  jboolean endsWith (::java::lang::String *);
  jint indexOf (jint);
  jint indexOf (jint, jint);
  jint indexOf (::java::lang::String *);
  jint indexOf (::java::lang::String *, jint);
  jint lastIndexOf (jint);
  jint lastIndexOf (jint, jint);
  jint lastIndexOf (::java::lang::String *);
  jint lastIndexOf (::java::lang::String *, jint);
  ::java::lang::String *substring (jint);
  ::java::lang::String *substring (jint, jint);
  ::java::lang::String *concat (::java::lang::String *);
  ::java::lang::String *replace (jchar, jchar);
  ::java::lang::String *toLowerCase (::java::util::Locale *);
  ::java::lang::String *toUpperCase (::java::util::Locale *);
  ::java::lang::String *toLowerCase ();
  ::java::lang::String *toUpperCase ();
  ::java::lang::String *trim ();
  static ::java::lang::String *valueOf (::java::lang::Object *);
  static ::java::lang::String *valueOf (jcharArray);
  static ::java::lang::String *valueOf (jcharArray, jint, jint);
  static ::java::lang::String *valueOf (jboolean);
  static ::java::lang::String *valueOf (jchar);
  static ::java::lang::String *valueOf (jint);
  static ::java::lang::String *valueOf (jlong);
  static ::java::lang::String *valueOf (jfloat);
  static ::java::lang::String *valueOf (jdouble);
  ::java::lang::String *intern ();
private:
  void init ();
  void init (jcharArray, jint, jint, jboolean);
  void init (jbyteArray, jint, jint, jint);
  void init (jbyteArray, jint, jint, ::java::lang::String *);
  static void rehash ();
  ::java::lang::Object *data;
  jint boffset;
  jint count;
  static const jlong serialVersionUID = -6849794470754667710LL;
public:
  static ::java::util::Comparator *CASE_INSENSITIVE_ORDER;
  friend jchar* _Jv_GetStringChars (jstring str);
  friend jstring* _Jv_StringFindSlot (jchar*, jint, jint);
  friend jstring* _Jv_StringGetSlot (jstring);
  friend jstring _Jv_NewStringUtf8Const (_Jv_Utf8Const* str);
  friend jstring _Jv_NewStringLatin1 (const char*, jsize);
  friend jstring _Jv_AllocString (jsize);

  static ::java::lang::Class class$;
};
# 20 "/usr/local/include/java/lang/Class.h" 2 3
# 1 "/usr/local/include/java/net/URL.h" 1 3





#pragma interface



extern "Java"
{
  namespace java
  {
    namespace net
    {
      class URLConnection;
      class URL;
      class URLStreamHandlerFactory;
      class URLStreamHandler;
    }
  }
};

class ::java::net::URL : public ::java::lang::Object
{
public:
  URL (::java::lang::String *, ::java::lang::String *, jint, ::java::lang::String *);
  URL (::java::lang::String *, ::java::lang::String *, ::java::lang::String *);
  URL (::java::lang::String *, ::java::lang::String *, jint, ::java::lang::String *, ::java::net::URLStreamHandler *);
  URL (::java::lang::String *);
  URL (::java::net::URL *, ::java::lang::String *);
  URL (::java::net::URL *, ::java::lang::String *, ::java::net::URLStreamHandler *);
  jboolean equals (::java::lang::Object *);
  ::java::lang::Object *getContent ();
  ::java::lang::String *getFile () { return file; }
  ::java::lang::String *getHost () { return host; }
  jint getPort () { return port; }
  ::java::lang::String *getProtocol () { return protocol; }
  ::java::lang::String *getRef () { return ref; }
  jint hashCode ();
  ::java::net::URLConnection *openConnection ();
  ::java::io::InputStream *openStream ();
  jboolean sameFile (::java::net::URL *);
public:
  void set (::java::lang::String *, ::java::lang::String *, jint, ::java::lang::String *, ::java::lang::String *);
public:
  static void setURLStreamHandlerFactory (::java::net::URLStreamHandlerFactory *);
  ::java::lang::String *toExternalForm ();
  ::java::lang::String *toString ();
private:
  ::java::net::URLStreamHandler *setURLStreamHandler (::java::lang::String *);
  void readObject (::java::io::ObjectInputStream *);
  void writeObject (::java::io::ObjectOutputStream *);
  ::java::lang::String *protocol;
  ::java::lang::String *host;
  jint port;
  ::java::lang::String *file;
  ::java::lang::String *ref;
  jint hashCode__;
  ::java::net::URLStreamHandler *handler;
  static ::java::util::Hashtable *handlers;
  static ::java::net::URLStreamHandlerFactory *factory;
  static const jlong serialVersionUID = -7627629688361524110LL;
public:

  static ::java::lang::Class class$;
};
# 21 "/usr/local/include/java/lang/Class.h" 2 3
# 1 "/usr/local/include/java/lang/reflect/Modifier.h" 1 3





#pragma interface



class ::java::lang::reflect::Modifier : public ::java::lang::Object
{
public:
  static jboolean isAbstract (jint);
  static jboolean isFinal (jint);
  static jboolean isInterface (jint);
  static jboolean isNative (jint);
  static jboolean isPrivate (jint);
  static jboolean isProtected (jint);
  static jboolean isPublic (jint);
  static jboolean isStatic (jint);
  static jboolean isStrict (jint);
  static jboolean isSynchronized (jint);
  static jboolean isTransient (jint);
  static jboolean isVolatile (jint);
  static ::java::lang::String *toString (jint);
public:
  static void toString (jint, ::java::lang::StringBuffer *);
public:
  Modifier ();
  static const jint PUBLIC = 1L;
  static const jint PRIVATE = 2L;
  static const jint PROTECTED = 4L;
  static const jint STATIC = 8L;
  static const jint FINAL = 16L;
  static const jint SYNCHRONIZED = 32L;
  static const jint VOLATILE = 64L;
  static const jint TRANSIENT = 128L;
  static const jint NATIVE = 256L;
  static const jint INTERFACE = 512L;
  static const jint ABSTRACT = 1024L;
  static const jint STRICT = 2048L;
public:
  static const jint ALL_FLAGS = 4095L;
public:

  static ::java::lang::Class class$;
};
# 22 "/usr/local/include/java/lang/Class.h" 2 3


extern "C" void _Jv_InitClass (jclass klass);
extern "C" void _Jv_RegisterClasses (jclass *classes);


extern "C" void *_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface,
                                               int meth_idx);




enum
{
  JV_STATE_NOTHING = 0,

  JV_STATE_PRELOADING = 1,
  JV_STATE_LOADING = 3,
  JV_STATE_LOADED = 5,

  JV_STATE_COMPILED = 6,

  JV_STATE_PREPARED = 7,
  JV_STATE_LINKED = 9,

  JV_STATE_IN_PROGRESS = 10,
  JV_STATE_DONE = 12,

  JV_STATE_ERROR = 14
};

struct _Jv_Field;
struct _Jv_VTable;
union _Jv_word;

struct _Jv_Constants
{
  jint size;
  jbyte *tags;
  _Jv_word *data;
};

struct _Jv_Method
{
  _Jv_Utf8Const *name;
  _Jv_Utf8Const *signature;
  _Jv_ushort accflags;
  void *ncode;
  _Jv_Method *getNextMethod ()
  { return this + 1; }
};


union _Jv_IDispatchTable
{
  struct
  {

    jshort iindex;
    jshort itable_length;

    void **itable;
  } cls;

  struct
  {

    jshort *ioffsets;
  } iface;
};


struct _Jv_ifaces
{
  jclass *list;
  jshort len;
  jshort count;
};


union _Jv_Self
{
  char *vtable_ptr;
  jclass self;
};





class java::lang::Class : public java::lang::Object
{
public:
  static jclass forName (jstring className, jboolean initialize,
                         java::lang::ClassLoader *loader);
  static jclass forName (jstring className);
  JArray<jclass> *getClasses (void);

  java::lang::ClassLoader *getClassLoader (void)
    {
      return loader;
    }

  java::lang::reflect::Constructor *getConstructor (JArray<jclass> *);
  JArray<java::lang::reflect::Constructor *> *getConstructors (void);
  java::lang::reflect::Constructor *getDeclaredConstructor (JArray<jclass> *);
  JArray<java::lang::reflect::Constructor *> *getDeclaredConstructors (void);
  java::lang::reflect::Field *getDeclaredField (jstring);
  JArray<java::lang::reflect::Field *> *getDeclaredFields (void);
  java::lang::reflect::Method *getDeclaredMethod (jstring, JArray<jclass> *);
  JArray<java::lang::reflect::Method *> *getDeclaredMethods (void);

  JArray<jclass> *getDeclaredClasses (void);
  jclass getDeclaringClass (void);

  java::lang::reflect::Field *getField (jstring);
private:
  jint _getFields (JArray<java::lang::reflect::Field *> *result, jint offset);
  JArray<java::lang::reflect::Constructor *> *_getConstructors (jboolean);
  java::lang::reflect::Field *getField (jstring, jint);
  jint _getMethods (JArray<java::lang::reflect::Method *> *result,
                    jint offset);
  java::lang::reflect::Field *getPrivateField (jstring);
  java::lang::reflect::Method *getPrivateMethod (jstring, JArray<jclass> *);

public:
  JArray<java::lang::reflect::Field *> *getFields (void);

  JArray<jclass> *getInterfaces (void);

  void getSignature (java::lang::StringBuffer *buffer);
  static jstring getSignature (JArray<jclass> *, jboolean is_constructor);
  java::lang::reflect::Method *getMethod (jstring, JArray<jclass> *);
  JArray<java::lang::reflect::Method *> *getMethods (void);

  inline jint getModifiers (void)
    {
      return accflags;
    }

  jstring getName (void);

  java::net::URL *getResource (jstring resourceName);
  java::io::InputStream *getResourceAsStream (jstring resourceName);
  JArray<jobject> *getSigners (void);

  inline jclass getSuperclass (void)
    {
      return superclass;
    }

  inline jboolean isArray (void)
    {
      return name->data[0] == '[';
    }

  inline jclass getComponentType (void)
    {
      return isArray () ? (* (jclass *) &methods) : 0;
    }

  jboolean isAssignableFrom (jclass cls);
  jboolean isInstance (jobject obj);

  inline jboolean isInterface (void)
  {
    return (accflags & java::lang::reflect::Modifier::INTERFACE) != 0;
  }

  inline jboolean isPrimitive (void)
    {
      return vtable == ((_Jv_VTable *) -1);
    }

  jobject newInstance (void);
  jstring toString (void);


  jint size (void)
    {
      return size_in_bytes;
    }


  void finalize ();



  Class (jobject cname, jbyte sig, jint len, jobject array_vtable)
  {
    using namespace java::lang::reflect;
    _Jv_Utf8Const *_Jv_makeUtf8Const (char *s, int len);



    ((_Jv_Self *)this)->vtable_ptr -= 2 * sizeof (void *);




    name = _Jv_makeUtf8Const ((char *) cname, -1);
    accflags = Modifier::PUBLIC | Modifier::FINAL | Modifier::ABSTRACT;
    method_count = sig;
    size_in_bytes = len;
    vtable = ((_Jv_VTable *) -1);
    state = JV_STATE_DONE;
    depth = -1;
    if (method_count != 'V')
      _Jv_NewArrayClass (this, __null, (_Jv_VTable *) array_vtable);
  }

  static java::lang::Class class$;

private:

  Class ();

  void checkMemberAccess (jint flags);

  void initializeClass (void);


  friend _Jv_Method *_Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name,
                                         _Jv_Utf8Const *signature);
  friend jboolean _Jv_IsAssignableFrom(jclass, jclass);
  friend jboolean _Jv_InterfaceAssignableFrom (jclass, jclass);
  friend void *_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface,
                                             int method_idx);

  inline friend void
  _Jv_InitClass (jclass klass)
  {
    if (__builtin_expect (klass->state == JV_STATE_DONE, true))
      return;
    klass->initializeClass ();
  }

  friend _Jv_Method* _Jv_LookupDeclaredMethod (jclass, _Jv_Utf8Const *,
                                               _Jv_Utf8Const*);
  friend jfieldID JvGetFirstInstanceField (jclass);
  friend jint JvNumInstanceFields (jclass);
  friend jfieldID JvGetFirstStaticField (jclass);
  friend jint JvNumStaticFields (jclass);

  friend jobject _Jv_AllocObject (jclass, jint);
  friend void *_Jv_AllocObj (jint, jclass);
  friend void *_Jv_AllocArray (jint, jclass);

  friend jobject _Jv_JNI_ToReflectedField (_Jv_JNIEnv *, jclass, jfieldID,
                                           jboolean);
  friend jobject _Jv_JNI_ToReflectedMethod (_Jv_JNIEnv *, jclass, jmethodID,
                                            jboolean);
  friend jfieldID _Jv_FromReflectedField (java::lang::reflect::Field *);

  friend jmethodID _Jv_FromReflectedMethod (java::lang::reflect::Method *);
  friend jmethodID _Jv_FromReflectedConstructor (java::lang::reflect::Constructor *);
  friend jint JvNumMethods (jclass);
  friend jmethodID JvGetFirstMethod (jclass);


  friend class java::lang::ClassLoader;

  friend class java::io::ObjectOutputStream;
  friend class java::io::ObjectInputStream;
  friend class java::io::ObjectStreamClass;

  friend void _Jv_WaitForState (jclass, int);
  friend void _Jv_RegisterClasses (jclass *classes);
  friend void _Jv_RegisterInitiatingLoader (jclass,java::lang::ClassLoader*);
  friend void _Jv_UnregisterClass (jclass);
  friend jclass _Jv_FindClass (_Jv_Utf8Const *name,
                               java::lang::ClassLoader *loader);
  friend jclass _Jv_FindClassInCache (_Jv_Utf8Const *name,
                                      java::lang::ClassLoader *loader);
  friend void _Jv_NewArrayClass (jclass element,
                                 java::lang::ClassLoader *loader,
                                 _Jv_VTable *array_vtable = 0);
  friend jclass _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
                              java::lang::ClassLoader *loader);

  friend void _Jv_PrepareCompiledClass (jclass);
  friend void _Jv_PrepareConstantTimeTables (jclass);
  friend jshort _Jv_GetInterfaces (jclass, _Jv_ifaces *);
  friend void _Jv_GenerateITable (jclass, _Jv_ifaces *, jshort *);
  friend jstring _Jv_GetMethodString(jclass, _Jv_Utf8Const *);
  friend jshort _Jv_AppendPartialITable (jclass, jclass, void **, jshort);
  friend jshort _Jv_FindIIndex (jclass *, jshort *, jshort);



  inline friend jclass
  _Jv_GetArrayClass (jclass klass, java::lang::ClassLoader *loader)
  {
    if (__builtin_expect (!klass->arrayclass, false))
      _Jv_NewArrayClass (klass, loader);
    return klass->arrayclass;
  }
# 344 "/usr/local/include/java/lang/Class.h" 3
  jclass next;

  _Jv_Utf8Const *name;

  _Jv_ushort accflags;

  jclass superclass;

  _Jv_Constants constants;


  _Jv_Method *methods;


  jshort method_count;

  jshort vtable_method_count;

  _Jv_Field *fields;

  jint size_in_bytes;

  jshort field_count;

  jshort static_field_count;

  _Jv_VTable *vtable;

  jclass *interfaces;

  java::lang::ClassLoader *loader;

  jshort interface_count;

  jbyte state;


  java::lang::Thread *thread;

  jshort depth;

  jclass *ancestors;

  _Jv_IDispatchTable *idt;

  jclass arrayclass;
};
# 18 "/usr/local/include/gcj/cni.h" 2 3



# 1 "/usr/include/string.h" 1 3
# 26 "/usr/include/string.h" 3
# 1 "/usr/include/features.h" 1 3
# 283 "/usr/include/features.h" 3
# 1 "/usr/include/sys/cdefs.h" 1 3
# 284 "/usr/include/features.h" 2 3
# 312 "/usr/include/features.h" 3
# 1 "/usr/include/gnu/stubs.h" 1 3
# 313 "/usr/include/features.h" 2 3
# 27 "/usr/include/string.h" 2 3

extern "C" {




# 1 "/home/spin_test/awk/compilers/gcc-3.1-hol/lib/gcc-lib/i686-pc-linux-gnu/3.1/include/stddef.h" 1 3
# 34 "/usr/include/string.h" 2 3



extern void *memcpy (void *__restrict __dest,
                     __const void *__restrict __src, size_t __n) throw ();


extern void *memmove (void *__dest, __const void *__src, size_t __n)
     throw ();





extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
                      int __c, size_t __n)
     throw ();




extern void *memset (void *__s, int __c, size_t __n) throw ();


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern void *memchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__));




extern void *rawmemchr (__const void *__s, int __c) throw () __attribute__ ((__pure__));


extern void *memrchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__));




extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     throw ();

extern char *strncpy (char *__restrict __dest,
                      __const char *__restrict __src, size_t __n) throw ();


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     throw ();

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
                      size_t __n) throw ();


extern int strcmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern int strcoll (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));

extern size_t strxfrm (char *__restrict __dest,
                       __const char *__restrict __src, size_t __n) throw ();





# 1 "/usr/include/xlocale.h" 1 3
# 28 "/usr/include/xlocale.h" 3
typedef struct __locale_struct
{

  struct locale_data *__locales[13];


  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;
} *__locale_t;
# 109 "/usr/include/string.h" 2 3


extern int __strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
     throw () __attribute__ ((__pure__));

extern size_t __strxfrm_l (char *__dest, __const char *__src, size_t __n,
                           __locale_t __l) throw ();




extern char *strdup (__const char *__s) throw () __attribute__ ((__malloc__));






extern char *strndup (__const char *__string, size_t __n)
     throw () __attribute__ ((__malloc__));
# 155 "/usr/include/string.h" 3
extern char *strchr (__const char *__s, int __c) throw () __attribute__ ((__pure__));

extern char *strrchr (__const char *__s, int __c) throw () __attribute__ ((__pure__));




extern char *strchrnul (__const char *__s, int __c) throw () __attribute__ ((__pure__));




extern size_t strcspn (__const char *__s, __const char *__reject)
     throw () __attribute__ ((__pure__));


extern size_t strspn (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__));

extern char *strpbrk (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__));

extern char *strstr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__));



extern char *strcasestr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__));



extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
     throw ();



extern char *__strtok_r (char *__restrict __s,
                         __const char *__restrict __delim,
                         char **__restrict __save_ptr) throw ();

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
                       char **__restrict __save_ptr) throw ();






extern void *memmem (__const void *__haystack, size_t __haystacklen,
                     __const void *__needle, size_t __needlelen)
     throw () __attribute__ ((__pure__));



extern void *__mempcpy (void *__restrict __dest,
                        __const void *__restrict __src, size_t __n) throw ();
extern void *mempcpy (void *__restrict __dest,
                      __const void *__restrict __src, size_t __n) throw ();




extern size_t strlen (__const char *__s) throw () __attribute__ ((__pure__));




extern size_t strnlen (__const char *__string, size_t __maxlen)
     throw () __attribute__ ((__pure__));




extern char *strerror (int __errnum) throw ();



extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) throw ();




extern void __bzero (void *__s, size_t __n) throw ();



extern void bcopy (__const void *__src, void *__dest, size_t __n) throw ();


extern void bzero (void *__s, size_t __n) throw ();


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern char *index (__const char *__s, int __c) throw () __attribute__ ((__pure__));


extern char *rindex (__const char *__s, int __c) throw () __attribute__ ((__pure__));



extern int ffs (int __i) throw () __attribute__ ((__const__));




extern int ffsl (long int __l) throw () __attribute__ ((__const__));

__extension__ extern int ffsll (long long int __ll)
     throw () __attribute__ ((__const__));




extern int strcasecmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__));





extern int __strcasecmp_l (__const char *__s1, __const char *__s2,
                           __locale_t __loc) throw () __attribute__ ((__pure__));

extern int __strncasecmp_l (__const char *__s1, __const char *__s2,
                            size_t __n, __locale_t __loc)
     throw () __attribute__ ((__pure__));





extern char *strsep (char **__restrict __stringp,
                     __const char *__restrict __delim) throw ();




extern int strverscmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__));


extern char *strsignal (int __sig) throw ();


extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw ();
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw ();



extern char *__stpncpy (char *__restrict __dest,
                        __const char *__restrict __src, size_t __n) throw ();
extern char *stpncpy (char *__restrict __dest,
                      __const char *__restrict __src, size_t __n) throw ();


extern char *strfry (char *__string) throw ();


extern void *memfrob (void *__s, size_t __n) throw ();






extern char *basename (__const char *__filename) throw ();
# 364 "/usr/include/string.h" 3
}
# 22 "/usr/local/include/gcj/cni.h" 2 3

extern inline jobject
JvAllocObject (jclass cls)
{
  return _Jv_AllocObject (cls, cls->size());
}

extern inline jobject
JvAllocObject (jclass cls, jsize sz)
{
  return _Jv_AllocObject (cls, sz);
}

extern "C" jstring _Jv_NewStringUTF (const char *bytes);
extern "C" void _Jv_InitClass (jclass);

extern inline void
JvInitClass (jclass cls)
{
  return _Jv_InitClass (cls);
}

extern inline jstring
JvAllocString (jsize sz)
{
  return _Jv_AllocString (sz);
}

extern inline jstring
JvNewString (const jchar *chars, jsize len)
{
  return _Jv_NewString (chars, len);
}

extern inline jstring
JvNewStringLatin1 (const char *bytes, jsize len)
{
  return _Jv_NewStringLatin1 (bytes, len);
}

extern inline jstring
JvNewStringLatin1 (const char *bytes)
{
  return _Jv_NewStringLatin1 (bytes, strlen (bytes));
}

extern inline jchar *
_Jv_GetStringChars (jstring str)
{
  return (jchar*)((char*) str->data + str->boffset);
}

extern inline jchar*
JvGetStringChars (jstring str)
{
  return _Jv_GetStringChars (str);
}

extern inline jsize
JvGetStringUTFLength (jstring string)
{
  return _Jv_GetStringUTFLength (string);
}

extern inline jsize
JvGetStringUTFRegion (jstring str, jsize start, jsize len, char *buf)
{
  return _Jv_GetStringUTFRegion (str, start, len, buf);
}

extern inline jstring
JvNewStringUTF (const char *bytes)
{
  return _Jv_NewStringUTF (bytes);
}

class JvSynchronize
{
private:
  jobject obj;
public:
  JvSynchronize (const jobject &o) : obj (o)
    { _Jv_MonitorEnter (obj); }
  ~JvSynchronize ()
    { _Jv_MonitorExit (obj); }
};


extern void JvThrow (jobject obj) __attribute__ ((__noreturn__));
extern inline void
JvThrow (jobject obj)
{
  _Jv_Throw ((jthrowable) obj);
}


extern inline void *
JvMalloc (jsize size)
{
  return _Jv_Malloc (size);
}

extern inline void
JvFree (void *ptr)
{
  return _Jv_Free (ptr);
}
# 2 "/tmp/tesla.cc" 2



# 1 "/tmp/bigClass.h" 1
#pragma interface


extern "Java"
{
    namespace com
    {
        namespace spinnakernet
        {
            namespace bogus
            {
                namespace here
                {
                    class bigClass;
                }
            }
        }
    }
}

class com::spinnakernet::bogus::here::bigClass : public ::java::lang::Object
{
    public:
        virtual JArray< ::java::lang::String *> *getPortAttr (jint);
    public:
        bigClass();

        static ::java::lang::Class class$;
};
# 6 "/tmp/tesla.cc" 2


using namespace ::com::spinnakernet::bogus::here;

JArray< ::java::lang::String *> *
bigClass::getPortAttr(jint ifNum)
{
    typedef ::java::lang::String *JavaStringPtr;

    JArray<JavaStringPtr> *resultArray = new JArray<JavaStringPtr>;

    return __null;
}

>Fix:

>Release-Note:
>Audit-Trail:
>Unformatted:


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]