diff options
Diffstat (limited to 'com')
42 files changed, 1032 insertions, 0 deletions
diff --git a/com/README b/com/README new file mode 100644 index 0000000..806c62a --- /dev/null +++ b/com/README @@ -0,0 +1,4 @@ +This directory contains various useful command scripts. Scripts +that are specific to a particular host Lisp are found in the appropriate +subdirectories. Scripts for building release distribution are in the +distrib subdirectory. diff --git a/com/akcl/README b/com/akcl/README new file mode 100644 index 0000000..1e997d5 --- /dev/null +++ b/com/akcl/README @@ -0,0 +1,39 @@ +This directory contains command scripts used for building Yale Haskell +from the source distribution under AKCL. We have been using +AKCL version 1.615 on a Sparc, but we don't expect that there would +be difficulties in building with AKCL on other platforms. + +Developers need to source haskell-development instead of haskell-setup +in the .cshrc file. + +To rebuild the system: + +* You need to define environment variables Y2 and AKCL to point to the + appropriate pathnames. See the haskell-development script for details. + +* Make sure that the environment variable PRELUDEBIN (in the + haskell-setup script) points to $PRELUDE/akcl. + +* Execute the "compile" script. This will recompile all of the Lisp + source files that make up the Yale Haskell system. Compiled files are + put in the "akcl" subdirectory of each source directory. + +* Execute the "build-prelude" script to compile the standard prelude. + Note that this process tends to use up a huge amount of memory! + +* Execute the "savesys" script to build a new executable. + +* The new executable is initially called "bin/new-akcl-haskell". Try + it out. If it works, you should rename it to "bin/akcl-haskell". + Make sure that HASKELLPROG (in the haskell-setup script) is correct. + +A word of warning: we have noticed that AKCL is slower by a factor of +three or four than the other Common Lisps we've ported Yale Haskell +to. We don't really support AKCL and we encourage you to buy one of +the commercial Lisp products instead. + +We do not support our Haskell-to-CLX interface under AKCL, either. + + + + diff --git a/com/akcl/build-prelude b/com/akcl/build-prelude new file mode 100755 index 0000000..8f61827 --- /dev/null +++ b/com/akcl/build-prelude @@ -0,0 +1,35 @@ +#!/bin/csh +# +# build-prelude -- recompile the prelude, saving the old one as old-prelude.* +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/akcl +rm $PRELUDEBIN/old* +if (-e $PRELUDEBIN/Prelude.o) then + foreach i ($PRELUDEBIN/Prelude*.{o,scm}) + mv $i $PRELUDEBIN/old-$i:t + end + endif +$AKCL <<EOF +;; Need a big heap to compile the prelude. +;(setf ext:*bytes-consed-between-gcs* 10000000) +;; If you want to recompile +;; everything from scratch, execute the "clean" script first, or +;; else use the "compile" script to do this. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(load "cl-support/cl-init.lisp") +;; Use the same compiler settings for processing the prelude. +(in-package :mumble-user) +(setf *printers* '(phase-time dump-stat)) +(setf *optimizers* *all-optimizers*) +;; The compiler barfs while compiling the interface file for the prelude, +;; so set the flag for writing it as a source file. +;; Also have it break up the prelude code file into many small pieces +;; to avoid overwhelming the C compiler. +(setf *code-chunk-size* 100) +(setf *compile-interface* '#f) +(compile/compile *prelude-unit-filename*) +(lisp:bye) +EOF diff --git a/com/akcl/clean b/com/akcl/clean new file mode 100755 index 0000000..aba58af --- /dev/null +++ b/com/akcl/clean @@ -0,0 +1,4 @@ +#!/bin/csh +# +# delete AKCL binaries +'rm' $Y2/*/akcl/*.o diff --git a/com/akcl/compile b/com/akcl/compile new file mode 100755 index 0000000..3ed28f5 --- /dev/null +++ b/com/akcl/compile @@ -0,0 +1,11 @@ +#!/bin/csh +# +# compile -- compile the Yale Haskell system from scratch. +# +# +cd $Y2 +$AKCL <<EOF +;; Default optimize settings for AKCL are (speed 3) (safety 0) +(load "support/cl-support/cl-init.lisp") +(bye) +EOF diff --git a/com/akcl/savesys b/com/akcl/savesys new file mode 100755 index 0000000..c01db2b --- /dev/null +++ b/com/akcl/savesys @@ -0,0 +1,46 @@ +#!/bin/csh +# +# savesys -- build a saved executable in bin/new-cmu-haskell.core +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/akcl +if !(-e $PRELUDEBIN/Prelude.o) then + echo "Build the prelude first, stupid..." + exit + endif +$AKCL <<EOF +;;; Load the Haskell system. +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(load "cl-support/cl-init.lisp") +;;; Set various internal switches to appropriate values for running +;;; Haskell code. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(setf *load-verbose* nil) +(setf compiler:*compile-verbose* nil) +(in-package :mumble-user) +(setf *printers* '(compiling loading)) +(setf *optimizers* '()) +(setf *compile-interface* '#f) +(setf *code-chunk-size* 100) +;;; Load the prelude. +(compile/load *prelude-unit-filename*) +;;; Set up the saved system. +;;; AKCL doesn't have the new CL condition system, so define the +;;; restart function using catch and throw. +(define (haskell-toplevel) + (setf lisp:*package* (lisp:find-package :mumble-user)) + (setf lisp:*default-pathname-defaults* (lisp:truename "./")) + (load-init-files) + (do () ('#f) + (lisp:catch 'restart-haskell + (heval)))) +(define (restart-haskell) + (lisp:throw 'restart-haskell '#f)) +;;; Have to do garbage collection and set-up of top-level function +;;; by hand before calling save. +;;; AKCL exits automatically after calling save. +(lisp:gbc 3) +(setf system::*top-level-hook* (function haskell-toplevel)) +(lisp:save "bin/new-akcl-haskell") +EOF diff --git a/com/allegro/README b/com/allegro/README new file mode 100644 index 0000000..b9dc676 --- /dev/null +++ b/com/allegro/README @@ -0,0 +1,40 @@ +This directory contains command scripts used for building Yale Haskell +from the source distribution under Franz Allegro Common Lisp. We've +been using version 4.1 on both NeXT and Sparc platforms -- don't +expect our code to work without modifications under earlier versions. + +Be sure you load the Allegro patches -- the scripts do this +automatically. If you're trying to build on some other kind of +platform, you'll have to get the equivalent patches from Franz Inc. +Our code won't work without these bug fixes. + +Developers need to source haskell-development instead of haskell-setup +in the .cshrc file. + +To rebuild the system: + +* You need to define environment variables Y2 and ALLEGRO to point to the + appropriate pathnames. See the haskell-development script for details. + +* Make sure that the environment variable PRELUDEBIN (in the + haskell-setup script) points to $PRELUDE/allegro (or $PRELUDE/allegro-next, + as appropriate). + +* Execute the "compile" script. This will recompile all of the Lisp + source files that make up the Yale Haskell system. Compiled files are + put in the "allegro" or "allegro-next" subdirectory of each source directory. + +* Execute the "build-prelude" script to compile the standard prelude. + Note that this process tends to use up a huge amount of memory! + +* Execute the "savesys" script to build a new executable. + +* The new executable is initially called "bin/new-allegro-haskell". Try + it out. If it works, you should rename it to "bin/allegro-haskell". + Make sure that HASKELLPROG (in the haskell-setup script) is correct. + +* If you want to build an executable with the X support, you'll also + need to run the "build-xlib" and "savesys-xlib" scripts. You may + need to edit these scripts to change the pathname of the file + containing the CLX library (or suppress the load entirely if you + are using a Lisp executable with CLX pre-loaded.). diff --git a/com/allegro/build-prelude b/com/allegro/build-prelude new file mode 100755 index 0000000..44fb422 --- /dev/null +++ b/com/allegro/build-prelude @@ -0,0 +1,32 @@ +#!/bin/csh +# +# build-prelude -- recompile the prelude, saving the old one as old-prelude.* +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/$ALLEGRODIR +if (-e $PRELUDEBIN/Prelude.fasl) then + rm $PRELUDEBIN/old* + foreach i ($PRELUDEBIN/Prelude*.{fasl,scm}) + mv $i $PRELUDEBIN/old-$i:t + end + endif +$ALLEGRO <<EOF +;; Need a big heap to compile the prelude. +;;(lcl:change-memory-management :expand 512 :growth-limit 2048) +#+next (progn (load "com/allegro/next-patches/patch0149.fasl") + (load "com/allegro/next-patches/patch0151.fasl")) +#+sparc (load "com/allegro/sparc-patches/patch0151.fasl") +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(load "cl-support/cl-init") +(in-package :mumble-user) +(setf *printers* '(phase-time dump-stat)) +(setf *optimizers* *all-optimizers*) +;; Set appropriate compiler settings for processing the prelude. +;; Don't try to compile the interface. +(setf *code-chunk-size* 300) +(setf *compile-interface* '#f) +(compile/compile *prelude-unit-filename*) +(excl:exit) +EOF diff --git a/com/allegro/build-xlib b/com/allegro/build-xlib new file mode 100755 index 0000000..a805308 --- /dev/null +++ b/com/allegro/build-xlib @@ -0,0 +1,14 @@ +#!/bin/csh +# +# build-xlib -- recompile the xlib stuff +# +# note that allegro's loader will look in its lib directory automagically +# for the clx library +cd $Y2 +setenv LIBRARYBIN $Y2/progs/lib/X11/$ALLEGRODIR +rm $LIBRARYBIN/xlib*.sbin +bin/allegro-haskell <<EOF +:(lisp:load "clx") +:(setf *code-quality* 3) +:compile \$HASKELL_LIBRARY/X11/xlib +EOF diff --git a/com/allegro/clean b/com/allegro/clean new file mode 100755 index 0000000..dadab0f --- /dev/null +++ b/com/allegro/clean @@ -0,0 +1,5 @@ +#!/bin/csh +# +# delete Allegro CL binaries +'rm' $Y2/*/$ALLEGRODIR/*.fasl + diff --git a/com/allegro/compile b/com/allegro/compile new file mode 100755 index 0000000..6aadee8 --- /dev/null +++ b/com/allegro/compile @@ -0,0 +1,15 @@ +#!/bin/csh +# +# compile -- compile the Yale Haskell system from scratch. +# +# +cd $Y2 +$ALLEGRO <<EOF +#+next (progn (load "com/allegro/next-patches/patch0149.fasl") + (load "com/allegro/next-patches/patch0151.fasl")) +#+sparc (load "com/allegro/sparc-patches/patch0151.fasl") +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(load "cl-support/cl-init") +(excl:exit) +EOF diff --git a/com/allegro/next-patches/patch0149.fasl b/com/allegro/next-patches/patch0149.fasl Binary files differnew file mode 100644 index 0000000..da10254 --- /dev/null +++ b/com/allegro/next-patches/patch0149.fasl diff --git a/com/allegro/next-patches/patch0151.fasl b/com/allegro/next-patches/patch0151.fasl Binary files differnew file mode 100644 index 0000000..c954667 --- /dev/null +++ b/com/allegro/next-patches/patch0151.fasl diff --git a/com/allegro/savesys b/com/allegro/savesys new file mode 100755 index 0000000..3d3abd8 --- /dev/null +++ b/com/allegro/savesys @@ -0,0 +1,54 @@ +#!/bin/csh +# +# savesys -- build a saved executable in bin/new-allegro-haskell +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/$ALLEGRODIR +if !(-e $PRELUDEBIN/Prelude.fasl) then + echo "Build the prelude first, stupid..." + exit + endif +$ALLEGRO <<EOF +;;; Load the Haskell system. +#+next (progn (load "com/allegro/next-patches/patch0149.fasl") + (load "com/allegro/next-patches/patch0151.fasl")) +#+sparc (load "com/allegro/sparc-patches/patch0151.fasl") +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(load "cl-support/cl-init") +;;; Set various internal switches to appropriate values for running +;;; Haskell code. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(setf *compile-verbose* nil) +(setf *load-verbose* nil) +(setf excl:*load-source-file-info* nil) +(setf excl:*record-source-file-info* nil) +(setf excl:*load-xref-info* nil) +(setf excl:*record-source-file-info* nil) +(in-package :mumble-user) +(setf *printers* '(compiling loading)) +(setf *optimizers* '()) +(setf *compile-interface* '#f) +;;; Load the prelude. +(compile/load *prelude-unit-filename*) +;;; Set up the saved system. +(define *saved-readtable* (lisp:copy-readtable lisp:*readtable*)) +(define (haskell-toplevel) + ;; Saved system always starts up in USER package. + (setf lisp:*package* (lisp:find-package :mumble-user)) + ;; Saved system seems to forget about our readtable hacks. + (setf lisp:*readtable* *saved-readtable*) + ;; Set printer variables w/implementation-defined initial values + ;; to known values + (setf *print-pretty* '#f) + (load-init-files) + (do () ('#f) + (cl:with-simple-restart (restart-haskell "Restart Haskell.") + (heval)))) +(define (restart-haskell) + (cl:invoke-restart 'restart-haskell)) +(excl:dumplisp + :name #+next "bin/new-allegro-next-haskell" #-next "bin/new-allegro-haskell" + :restart-function 'haskell-toplevel) +(excl:exit) +EOF diff --git a/com/allegro/savesys-xlib b/com/allegro/savesys-xlib new file mode 100755 index 0000000..c8443a3 --- /dev/null +++ b/com/allegro/savesys-xlib @@ -0,0 +1,65 @@ +#!/bin/csh +# +# savesys -- build a saved executable in bin/new-allegro-haskell +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/$ALLEGRODIR +if !(-e $PRELUDEBIN/Prelude.fasl) then + echo "Build the prelude first, stupid..." + exit + endif +setenv LIBRARYBIN $Y2/progs/lib/X11/$ALLEGRODIR +if !(-e $LIBRARYBIN/xlib.fasl) then + echo "Build the xlib stuff first, silly..." + exit + endif +$ALLEGRO <<EOF +;;; Load the Haskell system. +#+next (progn (load "com/allegro/next-patches/patch0149.fasl") + (load "com/allegro/next-patches/patch0151.fasl")) +#+sparc (load "com/allegro/sparc-patches/patch0151.fasl") +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(load "cl-support/cl-init") +;;; Set various internal switches to appropriate values for running +;;; Haskell code. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(setf *compile-verbose* nil) +(setf *load-verbose* nil) +(setf excl:*load-source-file-info* nil) +(setf excl:*record-source-file-info* nil) +(setf excl:*load-xref-info* nil) +(setf excl:*record-source-file-info* nil) +(in-package :mumble-user) +(setf *printers* '(compiling loading)) +(setf *optimizers* '()) +(setf *compile-interface* '#f) +;;; Load the prelude. +(compile/load *prelude-unit-filename*) +;;; Load the X support. +(lisp:load "clx") +(compile/load "\$HASKELL_LIBRARY/X11/xlib") +(setf *haskell-compiler-update* + (string-append *haskell-compiler-update* "-X11")) +;;; Set up the saved system. +(define *saved-readtable* (lisp:copy-readtable lisp:*readtable*)) +(define (haskell-toplevel) + ;; Saved system always starts up in USER package. + (setf lisp:*package* (lisp:find-package :mumble-user)) + ;; Saved system seems to forget about our readtable hacks. + (setf lisp:*readtable* *saved-readtable*) + ;; Set printer variables w/implementation-defined initial values + ;; to known values + (setf *print-pretty* '#f) + (load-init-files) + (do () ('#f) + (cl:with-simple-restart (restart-haskell "Restart Haskell.") + (heval)))) +(define (restart-haskell) + (cl:invoke-restart 'restart-haskell)) +(excl:dumplisp + :name #+next "bin/new-allegro-next-clx-haskell" + #-next "bin/new-allegro-clx-haskell" + :restart-function 'haskell-toplevel) +(excl:exit) +EOF diff --git a/com/allegro/sparc-patches/patch0151.fasl b/com/allegro/sparc-patches/patch0151.fasl Binary files differnew file mode 100644 index 0000000..cfbc48f --- /dev/null +++ b/com/allegro/sparc-patches/patch0151.fasl diff --git a/com/clean b/com/clean new file mode 100755 index 0000000..91918e2 --- /dev/null +++ b/com/clean @@ -0,0 +1,14 @@ +#!/bin/csh +# +# clean -- delete binaries +# + +$Y2/com/lucid/clean +$Y2/com/cmu/clean +$Y2/com/allegro/clean +$Y2/com/lispworks/clean +$Y2/com/akcl/clean + +# T stuff +'rm' $Y2/*/t/*.{si,sd,sn,so} +'rm' $Y2/support/t-support/*.{si,sd,sn,so} diff --git a/com/cmu/README b/com/cmu/README new file mode 100644 index 0000000..3653d60 --- /dev/null +++ b/com/cmu/README @@ -0,0 +1,45 @@ +This directory contains command scripts used for building Yale Haskell +from the source distribution under CMU Common Lisp on the sparc. + +We have been using version 16f of CMU Common Lisp to build Haskell. +You can ftp this from lisp-rt1.slisp.cs.cmu.edu (128.2.217.9). +There is a known problem with this version of CMU CL: core files built +under SunOS 4.1.2 won't work under 4.1.3, and vice versa. There are +also apparently compatibility problems with 4.1.3 between sun4c and +sun4m architectures. Anyway, we have built under 4.1.2 on a sun4c +and 4.1.3 on a sun4m. + +Developers need to source haskell-development instead of haskell-setup +in the .cshrc file. + +To rebuild the system: + +* You need to define environment variables Y2, CMUCL, and CMUCLLIB to + point to the appropriate pathnames. See the haskell-development + script for details. + +* Make sure that the environment variable PRELUDEBIN (in the + haskell-setup script) points to $PRELUDE/cmu. + +* Execute the "compile" script. This will recompile all of the Lisp + source files that make up the Yale Haskell system. Compiled files + are put in the "cmu" subdirectory of each source directory. + +* Execute the "build-prelude" script to compile the standard prelude. + Note that this process tends to use up a huge amount of memory! + +* Execute the "savesys" script to save a core file. + +* The new core file is initially called "bin/new-cmu-haskell.core". + Use the -core command line argument to cmucl to test it. If it + works, you should rename it to "bin/sun4c-haskell.core" (or + "bin/sun4m-haskell.core") and use the "bin/cmu-haskell" script + to execute it. Make sure HASKELLPROG (in the haskell-setup script) + is correct. Depending on where you have cmucl this script may need + editing. + +* If you want to build an executable with the X support, you'll also + need to run the "build-xlib" and "savesys-xlib" scripts. You + need to edit these scripts to change the pathname of the file + containing the CLX library (or suppress the load entirely if you + are using a Lisp executable with CLX pre-loaded.). diff --git a/com/cmu/build-prelude b/com/cmu/build-prelude new file mode 100755 index 0000000..68d2621 --- /dev/null +++ b/com/cmu/build-prelude @@ -0,0 +1,32 @@ +#!/bin/csh +# +# build-prelude -- recompile the prelude, saving the old one as old-prelude.* +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/cmu +if (-e $PRELUDEBIN/Prelude.sparcf) then + rm $PRELUDEBIN/old* + foreach i ($PRELUDEBIN/Prelude*.{scm,sparcf}) + mv $i $PRELUDEBIN/old-$i:t + end + endif +$CMUCL <<EOF +;; Need a big heap to compile the prelude. +(setf ext:*bytes-consed-between-gcs* 10000000) +;; If you want to recompile +;; everything from scratch, execute the "clean" script first, or +;; else use the "compile" script to do this. +(proclaim '(optimize (speed 3) (safety 0) (debug 0) (ext:inhibit-warnings 3))) +(load "cl-support/cl-init") +;; Use the same compiler settings for processing the prelude. +(in-package :mumble-user) +(setf *printers* '(phase-time dump-stat)) +(setf *optimizers* *all-optimizers*) +;; The compiler barfs while compiling the interface file for the prelude, +;; so set the flag for writing it as a source file. +(setf *code-chunk-size* 300) +(setf *compile-interface* '#f) +(compile/compile *prelude-unit-filename*) +(ext:quit) +EOF diff --git a/com/cmu/build-xlib b/com/cmu/build-xlib new file mode 100755 index 0000000..df6eb05 --- /dev/null +++ b/com/cmu/build-xlib @@ -0,0 +1,15 @@ +#!/bin/csh +# +# build-xlib -- recompile the xlib stuff +# +# +cd $Y2 +setenv CLXFILE /net/nebula/homes/systems/hcompile/cmu/lib/subsystems/clx-library.sparcf +setenv LIBRARYBIN $Y2/progs/lib/bin/cmu +rm $LIBRARYBIN/xlib*.sparcf +bin/cmu-haskell <<EOF +:(setf ext:*bytes-consed-between-gcs* 8000000) +:(load "\$CLXFILE") +:(setf *code-quality* 3) +:compile \$HASKELL_LIBRARY/X11/xlib +EOF diff --git a/com/cmu/clean b/com/cmu/clean new file mode 100755 index 0000000..370ed36 --- /dev/null +++ b/com/cmu/clean @@ -0,0 +1,4 @@ +#!/bin/csh +# +# delete CMU CL binaries +'rm' $Y2/*/cmu/*.sparcf diff --git a/com/cmu/compile b/com/cmu/compile new file mode 100755 index 0000000..e4126ea --- /dev/null +++ b/com/cmu/compile @@ -0,0 +1,12 @@ +#!/bin/csh +# +# compile -- compile the Yale Haskell system from scratch. +# +# +cd $Y2 +$CMUCL <<EOF +(setf ext:*bytes-consed-between-gcs* 4000000) +(proclaim '(optimize (speed 3) (safety 0) (debug 0) (ext:inhibit-warnings 3))) +(load "cl-support/cl-init") +(quit) +EOF diff --git a/com/cmu/savesys b/com/cmu/savesys new file mode 100755 index 0000000..b3b0672 --- /dev/null +++ b/com/cmu/savesys @@ -0,0 +1,46 @@ +#!/bin/csh +# +# savesys -- build a saved executable in bin/new-cmu-haskell.core +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/cmu +if !(-e $PRELUDEBIN/Prelude.sparcf) then + echo "Build the prelude first, stupid..." + exit + endif +$CMUCL <<EOF +;;; Load the Haskell system. +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(load "cl-support/cl-init") +;;; Set various internal switches to appropriate values for running +;;; Haskell code. +(setf ext:*bytes-consed-between-gcs* 4000000) +(proclaim '(optimize (speed 3) (safety 0) (debug 0) (ext:inhibit-warnings 3))) +(setf *load-verbose* nil) +(setf *compile-verbose* nil) +(in-package :mumble-user) +(gc-messages '#f) +(setf *printers* '(compiling loading)) +(setf *optimizers* '()) +(setf *compile-interface* '#f) +;;; Load the prelude. +(compile/load *prelude-unit-filename*) +;;; Set up the saved system. +(define (haskell-toplevel) + (load-init-files) + (do () ('#f) + (lisp:with-simple-restart (restart-haskell "Restart Haskell.") + (heval)))) +(define (restart-haskell) + (lisp:invoke-restart 'restart-haskell)) +(ext:save-lisp "bin/new-cmu-haskell.core" + :purify '#t + :root-structures '() + :init-function 'haskell-toplevel + :load-init-file '#f + :site-init '#f + :print-herald '#f + ) +(ext:quit) +EOF diff --git a/com/cmu/savesys-xlib b/com/cmu/savesys-xlib new file mode 100755 index 0000000..763e680 --- /dev/null +++ b/com/cmu/savesys-xlib @@ -0,0 +1,57 @@ +#!/bin/csh +# +# savesys-xlib -- build a saved executable in bin/new-cmu-clx-haskell.core +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/cmu +if !(-e $PRELUDEBIN/Prelude.sparcf) then + echo "Build the prelude first, stupid..." + exit + endif +setenv CLXFILE /net/nebula/homes/systems/hcompile/cmu/lib/subsystems/clx-library.sparcf +setenv LIBRARYBIN $Y2/progs/lib/bin/cmu +if !(-e $LIBRARYBIN/xlib.sparcf) then + echo "Build the xlib stuff first, silly..." + exit + endif +$CMUCL <<EOF +;;; Load the Haskell system. +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(load "cl-support/cl-init") +;;; Set various internal switches to appropriate values for running +;;; Haskell code. +(setf ext:*bytes-consed-between-gcs* 4000000) +(proclaim '(optimize (speed 3) (safety 0) (debug 0) (ext:inhibit-warnings 3))) +(setf *load-verbose* nil) +(setf *compile-verbose* nil) +(in-package :mumble-user) +(gc-messages '#f) +(setf *printers* '(compiling loading)) +(setf *optimizers* '()) +(setf *compile-interface* '#f) +;;; Load the prelude. +(compile/load *prelude-unit-filename*) +;;; Load the X support. +(load "\$CLXFILE") +(compile/load "\$HASKELL_LIBRARY/X11/xlib") +(setf *haskell-compiler-update* + (string-append *haskell-compiler-update* "-X11")) +;;; Set up the saved system. +(define (haskell-toplevel) + (load-init-files) + (do () ('#f) + (lisp:with-simple-restart (restart-haskell "Restart Haskell.") + (heval)))) +(define (restart-haskell) + (lisp:invoke-restart 'restart-haskell)) +(ext:save-lisp "bin/new-cmu-clx-haskell.core" + :purify '#t + :root-structures '() + :init-function 'haskell-toplevel + :load-init-file '#f + :site-init '#f + :print-herald '#f + ) +(ext:quit) +EOF diff --git a/com/lispworks/README b/com/lispworks/README new file mode 100644 index 0000000..bf7aab2 --- /dev/null +++ b/com/lispworks/README @@ -0,0 +1,43 @@ +This directory contains command scripts used for building Yale Haskell +from the source distribution under Lispworks from Harlequin. We have +been using version 3.1.1 on a Sparc. + +Developers need to source haskell-development instead of haskell-setup +in the .cshrc file. + +Important: Make sure you load the stuff in the patches directory +before trying to build the system (the command files do this for you). +If you're building on some platform other than a sparc, you'll have to +get equivalent patches from Harlequin before proceeding. + +To rebuild the system: + +* You need to define environment variables Y2 and LISPWORKS to point to the + appropriate pathnames. See the haskell-development script for details. + +* Make sure that the environment variable PRELUDEBIN (in the + haskell-setup script) points to $PRELUDE/lispworks. + +* Execute the "compile" script. This will recompile all of the Lisp + source files that make up the Yale Haskell system. Compiled files are + put in the "lispworks" subdirectory of each source directory. + +* Execute the "build-prelude" script to compile the standard prelude. + Note that this process tends to use up a huge amount of memory! + +* Execute the "savesys" script to build a new executable. + +* The new executable is initially called "bin/new-lispworks-haskell". Try + it out. If it works, you should rename it to "bin/lispworks-haskell". + Make sure that HASKELLPROG (in the haskell-setup script) is correct. + +* If you want to build an executable with the X support, you'll also + need to run the "build-xlib" and "savesys-xlib" scripts. You may + need to edit these scripts to load the CLX library explicitly if + you are using a Lisp executable that doesn't have CLX pre-loaded. + +When you compile things with the Lispworks compiler, you'll see a +bunch of messages complaining about forward references to things that +haven't yet been defined. We haven't been able to figure out how to +suppress these messages, so unless something else goes wrong you should +just ignore them. diff --git a/com/lispworks/build-prelude b/com/lispworks/build-prelude new file mode 100755 index 0000000..cde5619 --- /dev/null +++ b/com/lispworks/build-prelude @@ -0,0 +1,35 @@ +#!/bin/csh +# +# build-prelude -- recompile the prelude, saving the old one as old-prelude.* +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/lispworks +if (-e $PRELUDEBIN/Prelude.wfasl) then + rm $PRELUDEBIN/old* + foreach i ($PRELUDEBIN/Prelude*.{wfasl,scm}) + mv $i $PRELUDEBIN/old-$i:t + end + endif +$LISPWORKS <<EOF +(load "com/lispworks/patches/safe-fo-closure.wfasl") +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +;; Need a bigger than normal stack for compiling the prelude. +(setf system::*stack-overflow-behaviour* :warn) +;; Need a big heap to compile the prelude. +;(lcl:change-memory-management :expand 512 :growth-limit 2048) +;; If you want to recompile +;; everything from scratch, execute the "clean" script first, or +;; else use the "compile" script to do this. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(load "cl-support/cl-init") +(in-package :mumble-user) +(setf *printers* '(phase-time dump-stat)) +(setf *optimizers* *all-optimizers*) +;; Set appropriate compiler settings for processing the prelude. +;; Don't try to compile the interface files. +(setf *code-chunk-size* 300) +(setf *compile-interface* '#f) +(compile/compile *prelude-unit-filename*) +(lw:bye) +EOF diff --git a/com/lispworks/build-xlib b/com/lispworks/build-xlib new file mode 100755 index 0000000..612820e --- /dev/null +++ b/com/lispworks/build-xlib @@ -0,0 +1,12 @@ +#!/bin/csh +# +# build-xlib -- recompile the xlib stuff +# +# note that lispworks comes with clx pre-loaded! +cd $Y2 +setenv LIBRARYBIN $Y2/progs/lib/X11/lispworks +rm $LIBRARYBIN/xlib*.wfasl +bin/lispworks-haskell <<EOF +:(setf *code-quality* 3) +:compile \$HASKELL_LIBRARY/X11/xlib +EOF diff --git a/com/lispworks/clean b/com/lispworks/clean new file mode 100755 index 0000000..7eb1459 --- /dev/null +++ b/com/lispworks/clean @@ -0,0 +1,5 @@ +#!/bin/csh +# +# delete lispworks binaries +'rm' $Y2/*/lispworks/*.{wfasl} + diff --git a/com/lispworks/compile b/com/lispworks/compile new file mode 100755 index 0000000..de0b459 --- /dev/null +++ b/com/lispworks/compile @@ -0,0 +1,13 @@ +#!/bin/csh +# +# compile -- compile the Yale Haskell system from scratch. +# +# +cd $Y2 +$LISPWORKS <<EOF +(load "com/lispworks/patches/safe-fo-closure.wfasl") +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(load "cl-support/cl-init") +(lw:bye) +EOF diff --git a/com/lispworks/patches/safe-fo-closure.wfasl b/com/lispworks/patches/safe-fo-closure.wfasl Binary files differnew file mode 100644 index 0000000..71c9a5f --- /dev/null +++ b/com/lispworks/patches/safe-fo-closure.wfasl diff --git a/com/lispworks/savesys b/com/lispworks/savesys new file mode 100755 index 0000000..f97b6f6 --- /dev/null +++ b/com/lispworks/savesys @@ -0,0 +1,43 @@ +#!/bin/csh +# +# savesys -- build a saved executable in bin/new-lispworks-haskell +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/lispworks +if !(-e $PRELUDEBIN/Prelude.wfasl) then + echo "Build the prelude first, stupid..." + exit + endif +$LISPWORKS <<EOF +;;; Load the Haskell system. +(load "com/lispworks/patches/safe-fo-closure.wfasl") +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(load "cl-support/cl-init") +;;; Set various internal switches to appropriate values for running +;;; Haskell code. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(setf *load-verbose* nil) +(setf *compile-verbose* nil) +(in-package :mumble-user) +(setf *printers* '(compiling loading)) +(setf *optimizers* '()) +(setf *compile-interface* '#f) +;;; Load the prelude +(compile/load *prelude-unit-filename*) +;;; Set up the saved system. +(define (haskell-toplevel) + ;; Need to reset pathname defaults + (setf lisp:*default-pathname-defaults* (lisp:truename "")) + (load-init-files) + (do () ('#f) + (lisp:with-simple-restart (restart-haskell "Restart Haskell.") + (heval)))) +(define (restart-haskell) + (lisp:invoke-restart 'restart-haskell)) +(lw:save-image "bin/new-lispworks-haskell" + :gc '#t + :normal-gc '#f ; don't reset gc parameters + :restart-function 'haskell-toplevel) +(lw:bye) +EOF diff --git a/com/lispworks/savesys-xlib b/com/lispworks/savesys-xlib new file mode 100755 index 0000000..d1e81a0 --- /dev/null +++ b/com/lispworks/savesys-xlib @@ -0,0 +1,52 @@ +#!/bin/csh +# +# savesys -- build a saved executable in bin/new-lispworks-haskell +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/lispworks +if !(-e $PRELUDEBIN/Prelude.wfasl) then + echo "Build the prelude first, stupid..." + exit + endif +setenv LIBRARYBIN $Y2/progs/lib/X11/lispworks +if !(-e $LIBRARYBIN/xlib.wfasl) then + echo "Build the xlib stuff first, silly..." + exit + endif +$LISPWORKS <<EOF +;;; Load the Haskell system. +(load "com/lispworks/patches/safe-fo-closure.wfasl") +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(load "cl-support/cl-init") +;;; Set various internal switches to appropriate values for running +;;; Haskell code. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(setf *load-verbose* nil) +(setf *compile-verbose* nil) +(in-package :mumble-user) +(setf *printers* '(compiling loading)) +(setf *optimizers* '()) +(setf *compile-interface* '#f) +;;; Load the prelude. +(compile/load *prelude-unit-filename*) +;;; Load the X support. +(compile/load "\$HASKELL_LIBRARY/X11/xlib") +(setf *haskell-compiler-update* + (string-append *haskell-compiler-update* "-X11")) +;;; Set up the saved system. +(define (haskell-toplevel) + ;; Need to reset pathname defaults + (setf lisp:*default-pathname-defaults* (lisp:truename "")) + (load-init-files) + (do () ('#f) + (lisp:with-simple-restart (restart-haskell "Restart Haskell.") + (heval)))) +(define (restart-haskell) + (lisp:invoke-restart 'restart-haskell)) +(lw:save-image "bin/new-lispworks-clx-haskell" + :gc '#t + :normal-gc '#f ; don't reset gc parameters + :restart-function 'haskell-toplevel) +(lw:bye) +EOF diff --git a/com/locked b/com/locked new file mode 100755 index 0000000..f98fd19 --- /dev/null +++ b/com/locked @@ -0,0 +1,14 @@ +#!/bin/csh +# +# +# identify locked source files +# + +cd $Y2 +foreach i (*/*.scm */*.lisp) + if (-e $i:h/RCS/$i:t,v) then + foreach j (`rlog -R -L $i:h/RCS/$i:t,v`) + ls -l $i + end + endif +end diff --git a/com/lookfor b/com/lookfor new file mode 100755 index 0000000..4b07f33 --- /dev/null +++ b/com/lookfor @@ -0,0 +1,9 @@ +#!/bin/csh +# +# +# look for the argument in source files. +# useful for finding all references of a function, etc. +# + +cd $Y2 +fgrep -i $1 */*.scm diff --git a/com/lucid/README b/com/lucid/README new file mode 100644 index 0000000..508ed40 --- /dev/null +++ b/com/lucid/README @@ -0,0 +1,39 @@ +This directory contains command scripts used for building Yale Haskell +from the source distribution under Lucid Common Lisp. We have been using +Lucid version 4.0.0 on a Sparc, but we don't expect that there would +be difficulties in building with Lucid on other platforms. + +Developers need to source haskell-development instead of haskell-setup +in the .cshrc file. + +To rebuild the system: + +* You need to define environment variables Y2 and LUCID to point to the + appropriate pathnames. See the haskell-development script for details. + +* Make sure that the environment variable PRELUDEBIN (in the + haskell-setup script) points to $PRELUDE/lucid. + +* Execute the "compile" script. This will recompile all of the Lisp + source files that make up the Yale Haskell system. Compiled files are + put in the "lucid" subdirectory of each source directory. + +* Execute the "build-prelude" script to compile the standard prelude. + Note that this process tends to use up a huge amount of memory! + +* Execute the "savesys" script to build a new executable. + +* The new executable is initially called "bin/new-lucid-haskell". Try + it out. If it works, you should rename it to "bin/lucid-haskell". + Make sure that HASKELLPROG (in the haskell-setup script) is correct. + +* If you want to build an executable with the X support, you'll also + need to run the "build-xlib" and "savesys-xlib" scripts. You + need to edit these scripts to change the pathname of the file + containing the CLX library (or suppress the load entirely if you + are using a Lisp executable with CLX pre-loaded.). + +Important note for Emacs users: We've been told that Lucid provides +some patches to GNU Emacs that cause the Haskell Emacs mode not to work. +(Apparently these patches redefine some of the interprocess communication +functions in an incompatible way.) Use a standard Emacs. diff --git a/com/lucid/build-prelude b/com/lucid/build-prelude new file mode 100755 index 0000000..aee2274 --- /dev/null +++ b/com/lucid/build-prelude @@ -0,0 +1,36 @@ +#!/bin/csh +# +# build-prelude -- recompile the prelude, saving the old one as old-prelude.* +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/lucid +if (-e $PRELUDEBIN/Prelude.sbin) then + rm $PRELUDEBIN/old* + foreach i ($PRELUDEBIN/Prelude*.{sbin,scm}) + mv $i $PRELUDEBIN/old-$i:t + end + endif +$LUCID <<EOF +;; Need a big heap to compile the prelude. +(lcl:change-memory-management :expand 512 :growth-limit 2048) +;; This will make sure any files that need to get compiled will be +;; compiled with Lucid's production compiler. If you want to recompile +;; everything from scratch, execute the "clean" script first, or +;; else use the "compile" script to do this. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(load "cl-support/cl-init") +(in-package :mumble-user) +(setf *printers* '(phase-time dump-stat)) +(setf *optimizers* *all-optimizers*) +;; Set appropriate compiler settings for processing the prelude. +;; Use production compiler on prelude code and split it up into pieces. +;; Use fast development compiler on interface. +(setf *code-chunk-size* 200) +(setf *compile-interface* '#t) +(setf *interface-code-quality* 2) +(setf *interface-chunk-size* '#f) +(compile/compile *prelude-unit-filename*) +(lcl:quit) +EOF diff --git a/com/lucid/build-xlib b/com/lucid/build-xlib new file mode 100755 index 0000000..960bd13 --- /dev/null +++ b/com/lucid/build-xlib @@ -0,0 +1,15 @@ +#!/bin/csh +# +# build-xlib -- recompile the xlib stuff +# +# +cd $Y2 +setenv CLXFILE /cs/licensed/sclisp-4.0/windows-x.sbin +setenv LIBRARYBIN $Y2/progs/lib/bin/lucid +rm $LIBRARYBIN/xlib*.sbin +bin/haskell <<EOF +:(lcl:change-memory-management :expand 512) +:(load "\$CLXFILE") +:(setf *code-quality* 3) +:compile \$HASKELL_LIBRARY/X11/xlib +EOF diff --git a/com/lucid/clean b/com/lucid/clean new file mode 100755 index 0000000..4c72d9b --- /dev/null +++ b/com/lucid/clean @@ -0,0 +1,5 @@ +#!/bin/csh +# +# delete lucid binaries +'rm' $Y2/*/lucid/*.{sbin,rbin} + diff --git a/com/lucid/compile b/com/lucid/compile new file mode 100755 index 0000000..115156a --- /dev/null +++ b/com/lucid/compile @@ -0,0 +1,13 @@ +#!/bin/csh +# +# compile -- compile the Yale Haskell system from scratch. +# +# +cd $Y2 +$LUCID <<EOF +;; To get Lucid's development mode compiler, remove (compilation-speed 0) +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(load "cl-support/cl-init") +(quit) +EOF diff --git a/com/lucid/savesys b/com/lucid/savesys new file mode 100755 index 0000000..786f44e --- /dev/null +++ b/com/lucid/savesys @@ -0,0 +1,44 @@ +#!/bin/csh +# +# savesys -- build a saved executable in bin/new-lucid-haskell +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/lucid +if !(-e $PRELUDEBIN/Prelude.sbin) then + echo "Build the prelude first, stupid..." + exit + endif +$LUCID <<EOF +;;; Load the Haskell system. +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(setf lcl:*record-source-files* nil) +(load "cl-support/cl-init") +;;; Set various internal switches to appropriate values for running +;;; Haskell code. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(lcl:compiler-options :file-messages nil) +(setf lcl:*redefinition-action* nil) +(setf *load-verbose* nil) +(in-package :mumble-user) +(setf *printers* '(compiling loading)) +(setf *optimizers* '()) +(setf *compile-interface* '#t) +(setf *interface-code-quality* 1) +(setf *code-chunk-size* 200) +;;; Load the prelude. +(compile/load *prelude-unit-filename*) +;;; Set up the saved system. +(define (haskell-toplevel) + (load-init-files) + (do () ('#f) + (lcl:with-simple-restart (restart-haskell "Restart Haskell.") + (heval)))) +(define (restart-haskell) + (lcl:invoke-restart 'restart-haskell)) +(lcl:gc) +(lcl:disksave "bin/new-lucid-haskell" + :reserved-free-segments 64 :dynamic-free-segments 25 + :restart-function 'haskell-toplevel :full-gc '#t) +(lcl:quit) +EOF diff --git a/com/lucid/savesys-xlib b/com/lucid/savesys-xlib new file mode 100755 index 0000000..0d5a959 --- /dev/null +++ b/com/lucid/savesys-xlib @@ -0,0 +1,55 @@ +#!/bin/csh +# +# savesys-xlib -- build a saved executable in bin/new-lucid-clx-haskell +# +# +cd $Y2 +setenv PRELUDEBIN $Y2/progs/prelude/lucid +if !(-e $PRELUDEBIN/Prelude.sbin) then + echo "Build the prelude first, stupid..." + exit + endif +setenv CLXFILE /cs/licensed/sclisp-4.0/windows-x.sbin +setenv LIBRARYBIN $Y2/progs/lib/bin/lucid +if !(-e $LIBRARYBIN/xlib.sbin) then + echo "Build the xlib stuff first, silly..." + exit + endif +$LUCID <<EOF +;;; Load the Haskell system. +(make-package "MUMBLE-IMPLEMENTATION" :use '("LISP")) +(setf lcl:*record-source-files* nil) +(load "cl-support/cl-init") +;;; Set various internal switches to appropriate values for running +;;; Haskell code. +(proclaim '(optimize (speed 3) (safety 0) (compilation-speed 0))) +(lcl:compiler-options :file-messages nil) +(setf lcl:*redefinition-action* nil) +(setf *load-verbose* nil) +(in-package :mumble-user) +(setf *printers* '(compiling loading)) +(setf *optimizers* '()) +(setf *compile-interface* '#t) +(setf *interface-code-quality* 1) +(setf *code-chunk-size* 200) +;;; Load the prelude. +(compile/load *prelude-unit-filename*) +;;; Load the X support. +(load "\$CLXFILE") +(compile/load "\$HASKELL_LIBRARY/X11/xlib") +(setf *haskell-compiler-update* + (string-append *haskell-compiler-update* "-X11")) +;;; Set up the saved system. +(define (haskell-toplevel) + (load-init-files) + (do () ('#f) + (lcl:with-simple-restart (restart-haskell "Restart Haskell.") + (heval)))) +(define (restart-haskell) + (lcl:invoke-restart 'restart-haskell)) +(lcl:gc) +(lcl:disksave "bin/new-lucid-clx-haskell" + :reserved-free-segments 64 :dynamic-free-segments 25 + :restart-function 'haskell-toplevel :full-gc '#t) +(lcl:quit) +EOF diff --git a/com/unchecked b/com/unchecked new file mode 100755 index 0000000..b80d166 --- /dev/null +++ b/com/unchecked @@ -0,0 +1,10 @@ +#!/bin/csh +# +# +# identify unchecked-in source files +# + +cd $Y2 +foreach i (*/*.scm) + if !(-e $i:h/RCS/$i:t,v) ls -l $i +end |