🚀 go-pugleaf

In article <JANSSEN.94Nov9184617@holmes.PARC.Xerox.Com>
janssen@parc.xerox.com (Bill Janssen) writes:

   In article <BOBO.94Nov9112502@avogadro.arc.nasa.gov>
   bobo@avogadro.arc.nasa.gov (Mark Friedman) writes:

      Essentially, we need a free version of an Open Doc / OLE
      / Corba kind of thing. ILU is one such beast (see
      ftp://parcftp.parc.xerox.com/pub/ilu/1.6.4/announce.html). I think it
      has some problems (e.g. no support for first class procedures) but it
      would be one place to start.

   Mark and I have discussed the lack of first class procedures in ILU a
   bit.  It might be interesting syntactic sugar, but all functionality
   it would provide is already provided via the normal ILU object system.

I hate to get into one of these he said / she said discussions, but I
certainly do not agree that ILU supports first class procedures. 

I guess it comes down to what one believes "first class procedures"
means. To me it means (in the context of something like ILU) that you
could pass a procedure P-CA (as defined in the calling language CA) to a
procedure P-CE implemented in the callee language CE and have P-CE be
able to call P-CA using the native calling mechanism of CE. For
example I'd like to be able to do something like the following using C
and Lisp as examples of P-CE and P-CA respectively (using a made up
ILU-like language):

foo.c:

  TYPE Proc1 =  PROC (INT) RETURNS INT;
  DECLARE foo (INT, Proc1) RETURNS INT;

  int foo (my_int, lisp_proc) 
    int my_int;
    int *lisp_proc();
  {
    lisp_proc(my_int);
  }

bar.lisp

  (ilu-declare-type proc1 (int) int)
  (ilu-declare foo (int proc1) int)

  (defun lisp-proc (my-int)
     (whatever my-int))

  (foo #'lisp-proc)

I don't believe that ILU can support this kind of use. As Bill
mentioned to me, it can't be done by an portable implementation coded
entirely in C. You need to be able to create the C lisp_proc at
runtime and C has no capability for that. You need a little assembly
language procedure (or call your C compiler at run time and
dynamically load some code) to build it.

The reason that I want this is so that I can pass arbitrary Lisp
callbacks to C functions whose source code I have no access to. The
callback has to just look like a C function.

   We are considering describing a possible ILU "cliche", such as

     TYPE CallbackProc1 = OBJECT SUPERTYPES ilu.FirstClassProc END
       METHODS
	 Invoke (  (* args here *)  )
       END;

The problem that I have with this approach is that I have to do my own
bookeeping on the Lisp side. I only have a single function
(i.e. Invoke) which all the C functions use as their callback
function. It's up to Invoke on the Lisp side to figure out which Lisp
procedure I really wanted to call.

This might work if the C function passes enough information to
determine where the callback was called from, but in general it might
not do that.

-Mark
-- 
Mark Friedman
NASA-Ames Research Center
MS 269-2
Moffett Field, CA 94035-1000

vmail: (415) 604-0573
email: bobo@ptolemy.arc.nasa.gov