Native objects -- crossing the language boundary

Native bindings for these languages are available only on the level of functions. Even for Java, native methods of an object are defined as functions that receive a handle to the invoking object. Given a language with objects, possibly by adopting an object extension for the languages without objects, the problem is to find a proper correspondence between objects defined in the high-level (script) language and the native objects defined in C/C++.

In this (sub)section we will first study an extension of Prolog with objects, and then indicate a solution to establish a close correspondence between the (Prolog) objects and their native counterparts. In the next (sub)section, we will apply this approach to establish a correspondence between Java and C++ objects.

requirements

• low overhead, especially when not needed
• natural syntax for object clause definitions
• support for native objects

Objects (or classes of objects, if you prefer) are defined by a collection of clauses with a head predicate of the form class_method(This,...), specifying the class, method and object identity parameter. The actual invocation of the method takes the form self(This):method(...), where the colon acts as the familiar dot object access parameter. Note that the identity parameter (This) does not occur among the method parameters, but is instead contained in the object specifier. Instead of the keyword self, we may also use a class name to enforce a cast to specific object type when invoking the method. In the actual object extension, we also support object state instance variables, which are however not relevant for our discussion here.

Object methods may be defined as native by including a goal of the form native(Handler, Method, Result), where Handler specifies the (native) handler to be invoked, Method the actual request, and Result a variable to store the possible outcome of the request. When the Handler parameter is left unspecified, the handler defined for the object will be taken to effect the native call.

  
   midi  


  :- use(library(midi:[midi,lily,music,process])).
  :- declare(midi:object,class(midi),[handler]). 
  
  midi_midi(This) :- // constructor
          midi(This):handler(H),   // gets Handler from class
          declare(H,new(midi(This)),[],[],_).
  
  

  
 native methods


  midi_read(This,F) :- native(_,This,read(F),_). 
  midi_analyse(This,I,O) :- native(_,This,analyse(I,O),_).
  midi_open(This,F) :- native(_,This,open(F),_).
  midi_header(This,M) :- native(_,This,header(M,0,480),_).
  midi_track(This,X) :- native(_,This,track(X),_).
  midi_tempo(This,X) :- native(_,This,tempo(X),_).
  midi_event(This,D,C,M,T,V) :-
  		      native(_,This,event(D,C,M,T,V),_).
  

  midi_note(This,D,C,T,V) :- 
          Self = midi(This), // cast to midi
          Self:event(D,C,note_on,T,V),
          Self:event(D,C,note_off,T,V).
  
  midi_melody(This,L) :- self(This):melody(480,1,L,64).
  
  midi_melody(_This,_,_,[],_).
  
  midi_melody(This,D,C,[X|R],V) :-
          Self = self(This),
          Self:note(D,C,X,V),  
          midi_melody(This,D,C,R,V).   // direct invocation
  

Combining Java and C++

The solution to establishing corresponding object class hierarchies in Java and C++ that we have adopted relies on storing a reference to the native C++ object in the Java object and the conversion of this reference to a smart pointer encapsulating access to the native C++ object. Upcalls, which occur for example when Java handlers are invoked in response to an event, require some additional machinery, as will be explained shortly.

  JNIEXPORT jstring JNICALL method(getresult)(JNIEnv *env, jobject obj)
  {
    java_vm vm(env,obj);
    char *s = vm->result();
    if (s) return vm.string(s);
    else return vm.string("-");
  }
  

  JNIEXPORT void JNICALL method(bind)(JNIEnv *env, jobject obj,
  	       jstring s, jobject o)
  {
    java_vm vm(env,obj);
    java_vm* vmp = new java_vm(env,o,"Handler");
    const char *str = vm.get(s);
    handler* h = new handler();
    session::_default->_register(h);
    h->_vmp = vmp;
    h->_register(vmp);
    vm->bind(str,h);
    vm.release(s, str);
  }