[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

ACL 3.1 for NeXT 2.0/2.1 (030 and 040)

I am happy to announce that Allegro Common Lisp for NeXT 2.0/2.1 with
either an 030 or 040 board is now released.  It is being distributed
on 8-1.44MB 3.5" micro floppy disks.

Contact Franz Inc. at (415) 548-3600 or info@franz.com for more

I've appended a response I sent to comp.sys.next, which contains some
potentially interesting information about the NeXT ACL.

Kevin Layer, Franz Inc.         1995 University Avenue, Suite 275
layer@Franz.COM (internet)      Berkeley, CA  94704
uunet!franz!layer (uucp)        Phone: (415) 548-3600; FAX: (415) 548-8253

 article <210@gouche.UUCP> grant@gouche.UUCP (Grant Munsey) writes:

   Is the complete version of
   Allegro 3.1 for Next 2.0 shipping? Does it have any hooks into
   NIB/Objective C.

While you want a user's testimony of Allegro CL on the NeXT, I can add
that ACL on the NeXT is complete with respect to ACL 3.1 available on
other machines.  In addition to being complete, there are some nice
additional features of ACL on the NeXT:

1. Due to Mach, running an image created dumplisp (saving the running
   image to disk for later execution in the "same" state) is
   particularly efficient at start because we use the memory mapping
   features of the Mach-O (object) file format.  On non-Mach systems
   we must "shuffle" parts of the heap to their final location instead
   of having them mapped there from the object file itself.

2. Also due to Mach, a foreign file can be reloaded without removing
   the entry points that clash.  So,

	(load "foo.o")
	(load "foo.o")

   will "unmap" foo.o before the second load.

3. There is an interface to Objective-C, which offers the ability to
   dynamically load Objective-C object files into ACL and to define
   Objective-C classes and methods.  Below is an example application,
   which creates a window that reads expressions from the users,
   evaluates the results and prints the *Lisp* results.  There is a
   `nib' file which is not included here (it is on the Allegro CL
   distribution, however).

;; Evaluator
;; A very simple class and set of method definitions which demonstrates
;; the high interactiveness between lisp and an interface built by the
;; interface builder.
;; Written by Charley Cox, Franz Inc. Aug, 1989
;; When this file is loaded into lisp, a window with two text forms,
;; a button, and a sample form cell is brought up.  One can type
;; forms into the input form, and see what lisp returns through the
;; output form.  The output form is not bound to *standard-output*.
;; Thus, *standard-output* will, by default, be the terminal running lisp.
;; Hitting return in the input form is equivalent to clicking on the
;; button (this example is heavily inspired by the sample
;; project in the NeXT chapter on using the interface builder).
;; Some things to play with are to see what happens when you type the
;; following things into lisp:
;; self
;; (break)	;; This enters a lisp break loop--to continue with the
;;		;; application, type `:cont' to the lisp.  Do not type
;;		;; `:res' or (reset) since that throws you out of the
;;		;; application.
;; The following (print-* ...) functions will print to standard output
;; and not to the display window.
;; (print-class-ivars (send self "class"))
;;		;; This should print out the three outlets that were designed
;;		;; by the interface builder.  They are outputForm, inputForm,
;;		;; and testForm.  testForm is for the TestForm Cell.
;; (print-class-methods (send (iv "testForm") "class"))
;;		;; This prints the methods available to the TestForm Cell.
;;		;; One of these methods should be `setEnabled:'.
;; (send (iv "testForm") "setEnabled=" 0)
;;		;; This `dims' the test form cell.  Calling "setEnabled="
;;		;; with argument 1, restores it.
;; (send (iv "testForm") "setStringValue=" (string-to-char* "Hello, There"))
;;		;; This displays the string in TestForm's window.

;; $aclHeader: Evaluator.cl,v 1.1 89/08/28 18:51:30 layer Exp Locker: layer $

(in-package :evaluator)

(require :objc)

(require :foreign)
(use-package :excl)
(use-package :objc)
(use-package :appkit)
(use-package :foreign-functions)

(def-objc-class Evaluator (Object)
  ((outputForm :type :id)
   (inputForm :type :id)
   (testForm :type :id)))

(def-objc-method (setOutputForm= Evaluator :id) ((anObject :id))
  (setf (iv "outputForm") anObject)

(def-objc-method (setInputForm= Evaluator :id) ((anObject :id))
  (setf (iv "inputForm") anObject)

(def-objc-method (setTestForm= Evaluator :id) ((anObject :id))
  (setf (iv "testForm") anObject)

(def-objc-method (eval= Evaluator :id) ((sender :id))
  (let* ((raw-input-string (send (iv "inputForm") "stringValue"))
	 (input-string (char*-to-string raw-input-string)))    
    (send (iv "inputForm") "selectText=" sender)
    (send (iv "outputForm") 
	     (read-from-string input-string)))))))

(format t "Starting application...~%")

(format t "making application...") (force-output)
(make-application "eval")

(format t "loading nib file...") (force-output)
(send NXApp "loadNibFile=owner="
      (namestring (merge-pathnames "objc/Evaluator.nib"

(format t "running...")

(format t "done~%")