include: java.h hush-3.1/include/hush

  ifndef HUSH_JAVA_H
  define HUSH_JAVA_H
  
  include <hush/export.h>
  include <hush/flags.h>
  
  include <hush/vm.h> 
  
  ifdef JAVA
  
  include <jni.h>
  include <string.h>
  include <hush/io.h>
  
  #undef string
  
  

java_vm

  template<class T>
  class java_vm : public vm<T> {
  public:
  java_vm(const char* clazz = 0, const char* classpath = 0) {
          jint res; _self = 0; _global = 0;
          if (!vm_type::jvm) {
                  JNIEnv *env;
                  JavaVM *jvm;
                  JDK1_1InitArgs vm_args;
                  vm_args.version = 0x00010001;
                  if (classpath) vm_args.classpath = (char*) classpath;
                  JNI_GetDefaultJavaVMInitArgs(&vm_args);
                  res = JNI_CreateJavaVM(&jvm,&env,&vm_args);
                  if (res < 0) {
                      cerr << "Can't create Java VM" << endl;
                      }
                  else {
                          vm_type::jvm = (void*) jvm;
                          vm_type::env = (void*) env;
                          }
                  }
          _jvm = (JavaVM*) vm_type::jvm;
          _env = (JNIEnv*) vm_type::env;
          _cls = 0;
          if (clazz) {
                  strcpy(_clazz,clazz);
                  _cls = _env->FindClass(_clazz);
                  }
          _obj = 0;
          }
  
  

  public:
  
  java_vm(JNIEnv* env_, jobject obj_, char* clazz_ = 0) { 
          _jvm = 0;
          _global = 0;
          _env = env_; 
          _obj = obj_;
          _cls = _env->GetObjectClass(_obj);
          if (clazz_) {
                  strcpy(_clazz,clazz_); 
                  _global = 1;
                  _obj = _env->NewGlobalRef(_obj);
                  }
          else _clazz[0]='\0';
          _self = self();
          }
  
  ~java_vm() {
          if (_global && _obj)
                  env()->DeleteGlobalRef(_obj);
          }
  
  JNIEnv* env() { return _env?_env:((JNIEnv*)vm_type::env); }
  
  JavaVM* jvm() { return _jvm?_jvm:((JavaVM*)vm_type::jvm); }
  
  event* dispatch(event* e) {
          callIV("dispatch",(int)e);
          return e;
          }
  
  void trace() {
          //cerr << "Invoking" <<  clazz << endl;
          }
  
  

  public:
  
  T* operator->() { return _global?self():_self; }
  
  T* self() {
          jfieldID fid = fieldID("_self","I");
          return (T*) env()->GetIntField( object(), fid);
          }
  
  

  public:
  
  jfieldID fieldID(const char* fd, const char* sig) {
          if (_global) _cls = env()->GetObjectClass(object());
          return env()->GetFieldID( _jclass(), fd, sig);
          }
  
  jmethodID methodID(const char* md, const char* sig) {
          //cerr << "methodID " << md << " " << sig << endl;
          if (_global) _cls = env()->GetObjectClass(object());
          return env()->GetMethodID( _jclass(), md, sig);
          }
  
  jmethodID smethodID(const char* md, const char* sig) {
          //cerr << "smethodID " << md << " " << sig << " " <<  (void*)_cls << endl;
          if (_global) _cls = env()->GetObjectClass(object());
          return env()->GetStaticMethodID( _jclass(), md, sig);
          }
  
  

  public:
  
  void callV(const char* md) {
          jmethodID mid = methodID(md,"()V");
          env()->CallVoidMethod(object(), mid);
          }
  
  void callSaV(const char* md, /*jobjectArray*/ jarray args) {
          jmethodID mid = methodID(md,"([Ljava/lang/String;)V");
          env()->CallVoidMethod(object(), mid,args);
          }
  
  void callIV(const char* md, int i) {
          jmethodID mid = methodID(md,"(I)V");
          env()->CallVoidMethod(object(), mid, i);
          }
  
  int callVI(const char* md) {
          jmethodID mid = methodID(md,"()I");
          return env()->CallIntMethod(object(), mid);
          }
  
  int call(const char* md) { return callVI(md); }
  
  

  public:
  
  void scallV(const char* md) {
          jmethodID mid = smethodID(md,"()V");
          env()->CallStaticVoidMethod(_jclass(), mid);
          }
  
  void scallSaV(const char* md, /*jobjectArray*/jarray args) {
          jmethodID mid = smethodID(md,"([Ljava/lang/String;)V");
          env()->CallStaticVoidMethod(_jclass(), mid,args);
          }
  
  void scallOaV(const char* md, /*jobjectArray*/jarray args) {
          jmethodID mid = smethodID(md,"([Ljava/lang/Object;)V");
          env()->CallStaticVoidMethod(_jclass(), mid,args);
          }
  
  void scallIV(const char* md, int i) {
          jmethodID mid = smethodID(md,"(I)V");
          env()->CallStaticVoidMethod(_jclass(), mid, i);
          }
  
  void scallSV(const char* md, char* s) {
          jstring str = env()->NewStringUTF(s);
          jmethodID mid = smethodID(md,"(Ljava/lang/String;)V");
          env()->CallStaticVoidMethod(_jclass(), mid, str);
          }
  
  int scallVI(const char* md) {
          jmethodID mid = smethodID(md,"()I");
          return env()->CallStaticIntMethod(_jclass(), mid);
          }
  
  int scall(const char* md) { return scallVI(md); }
  
  

  public:
  
  jclass  _jclass(const char* clazz) {
          return env()->FindClass(clazz);
          }
  
  jclass  _jclass() {
          if (_cls) return _cls;
          if (_obj) _cls = env()->GetObjectClass(_obj);
          if (!_cls) _cls = env()->FindClass(_clazz);
          if (!_cls) {
                  cerr << "No .class. found for " << _clazz << endl;
                  }
          return _cls;
          }
  
  jclass  clazz(const char* cl) { return _jclass(cl); }
  
  jobject object() {
          if (_obj) return _obj;
          else {
                  //cerr << "No object found for " << _clazz << endl;
                  }
          return _obj;
          }
  
  jarray  array(int n, jclass cl, jobject o) {
          return env()->NewObjectArray(n,cl,o);
          }
  
  jstring string(const char* s) {
          return env()->NewStringUTF(s);
          }
  
  char* get(jstring js) {
          return hstr = (char*) env()->GetStringUTFChars(js, 0);
          }
  
  void release(jstring js, const char* str = 0) {
          char* p = str?(char*)str:hstr;
          env()->ReleaseStringUTFChars(js, p);
          }
  
  

  private:
  char* hstr; // to hold a string
  
  int _global;
  char _clazz[128];
  JNIEnv* _env;
  jobject _obj;
  jclass _cls;
  JavaVM* _jvm;
  T* _self;
  };

  
  inline void java_vm_cout(handler* h, char* s) {
          (*(java_vm<handler>*)h->the_vm()).trace();
          (*(java_vm<handler>*)h->the_vm()).scallSV("cout",s);
          }
  
  inline void java_vm_cerr(handler* h, char* s) {
          (*(java_vm<handler>*)h->the_vm()).trace();
          (*(java_vm<handler>*)h->the_vm()).scallSV("cerr",s);
          }
  
  inline event* java_vm_dispatch(handler* h, event* e) {
          (*(java_vm<handler>*)h->the_vm()).trace();
          (*(java_vm<handler>*)h->the_vm()).callIV("dispatch",(int)e);
          return e;
          }
  endif
  endif
  

Hush Online Technology hush@cs.vu.nl 11/03/98