Re: idea.. check and grab new versions..?

["William M. Perry" <wmperry@aventail.com>]

Shannon F. Stewman writes:

>> But that's the easy part...the slightly harder part is getting it
>> extracted and built (e.g. using scripts as posted by Jan Vroonhof).
>> And, from what I know, there even harder part is getting it done online
>> so that you can hit an "update gnus" button in a message online
>> (e.g. Lars' announcements) that will fire it all of, then "exit" your
>> current gnus version and fire up the new gnus version while you wait
>> (with bonus points for getting you back in where you left off - reading
>> the announcement message :-)).
>
>While I'm aware that this might hit a raw nerve on some people, and might
>be considered an extreme folly, why not build some kind of scripting
>language into Gnus that would allow something to this effect? Such a
>language (called ness) has been used at CMU for some time, and without any
>serious (that I know of) harm coming to the script runners.
>
>While elisp does seem a good choice, I doubt it would pass the safety
>inspection of the skeptics. Perhaps a small scheme interpreter or
>otherwise, or am I just looking at some pie in the sky dream?

  This should really be in the raw lisp interpreter.  It should be able to
have a 'safe' mode, similar to the Safe module in Perl, or the restricted
VM in java, etc.

  You take too much of a performance penalty when trying to implement
something like this in lisp.  Ask me, I tried. :)

  I've done something similar for the DSSSL parser I have for Emacs-W3.
Basically, parsing is a snap, but then when you get down to the nitty
gritty of evaluation, things bog down.  I keep the variables and function
defs in a big hashtable thats passed around in the interpreter.  Code
basically looks like:

(defun dsssl-eval (form)
  ;; We expect to have a 'defines' and 'units' hashtable floating around
  ;; from higher up the call stack.
  (declare (special defines units))
  (cond
   ((consp form)			; A function call
    (let ((func (car form))
	  (args (cdr form)))
      (case func
	(cons
	 (dsssl-check-args args 2)
	 (cons (dsssl-eval (pop args)) (dsssl-eval (pop args))))
	(cdr
.
.
.

  Which goes on for about 300 lines.  And its not even half finished, for a
limited implementation of a scheme-like language.  Function calls and let
bindings are a bitch.  But I think I'll be able to do lexical scoping and
closures.  Ohhhhhh yeah.

-Bill P.