diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..2c0e55c --- /dev/null +++ b/COPYING @@ -0,0 +1,60 @@ +Copyright (c) 1993, 1994 by Richard Kelsey and Jonathan Rees. +Copyright (c) 1996 by NEC Research Institute, Inc. + +Use of this software for non-commercial academic purposes is +permitted provided that the above copyright notice appears +in the software itself and in the accompanying documentation +and this permission notice appears in the documentation. + +Use of this software for commerical purposes is also +permitted, but only if, in addition to the conditions +required for non-commerical users, written notification of +such use is provided by the commerical user to NEC Research +Institute, Inc. (NECI) prior to the fabrication and +distribution of the software. + +This software is experimental. NECI does not make any +representations regarding the suitability of the software +for any purpose and NECI will not support the software. The +software is provided "AS IS". NECI does not make any +warranties either express or implied with regard to the +software. + +NECI also disclaims any warranty that the software is free +of infringement of any intellectual property rights of +others. No other license express or implied is hereby +provided. Users of this software for commercial purposes +agree to indemnify and hold harmless NECI from any claims +whatsoever arising from the commercial use or distribution +of the software, including claims and/or actions arising +from infringement of intellectual property rights. + +NECI shall not be liable for any damages, including general, +special, incidental or consequential, arising out of the use +or inability to use the software. + +The name of NEC Research Institute, Inc. shall not be used in +advertising or publicity related to the distribution of the +software, without the prior written consent of NECI. + + +Distributing Autoconf Output +**************************** + +[excerpt from autoconf documentation] + + The configuration scripts that Autoconf produces are covered by the +GNU General Public License. This is because they consist almost +entirely of parts of Autoconf itself, rearranged somewhat, and Autoconf +is distributed under the terms of the GPL. As applied to Autoconf, the +GPL just means that you need to distribute `configure.in' along with +`configure'. + + Programs that use Autoconf scripts to configure themselves do not +automatically come under the GPL. Distributing an Autoconf +configuration script as part of a program is considered to be *mere +aggregation* of that work with the Autoconf script. Such programs are +not derivative works based on Autoconf; only their configuration scripts +are. We still encourage software authors to distribute their work under +terms like those of the GPL, but doing so is not required to use +Autoconf. diff --git a/INSTALL b/INSTALL new file mode 100644 index 0000000..a85fdbb --- /dev/null +++ b/INSTALL @@ -0,0 +1,120 @@ + This is a generic INSTALL file for utilities distributions. +If this package does not come with, e.g., installable documentation or +data files, please ignore the references to them below. + + [For information specific to Scheme 48, see doc/install.txt.] + + The `configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation, and +creates the Makefile(s) (one in each subdirectory of the source +directory). In some packages it creates a C header file containing +system-dependent definitions. It also creates a file `config.status' +that you can run in the future to recreate the current configuration. + +To compile this package: + +1. Configure the package for your system. + + Normally, you just `cd' to the directory containing the package's +source code and type `./configure'. If you're using `csh' on an old +version of System V, you might need to type `sh configure' instead to +prevent `csh' from trying to execute `configure' itself. + + Running `configure' takes a minute or two. While it is running, it +prints some messages that tell what it is doing. If you don't want to +see the messages, run `configure' with its standard output redirected +to `/dev/null'; for example, `./configure >/dev/null'. + + To compile the package in a different directory from the one +containing the source code, you must use a version of `make' that +supports the `VPATH' variable, such as GNU `make'. `cd' to the +directory where you want the object files and executables to go and run +the `configure' script. `configure' automatically checks for the +source code in the directory that `configure' is in and in `..'. If +for some reason `configure' is not in the source code directory that +you are configuring, then it will report that it can't find the source +code. In that case, run `configure' with the option `--srcdir=DIR', +where DIR is the directory that contains the source code. + + By default, `make install' will install the package's files in +`/usr/local/bin', `/usr/local/man', etc. You can specify an +installation prefix other than `/usr/local' by giving `configure' the +option `--prefix=PATH'. Alternately, you can do so by consistently +giving a value for the `prefix' variable when you run `make', e.g., + make prefix=/usr/gnu + make prefix=/usr/gnu install + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +give `configure' the option `--exec-prefix=PATH' or set the `make' +variable `exec_prefix' to PATH, the package will use PATH as the prefix +for installing programs and libraries. Data files and documentation +will still use the regular prefix. Normally, all files are installed +using the same prefix. + + Some packages pay attention to `--with-PACKAGE' options to +`configure', where PACKAGE is something like `gnu-as' or `x' (for the X +Window System). The README should mention any `--with-' options that +the package recognizes. + + `configure' ignores any other arguments that you give it. + + On systems that require unusual options for compilation or linking +that the package's `configure' script does not know about, you can give +`configure' initial values for variables by setting them in the +environment. In Bourne-compatible shells, you can do that on the +command line like this: + + CC='gcc -traditional' LIBS=-lposix ./configure + + Here are the `make' variables that you might want to override with +environment variables when running `configure'. + + For these variables, any value given in the environment overrides the +value that `configure' would choose: + + - Variable: CC + C compiler program. The default is `cc'. + + - Variable: INSTALL + Program to use to install files. The default is `install' if you + have it, `cp' otherwise. + + For these variables, any value given in the environment is added to +the value that `configure' chooses: + + - Variable: DEFS + Configuration options, in the form `-Dfoo -Dbar...'. Do not use + this variable in packages that create a configuration header file. + + - Variable: LIBS + Libraries to link with, in the form `-lfoo -lbar...'. + + If you need to do unusual things to compile the package, we encourage +you to figure out how `configure' could check whether to do them, and +mail diffs or instructions to the address given in the README so we +can include them in the next release. + +2. Type `make' to compile the package. If you want, you can override +the `make' variables CFLAGS and LDFLAGS like this: + + make CFLAGS=-O2 LDFLAGS=-s + +3. If the package comes with self-tests and you want to run them, +type `make check'. If you're not sure whether there are any, try it; +if `make' responds with something like + make: *** No way to make target `check'. Stop. +then the package does not come with self-tests. + +4. Type `make install' to install programs, data files, and +documentation. + +5. You can remove the program binaries and object files from the +source directory by typing `make clean'. To also remove the +Makefile(s), the header file containing system-dependent definitions +(if the package uses one), and `config.status' (all the files that +`configure' created), type `make distclean'. + + The file `configure.in' is used to create `configure' by a program +called `autoconf'. You only need it if you want to regenerate +`configure' using a newer version of `autoconf'. diff --git a/KALI.README b/KALI.README new file mode 100644 index 0000000..f75b8f4 --- /dev/null +++ b/KALI.README @@ -0,0 +1,11 @@ +To make kali, follow the instructions in INSTALL. It has to be +installed some where in your PATH. (Before you do a + make install +you can try it out by running the `go' file in the source directory.) + +Documentation on using Kali can be found in doc/kali.{ps|html}. + +If you have problems building or using Kali, please send mail to + kali-request@research.nj.nec.com +and we'll see if we can be of any help. + diff --git a/Makefile.in b/Makefile.in new file mode 100644 index 0000000..26648dc --- /dev/null +++ b/Makefile.in @@ -0,0 +1,478 @@ +# Kali Makefile +# Documentation in files INSTALL and doc/install.txt + +SHELL = /bin/sh +srcdir = @srcdir@ +VPATH = @srcdir@ +CC = @CC@ +DEFS = @DEFS@ +LIBS = @LIBS@ +CFLAGS = @CFLAGS@ +INSTALL = @INSTALL@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_DATA = @INSTALL_DATA@ + +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ + +prefix = @prefix@ +exec_prefix = @exec_prefix@ +bindir = $(exec_prefix)/bin +libdir = $(exec_prefix)/lib +incdir = $(exec_prefix)/include +manext = 1 +mandir = $(prefix)/man/man$(manext) + +# HP 9000 series, if you don't have gcc +# CC = cc +# CFLAGS = -Aa -O +Obb1800 +# DEFS = -D_HPUX_SOURCE -Dhpux + +# Ultrix +# LDFLAGS = -N + +.c.o: + $(CC) -c $(CPPFLAGS) $(DEFS) -I$(srcdir)/c $(CFLAGS) -o $@ $< + +# You might want to change RUNNABLE to "s48" +RUNNABLE = kali +MANPAGE = $(RUNNABLE).$(manext) +LIB = $(libdir)/$(RUNNABLE) + +distdir = /tmp + +# If make barfs on this include line, just comment it out. It's only +# really needed if you want to build the linker or rebuild initial.image. +include $(srcdir)/build/filenames.make +# +#NetBSD make wants to see this instead: +#.include "$(srcdir)/build/filenames.make" + + +# Static linker: +# +# You only need the linker if you're going to make changes to the +# things that go into the initial.image, which in general means the +# files in rts/. If you decide you need to use the linker, then you +# gots your choice; it can run in just about any version of Scheme 48 +# or Pseudoscheme. (It has also been made to run in Scheme->C.) It +# doesn't matter a whole lot which Scheme you use as long as it's not +# broken or unavailable. The two best choices are: +# 1. As below: build the linker on the scheme48vm and kali.image +# that are in the current directory. +# 2. LINKER_VM = $(RUNNABLE) $(BIG_HEAP) +# LINKER_RUNNABLE = $(RUNNABLE) +# These settings requires you to already have a $(RUNNABLE) +# command. This is desirable if you are making changes to the +# system that might break scheme48vm and/or kali.image. But it +# requires you to have squirreled away a previous working version +# of kali. + +BIG_HEAP = -h 6000000 +LINKER_VM = ./$(VM) $(BIG_HEAP) +LINKER_RUNNABLE = $(LINKER_VM) -i $(IMAGE) +LINKER_IMAGE = build/linker.image +LINKER = $(LINKER_VM) -i $(LINKER_IMAGE) +START_LINKER = echo ',batch' && echo ',bench on' + + +# -------------------- +# You shouldn't have to change anything below this point. + +# Targets: + +IMAGE = kali.image +INITIAL = build/initial.image +VM = scheme48vm +UNIX_OBJS = c/unix/misc.o c/unix/io.o c/unix/fd-io.o c/unix/event.o \ + c/unix/socket.o c/unix/dynamo.o +OBJS = c/scheme48vm.o c/scheme48heap.o c/extension.o +FAKEHS = c/fake/sigact.h c/fake/strerror.h c/fake/sys-select.h + +# Sources: + +CONFIG_FILES = scheme/interfaces.scm scheme/low-packages.scm \ + scheme/rts-packages.scm scheme/comp-packages.scm + +# Rules: + +# The following is the first rule and therefore the "make" command's +# default target. +enough: $(VM) $(IMAGE) go .notify + +# The developers are curious to know. Don't be concerned if this fails. +.notify: build/minor-version-number + touch .notify + -echo Another 0.`cat $(srcdir)/build/minor-version-number` \ + installation. \ + | mail scheme-48-notifications@martigny.ai.mit.edu + +$(VM): c/main.o $(OBJS) $(UNIX_OBJS) $(LIBOBJS) + $(CC) $(LDFLAGS) $(CFLAGS) -o $@ c/main.o $(OBJS) $(UNIX_OBJS) \ + $(LIBOBJS) $(LIBS) + +c/main.o: c/main.c + $(CC) -c $(CFLAGS) -o $@ \ + -DDEFAULT_IMAGE_NAME=\"$(LIB)/$(IMAGE)\" \ + $(CPPFLAGS) $(DEFS) c/main.c + +c/scheme48vm.o: c/prescheme.h c/scheme48vm.h c/scheme48heap.h c/event.h \ + c/io.h c/fd-io.h +c/scheme48heap.o: c/prescheme.h c/scheme48vm.h c/scheme48heap.h c/event.h \ + c/io.h c/fd-io.h +c/extension.o: c/sysdep.h $(FAKEHS) c/kali.h c/socket.h +c/unix/event.o: c/sysdep.h $(FAKEHS) c/kali.h c/scheme48heap.h \ + c/event.h c/fd-io.h +c/unix/fd-io.o: c/sysdep.h $(FAKEHS) c/scheme48vm.h c/scheme48heap.h \ + c/event.h c/fd-io.h +c/unix/dynamo.o: c/sysdep.h $(FAKEHS) c/kali.h +c/unix/socket.o: c/sysdep.h $(FAKEHS) c/scheme48vm.h c/scheme48heap.h \ + c/event.h c/fd-io.h c/socket.h +c/unix/misc.o: c/sysdep.h $(FAKEHS) +c/unix/io.o: c/io.h +c/fake/strerror.o: c/fake/strerror.h + +# -------------------- +# Make kali.image from initial.image and library .scm files. +# +# For bootstrap reasons, initial.image is *not* listed as a source, +# even though it really is. + +$(IMAGE): $(VM) scheme/env/init-defpackage.scm scheme/more-interfaces.scm \ + scheme/link-packages.scm scheme/more-packages.scm \ + $(usual-files) build/initial.debug build/build-usual-image \ + Makefile + build/build-usual-image . "`pwd`/scheme" '$(IMAGE)' './$(VM)' \ + '$(INITIAL)' + +### Fake targets: all clean install man dist + +install: enough dirs inst-script inst-vm inst-misc inst-man inst-inc inst-image + +inst-vm: + $(INSTALL_PROGRAM) $(VM) $(LIB) + +inst-image: + rm -f '/tmp/$(IMAGE)' && \ + build/build-usual-image . '$(LIB)' '/tmp/$(IMAGE)' './$(VM)' \ + '$(INITIAL)' && \ + $(INSTALL_DATA) /tmp/$(IMAGE) $(LIB) && \ + rm /tmp/$(IMAGE) + +inst-man: + if [ -d $(mandir) -a -w $(mandir) ]; then \ + sed 's=LBIN=$(bindir)=g' doc/scheme48.man | \ + sed 's=LLIB=$(LIB)=g' | \ + sed 's=LS48=$(RUNNABLE)=g' >$(MANPAGE) && \ + $(INSTALL_DATA) $(MANPAGE) $(mandir) && \ + rm $(MANPAGE); \ + else \ + echo "$(mandir) not writable dir, not installing man page" \ + >&2; \ + fi + +inst-inc: + $(INSTALL_DATA) c/kali.h $(incdir) + +inst-misc: + for stub in env big opt misc link; do \ + for f in scheme/$$stub/*.scm; do \ + $(INSTALL_DATA) $$f $(LIB)/$$stub || exit 1; \ + done; \ + done && \ + for f in scheme/rts/*num.scm scheme/rts/jar-defrecord.scm; do \ + $(INSTALL_DATA) $$f $(LIB)/rts || exit 1; \ + done && + +inst-script: + script=$(bindir)/$(RUNNABLE) && \ + echo '#!/bin/sh' >$$script && \ + echo >>$$script && \ + echo 'lib=$(LIB)' >>$$script && \ + echo 'exec $$lib/$(VM) -o $$lib/$(VM) -i $$lib/$(IMAGE) "$$@"' \ + >>$$script && \ + chmod +x $$script + +# Script to run kali in this directory. +go: + echo '#!/bin/sh' >$@ && \ + echo >>$@ && \ + echo "lib=`pwd`" >>$@ && \ + echo 'exec $$lib/$(VM) -o $$lib/$(VM) -i $$lib/$(IMAGE) "$$@"' \ + >>$@ && \ + chmod +x $@ + +dirs: + for dir in $(libdir) $(bindir) $(incdir); do \ + [ -d $$dir -a -w $$dir ] || { \ + echo "$$dir not a writable directory" >&2; \ + exit 1; \ + }; \ + done + { mkdir -p $(LIB) && [ -w $(LIB) ]; } || { \ + echo "$(LIB) not a writable directory" >&2; \ + exit 1; \ + } + for dir in rts env big opt misc link; do \ + { mkdir -p $(LIB)/$$dir && [ -w $(LIB)/$$dir ]; } || { \ + echo "$(LIB)/$$dir not a writable directory" >&2; \ + exit 1; \ + }; \ + done + +configure: configure.in + autoheader && autoconf + +clean: + -rm -f $(VM) *.o c/unix/*.o c/*.o c/fake/*.o TAGS $(IMAGE) \ + build/*.tmp $(MANPAGE) build/linker.image \ + scheme/debug/*.image scheme/debug/*.debug config.cache \ + scheme/vm/scheme48vm.c scheme48heap.c \ + config.log config.status c/sysdep.h go $(distname) + +distclean: clean + rm -f Makefile + +check: $(VM) $(IMAGE) scheme/debug/check.scm + ( \ + echo ',batch'; \ + echo ',translate =scheme48 scheme'; \ + echo ',config ,load scheme/debug/test.scm'; \ + echo ',exec ,load scheme/debug/check.scm'; \ + echo ',exec (done)' \ + ) | ./$(VM) -i $(IMAGE) + +# -------------------- +# Rules from here on down are not essential for the basic installation +# procedure, and are not expected to work when srcdir is not the +# distribution directory. + +all: vm linker + $(MAKE) image +vm: $(VM) +linker: $(LINKER_IMAGE) +image: $(INITIAL) + $(MAKE) $(IMAGE) + +tags: + etags scheme/vm/arch.scm scheme/rts/*.scm scheme/bcomp/*.scm \ + scheme/*.scm scheme/env/*.scm scheme/big/*.scm scheme/link/*.scm \ + scheme/opt/*.scm scheme/debug/*.scm scheme/misc/*.scm + +# -------------------- +# Distribution... + +# DISTFILES should include all sources. +DISTFILES = README KALI.README COPYING INSTALL configure \ + acconfig.h configure.in Makefile.in install-sh \ + doc/*.ps doc/*.txt doc/*.html doc/scheme48.man \ + doc/src/*.tex doc/src/*.sty \ + emacs/README build/*-version-number build/*.exec \ + build/*.lisp build/build-usual-image build/filenames.make \ + build/filenames.scm build/initial.debug \ + build/initial.image build/initial.scm \ + c/*.[ch] c/*/*.[ch] \ + emacs/*.el gdbinit \ + scheme/*.scm scheme/*/*.scm \ + ps-compiler \ + c/sysdep.h.in + +distname = $(RUNNABLE)-0.`cat build/minor-version-number` + +dist: build/initial.image + distname=$(distname) && \ + distfile=$(distdir)/$$distname.tgz && \ + if [ -d $(distdir) ] && \ + [ -w $$distfile -o -w $(distdir) ]; then \ + rm -f $$distname && \ + ln -s . $$distname && \ + files='' && \ + for i in $(DISTFILES); do \ + if [ "$$i" != "c/sysdep.h" ]; then \ + files="$$files $$distname/$$i"; \ + fi \ + done && \ + tar -cf - $$files | \ + gzip --best >$$distfile && \ + rm $$distname; \ + else \ + echo "Can't write $$distfile" >&2; \ + exit 1; \ + fi + +# Increment the minor version number +inc: + f=build/minor-version-number && \ + expr `cat $$f` + 1 >$$f.tmp && \ + mv $$f.tmp $$f && \ + echo '(define version-info "0.'`cat $$f`'")' \ + >scheme/env/version-info.scm + + +# -------------------- +# Generate build/filenames.make from *packages.scm +# +# This hack traces the module dependencies described in the +# various configuration files and converts them into dependency lists +# that "make" can use for its purposes. +# +# Since the distribution comes with a filenames.make, this rule +# shouldn't be invoked for simple installations. But it will be used +# if you change any of the *-packages.scm files. +# +# You can actually run the forms in filenames.scm in any Scheme +# implementation that has syntax-rules and explicit-renaming low-level +# macros (e.g., most versions of Scheme 48 and Pseudoscheme). +# If there are errors running this script, and you need to debug, +# don't use the initial.image, use something that has a reasonable +# environment. +# +# If this fails and you don't feel like debugging or fixing the problem, +# try "touch filenames.make" and hope for the best. + +PACKAGES=scheme/packages.scm scheme/rts-packages.scm scheme/alt-packages.scm \ + scheme/comp-packages.scm scheme/initial-packages.scm \ + scheme/link-packages.scm scheme/more-packages.scm \ + build/filenames.scm + +build/filenames.make: $(PACKAGES) + $(MAKE) $(VM) PACKAGES= + ./$(VM) -i $(srcdir)/$(INITIAL) -a batch C compiler + c/ c source files + sysdep.h.in input to configure + scheme48vm.c most of the VM (generated by Pre-Scheme compiler) + scheme48vm.h extern declarations for scheme48vm.c + scheme48heap.c storage management (generated by Pre-Scheme compiler) + scheme48heap.h extern declarations for scheme48heap.c + main.c entry point for the VM + prescheme.h part of the VM + extension.c default definition of vm_extension() + scheme48.h C declarations and macros for Scheme 48 data structures + event.h header file for OS interface + fd-io.h ditto + socket.h ditto + unix/ Unix-specific source files + fake/ C files for insufficiently Posix compliant systems + build/ code for building the system + filenames.make included by Makefile, generated automatically + filenames.scm code for generating filenames.make + initial.image an image file containing a minimal Scheme system + initial.debug debugging database for same + initial.scm script for creating initial.image + build-usual-image script for creating scheme48.image + emacs/ gnu emacs support diff --git a/acconfig.h b/acconfig.h new file mode 100644 index 0000000..ece5e70 --- /dev/null +++ b/acconfig.h @@ -0,0 +1,32 @@ +/* + * HAVE_SIGACTION is defined iff sigaction() is available. + */ +#undef HAVE_SIGACTION + +/* + * HAVE_STRERROR is defined iff the standard libraries provide strerror(). + */ +#undef HAVE_STRERROR + +/* + * NLIST_HAS_N_NAME is defined iff a struct nlist has an n_name member. + * If it doesn't then we assume it has an n_un member which, in turn, + * has an n_name member. + */ +#undef NLIST_HAS_N_NAME + +/* + * HAVE_SYS_SELECT_H is defined iff we have the include file sys/select.h. + */ +#undef HAVE_SYS_SELECT_H + +/* + * USCORE is defined iff C externals are prepended with an underscore. + */ +#undef USCORE + +@BOTTOM@ + +#include "fake/sigact.h" +#include "fake/strerror.h" +#include "fake/sys-select.h" diff --git a/build/build-usual-image b/build/build-usual-image new file mode 100755 index 0000000..890b0f7 --- /dev/null +++ b/build/build-usual-image @@ -0,0 +1,36 @@ +#!/bin/sh +# Build the usual development environment image. + +date=`date` +srcdir=$1 +lib=$2 +image=$3 +vm=$4 +initial=$5 +USER=${USER-`logname 2>/dev/null || echo '*GOK*'`} + +$vm -i $initial -a batch < name +(0 low-structures) +(1 debug-low-structures) +(2 alt-features-structures) +(3 cheat-features-structures) +(4 the-interfaces) +(5 meta-module-system) +(6 run-time-structures) +(7 compiler-structures) +(8 initial-structures) +(9 debug-structures) +(10 usual-structures) +(11 alt-low-structures) +(12 compiler-structures) +(13 linker-structures) +(14 scheme-level-0) +(15 scheme-level-1) +(16 records) +(17 define-record-types) +(18 methods) +(19 number-i/o) +(20 fluids) +(21 wind) +(22 session-data) +(23 i/o) +(24 channel-i/o) +(25 conditions) +(26 writing) +(27 reading) +(28 scheme-level-2) +(29 features) +(30 templates) +(31 continuations) +(32 more-types) +(33 enumerated) +(34 architecture) +(35 exceptions) +(36 interrupts) +(37 threads) +(38 scheduler) +(39 root-scheduler) +(40 enum-case) +(41 queues) +(42 locks) +(43 usual-resumer) +(44 weak) +(45 display-conditions) +(46 meta-types) +(47 bindings) +(48 names) +(49 thingies) +(50 nodes) +(51 compiler-envs) +(52 syntactic) +(53 usual-macros) +(54 var-utilities) +(55 debug-data) +(56 stack-check) +(57 segments) +(58 primops) +(59 reconstruction) +(60 compiler) +(61 reading-forms) +(62 flatten) +(63 interfaces) +(64 packages) +(65 scan-package) +(66 optimizer) +(67 compile-packages) +(68 defpackage) +(69 types) +(70 module-system) +(71 usages) +(72 analysis) +(73 inline) +(74 strong) +(75 tables) +(76 filenames) +(77 environments) +(78 evaluation) +(79 ensures-loaded) +(80 for-reification) +(81 scheme) +(82 mini-command) +(83 initial-system) +- +; Location uid -> (name . package-uid) +(0 (and . 14)) +(1 (cond . 14)) +(2 (do . 14)) +(3 (let . 14)) +(4 (let* . 14)) +(5 (or . 14)) +(6 (code-quote . 14)) +(7 (quote . 14)) +(8 (unspecific . 14)) +(9 (define-syntax . 14)) +(10 (lambda . 14)) +(11 (begin . 14)) +(12 (unassigned . 14)) +(13 (flat-lambda . 14)) +(14 (primitive-procedure . 14)) +(15 (define . 14)) +(16 (if . 14)) +(17 (letrec-syntax . 14)) +(18 (%file-name% . 14)) +(19 (let-syntax . 14)) +(20 (structure-ref . 14)) +(21 (loophole . 14)) +(22 (letrec . 14)) +(23 (lap . 14)) +(24 (set! . 14)) +(25 (call . 14)) +(26 (atan . 14)) +(27 (set-location-defined?! . 14)) +(28 (acos . 14)) +(29 (address-space-uid . 14)) +(30 (vm-extension . 14)) +(31 (asin . 14)) +(32 (location-defined? . 14)) +(33 (time . 14)) +(34 (template-set! . 14)) +(35 (cons . 14)) +(36 (wait . 14)) +(37 (trap . 14)) +(38 (assq . 14)) +(39 (make-weak-pointer . 14)) +(40 (push . 14)) +(41 (set-contents! . 14)) +(42 (read-char . 14)) +(43 (make-cell . 14)) +(44 (sqrt . 14)) +(45 (* . 14)) +(46 (contents . 14)) +(47 (+ . 14)) +(48 (peek-char . 14)) +(49 (- . 14)) +(50 (continuation-set! . 14)) +(51 (/ . 14)) +(52 (weak-pointer? . 14)) +(53 (really-decode . 14)) +(54 (quotient . 14)) +(55 (close-channel . 14)) +(56 (channel-abort . 14)) +(57 (really-make-proxy . 14)) +(58 (char? . 14)) +(59 (< . 14)) +(60 (= . 14)) +(61 (> . 14)) +(62 (really-encode . 14)) +(63 (make-location . 14)) +(64 (imag-part . 14)) +(65 (set-port-data! . 14)) +(66 (make-template . 14)) +(67 (real? . 14)) +(68 (real-part . 14)) +(69 (get-cont-from-heap . 14)) +(70 (external-call . 14)) +(71 (record-length . 14)) +(72 (port-data . 14)) +(73 (make-external . 14)) +(74 (pair? . 14)) +(75 (external-name . 14)) +(76 (make-port . 14)) +(77 (set-port-lock! . 14)) +(78 (return-from-exception . 14)) +(79 (location? . 14)) +(80 (channel-maybe-read . 14)) +(81 (checked-record-ref . 14)) +(82 (add-finalizer! . 14)) +(83 (rational? . 14)) +(84 (template? . 14)) +(85 (port-lock . 14)) +(86 (vector-length . 14)) +(87 (make-continuation . 14)) +(88 (address-space-data . 14)) +(89 (external? . 14)) +(90 (string-length . 14)) +(91 (make-address-space . 14)) +(92 (port? . 14)) +(93 (angle . 14)) +(94 (set-proxy-data-reference-count! . 14)) +(95 (proxy-data-has-local-value? . 14)) +(96 (false . 14)) +(97 (vm-return . 14)) +(98 (proxy-data-reference-count . 14)) +(99 (remainder . 14)) +(100 (continuation? . 14)) +(101 (binary-reduce1 . 14)) +(102 (binary-reduce2 . 14)) +(103 (char= . 14)) +(110 (with-continuation . 14)) +(111 (floor . 14)) +(112 (address-space-proxy-vector . 14)) +(113 (code-vector-length . 14)) +(114 (apply . 14)) +(115 (memory-status . 14)) +(116 (checked-record-set! . 14)) +(117 (inexact->exact . 14)) +(118 (exact->inexact . 14)) +(119 (error . 14)) +(120 (set-proxy-data-uid! . 14)) +(121 (extended-number-length . 14)) +(122 (channel-id . 14)) +(123 (proxy-data-uid . 14)) +(124 (numerator . 14)) +(125 (eof-object . 14)) +(126 (set-address-space-decode-vector! . 14)) +(127 (address-space-decode-vector . 14)) +(128 (record-ref . 14)) +(129 (set-proxy-data-waiters! . 14)) +(130 (make-polar . 14)) +(131 (proxy-data-waiters . 14)) +(132 (write-char . 14)) +(133 (symbol->string . 14)) +(134 (exact? . 14)) +(135 (vector-ref . 14)) +(136 (set-symbol-uid! . 14)) +(137 (set-current-thread! . 14)) +(138 (immutable? . 14)) +(139 (set-exception-handlers! . 14)) +(140 (string-ref . 14)) +(141 (set-port-index! . 14)) +(142 (symbol-uid . 14)) +(143 (current-thread . 14)) +(144 (channel-status . 14)) +(145 (proxy-data . 14)) +(146 (set-port-limit! . 14)) +(147 (port-index . 14)) +(148 (make-immutable! . 14)) +(149 (external-value . 14)) +(150 (set-enabled-interrupts! . 14)) +(151 (port-limit . 14)) +(152 (ascii->char . 14)) +(153 (char->ascii . 14)) +(154 (record-set! . 14)) +(155 (eof-object? . 14)) +(156 (set-interrupt-handlers! . 14)) +(157 (record . 14)) +(158 (proxy? . 14)) +(159 (schedule-interrupt . 14)) +(160 (code-vector-ref . 14)) +(161 (channel-maybe-write . 14)) +(162 (extended-number-ref . 14)) +(163 (vector-set! . 14)) +(164 (copy-bytes! . 14)) +(165 (string-set! . 14)) +(166 (values . 14)) +(167 (make-proxy-data . 14)) +(168 (intern . 14)) +(169 (vector . 14)) +(170 (set-proxy-data-self! . 14)) +(171 (proxy-data-self . 14)) +(172 (proxy-data? . 14)) +(173 (make-record . 14)) +(174 (set-location-id! . 14)) +(175 (code-vector-set! . 14)) +(176 (location-id . 14)) +(177 (bitwise-and . 14)) +(178 (eq? . 14)) +(179 (write-image . 14)) +(180 (extended-number-set! . 14)) +(181 (make-vector . 14)) +(182 (record? . 14)) +(183 (make-string . 14)) +(184 (set-port-buffer! . 14)) +(185 (primitive-catch . 14)) +(186 (proxy-data-local-ref . 14)) +(187 (string-hash . 14)) +(188 (template-length . 14)) +(189 (number? . 14)) +(190 (port-buffer . 14)) +(191 (untyped-indexed-set! . 14)) +(192 (bitwise-ior . 14)) +(193 (set-car! . 14)) +(194 (closure-env . 14)) +(195 (vector? . 14)) +(196 (bitwise-not . 14)) +(197 (set-cdr! . 14)) +(198 (symbol? . 14)) +(199 (string? . 14)) +(200 (car . 14)) +(201 (bitwise-xor . 14)) +(202 (cdr . 14)) +(203 (make-code-vector . 14)) +(204 (find-all-records . 14)) +(205 (continuation-length . 14)) +(206 (log . 14)) +(207 (message . 14)) +(208 (tan . 14)) +(209 (external-lookup . 14)) +(210 (collect . 14)) +(211 (cos . 14)) +(212 (channel-os-index . 14)) +(213 (make-extended-number . 14)) +(214 (set-port-status! . 14)) +(215 (sin . 14)) +(216 (exp . 14)) +(217 (pop . 14)) +(218 (port-status . 14)) +(219 (code-vector? . 14)) +(220 (set-port-locked?! . 14)) +(221 (find-all-symbols . 14)) +(222 (weak-pointer-ref . 14)) +(223 (call-with-values . 14)) +(224 (denominator . 14)) +(225 (port-locked? . 14)) +(226 (reverse-list->string . 14)) +(227 (extended-number? . 14)) +(228 (set-proxy-data-value! . 14)) +(229 (find-all . 14)) +(230 (cell-ref . 14)) +(231 (proxy-data-value . 14)) +(232 (string=? . 14)) +(233 (set-proxy-data-owner! . 14)) +(234 (open-channel . 14)) +(235 (channel? . 14)) +(236 (proxy-data-owner . 14)) +(237 (set-location-uid! . 14)) +(238 (make-rectangular . 14)) +(239 (set-session-data! . 14)) +(240 (template-ref . 14)) +(241 (location-uid . 14)) +(242 (make-closure . 14)) +(243 (set-external-uid! . 14)) +(244 (session-data . 14)) +(245 (integer? . 14)) +(246 (signal-condition . 14)) +(247 (port-handler . 14)) +(248 (external-uid . 14)) +(249 (set-port-pending-eof?! . 14)) +(250 (arithmetic-shift . 14)) +(251 (complex? . 14)) +(252 (port-pending-eof? . 14)) +(253 (cell-set! . 14)) +(254 (binary-comparison-reduce2 . 14)) +(255 (closure? . 14)) +(256 (continuation-ref . 14)) +(257 (set-address-space-uid! . 14)) +(258 (closure-template . 14)) +(259 (current-cont . 14)) +(260 (char->integer . 14)) +(261 (integer->char . 14)) +(262 (ascii-limit . 14)) +(263 (ascii-whitespaces . 14)) +(264 (procedure? . 14)) +(265 (invoke-closure . 14)) +(266 (primitive-cwcc . 14)) +(267 (make-undefined-location . 14)) +(268 (location-assigned? . 14)) +(269 (vector-unassigned? . 14)) +(270 (string-copy . 14)) +(271 (string->symbol . 14)) +(272 (*the-symbol-table* . 14)) +(273 (flush-the-symbol-table! . 14)) +(274 (restore-the-symbol-table! . 14)) +(275 (input-port? . 14)) +(276 (output-port? . 14)) +(277 (channel-read . 14)) +(278 (buffer-length . 14)) +(279 (channel-write . 14)) +(280 (debug-message . 14)) +(281 (proxy-base-count . 14)) +(282 (make-nonlocal-proxy . 14)) +(283 (make-proxy . 14)) +(284 (proxy-data->proxy . 14)) +(285 (proxy-has-local-value? . 14)) +(286 (proxy-local-ref . 14)) +(287 (proxy-local-set! . 14)) +(288 (any-proxy-value . 14)) +(289 (proxy-remote-value . 14)) +(290 (initialize-any-proxy-value! . 14)) +(291 (encode . 14)) +(292 (decode . 14)) +(293 (make-condition . 14)) +(294 (signal . 14)) +(295 (warn . 14)) +(296 (syntax-error . 14)) +(297 (call-error . 14)) +(298 (case . 15)) +(299 (quasiquote . 15)) +(300 (syntax-rules . 15)) +(301 (not . 15)) +(302 (boolean? . 15)) +(303 (eqv? . 15)) +(304 (equal? . 15)) +(305 (max . 15)) +(306 (min . 15)) +(307 (max-or-min . 15)) +(308 (abs . 15)) +(309 (zero? . 15)) +(310 (positive? . 15)) +(311 (negative? . 15)) +(312 (even? . 15)) +(313 (odd? . 15)) +(314 (caar . 15)) +(315 (cadr . 15)) +(316 (cdar . 15)) +(317 (cddr . 15)) +(318 (caaar . 15)) +(319 (caadr . 15)) +(320 (cadar . 15)) +(321 (caddr . 15)) +(322 (cdaar . 15)) +(323 (cdadr . 15)) +(324 (cddar . 15)) +(325 (cdddr . 15)) +(326 (caaaar . 15)) +(327 (caaadr . 15)) +(328 (caadar . 15)) +(329 (caaddr . 15)) +(330 (cadaar . 15)) +(331 (cadadr . 15)) +(332 (caddar . 15)) +(333 (cadddr . 15)) +(334 (cdaaar . 15)) +(335 (cdaadr . 15)) +(336 (cdadar . 15)) +(337 (cdaddr . 15)) +(338 (cddaar . 15)) +(339 (cddadr . 15)) +(340 (cdddar . 15)) +(341 (cddddr . 15)) +(342 (null? . 15)) +(343 (list . 15)) +(344 (length . 15)) +(345 (real-length . 15)) +(346 (append . 15)) +(347 (reverse . 15)) +(348 (append-reverse . 15)) +(349 (list-tail . 15)) +(350 (list-ref . 15)) +(351 (mem . 15)) +(352 (memq . 15)) +(353 (memv . 15)) +(354 (member . 15)) +(355 (ass . 15)) +(356 (assv . 15)) +(357 (assoc . 15)) +(358 (list? . 15)) +(359 (char>? . 15)) +(360 (char>=? . 15)) +(361 (char<=? . 15)) +(362 (char-whitespace? . 15)) +(363 (char-lower-case? . 15)) +(364 (char-upper-case? . 15)) +(365 (char-numeric? . 15)) +(366 (char-alphabetic? . 15)) +(367 (char-case-delta . 15)) +(368 (make-character-map . 15)) +(369 (upcase-map . 15)) +(370 (char-upcase . 15)) +(371 (downcase-map . 15)) +(372 (char-downcase . 15)) +(373 (char-ci-compare . 15)) +(374 (char-ci=? . 15)) +(375 (char-ci? . 15)) +(378 (char-ci>=? . 15)) +(379 (string . 15)) +(380 (substring . 15)) +(381 (string-append . 15)) +(382 (string->list . 15)) +(383 (list->string . 15)) +(384 (string-fill! . 15)) +(385 (make-string=? . 15)) +(386 (string-ci=? . 15)) +(387 (make-string? . 15)) +(391 (string<=? . 15)) +(392 (string>=? . 15)) +(393 (string-ci>? . 15)) +(394 (string-ci<=? . 15)) +(395 (string-ci>=? . 15)) +(396 (vector->list . 15)) +(397 (list->vector . 15)) +(398 (vector-fill! . 15)) +(399 (map . 15)) +(400 (map1 . 15)) +(401 (map2+ . 15)) +(402 (for-each . 15)) +(403 (for-each1 . 15)) +(404 (for-each2+ . 15)) +(405 (delay . 15)) +(406 (make-promise . 15)) +(407 (force . 15)) +(408 (unspecific . 15)) +(409 (reduce . 15)) +(410 (filter . 15)) +(411 (pos . 15)) +(412 (posq . 15)) +(413 (posv . 15)) +(414 (position . 15)) +(415 (any . 15)) +(416 (every . 15)) +(417 (sublist . 15)) +(418 (last . 15)) +(419 (insert . 15)) +(420 (fold . 15)) +(421 (fold->2 . 15)) +(422 (fold->3 . 15)) +(423 (inexact? . 15)) +(424 (modulo . 15)) +(425 (ceiling . 15)) +(426 (truncate . 15)) +(427 (round . 15)) +(428 (gcd . 15)) +(429 (euclid . 15)) +(430 (lcm . 15)) +(431 (expt . 15)) +(432 (raise-to-integer-power . 15)) +(433 (rationalize . 15)) +(434 (simplest-rational . 15)) +(435 (record-type . 16)) +(436 (*record-type-uid* . 16)) +(437 (*record-type* . 16)) +(438 (make-record-type . 16)) +(439 (record-type? . 16)) +(440 (record-type-uid . 16)) +(441 (record-type-name . 16)) +(442 (record-type-field-names . 16)) +(443 (record-type-discloser . 16)) +(444 (record-field-index . 16)) +(445 (record-constructor . 16)) +(446 (record-accessor . 16)) +(447 (record-modifier . 16)) +(448 (record-predicate . 16)) +(449 (define-record-discloser . 16)) +(450 (disclose-record . 16)) +(451 (default-record-discloser . 16)) +(452 (:record-type . 16)) +(453 (define-record-type . 17)) +(454 (define-constructor . 17)) +(455 (define-accessors . 17)) +(456 (define-accessor . 17)) +(457 (:simple-type . 18)) +(458 (really-make-simple-type . 18)) +(459 (simple-type-id . 18)) +(460 (simple-type-priority . 18)) +(461 (simple-type-predicate . 18)) +(462 (simple-type-superiors . 18)) +(463 (simple-type? . 18)) +(464 (make-simple-type . 18)) +(465 (compute-priority . 18)) +(466 (*increment* . 18)) +(467 (%type-priority . 18)) +(468 (%type-predicate . 18)) +(469 (%same-type? . 18)) +(470 (define-simple-type . 18)) +(471 (:syntax . 18)) +(472 (:values . 18)) +(473 (value? . 18)) +(474 (:value . 18)) +(475 (:zero . 18)) +(476 (:number . 18)) +(477 (:complex . 18)) +(478 (:real . 18)) +(479 (:rational . 18)) +(480 (:integer . 18)) +(481 (:exact-integer . 18)) +(482 (:boolean . 18)) +(483 (:symbol . 18)) +(484 (:char . 18)) +(485 (:null . 18)) +(486 (:pair . 18)) +(487 (:vector . 18)) +(488 (:string . 18)) +(489 (:procedure . 18)) +(490 (:input-port . 18)) +(491 (:output-port . 18)) +(492 (:eof-object . 18)) +(493 (:record . 18)) +(494 (record-type-priority . 18)) +(495 (:method-info . 18)) +(496 (really-make-method-info . 18)) +(497 (method-info-proc . 18)) +(498 (method-info-n-ary? . 18)) +(499 (method-info-types . 18)) +(500 (method-info? . 18)) +(501 (make-method-info . 18)) +(502 (empty-method-list . 18)) +(503 (insert-method . 18)) +(504 (same-applicability? . 18)) +(505 (every2 . 18)) +(506 (more-specific? . 18)) +(507 (more-specific-type? . 18)) +(508 (:method-table . 18)) +(509 (really-make-method-table . 18)) +(510 (method-table-id . 18)) +(511 (method-table-set-perform! . 18)) +(512 (method-table-get-perform . 18)) +(513 (make-generic . 18)) +(514 (method-table-prototype . 18)) +(515 (method-table-methods . 18)) +(516 (set-method-table-methods! . 18)) +(517 (method-table? . 18)) +(518 (make-method-table . 18)) +(519 (make-cell-for-generic . 18)) +(520 (add-to-method-table! . 18)) +(521 (set-final-method! . 18)) +(522 (apply-generic . 18)) +(523 (define-generic . 18)) +(524 (methods->perform . 18)) +(525 (last-action . 18)) +(526 (one-action . 18)) +(527 (argument-sequence-predicate . 18)) +(528 (check-for-next . 18)) +(529 (check-next . 18)) +(530 (method-info . 18)) +(531 (method-internal . 18)) +(532 (with-next-method . 18)) +(533 (define-method . 18)) +(534 (&add-method! . 18)) +(535 (add-method! . 18)) +(536 (&type-predicate . 18)) +(537 (type-predicate . 18)) +(538 (&type-priority . 18)) +(539 (type-priority . 18)) +(540 (&type-superiors . 18)) +(541 (type-superiors . 18)) +(542 (&same-type? . 18)) +(543 (same-type? . 18)) +(544 (:singleton . 18)) +(545 (singleton . 18)) +(546 (singleton-value . 18)) +(547 (compare-to . 18)) +(548 (&disclose . 18)) +(549 (disclose . 18)) +(550 (proc->discloser . 18)) +(551 (&number->string . 19)) +(552 (number->string . 19)) +(553 (integer->string . 19)) +(554 (string->number . 19)) +(555 (&really-string->number . 19)) +(556 (really-string->number . 19)) +(557 (:integer-string . 19)) +(558 (set-exactness . 19)) +(559 (string->integer . 19)) +(560 (:thread . 20)) +(561 (make-thread . 20)) +(562 (thread-dynamic-point . 20)) +(563 (thread-dynamic-env . 20)) +(564 (get-dynamic-env . 20)) +(565 (set-dynamic-env! . 20)) +(566 (get-dynamic-point . 20)) +(567 (set-dynamic-point! . 20)) +(568 (initialize-dynamic-state! . 20)) +(569 (with-dynamic-env . 20)) +(570 (empty-dynamic-env . 20)) +(571 (:fluid . 20)) +(572 (really-make-fluid . 20)) +(573 (really-fluid-top-level-value . 20)) +(574 (really-set-fluid-top-level-value! . 20)) +(575 (fluid? . 20)) +(576 (make-fluid . 20)) +(577 (fluid-top-level-value . 20)) +(578 (set-fluid-top-level-value! . 20)) +(579 (real-fluid-lookup . 20)) +(580 (fluid . 20)) +(581 (set-fluid! . 20)) +(582 (let-fluid . 20)) +(583 (let-fluids . 20)) +(584 (fluid-lookup . 20)) +(585 (define-enumeration . 33)) +(586 (components . 33)) +(587 (enum . 33)) +(588 (enumerand->name . 33)) +(589 (name->enumerand . 33)) +(590 (lookup-enumerand . 33)) +(591 (architecture-version . 34)) +(592 (bits-used-per-byte . 34)) +(593 (byte-limit . 34)) +(594 (define-instruction-set . 34)) +(595 (op . 34)) +(596 (op-enumeration . 34)) +(597 (op-count . 34)) +(598 (opcode-arg-specs . 34)) +(599 (interrupt . 34)) +(600 (interrupt-enumeration . 34)) +(601 (interrupt-count . 34)) +(602 (exception . 34)) +(603 (exception-enumeration . 34)) +(604 (exception-count . 34)) +(605 (current-port-marker . 34)) +(606 (current-port-marker-enumeration . 34)) +(607 (current-port-marker-count . 34)) +(608 (maximum-stack-args . 34)) +(609 (*last-protocol* . 34)) +(610 (next-protocol . 34)) +(611 (two-byte-nargs-protocol . 34)) +(612 (two-byte-nargs+list-protocol . 34)) +(613 (big-stack-protocol . 34)) +(614 (args+nargs-protocol . 34)) +(615 (nary-dispatch-protocol . 34)) +(616 (default-stack-space . 34)) +(617 (environment-stack-size . 34)) +(618 (continuation-stack-size . 34)) +(619 (available-stack-space . 34)) +(620 (time-option . 34)) +(621 (time-option-enumeration . 34)) +(622 (time-option-count . 34)) +(623 (memory-status-option . 34)) +(624 (memory-status-option-enumeration . 34)) +(625 (memory-status-option-count . 34)) +(626 (channel-status-option . 34)) +(627 (channel-status-option-enumeration . 34)) +(628 (channel-status-option-count . 34)) +(629 (port-status-options . 34)) +(630 (port-status-options-enumeration . 34)) +(631 (port-status-options-count . 34)) +(632 (stob . 34)) +(633 (stob-enumeration . 34)) +(634 (stob-count . 34)) +(635 (least-b-vector-type . 34)) +(636 (stob-data . 34)) +(637 (proxy-base-count . 34)) +(638 (max-proxy-debit . 34)) +(639 (max-proxy-count . 34)) +(640 (:queue . 41)) +(641 (really-make-queue . 41)) +(642 (queue-tail . 41)) +(643 (set-queue-tail! . 41)) +(644 (queue-head . 41)) +(645 (set-queue-head! . 41)) +(646 (queue-uid . 41)) +(647 (queue? . 41)) +(648 (*queue-uid* . 41)) +(649 (make-queue . 41)) +(650 (queue-empty? . 41)) +(651 (enqueue! . 41)) +(652 (queue-front . 41)) +(653 (dequeue! . 41)) +(654 (on-queue? . 41)) +(655 (delete-from-queue! . 41)) +(656 (delete-from-queue-if! . 41)) +(657 (queue->list . 41)) +(658 (queue-length . 41)) +(659 (*condition-types* . 25)) +(660 (condition-supertypes . 25)) +(661 (define-condition-type . 25)) +(662 (condition-predicate . 25)) +(663 (condition? . 25)) +(664 (condition-type . 25)) +(665 (condition-stuff . 25)) +(666 (error? . 25)) +(667 (call-error? . 25)) +(668 (read-error? . 25)) +(669 (exception? . 25)) +(670 (exception-opcode . 25)) +(671 (exception-reason . 25)) +(672 (exception-arguments . 25)) +(673 (make-exception . 25)) +(674 (warning? . 25)) +(675 (syntax-error? . 25)) +(676 (interrupt? . 25)) +(677 (*session-data-initializers* . 22)) +(678 (make-session-data-slot! . 22)) +(679 (session-data-ref . 22)) +(680 (session-data-set! . 22)) +(681 (initialize-session-data! . 22)) +(682 (initialize-interrupts! . 36)) +(683 (interrupt-handlers . 36)) +(684 (set-interrupt-handler! . 36)) +(685 (no-interrupts . 36)) +(686 (all-interrupts . 36)) +(687 (with-interrupts-inhibited . 36)) +(688 (with-interrupts-allowed . 36)) +(689 (disable-interrupts! . 36)) +(690 (enable-interrupts! . 36)) +(691 (with-interrupts . 36)) +(692 (enabled-interrupts . 36)) +(693 (*post-gc-procedures* . 36)) +(694 (call-after-gc! . 36)) +(695 (post-gc-handler . 36)) +(696 (required-post-gc-space . 36)) +(697 (space-shortage-handler . 36)) +(698 (call-before-heap-overflow! . 36)) +(699 (dynamic-wind . 21)) +(700 (call-with-current-continuation . 21)) +(701 (continuation->procedure . 21)) +(702 (:point . 21)) +(703 (make-point . 21)) +(704 (point-parent . 21)) +(705 (point-dynamic-env . 21)) +(706 (point-out . 21)) +(707 (point-in . 21)) +(708 (point-depth . 21)) +(709 (travel-to-point! . 21)) +(710 (template-overhead . 30)) +(711 (template-code . 30)) +(712 (template-info . 30)) +(713 (template-id . 30)) +(714 (set-template-code! . 30)) +(715 (set-template-info! . 30)) +(716 (set-template-id! . 30)) +(717 (:closure . 32)) +(718 (:code-vector . 32)) +(719 (:location . 32)) +(720 (:template . 32)) +(721 (:channel . 32)) +(722 (:port . 32)) +(723 (:weak-pointer . 32)) +(724 (:proxy . 32)) +(725 (:address-space . 32)) +(726 (:proxy-data . 32)) +(727 (:external . 32)) +(728 (continuation-cont . 31)) +(729 (real-continuation-pc . 31)) +(730 (real-continuation-template . 31)) +(731 (continuation-env . 31)) +(732 (exception-continuation-pc . 31)) +(733 (exception-continuation-template . 31)) +(734 (exception-continuation-exception . 31)) +(735 (exception-continuation? . 31)) +(736 (continuation-pc . 31)) +(737 (continuation-template . 31)) +(738 (normal-continuation-overhead . 31)) +(739 (exception-continuation-overhead . 31)) +(740 (continuation-arg . 31)) +(741 (continuation-arg-count . 31)) +(742 (:continuation . 31)) +(743 (continuation-parent . 31)) +(744 (define-exception-handler . 35)) +(745 (signal-exception . 35)) +(746 (exception-handlers . 35)) +(747 (extend-opcode! . 35)) +(748 (really-signal-condition . 35)) +(749 (with-handler . 35)) +(750 ($condition-handlers . 35)) +(751 (initialize-exceptions! . 35)) +(752 (last-resort-condition-handler . 35)) +(753 (report-utter-lossage . 35)) +(754 (continuation-preview . 35)) +(755 (ignore-errors . 35)) +(756 (report-errors-as-warnings . 35)) +(757 (:thread . 37)) +(758 (really-make-thread . 37)) +(759 (thread-name . 37)) +(760 (thread-uid . 37)) +(761 (thread-current-task . 37)) +(762 (set-thread-current-task! . 37)) +(763 (thread-events . 37)) +(764 (set-thread-events! . 37)) +(765 (thread-data . 37)) +(766 (set-thread-data! . 37)) +(767 (thread-scheduler . 37)) +(768 (set-thread-scheduler! . 37)) +(769 (thread-time . 37)) +(770 (set-thread-time! . 37)) +(771 (thread-arguments . 37)) +(772 (set-thread-arguments! . 37)) +(773 (thread-queue . 37)) +(774 (set-thread-queue! . 37)) +(775 (thread-continuation . 37)) +(776 (set-thread-continuation! . 37)) +(777 (thread-dynamic-point . 37)) +(778 (set-thread-dynamic-point! . 37)) +(779 (thread-dynamic-env . 37)) +(780 (thread? . 37)) +(781 (*thread-uid* . 37)) +(782 (make-thread . 37)) +(783 (thread-top-level . 37)) +(784 (thread-uid->thread . 37)) +(785 (all-threads . 37)) +(786 (add-event! . 37)) +(787 (thunk->continuation . 37)) +(788 (compose-continuation . 37)) +(789 (make-thread-queue . 37)) +(790 (thread-queue-empty? . 37)) +(791 (enqueue-thread! . 37)) +(792 (dequeue-thread! . 37)) +(793 (remove-thread-from-queue! . 37)) +(794 (current-thread . 37)) +(795 (set-current-thread! . 37)) +(796 (event-type . 37)) +(797 (event-type-enumeration . 37)) +(798 (event-type-count . 37)) +(799 (run . 37)) +(800 (find-and-run-next-thread . 37)) +(801 (debit-thread-times-and-run! . 37)) +(802 (handle-timer-interrupt . 37)) +(803 (run-next-thread . 37)) +(804 (min . 37)) +(805 (switch-to-thread . 37)) +(806 (run-thread . 37)) +(807 (suspend . 37)) +(808 (suspend-to . 37)) +(809 (debit-down! . 37)) +(810 (exit . 37)) +(811 (wait . 37)) +(812 (waiting? . 37)) +(813 (block . 37)) +(814 (relinquish-timeslice . 37)) +(815 (upcall . 37)) +(816 (propogate-upcall . 37)) +(817 (kill-thread! . 37)) +(818 (interrupt-thread . 37)) +(819 (get-next-event! . 37)) +(820 (event-pending? . 37)) +(821 (schedule-event . 37)) +(822 (schedule-wakeup . 37)) +(823 (show-running . 37)) +(824 (running? . 37)) +(825 (spawn . 37)) +(826 (spawn-on-root . 37)) +(827 (spawn-on-scheduler . 37)) +(828 (make-ready . 37)) +(829 (schedule-interrupt! . 37)) +(830 (cancel-timer-interrupt! . 37)) +(831 (interrupt-timer-time . 37)) +(832 (real-time . 37)) +(833 (with-threads . 37)) +(834 (start-multitasking . 37)) +(835 (deadlock? . 37)) +(836 (terminate? . 37)) +(837 (terminate-current-thread . 37)) +(838 (root-scheduler-slot . 37)) +(839 (root-scheduler . 37)) +(840 (sleep . 37)) +(841 (*dozers* . 37)) +(842 (insert . 37)) +(843 (wake-some-threads . 37)) +(844 (:lock . 42)) +(845 (really-make-lock . 42)) +(846 (lock-uid . 42)) +(847 (lock-queue . 42)) +(848 (lock-owner-uid . 42)) +(849 (set-lock-owner-uid! . 42)) +(850 (lock? . 42)) +(851 (*lock-uid* . 42)) +(852 (make-lock . 42)) +(853 (obtain-lock . 42)) +(854 (maybe-obtain-lock . 42)) +(855 (release-lock . 42)) +(856 (:port-handler . 23)) +(857 (make-port-handler . 23)) +(858 (port-handler-buffer-proc . 23)) +(859 (port-handler-close . 23)) +(860 (port-handler-discloser . 23)) +(861 (port-handler? . 23)) +(862 (disclose-port . 23)) +(863 (obtain-port-lock . 23)) +(864 (maybe-obtain-port-lock . 23)) +(865 (release-port-lock . 23)) +(866 (initialize-i/o-handlers! . 23)) +(867 (one-arg-proc->handler . 23)) +(868 (two-arg-proc->handler . 23)) +(869 (read-char-handler . 23)) +(870 (fill-port-buffer! . 23)) +(871 (write-char-handler . 23)) +(872 (empty-port-buffer! . 23)) +(873 (port-flushed? . 23)) +(874 (set-port-flushed?! . 23)) +(875 (close-input-port . 23)) +(876 (close-output-port . 23)) +(877 (define-port-op . 23)) +(878 (real-char-ready? . 23)) +(879 (read-block . 23)) +(880 (really-read-block . 23)) +(881 (buffer-length . 23)) +(882 (read-more . 23)) +(883 (okay-limits? . 23)) +(884 (write-block . 23)) +(885 (write-string . 23)) +(886 (write-buffered-block . 23)) +(887 (write-unbuffered-block . 23)) +(888 (force-output . 23)) +(889 (really-force-output . 23)) +(890 (default-buffer-size . 23)) +(891 (open-port? . 23)) +(892 (open-port-mask . 23)) +(893 (input-port-mask . 23)) +(894 (open-input-port-mask . 23)) +(895 (open-input-port-status . 23)) +(896 (open-input-port? . 23)) +(897 (make-input-port-closed! . 23)) +(898 (make-input-port . 23)) +(899 (okay-buffer? . 23)) +(900 (output-port-mask . 23)) +(901 (open-output-port-mask . 23)) +(902 (open-output-port-status . 23)) +(903 (open-output-port? . 23)) +(904 (make-output-port-closed! . 23)) +(905 (make-output-port . 23)) +(906 (make-unbuffered-output-port . 23)) +(907 (null-output-port-handler . 23)) +(908 (make-null-output-port . 23)) +(909 (*flush-these-ports* . 23)) +(910 (initialize-output-port-list! . 23)) +(911 (periodically-force-output! . 23)) +(912 (output-port-forcers . 23)) +(913 (make-forcing-thunk . 23)) +(914 ($current-input-port . 23)) +(915 ($current-output-port . 23)) +(916 ($current-error-port . 23)) +(917 ($current-noise-port . 23)) +(918 (current-input-port . 23)) +(919 (current-output-port . 23)) +(920 (current-error-port . 23)) +(921 (current-noise-port . 23)) +(922 (initialize-i/o . 23)) +(923 (with-current-ports . 23)) +(924 (call-with-current-input-port . 23)) +(925 (call-with-current-output-port . 23)) +(926 (call-with-current-noise-port . 23)) +(927 (silently . 23)) +(928 (newline . 23)) +(929 (char-ready? . 23)) +(930 (output-port-option . 23)) +(931 (input-port-option . 23)) +(932 (write . 26)) +(933 (recurring-write . 26)) +(934 (write-boolean . 26)) +(935 (write-number . 26)) +(936 (write-char-literal . 26)) +(937 (character-name . 26)) +(938 (write-string-literal . 26)) +(939 (write-list . 26)) +(940 (quotation? . 26)) +(941 (write-vector . 26)) +(942 (write-other . 26)) +(943 (display-type-name . 26)) +(944 (display . 26)) +(945 (read . 27)) +(946 (sub-read-carefully . 27)) +(947 (reader-token-marker . 27)) +(948 (make-reader-token . 27)) +(949 (reader-token? . 27)) +(950 (close-paren . 27)) +(951 (dot . 27)) +(952 (sub-read . 27)) +(953 (read-dispatch-vector . 27)) +(954 (read-terminating?-vector . 27)) +(955 (set-standard-syntax! . 27)) +(956 (set-standard-read-macro! . 27)) +(957 (sub-read-list . 27)) +(958 (gobble-line . 27)) +(959 (*sharp-macros* . 27)) +(960 (define-sharp-macro . 27)) +(961 (sub-read-token . 27)) +(962 (parse-token . 27)) +(963 (strange-symbol-names . 27)) +(964 (p-c-v . 27)) +(965 (preferred-case . 27)) +(966 (reading-error . 27)) +(967 (input-channel-handler . 24)) +(968 (input-channel->port . 24)) +(969 (output-channel-handler . 24)) +(970 (make-unbuffered-output-channel-handler . 24)) +(971 (output-channel->port . 24)) +(972 (maybe-force-output . 24)) +(973 (maybe-open-file . 24)) +(974 (open-input-file . 24)) +(975 (open-output-file . 24)) +(976 (call-with-input-file . 24)) +(977 (call-with-output-file . 24)) +(978 (with-input-from-file . 24)) +(979 (with-output-to-file . 24)) +(980 (steal-channel-port! . 24)) +(981 (really-steal-channel-port! . 24)) +(982 (initialize-channel-i/o! . 24)) +(983 (i/o-completion-handler . 24)) +(984 (waiting-for-i/o? . 24)) +(985 (wait-for-channel . 24)) +(986 (steal-channel! . 24)) +(987 (i/o-wait-count-slot . 24)) +(988 (i/o-wait-count . 24)) +(989 (increment-i/o-wait-count! . 24)) +(990 (decrement-i/o-wait-count! . 24)) +(991 (i/o-wait-queues-slot . 24)) +(992 (i/o-wait-queue . 24)) +(993 (make-i/o-wait-queues . 24)) +(994 (:table . 75)) +(995 (really-make-table . 75)) +(996 (table-set!-procedure . 75)) +(997 (set-table-set!-procedure! . 75)) +(998 (table-ref-procedure . 75)) +(999 (set-table-ref-procedure! . 75)) +(1000 (table-data . 75)) +(1001 (set-table-data! . 75)) +(1002 (table-size . 75)) +(1003 (set-table-size! . 75)) +(1004 (table? . 75)) +(1005 (table-ref . 75)) +(1006 (table-set! . 75)) +(1007 (linear-table-size-limit . 75)) +(1008 (next-table-size . 75)) +(1009 (make-table-maker . 75)) +(1010 (null-entry . 75)) +(1011 (new-entry . 75)) +(1012 (entry-value . 75)) +(1013 (entry-key . 75)) +(1014 (set-entry-value! . 75)) +(1015 (delete-entry! . 75)) +(1016 (make-assoc . 75)) +(1017 (make-linear-table-ref . 75)) +(1018 (make-linear-table-set! . 75)) +(1019 (make->hash-table . 75)) +(1020 (make-hash-table-ref . 75)) +(1021 (make-hash-table-set! . 75)) +(1022 (expand-hash-table! . 75)) +(1023 (table-enter-alist! . 75)) +(1024 (table-expand-table! . 75)) +(1025 (table-walk . 75)) +(1026 (really-table-walk . 75)) +(1027 (alist-walk . 75)) +(1028 (make-table-immutable! . 75)) +(1029 (table->entry-list . 75)) +(1030 (default-table-hash-function . 75)) +(1031 (symbol-hash . 75)) +(1032 (make-table . 75)) +(1033 (make-string-table . 75)) +(1034 (make-symbol-table . 75)) +(1035 (make-integer-table . 75)) +(1036 (make-population . 44)) +(1037 (add-to-population! . 44)) +(1038 (weak-memq . 44)) +(1039 (population-reduce . 44)) +(1040 (population->list . 44)) +(1041 (walk-population . 44)) +(1042 (:meta-type . 46)) +(1043 (really-make-type . 46)) +(1044 (type-info . 46)) +(1045 (type-more . 46)) +(1046 (type-mask . 46)) +(1047 (meta-type? . 46)) +(1048 (make-type . 46)) +(1049 (name->type-table . 46)) +(1050 (mask->name-table . 46)) +(1051 (name->type . 46)) +(1052 (set-type-name! . 46)) +(1053 (*mask* . 46)) +(1054 (new-type-bit . 46)) +(1055 (mask->type . 46)) +(1056 (bottom-type . 46)) +(1057 (error-type . 46)) +(1058 (bottom-type? . 46)) +(1059 (new-atomic-type . 46)) +(1060 (named-atomic-type . 46)) +(1061 (syntax-type . 46)) +(1062 (other-static-type . 46)) +(1063 (empty-rail-type . 46)) +(1064 (rail-type . 46)) +(1065 (make-optional-type . 46)) +(1066 (make-rest-type . 46)) +(1067 (head-type . 46)) +(1068 (head-type-really . 46)) +(1069 (tail-type . 46)) +(1070 (empty-rail-type? . 46)) +(1071 (rest-type? . 46)) +(1072 (optional-type? . 46)) +(1073 (mask/no-values . 46)) +(1074 (mask/two-or-more . 46)) +(1075 (mask/&rest . 46)) +(1076 (value-type . 46)) +(1077 (mask/value . 46)) +(1078 (value-type? . 46)) +(1079 (any-values-type . 46)) +(1080 (any-arguments-type . 46)) +(1081 (mask/one-or-more . 46)) +(1082 (same-type? . 46)) +(1083 (subtype? . 46)) +(1084 (meet-type . 46)) +(1085 (other-type-info . 46)) +(1086 (meet-rail . 46)) +(1087 (meet-procedure . 46)) +(1088 (meet? . 46)) +(1089 (meet-procedure? . 46)) +(1090 (join-type . 46)) +(1091 (join-rail . 46)) +(1092 (join-procedure . 46)) +(1093 (number-hierarchy . 46)) +(1094 (integer-type . 46)) +(1095 (rational-type . 46)) +(1096 (real-type . 46)) +(1097 (complex-type . 46)) +(1098 (number-type . 46)) +(1099 (exact-type . 46)) +(1100 (inexact-type . 46)) +(1101 (exact-integer-type . 46)) +(1102 (inexact-real-type . 46)) +(1103 (boolean-type . 46)) +(1104 (pair-type . 46)) +(1105 (null-type . 46)) +(1106 (record-type . 46)) +(1107 (any-procedure-type . 46)) +(1108 (other-value-type . 46)) +(1109 (mask/other . 46)) +(1110 (make-other-type . 46)) +(1111 (char-type . 46)) +(1112 (unspecific-type . 46)) +(1113 (string-type . 46)) +(1114 (symbol-type . 46)) +(1115 (vector-type . 46)) +(1116 (escape-type . 46)) +(1117 (structure-type . 46)) +(1118 (mask/procedure . 46)) +(1119 (procedure-type . 46)) +(1120 (make-procedure-type . 46)) +(1121 (procedure-type-domain . 46)) +(1122 (procedure-type-codomain . 46)) +(1123 (restrictive? . 46)) +(1124 (sexp->type . 46)) +(1125 (sexp->values-type . 46)) +(1126 (type->sexp . 46)) +(1127 (atomic-type->sexp . 46)) +(1128 (rail-type->sexp . 46)) +(1129 (disjoin-type . 46)) +(1130 (disjoin-rest . 46)) +(1131 (mask/number . 46)) +(1132 (make-some-values-type . 46)) +(1133 (proc . 46)) +(1134 (some-values . 46)) +(1135 (procedure-type? . 46)) +(1136 (fixed-arity-procedure-type? . 46)) +(1137 (procedure-type-arity . 46)) +(1138 (procedure-type-argument-types . 46)) +(1139 (variable-type . 46)) +(1140 (variable-type? . 46)) +(1141 (variable-value-type . 46)) +(1142 (usual-variable-type . 46)) +(1143 (undeclared-type . 46)) +(1144 (compatible-types? . 46)) +(1145 (:interface . 63)) +(1146 (really-make-interface . 63)) +(1147 (interface-name . 63)) +(1148 (set-interface-name! . 63)) +(1149 (interface-clients . 63)) +(1150 (walk-method . 63)) +(1151 (ref-method . 63)) +(1152 (interface? . 63)) +(1153 (interface-ref . 63)) +(1154 (for-each-declaration . 63)) +(1155 (note-reference-to-interface! . 63)) +(1156 (make-interface . 63)) +(1157 (make-simple-interface . 63)) +(1158 (really-make-simple-interface . 63)) +(1159 (make-compound-interface . 63)) +(1160 (note-interface-name! . 63)) +(1161 (binding? . 47)) +(1162 (binding-type . 47)) +(1163 (binding-place . 47)) +(1164 (binding-static . 47)) +(1165 (binding-path . 47)) +(1166 (set-binding-place! . 47)) +(1167 (make-binding . 47)) +(1168 (add-path . 47)) +(1169 (clobber-binding! . 47)) +(1170 (impose-type . 47)) +(1171 (forget-integration . 47)) +(1172 (same-denotation? . 47)) +(1173 (maybe-fix-place! . 47)) +(1174 (follow-forwarding-pointers . 47)) +(1175 (name? . 48)) +(1176 (:generated . 48)) +(1177 (make-generated . 48)) +(1178 (generated-parent-name . 48)) +(1179 (generated-env . 48)) +(1180 (generated-token . 48)) +(1181 (generated-symbol . 48)) +(1182 (generated? . 48)) +(1183 (generate-name . 48)) +(1184 (generated-uid . 48)) +(1185 (*generated-uid* . 48)) +(1186 (name->symbol . 48)) +(1187 (name-hash . 48)) +(1188 (make-name-table . 48)) +(1189 (desyntaxify . 48)) +(1190 (make-qualified . 48)) +(1191 (qualified? . 48)) +(1192 (qualified-parent-name . 48)) +(1193 (qualified-symbol . 48)) +(1194 (name->qualified . 48)) +(1195 (qualify-parent . 48)) +(1196 (:transform . 48)) +(1197 (really-make-transform . 48)) +(1198 (transform-id . 48)) +(1199 (transform-source . 48)) +(1200 (transform-aux-names . 48)) +(1201 (transform-type . 48)) +(1202 (transform-env . 48)) +(1203 (transform-procedure . 48)) +(1204 (transform? . 48)) +(1205 (make-transform . 48)) +(1206 (maybe-apply-macro-transform . 48)) +(1207 (apply-inline-transform . 48)) +(1208 (make-keyword-comparator . 48)) +(1209 (name->source-name . 48)) +(1210 (bind-aliases . 48)) +(1211 (make-name-generator . 48)) +(1212 (lookup . 48)) +(1213 (lookup . 51)) +(1214 (bind1 . 51)) +(1215 (bind . 51)) +(1216 (bindrec . 51)) +(1217 (make-compiler-env . 51)) +(1218 (funny-name/macro-eval . 51)) +(1219 (environment-macro-eval . 51)) +(1220 (funny-name/define! . 51)) +(1221 (environment-define! . 51)) +(1222 (funny-name/package . 51)) +(1223 (extract-package-from-environment . 51)) +(1224 (funny-name/source-file-name . 51)) +(1225 (bind-source-file-name . 51)) +(1226 (source-file-name . 51)) +(1227 (:thingie . 49)) +(1228 (make-thingie . 49)) +(1229 (thingie-want-type . 49)) +(1230 (thingie-name . 49)) +(1231 (thingie-binding . 49)) +(1232 (thingie? . 49)) +(1233 (:structure . 64)) +(1234 (really-make-structure . 64)) +(1235 (structure-name . 64)) +(1236 (set-structure-name! . 64)) +(1237 (structure-clients . 64)) +(1238 (structure-package . 64)) +(1239 (structure-interface-really . 64)) +(1240 (set-structure-interface! . 64)) +(1241 (structure-interface-thunk . 64)) +(1242 (structure? . 64)) +(1243 (structure-interface . 64)) +(1244 (initialize-structure! . 64)) +(1245 (make-structure . 64)) +(1246 (note-structure-name! . 64)) +(1247 (structure-unstable? . 64)) +(1248 (for-each-export . 64)) +(1249 (:package . 64)) +(1250 (really-make-package . 64)) +(1251 (package-cached . 64)) +(1252 (package-clients . 64)) +(1253 (package-real-undefined-but-assigneds . 64)) +(1254 (set-package-undefined-but-assigneds! . 64)) +(1255 (package-real-undefineds . 64)) +(1256 (set-package-undefineds! . 64)) +(1257 (package-accesses-thunk . 64)) +(1258 (package-opens-thunk . 64)) +(1259 (set-package-opens-thunk! . 64)) +(1260 (package->environment . 64)) +(1261 (set-package->environment! . 64)) +(1262 (package-loaded? . 64)) +(1263 (set-package-loaded?! . 64)) +(1264 (package-clauses . 64)) +(1265 (package-file-name . 64)) +(1266 (package-get-location . 64)) +(1267 (set-package-get-location! . 64)) +(1268 (package-integrate? . 64)) +(1269 (set-package-integrate?! . 64)) +(1270 (package-unstable? . 64)) +(1271 (package-definitions . 64)) +(1272 (package-opens-really . 64)) +(1273 (set-package-opens! . 64)) +(1274 (package-uid . 64)) +(1275 (package? . 64)) +(1276 (make-package . 64)) +(1277 (really-package->environment . 64)) +(1278 (lazy-table-accessor . 64)) +(1279 (package-undefineds . 64)) +(1280 (package-undefined-but-assigneds . 64)) +(1281 (new-package-uid . 64)) +(1282 (*package-uid* . 64)) +(1283 (package-name-table . 64)) +(1284 (package-name . 64)) +(1285 (note-package-name! . 64)) +(1286 (package-opens . 64)) +(1287 (initialize-package-if-necessary! . 64)) +(1288 (package-accesses . 64)) +(1289 (make-simple-package . 64)) +(1290 (package-definition . 64)) +(1291 (package-define! . 64)) +(1292 (package-add-static! . 64)) +(1293 (package-refine-type! . 64)) +(1294 (package-lookup . 64)) +(1295 (really-package-lookup . 64)) +(1296 (search-opens . 64)) +(1297 (structure-lookup . 64)) +(1298 (real-structure-lookup . 64)) +(1299 (generic-lookup . 64)) +(1300 (initialize-package! . 64)) +(1301 (for-each-definition . 64)) +(1302 (get-new-location . 64)) +(1303 (make-new-location . 64)) +(1304 ($get-location . 64)) +(1305 (*location-uid* . 64)) +(1306 (location-info-table . 64)) +(1307 (flush-location-names . 64)) +(1308 (link! . 64)) +(1309 (really-link! . 64)) +(1310 (get-location . 64)) +(1311 (location-on-demand . 64)) +(1312 (get-undefined . 64)) +(1313 (location-for-assignment . 64)) +(1314 (package-note-caching! . 64)) +(1315 (note-caching! . 64)) +(1316 (get-location-for-unassignable . 64)) +(1317 (get-location-for-undefined . 64)) +(1318 ($note-undefined . 64)) +(1319 (cenv->package . 64)) +(1320 (location-for-reference . 64)) +(1321 (noting-undefined-variables . 64)) +(1322 (print-undefined-names . 64)) +(1323 (environment-ref . 77)) +(1324 (environment-set! . 77)) +(1325 (environment-define! . 77)) +(1326 (*structure-ref . 77)) +(1327 (carefully . 77)) +(1328 ($interaction-environment . 77)) +(1329 (interaction-environment . 77)) +(1330 (set-interaction-environment! . 77)) +(1331 (with-interaction-environment . 77)) +(1332 (scheme-report-environment . 77)) +(1333 (*scheme-report-environment* . 77)) +(1334 (*null-environment* . 77)) +(1335 (*scheme-report-number* . 77)) +(1336 (set-scheme-report-environment! . 77)) +(1337 (null-environment . 77)) +(1338 (make-reflective-tower . 77)) +(1339 (set-reflective-tower-maker! . 77)) +(1340 (namestring . 76)) +(1341 (directory-component-separator . 76)) +(1342 (type-component-separator . 76)) +(1343 (namestring-component . 76)) +(1344 (file-name-preferred-case . 76)) +(1345 (*scheme-file-type* . 76)) +(1346 (*load-file-type* . 76)) +(1347 (file-name-directory . 76)) +(1348 (file-name-nondirectory . 76)) +(1349 (file-nondirectory-position . 76)) +(1350 (string-posq . 76)) +(1351 (*translations* . 76)) +(1352 (translations . 76)) +(1353 (set-translation! . 76)) +(1354 (translate . 76)) +(1355 ($note-file-package . 61)) +(1356 (read-forms . 61)) +(1357 (really-read-forms . 61)) +(1358 (:operator . 50)) +(1359 (make-operator . 50)) +(1360 (operator-name . 50)) +(1361 (operator-uid . 50)) +(1362 (operator-nargs . 50)) +(1363 (operator-type . 50)) +(1364 (set-operator-type! . 50)) +(1365 (operator? . 50)) +(1366 (usual-operator-type . 50)) +(1367 (get-operator . 50)) +(1368 (*operator-uid* . 50)) +(1369 (operators-table . 50)) +(1370 (number-of-operators . 50)) +(1371 (the-operators . 50)) +(1372 (make-operator-table . 50)) +(1373 (operator-table-ref . 50)) +(1374 (operator-lookup . 50)) +(1375 (operator-define! . 50)) +(1376 (:node . 50)) +(1377 (really-make-node . 50)) +(1378 (node-plist . 50)) +(1379 (set-node-plist! . 50)) +(1380 (node-form . 50)) +(1381 (node-operator-id . 50)) +(1382 (node? . 50)) +(1383 (make-node . 50)) +(1384 (node-ref . 50)) +(1385 (node-set! . 50)) +(1386 (node-operator . 50)) +(1387 (node-predicate . 50)) +(1388 (make-similar-node . 50)) +(1389 (force-node . 50)) +(1390 (schemify . 50)) +(1391 (schemifiers . 50)) +(1392 (schemify-node . 50)) +(1393 (schemify-nodes . 50)) +(1394 (define-schemifier . 50)) +(1395 (schemify-lambda . 50)) +(1396 (schemify-formals . 50)) +(1397 (schemify-sexp . 50)) +(1398 (number-of-required-args . 54)) +(1399 (n-ary? . 54)) +(1400 (normalize-formals . 54)) +(1401 (scan-forms . 52)) +(1402 (expand-form . 52)) +(1403 (scan-define . 52)) +(1404 (expand-define . 52)) +(1405 (scan-define-syntax . 52)) +(1406 (expand-head . 52)) +(1407 (destructure-define . 52)) +(1408 (make-operator-predicate . 52)) +(1409 (define? . 52)) +(1410 (begin? . 52)) +(1411 (define-syntax? . 52)) +(1412 (static-value . 52)) +(1413 (expand-body . 52)) +(1414 (scan-body-forms . 52)) +(1415 (body-lossage . 52)) +(1416 (expand . 52)) +(1417 (expand-list . 52)) +(1418 (expand-literal . 52)) +(1419 (expand-call . 52)) +(1420 (expand-name . 52)) +(1421 (expand-macro-application . 52)) +(1422 (expand-operator-form . 52)) +(1423 (expanders . 52)) +(1424 (define-expander . 52)) +(1425 (unspecific-node . 52)) +(1426 (expand-lambda . 52)) +(1427 (bind-names . 52)) +(1428 (names? . 52)) +(1429 (expand-letrec . 52)) +(1430 (process-syntax . 52)) +(1431 (this-long? . 52)) +(1432 (at-least-this-long? . 52)) +(1433 (specs? . 52)) +(1434 (literal? . 52)) +(1435 (syntax? . 52)) +(1436 (begin-node? . 52)) +(1437 (call-node? . 52)) +(1438 (name-node? . 52)) +(1439 (operator/literal . 52)) +(1440 (operator/quote . 52)) +(1441 (operator/call . 52)) +(1442 (operator/name . 52)) +(1443 (operator/unspecific . 52)) +(1444 (operator/unassigned . 52)) +(1445 (operator/lambda . 52)) +(1446 (operator/begin . 52)) +(1447 (operator/letrec . 52)) +(1448 (operator/define . 52)) +(1449 (operator/primitive-procedure . 52)) +(1450 (:primop . 58)) +(1451 (make-primop . 58)) +(1452 (primop-compilator . 58)) +(1453 (primop-closed . 58)) +(1454 (primop-type . 58)) +(1455 (primop-name . 58)) +(1456 (primop? . 58)) +(1457 (primop-table . 58)) +(1458 (walk-primops . 58)) +(1459 (define-compiler-primitive . 58)) +(1460 (get-primop . 58)) +(1461 (:debug-data . 55)) +(1462 (make-debug-data . 55)) +(1463 (debug-data-source . 55)) +(1464 (set-debug-data-source! . 55)) +(1465 (debug-data-env-maps . 55)) +(1466 (set-debug-data-env-maps! . 55)) +(1467 (debug-data-pc-in-parent . 55)) +(1468 (debug-data-parent . 55)) +(1469 (debug-data-name . 55)) +(1470 (debug-data-uid . 55)) +(1471 (debug-data? . 55)) +(1472 (maximum-stack-use . 56)) +(1473 (protocol-skip . 56)) +(1474 (stack-delta . 56)) +(1475 (define-delta . 56)) +(1476 (stack-max . 56)) +(1477 (nothing . 56)) +(1478 (popper . 56)) +(1479 (pusher . 56)) +(1480 (continue . 56)) +(1481 (continuer . 56)) +(1482 (do-make-cont . 56)) +(1483 (stack-function . 56)) +(1484 (arg-spec-size . 56)) +(1485 (imax . 56)) +(1486 (get-offset . 56)) +(1487 (new-template-uid . 57)) +(1488 (*template-uid* . 57)) +(1489 (template-uid . 57)) +(1490 (set-template-uid! . 57)) +(1491 (debug-flag-names . 57)) +(1492 (type/debug-flags . 57)) +(1493 (make-debug-flags . 57)) +(1494 ($debug-flags . 57)) +(1495 (debug-flag-accessor . 57)) +(1496 (debug-flag-modifier . 57)) +(1497 (keep-source-code? . 57)) +(1498 (keep-environment-maps? . 57)) +(1499 (keep-procedure-names? . 57)) +(1500 (keep-file-names? . 57)) +(1501 (tabulate-debug-data? . 57)) +(1502 (debug-data-table . 57)) +(1503 (with-fresh-compiler-state . 57)) +(1504 (saving-and-restoring . 57)) +(1505 (debug-data->info . 57)) +(1506 (get-debug-data . 57)) +(1507 (note-debug-data! . 57)) +(1508 (new-debug-data . 57)) +(1509 (make-segment . 57)) +(1510 (segment-size . 57)) +(1511 (segment-emitter . 57)) +(1512 (segment->template . 57)) +(1513 (segment-data->template . 57)) +(1514 (check-stack-use . 57)) +(1515 (:assembly-state . 57)) +(1516 (make-assembly-state . 57)) +(1517 (astate-literals . 57)) +(1518 (set-astate-literals! . 57)) +(1519 (astate-count . 57)) +(1520 (set-astate-count! . 57)) +(1521 (astate-pc . 57)) +(1522 (set-astate-pc! . 57)) +(1523 (astate-code-vector . 57)) +(1524 (make-astate . 57)) +(1525 (emit-byte! . 57)) +(1526 (literal->index . 57)) +(1527 (emit-literal! . 57)) +(1528 (emit-segment! . 57)) +(1529 (empty-segment . 57)) +(1530 (instruction . 57)) +(1531 (sequentially . 57)) +(1532 (sequentially-2 . 57)) +(1533 (instruction-with-literal . 57)) +(1534 (instruction-with-location . 57)) +(1535 (template . 57)) +(1536 (make-label . 57)) +(1537 (instruction-using-label . 57)) +(1538 (computed-goto-label-size . 57)) +(1539 (computed-goto-instruction . 57)) +(1540 (attach-label . 57)) +(1541 (insert-label! . 57)) +(1542 (code-vector-set2! . 57)) +(1543 (two-byte-limit . 57)) +(1544 (high-byte . 57)) +(1545 (low-byte . 57)) +(1546 ($debug-data . 57)) +(1547 (note-source-code . 57)) +(1548 (note-environment . 57)) +(1549 (emit-with-environment-maps! . 57)) +(1550 ($environment-maps . 57)) +(1551 (optimizers-table . 66)) +(1552 (set-optimizer! . 66)) +(1553 (get-optimizer . 66)) +(1554 (apply-optimizers . 66)) +(1555 (*standard-optimizer-names* . 66)) +(1556 (default-standard-optimizer . 66)) +(1557 (*standard-optimizer* . 66)) +(1558 (set-standard-optimizers! . 66)) +(1559 (get-optimizers . 66)) +(1560 (make-standard-optimizer . 66)) +(1561 (flatten-form . 62)) +(1562 (flatten-node . 62)) +(1563 (flatteners . 62)) +(1564 (define-flattener . 62)) +(1565 (flatten-list . 62)) +(1566 (no-free-vars . 62)) +(1567 (flatten-lambda . 62)) +(1568 (convert-lambda-body . 62)) +(1569 (add-cells . 62)) +(1570 (assigned? . 62)) +(1571 (mark-set-variables! . 62)) +(1572 (mark-sets . 62)) +(1573 (define-set-marker . 62)) +(1574 (no-sets . 62)) +(1575 (make-cell . 62)) +(1576 (make-unassigned-cell . 62)) +(1577 (make-cell-ref . 62)) +(1578 (make-cell-set! . 62)) +(1579 (make-primop-call . 62)) +(1580 (operator/flat-lambda . 62)) +(1581 (operator/lambda . 62)) +(1582 (operator/begin . 62)) +(1583 (operator/literal . 62)) +(1584 (operator/call . 62)) +(1585 (operator/unassigned . 62)) +(1586 (operator/set! . 62)) +(1587 (define-node? . 62)) +(1588 (lambda-node? . 62)) +(1589 (define-primop . 62)) +(1590 (temp0 . 62)) +(1591 (make-cell-primop . 62)) +(1592 (temp1 . 62)) +(1593 (cell-ref-primop . 62)) +(1594 (temp2 . 62)) +(1595 (cell-set!-primop . 62)) +(1596 (union . 62)) +(1597 (set-difference . 62)) +(1598 (node-type . 59)) +(1599 (reconstruct-type . 59)) +(1600 (reconstruct . 59)) +(1601 (examine . 59)) +(1602 (reconstructors . 59)) +(1603 (define-reconstructor . 59)) +(1604 (reconstruct-lambda . 59)) +(1605 (careful-codomain . 59)) +(1606 (reconstruct-name . 59)) +(1607 (proc->reconstructor . 59)) +(1608 (reconstruct-call . 59)) +(1609 (fork-constraints . 59)) +(1610 (node->type . 59)) +(1611 (name-node? . 59)) +(1612 (literal-node? . 59)) +(1613 (lambda-node? . 59)) +(1614 (primop-reconstructors . 59)) +(1615 (define-primop-reconstructor . 59)) +(1616 (reconstruct-apply . 59)) +(1617 (constant-type . 59)) +(1618 (compile-expression . 60)) +(1619 (compile . 60)) +(1620 (compilators . 60)) +(1621 (define-compilator . 60)) +(1622 (compile-constant . 60)) +(1623 (compile-call . 60)) +(1624 (compile-name-call . 60)) +(1625 (compile-redex . 60)) +(1626 (compile-unknown-call . 60)) +(1627 (maybe-push-continuation . 60)) +(1628 (fixup-source . 60)) +(1629 (push-arguments . 60)) +(1630 (push-all-with-names . 60)) +(1631 (compile-lambda . 60)) +(1632 (compile-lambda-code . 60)) +(1633 (name-node->symbol . 60)) +(1634 (set-lexical-offsets! . 60)) +(1635 (compile-flat-lambda . 60)) +(1636 (get-variables-offsets . 60)) +(1637 (variable-env-data . 60)) +(1638 (sort-list . 60)) +(1639 (make-cont . 60)) +(1640 (cont-segment . 60)) +(1641 (cont-source-info . 60)) +(1642 (return-cont-segment . 60)) +(1643 (return-cont . 60)) +(1644 (return-cont? . 60)) +(1645 (fall-through-cont . 60)) +(1646 (fall-through-cont? . 60)) +(1647 (ignore-values-segment . 60)) +(1648 (ignore-values-cont . 60)) +(1649 (ignore-values-cont? . 60)) +(1650 (deliver-value . 60)) +(1651 (named-cont . 60)) +(1652 (cont-name . 60)) +(1653 (name-node-binding . 60)) +(1654 (generate-trap . 60)) +(1655 (type-check . 60)) +(1656 (set-type-check?! . 60)) +(1657 (*type-check?* . 60)) +(1658 (diagnose-call-error . 60)) +(1659 (lambda-node? . 60)) +(1660 (name-node? . 60)) +(1661 (literal-node? . 60)) +(1662 (operator/lambda . 60)) +(1663 (operator/set! . 60)) +(1664 (operator/call . 60)) +(1665 (operator/begin . 60)) +(1666 (direct-compilator . 60)) +(1667 (direct-closed-compilator . 60)) +(1668 (nargs->domain . 60)) +(1669 (get-primop-type . 60)) +(1670 (primop-types . 60)) +(1671 (define-simple-primitive . 60)) +(1672 (simple-compilator . 60)) +(1673 (simple-closed-compilator . 60)) +(1674 (symbol-append . 60)) +(1675 (define-stob-predicate . 60)) +(1676 (define-data-struct-primitives . 60)) +(1677 (define-vector-primitives . 60)) +(1678 (define-n-ary-compiler-primitive . 60)) +(1679 (n-ary-primitive-compilator . 60)) +(1680 (call-on-arg-and-id . 60)) +(1681 (call-on-args . 60)) +(1682 (op/unspecific . 60)) +(1683 (op/literal . 60)) +(1684 (push-all-but-last . 60)) +(1685 (dispatch-protocol-size . 60)) +(1686 (make-dispatch-protocol . 60)) +(1687 (compile-forms . 60)) +(1688 (compile-form . 60)) +(1689 (define-node? . 60)) +(1690 (compile-definition . 60)) +(1691 (location-contents-offset . 60)) +(1692 (make-startup-procedure . 60)) +(1693 (an-ignore-values-cont . 60)) +(1694 (eval . 78)) +(1695 (load-into . 78)) +(1696 (eval-from-file . 78)) +(1697 (load . 78)) +(1698 (really-load-into . 78)) +(1699 (compile-and-run . 78)) +(1700 (display-condition . 45)) +(1701 (really-display-condition . 45)) +(1702 (*depth* . 45)) +(1703 (*length* . 45)) +(1704 (&disclose-condition . 45)) +(1705 (disclose-condition . 45)) +(1706 (limited-write . 45)) +(1707 (command-processor . 82)) +(1708 (mini-load . 82)) +(1709 (read-string . 82)) +(1710 (enum-case . 40)) +(1711 (run-threads . 38)) +(1712 (run-threads-with-housekeeper . 38)) +(1713 (round-robin-event-handler . 38)) +(1714 (make-counter . 38)) +(1715 (counter-value . 38)) +(1716 (increment-counter! . 38)) +(1717 (decrement-counter! . 38)) +(1718 (root-scheduler . 39)) +(1719 (make-root-event-handler . 39)) +(1720 (root-handler . 39)) +(1721 (cheap-display-condition . 39)) +(1722 (abort-token . 39)) +(1723 (scheme-exit-now . 39)) +(1724 (root-wait . 39)) +(1725 (one-day-of-milliseconds . 39)) +(1726 (do-some-waiting . 39)) +(1727 (deadlock-handler . 39)) +(1728 (call-when-deadlocked! . 39)) +(1729 (spawn-output-forcers . 39)) +(1730 (unspecific . 39)) +(1731 (usual-resumer . 43)) +(1732 (initialize-rts . 43)) +(1733 (start . 83)) +(1734 (make-built-in-structures . 83)) +(1735 (initialize-interaction-environment! . 83)) +(1736 (make-initial-package . 83)) +(1737 (make-tower . 83)) +(1738 (the-usual-transforms . 53)) +(1739 (define-usual-macro . 53)) +(1740 (usual-transform . 53)) +(1741 (do-spec? . 53)) +(1742 (specs? . 53)) +(1743 (case-clause? . 53)) +(1744 (process-rules . 53)) +(1745 (segment-pattern? . 53)) +(1746 (segment-template? . 53)) +(1747 (indicators-for-zero-or-more . 53)) +(1748 (find-free-names-in-syntax-rules . 53)) +(1749 (strongly-connected-components . 74)) +(1750 (find-next-vertex . 74)) +(1751 (:vertex . 74)) +(1752 (really-make-vertex . 74)) +(1753 (vertex-lowpoint . 74)) +(1754 (set-vertex-lowpoint! . 74)) +(1755 (vertex-parent . 74)) +(1756 (set-vertex-parent! . 74)) +(1757 (vertex-index . 74)) +(1758 (set-vertex-index! . 74)) +(1759 (vertex-stack . 74)) +(1760 (set-vertex-stack! . 74)) +(1761 (vertex-edges . 74)) +(1762 (set-vertex-edges! . 74)) +(1763 (vertex-data . 74)) +(1764 (vertex? . 74)) +(1765 (make-vertex . 74)) +(1766 (make-vertices . 74)) +(1767 (do-vertex . 74)) +(1768 (get-strong . 74)) +(1769 (end-vertex . 74)) +(1770 (unwind-stack . 74)) +(1771 (follow-edge . 74)) +(1772 (pop-vertex-edge! . 74)) +(1773 (find-usages . 71)) +(1774 (maybe-update-known-type . 71)) +(1775 (find-node-usages . 71)) +(1776 (analyze . 71)) +(1777 (analyze-nodes . 71)) +(1778 (usage-analyzers . 71)) +(1779 (define-usage-analyzer . 71)) +(1780 (nothing . 71)) +(1781 (add-if-free . 71)) +(1782 (:usage . 71)) +(1783 (really-make-usage . 71)) +(1784 (usage-assignment-count . 71)) +(1785 (set-assignment! . 71)) +(1786 (usage-operator-count . 71)) +(1787 (set-operator! . 71)) +(1788 (usage-reference-count . 71)) +(1789 (set-reference! . 71)) +(1790 (usage-name-node . 71)) +(1791 (usage? . 71)) +(1792 (make-usage . 71)) +(1793 (make-package-usage . 71)) +(1794 (package-usage? . 71)) +(1795 (usage-incrementator . 71)) +(1796 (note-reference! . 71)) +(1797 (note-operator! . 71)) +(1798 (note-assignment! . 71)) +(1799 (lambda-node? . 71)) +(1800 (quote-node? . 71)) +(1801 (literal-node? . 71)) +(1802 (call-node? . 71)) +(1803 (name-node? . 71)) +(1804 (define-node? . 71)) +(1805 (sort-forms . 71)) +(1806 (stuff-count . 71)) +(1807 (maybe-make-aliased . 71)) +(1808 (topologically-sort . 71)) +(1809 (:form . 71)) +(1810 (really-make-form . 71)) +(1811 (form-temp . 71)) +(1812 (set-form-temp! . 71)) +(1813 (form-free . 71)) +(1814 (set-form-free! . 71)) +(1815 (form-unaliased? . 71)) +(1816 (set-form-unaliased?! . 71)) +(1817 (form-aliases . 71)) +(1818 (set-form-aliases! . 71)) +(1819 (form-node . 71)) +(1820 (form? . 71)) +(1821 (make-form . 71)) +(1822 (insert-aliases . 71)) +(1823 (make-inline-transform . 73)) +(1824 (clean-node . 73)) +(1825 (clean-lambda . 73)) +(1826 (clean-lookup . 73)) +(1827 (unused-name . 73)) +(1828 (inline-transform . 73)) +(1829 (make-substitution . 73)) +(1830 (reconstitute . 73)) +(1831 (reconstitute-name . 73)) +(1832 (operator/name . 73)) +(1833 (operator/literal . 73)) +(1834 (qualified->name . 73)) +(1835 (get-qualified-env . 73)) +(1836 (quote-node? . 73)) +(1837 (call-node? . 73)) +(1838 (lambda-node? . 73)) +(1839 (name-node? . 73)) +(1840 (loophole-node? . 73)) +(1841 (operator . 80)) +(1842 (primop . 80)) +(1843 (simple-interface . 80)) +(1844 (package . 80)) +(1845 (transform . 80)) +(1846 (package-define-static! . 80)) +(1847 (:syntax . 69)) +(1848 (:values . 69)) +(1849 (:arguments . 69)) +(1850 (:value . 69)) +(1851 (procedure . 69)) +(1852 (:boolean . 69)) +(1853 (:char . 69)) +(1854 (:null . 69)) +(1855 (:unspecific . 69)) +(1856 (:number . 69)) +(1857 (:complex . 69)) +(1858 (:real . 69)) +(1859 (:rational . 69)) +(1860 (:integer . 69)) +(1861 (:exact-integer . 69)) +(1862 (:pair . 69)) +(1863 (:string . 69)) +(1864 (:symbol . 69)) +(1865 (:vector . 69)) +(1866 (:procedure . 69)) +(1867 (:input-port . 69)) +(1868 (:output-port . 69)) +(1869 (:error . 69)) +(1870 (:escape . 69)) +(1871 (:structure . 69)) +(1872 (:type . 69)) +(1873 (def . 68)) +(1874 (really-def . 68)) +(1875 (define-multiple . 68)) +(1876 (define-interface . 68)) +(1877 (compound-interface . 68)) +(1878 (export . 68)) +(1879 (define-structure . 68)) +(1880 (define-structures . 68)) +(1881 (structure . 68)) +(1882 (structures . 68)) +(1883 (a-package . 68)) +(1884 (receive . 68)) +(1885 (define-reflective-tower-maker . 68)) +(1886 (export-reflective-tower-maker . 68)) +(1887 (define-module . 68)) +(1888 (make-a-package . 68)) +(1889 (loser . 68)) +(1890 (interface-of . 68)) +(1891 (*verify-later!* . 68)) +(1892 (verify-later! . 68)) +(1893 (set-verify-later! . 68)) +(1894 (note-name! . 68)) +(1895 (collect-packages . 65)) +(1896 (package-source . 65)) +(1897 (read-files . 65)) +(1898 (package-optimizer-names . 65)) +(1899 (check-structure . 65)) +(1900 (compile-package . 67)) +(1901 (expand-package . 67)) +(1902 (define-usual-transform . 67)) +(1903 (define-primitives . 67)) +(1904 (make-define-primitive-node . 67)) +(1905 (operator/define . 67)) +(1906 (operator/primitive-procedure . 67)) +(1907 (analyze-forms . 72)) +(1908 (analyze-form . 72)) +(1909 (inlinable-rhs? . 72)) +(1910 (simple-lambda? . 72)) +(1911 (operator/name . 72)) +(1912 (simple? . 72)) +(1913 (simple-list? . 72)) +(1914 (analyzers . 72)) +(1915 (define-analyzer . 72)) +(1916 (static-value . 72)) +(1917 (really-simple-call? . 72)) +(1918 (lexical-node? . 72)) +(1919 (no-ret . 72)) +(1920 (ret . 72)) +(1921 (simple-literal? . 72)) +(1922 (require . 72)) +(1923 (*debug?* . 72)) +(1924 (package-lookup-type . 72)) +(1925 (lambda-node? . 72)) +(1926 (name-node? . 72)) +(1927 (loophole-node? . 72)) +(1928 (define-node? . 72)) +(1929 (ensure-loaded . 79)) +- +; Template uid -> name, parent, pc in parent, env maps +(5 scheme-level-0 #f #f ()) +(6 call-error 5 46 ()) +(7 syntax-error 5 58 ()) +(8 warn 5 70 ()) +(9 signal 5 82 ()) +(10 decode 5 94 ()) +(11 encode 5 106 ()) +(12 initialize-any-proxy-value! 5 118 ()) +(13 any-proxy-value 5 130 ()) +(14 proxy-local-set! 5 142 ()) +(15 proxy-local-ref 5 154 ()) +(16 proxy-has-local-value? 5 166 ()) +(17 proxy-data->proxy 5 178 ()) +(18 make-proxy 5 190 ()) +(19 make-nonlocal-proxy 5 202 ()) +(20 debug-message 5 214 ()) +(21 channel-write 5 226 ()) +(22 #f 21 38 ()) +(23 channel-read 5 238 ()) +(24 #f 23 15 ()) +(25 #f 24 42 ()) +(26 #f 23 33 ()) +(27 buffer-length 5 250 ()) +(28 output-port? 5 262 ()) +(29 input-port? 5 274 ()) +(30 flush-the-symbol-table! 5 286 ()) +(31 string->symbol 5 298 ()) +(32 restore-the-symbol-table! 5 310 ()) +(33 string-copy 5 322 ()) +(34 vector-unassigned? 5 334 ()) +(35 location-assigned? 5 346 ()) +(36 make-undefined-location 5 358 ()) +(37 primitive-cwcc 5 370 ()) +(38 #f 37 15 ()) +(39 invoke-closure 5 382 ()) +(40 integer->char 5 394 ()) +(41 char->integer 5 406 ()) +(42 current-cont 5 417 ()) +(43 closure-template 5 428 ()) +(44 set-address-space-uid! 5 439 ()) +(45 continuation-ref 5 450 ()) +(46 closure? 5 461 ()) +(47 binary-comparison-reduce2 5 482 ()) +(48 cell-set! 5 493 ()) +(49 port-pending-eof? 5 504 ()) +(50 complex? 5 515 ()) +(51 arithmetic-shift 5 526 ()) +(52 set-port-pending-eof?! 5 537 ()) +(53 external-uid 5 548 ()) +(54 port-handler 5 559 ()) +(55 signal-condition 5 570 ()) +(56 integer? 5 581 ()) +(57 session-data 5 592 ()) +(58 set-external-uid! 5 603 ()) +(59 make-closure 5 614 ()) +(60 location-uid 5 625 ()) +(61 template-ref 5 636 ()) +(62 set-session-data! 5 647 ()) +(63 make-rectangular 5 658 ()) +(64 set-location-uid! 5 669 ()) +(65 proxy-data-owner 5 680 ()) +(66 channel? 5 691 ()) +(67 open-channel 5 702 ()) +(68 set-proxy-data-owner! 5 713 ()) +(69 string=? 5 724 ()) +(70 proxy-data-value 5 735 ()) +(71 cell-ref 5 746 ()) +(72 find-all 5 757 ()) +(73 set-proxy-data-value! 5 768 ()) +(74 extended-number? 5 779 ()) +(75 reverse-list->string 5 790 ()) +(76 port-locked? 5 801 ()) +(77 denominator 5 812 ()) +(78 call-with-values 5 823 ()) +(79 weak-pointer-ref 5 834 ()) +(80 find-all-symbols 5 845 ()) +(81 set-port-locked?! 5 856 ()) +(82 code-vector? 5 867 ()) +(83 port-status 5 878 ()) +(84 pop 5 889 ()) +(85 exp 5 900 ()) +(86 sin 5 911 ()) +(87 set-port-status! 5 922 ()) +(88 make-extended-number 5 933 ()) +(89 channel-os-index 5 944 ()) +(90 cos 5 955 ()) +(91 collect 5 966 ()) +(92 external-lookup 5 977 ()) +(93 tan 5 988 ()) +(94 message 5 999 ()) +(95 log 5 1010 ()) +(96 continuation-length 5 1021 ()) +(97 find-all-records 5 1032 ()) +(98 make-code-vector 5 1043 ()) +(99 cdr 5 1054 ()) +(100 bitwise-xor 5 1065 ()) +(101 car 5 1076 ()) +(102 string? 5 1087 ()) +(103 symbol? 5 1098 ()) +(104 set-cdr! 5 1109 ()) +(105 bitwise-not 5 1120 ()) +(106 vector? 5 1131 ()) +(107 closure-env 5 1142 ()) +(108 set-car! 5 1153 ()) +(109 bitwise-ior 5 1164 ()) +(110 untyped-indexed-set! 5 1175 ()) +(111 port-buffer 5 1186 ()) +(112 number? 5 1197 ()) +(113 template-length 5 1208 ()) +(114 string-hash 5 1219 ()) +(115 proxy-data-local-ref 5 1230 ()) +(116 primitive-catch 5 1241 ()) +(117 set-port-buffer! 5 1252 ()) +(118 make-string 5 1263 ()) +(119 record? 5 1274 ()) +(120 make-vector 5 1285 ()) +(121 extended-number-set! 5 1296 ()) +(122 write-image 5 1307 ()) +(123 eq? 5 1318 ()) +(124 bitwise-and 5 1329 ()) +(125 location-id 5 1340 ()) +(126 code-vector-set! 5 1351 ()) +(127 set-location-id! 5 1362 ()) +(128 make-record 5 1373 ()) +(129 proxy-data? 5 1384 ()) +(130 proxy-data-self 5 1395 ()) +(131 set-proxy-data-self! 5 1406 ()) +(132 vector 5 1417 ()) +(133 intern 5 1428 ()) +(134 make-proxy-data 5 1439 ()) +(135 values 5 1450 ()) +(136 unassigned 5 1461 ()) +(137 string-set! 5 1472 ()) +(138 copy-bytes! 5 1483 ()) +(139 vector-set! 5 1494 ()) +(140 extended-number-ref 5 1505 ()) +(141 unspecific 5 1516 ()) +(142 channel-maybe-write 5 1527 ()) +(143 code-vector-ref 5 1538 ()) +(144 schedule-interrupt 5 1549 ()) +(145 proxy? 5 1560 ()) +(146 record 5 1571 ()) +(147 set-interrupt-handlers! 5 1582 ()) +(148 eof-object? 5 1593 ()) +(149 record-set! 5 1604 ()) +(150 char->ascii 5 1615 ()) +(151 ascii->char 5 1626 ()) +(152 port-limit 5 1637 ()) +(153 set-enabled-interrupts! 5 1648 ()) +(154 external-value 5 1659 ()) +(155 make-immutable! 5 1670 ()) +(156 port-index 5 1681 ()) +(157 set-port-limit! 5 1692 ()) +(158 proxy-data 5 1703 ()) +(159 channel-status 5 1714 ()) +(160 current-thread 5 1725 ()) +(161 symbol-uid 5 1736 ()) +(162 set-port-index! 5 1747 ()) +(163 string-ref 5 1758 ()) +(164 set-exception-handlers! 5 1769 ()) +(165 immutable? 5 1780 ()) +(166 set-current-thread! 5 1791 ()) +(167 set-symbol-uid! 5 1802 ()) +(168 vector-ref 5 1813 ()) +(169 exact? 5 1824 ()) +(170 symbol->string 5 1835 ()) +(171 write-char 5 1846 ()) +(172 proxy-data-waiters 5 1857 ()) +(173 make-polar 5 1868 ()) +(174 set-proxy-data-waiters! 5 1879 ()) +(175 record-ref 5 1890 ()) +(176 address-space-decode-vector 5 1901 ()) +(177 set-address-space-decode-vector! 5 1912 ()) +(178 eof-object 5 1923 ()) +(179 numerator 5 1934 ()) +(180 proxy-data-uid 5 1945 ()) +(181 channel-id 5 1956 ()) +(182 extended-number-length 5 1967 ()) +(183 set-proxy-data-uid! 5 1978 ()) +(184 error 5 1989 ()) +(185 exact->inexact 5 2000 ()) +(186 inexact->exact 5 2011 ()) +(187 checked-record-set! 5 2022 ()) +(188 memory-status 5 2033 ()) +(189 apply 5 2044 ()) +(190 code-vector-length 5 2055 ()) +(191 address-space-proxy-vector 5 2066 ()) +(192 floor 5 2077 ()) +(193 with-continuation 5 2088 ()) +(194 >= 5 2099 ()) +(195 magnitude 5 2110 ()) +(196 set-address-space-proxy-vector! 5 2121 ()) +(197 <= 5 2132 ()) +(198 char=? 5 2143 ()) +(199 address-space? 5 2154 ()) +(200 char 5 2627 ()) +(243 = 5 2638 ()) +(244 < 5 2649 ()) +(245 char? 5 2660 ()) +(246 really-make-proxy 5 2671 ()) +(247 channel-abort 5 2682 ()) +(248 close-channel 5 2693 ()) +(249 quotient 5 2704 ()) +(250 really-decode 5 2715 ()) +(251 weak-pointer? 5 2726 ()) +(252 / 5 2737 ()) +(253 continuation-set! 5 2748 ()) +(254 - 5 2759 ()) +(255 peek-char 5 2770 ()) +(256 + 5 2781 ()) +(257 contents 5 2792 ()) +(258 * 5 2803 ()) +(259 sqrt 5 2814 ()) +(260 make-cell 5 2825 ()) +(261 read-char 5 2836 ()) +(262 set-contents! 5 2847 ()) +(263 push 5 2858 ()) +(264 make-weak-pointer 5 2869 ()) +(265 assq 5 2880 ()) +(266 trap 5 2891 ()) +(267 wait 5 2902 ()) +(268 cons 5 2913 ()) +(269 template-set! 5 2934 ()) +(270 time 5 2945 ()) +(271 location-defined? 5 2956 ()) +(272 asin 5 2967 ()) +(273 vm-extension 5 2978 ()) +(274 address-space-uid 5 2989 ()) +(275 acos 5 3000 ()) +(276 set-location-defined?! 5 3011 ()) +(277 atan 5 3022 ()) +(278 scheme-level-1 #f #f ()) +(279 rationalize 278 8 ()) +(280 simplest-rational 278 20 ()) +(281 #f 280 24 ()) +(282 expt 278 32 ()) +(283 raise-to-integer-power 278 44 ()) +(284 #f 283 52 ()) +(285 lcm 278 56 ()) +(286 #f 285 9 ()) +(287 gcd 278 68 ()) +(288 #f 287 9 ()) +(289 euclid 278 80 ()) +(290 round 278 92 ()) +(291 truncate 278 104 ()) +(292 ceiling 278 116 ()) +(293 modulo 278 128 ()) +(294 fold->3 278 140 ()) +(295 #f 294 43 ()) +(296 #f 295 38 ()) +(297 #f 295 60 ()) +(298 fold->2 278 152 ()) +(299 #f 298 40 ()) +(300 #f 299 35 ()) +(301 #f 299 56 ()) +(302 fold 278 164 ()) +(303 #f 302 27 ()) +(304 insert 278 176 ()) +(305 last 278 188 ()) +(306 sublist 278 200 ()) +(307 #f 306 71 ()) +(308 every 278 212 ()) +(309 pos 278 224 ()) +(310 #f 309 13 ()) +(311 #f 310 41 ()) +(312 filter 278 236 ()) +(313 #f 312 13 ()) +(314 force 278 248 ()) +(315 make-promise 278 260 ()) +(316 #f 315 39 ()) +(317 for-each 278 272 ()) +(318 for-each2+ 278 284 ()) +(319 #f 318 37 ()) +(320 for-each1 278 296 ()) +(321 #f 320 34 ()) +(322 map 278 308 ()) +(323 map2+ 278 320 ()) +(324 any 278 332 ()) +(325 map1 278 344 ()) +(326 vector-fill! 278 356 ()) +(327 #f 326 39 ()) +(328 list->vector 278 368 ()) +(329 #f 328 51 ()) +(330 vector->list 278 380 ()) +(331 #f 330 27 ()) +(332 string-ci>=? 278 392 ()) +(333 string-ci<=? 278 404 ()) +(334 string-ci>? 278 416 ()) +(335 string>=? 278 428 ()) +(336 string<=? 278 440 ()) +(337 string>? 278 452 ()) +(338 make-stringlist 278 512 ()) +(348 #f 347 34 ()) +(349 string-append 278 524 ()) +(350 #f 349 13 ()) +(351 #f 349 77 ()) +(352 #f 351 66 ()) +(353 substring 278 536 ()) +(354 #f 353 46 ()) +(355 string 278 548 ()) +(356 list->string 278 560 ()) +(357 #f 356 52 ()) +(358 char-ci-compare 278 572 ()) +(359 #f 358 13 ()) +(360 char-downcase 278 584 ()) +(361 char-upcase 278 596 ()) +(362 make-character-map 278 608 ()) +(363 #f 362 46 ()) +(364 char-alphabetic? 278 620 ()) +(365 char-numeric? 278 632 ()) +(366 char-upper-case? 278 644 ()) +(367 char-lower-case? 278 656 ()) +(368 char-whitespace? 278 668 ()) +(369 char<=? 278 680 ()) +(370 char>=? 278 692 ()) +(371 char>? 278 704 ()) +(372 list? 278 716 ()) +(373 #f 372 34 ()) +(374 ass 278 728 ()) +(375 #f 374 13 ()) +(376 #f 375 37 ()) +(377 mem 278 740 ()) +(378 #f 377 13 ()) +(379 #f 378 37 ()) +(380 list-ref 278 752 ()) +(381 list-tail 278 764 ()) +(382 reverse 278 776 ()) +(383 append-reverse 278 788 ()) +(384 append 278 800 ()) +(385 #f 384 47 ()) +(386 reduce 278 812 ()) +(387 length 278 824 ()) +(388 real-length 278 836 ()) +(389 list 278 848 ()) +(390 cddddr 278 860 ()) +(391 cdddar 278 872 ()) +(392 cddadr 278 884 ()) +(393 cddaar 278 896 ()) +(394 cdaddr 278 908 ()) +(395 cdadar 278 920 ()) +(396 cdaadr 278 932 ()) +(397 cdaaar 278 944 ()) +(398 cadddr 278 956 ()) +(399 caddar 278 968 ()) +(400 cadadr 278 980 ()) +(401 cadaar 278 992 ()) +(402 caaddr 278 1004 ()) +(403 caadar 278 1016 ()) +(404 caaadr 278 1028 ()) +(405 caaaar 278 1040 ()) +(406 cdddr 278 1052 ()) +(407 cddar 278 1064 ()) +(408 cdadr 278 1076 ()) +(409 cdaar 278 1088 ()) +(410 caddr 278 1100 ()) +(411 cadar 278 1112 ()) +(412 caadr 278 1124 ()) +(413 caaar 278 1136 ()) +(414 cddr 278 1148 ()) +(415 cdar 278 1160 ()) +(416 cadr 278 1172 ()) +(417 caar 278 1184 ()) +(418 odd? 278 1196 ()) +(419 even? 278 1208 ()) +(420 negative? 278 1220 ()) +(421 positive? 278 1232 ()) +(422 zero? 278 1244 ()) +(423 abs 278 1256 ()) +(424 min 278 1268 ()) +(425 max 278 1280 ()) +(426 max-or-min 278 1292 ()) +(427 #f 426 50 ()) +(428 inexact? 278 1304 ()) +(429 null? 278 1316 ()) +(430 equal? 278 1328 ()) +(431 #f 430 176 ()) +(432 eqv? 278 1340 ()) +(433 boolean? 278 1352 ()) +(434 not 278 1364 ()) +(435 #f 278 1497 ()) +(436 #f 278 1519 ()) +(437 records #f #f ()) +(438 disclose-record 437 26 ()) +(439 define-record-discloser 437 38 ()) +(440 record-predicate 437 50 ()) +(441 #f 440 13 ()) +(442 record-modifier 437 62 ()) +(443 #f 442 73 ()) +(444 record-accessor 437 74 ()) +(445 #f 444 73 ()) +(446 record-constructor 437 86 ()) +(447 #f 446 17 ()) +(448 #f 446 78 ()) +(449 #f 448 67 ()) +(450 record-field-index 437 98 ()) +(451 #f 450 49 ()) +(452 record-type-discloser 437 110 ()) +(453 record-type-field-names 437 122 ()) +(454 record-type-name 437 134 ()) +(455 record-type-uid 437 146 ()) +(456 record-type? 437 158 ()) +(457 make-record-type 437 170 ()) +(458 default-record-discloser 437 182 ()) +(459 record-type 437 194 ()) +(460 #f 437 259 ()) +(461 define-record-types #f #f ()) +(462 methods #f #f ()) +(463 proc->discloser 462 18 ()) +(464 #f 463 13 ()) +(465 #f 464 7 ()) +(466 compare-to 462 30 ()) +(467 #f 466 13 ()) +(468 apply-generic 462 42 ()) +(469 make-method-table 462 54 ()) +(470 #f 469 63 ()) +(471 #f 469 96 ()) +(472 make-cell-for-generic 462 66 ()) +(473 #f 472 24 ()) +(474 #f 472 36 ()) +(475 #f 472 48 ()) +(476 set-final-method! 462 78 ()) +(477 add-to-method-table! 462 90 ()) +(478 methods->perform 462 102 ()) +(479 #f 478 31 ()) +(480 argument-sequence-predicate 462 114 ()) +(481 #f 480 43 ()) +(482 check-next 462 126 ()) +(483 #f 482 14 ()) +(484 check-for-next 462 138 ()) +(485 #f 484 13 ()) +(486 one-action 462 150 ()) +(487 #f 486 15 ()) +(488 #f 487 30 ()) +(489 last-action 462 162 ()) +(490 #f 489 13 ()) +(491 method-table? 462 174 ()) +(492 insert-method 462 186 ()) +(493 #f 492 34 ()) +(494 same-applicability? 462 198 ()) +(495 every2 462 210 ()) +(496 more-specific? 462 222 ()) +(497 #f 496 161 ()) +(498 more-specific-type? 462 234 ()) +(499 empty-method-list 462 246 ()) +(500 make-method-info 462 258 ()) +(501 method-info? 462 270 ()) +(502 value? 462 282 ()) +(503 %same-type? 462 294 ()) +(504 %type-predicate 462 306 ()) +(505 make-simple-type 462 318 ()) +(506 compute-priority 462 330 ()) +(507 %type-priority 462 342 ()) +(508 simple-type? 462 354 ()) +(509 really-make-simple-type 462 390 ()) +(510 simple-type-id 462 402 ()) +(511 simple-type-priority 462 414 ()) +(512 simple-type-predicate 462 426 ()) +(513 simple-type-superiors 462 438 ()) +(514 #f 462 454 ()) +(515 #f 462 590 ()) +(516 #f 462 820 ()) +(517 record-type-priority 462 1348 ()) +(518 really-make-method-info 462 1385 ()) +(519 method-info-proc 462 1397 ()) +(520 method-info-n-ary? 462 1409 ()) +(521 method-info-types 462 1421 ()) +(522 #f 462 1437 ()) +(523 really-make-method-table 462 1477 ()) +(524 method-table-id 462 1489 ()) +(525 method-table-set-perform! 462 1501 ()) +(526 method-table-get-perform 462 1513 ()) +(527 make-generic 462 1525 ()) +(528 method-table-prototype 462 1537 ()) +(529 method-table-methods 462 1549 ()) +(530 set-method-table-methods! 462 1561 ()) +(531 #f 462 1577 ()) +(532 add-method! 462 1646 ()) +(533 add-method! 462 1741 ()) +(534 type-predicate 462 1829 ()) +(535 &type-predicate 462 1924 ()) +(536 &type-predicate 462 1998 ()) +(537 type-priority 462 2076 ()) +(538 &type-priority 462 2171 ()) +(539 &type-priority 462 2245 ()) +(540 type-superiors 462 2323 ()) +(541 &type-superiors 462 2418 ()) +(542 &type-superiors 462 2492 ()) +(543 same-type? 462 2574 ()) +(544 &same-type? 462 2673 ()) +(545 &same-type? 462 2751 ()) +(546 singleton 462 2804 ()) +(547 singleton-value 462 2816 ()) +(548 #f 462 2832 ()) +(549 &type-predicate 462 2893 ()) +(550 &type-priority 462 2967 ()) +(551 &same-type? 462 3045 ()) +(552 disclose 462 3123 ()) +(553 &disclose 462 3218 ()) +(554 &disclose 462 3292 ()) +(555 &add-method! 462 3373 ()) +(556 number-i/o #f #f ()) +(557 &number->string 556 92 ()) +(558 &number->string 556 170 ()) +(559 &number->string 556 248 ()) +(560 #f 556 313 ()) +(561 #f 560 71 ()) +(562 #f 556 331 ()) +(563 string->number 556 377 ()) +(564 #f 563 258 ()) +(565 radix-is 564 68 ()) +(566 exactness-is 564 88 ()) +(567 #f 564 347 ()) +(568 &really-string->number 556 481 ()) +(569 #f 556 528 ()) +(570 #f 569 47 ()) +(571 &really-string->number 556 603 ()) +(572 set-exactness 556 632 ()) +(573 #f 556 685 ()) +(574 #f 556 702 ()) +(575 #f 574 64 ()) +(576 #f 556 720 ()) +(577 fluids #f #f ()) +(578 fluid-lookup 577 8 ()) +(579 let-fluids 577 20 ()) +(580 #f 579 43 ()) +(581 let-fluid 577 32 ()) +(582 set-fluid! 577 44 ()) +(583 set-fluid-top-level-value! 577 56 ()) +(584 fluid-top-level-value 577 68 ()) +(585 fluid 577 80 ()) +(586 real-fluid-lookup 577 92 ()) +(587 #f 586 34 ()) +(588 make-fluid 577 104 ()) +(589 fluid? 577 116 ()) +(590 with-dynamic-env 577 128 ()) +(591 #f 590 67 ()) +(592 initialize-dynamic-state! 577 140 ()) +(593 empty-dynamic-env 577 152 ()) +(594 set-dynamic-point! 577 164 ()) +(595 get-dynamic-point 577 176 ()) +(596 set-dynamic-env! 577 188 ()) +(597 get-dynamic-env 577 200 ()) +(598 make-thread 577 236 ()) +(599 thread-dynamic-point 577 248 ()) +(600 thread-dynamic-env 577 260 ()) +(601 really-make-fluid 577 296 ()) +(602 really-fluid-top-level-value 577 308 ()) +(603 really-set-fluid-top-level-value! 577 320 ()) +(604 enumerated #f #f ()) +(605 lookup-enumerand 604 8 ()) +(606 #f 605 47 ()) +(607 architecture #f #f ()) +(608 next-protocol 607 162 ()) +(609 queues #f #f ()) +(610 queue-length 609 18 ()) +(611 queue->list 609 30 ()) +(612 #f 611 7 ()) +(613 delete-from-queue! 609 42 ()) +(614 #f 613 16 ()) +(615 delete-from-queue-if! 609 54 ()) +(616 #f 615 147 ()) +(617 on-queue? 609 66 ()) +(618 dequeue! 609 78 ()) +(619 queue-front 609 90 ()) +(620 enqueue! 609 102 ()) +(621 queue-empty? 609 114 ()) +(622 make-queue 609 126 ()) +(623 queue? 609 138 ()) +(624 really-make-queue 609 174 ()) +(625 queue-tail 609 186 ()) +(626 set-queue-tail! 609 198 ()) +(627 queue-head 609 210 ()) +(628 set-queue-head! 609 222 ()) +(629 queue-uid 609 234 ()) +(630 conditions #f #f ()) +(631 condition-supertypes 630 18 ()) +(632 define-condition-type 630 30 ()) +(633 #f 632 18 ()) +(634 condition-predicate 630 42 ()) +(635 #f 634 13 ()) +(636 condition? 630 54 ()) +(637 make-exception 630 268 ()) +(638 session-data #f #f ()) +(639 initialize-session-data! 638 18 ()) +(640 session-data-set! 638 30 ()) +(641 session-data-ref 638 42 ()) +(642 make-session-data-slot! 638 54 ()) +(643 interrupts #f #f ()) +(644 call-before-heap-overflow! 643 28 ()) +(645 call-after-gc! 643 40 ()) +(646 enable-interrupts! 643 52 ()) +(647 disable-interrupts! 643 64 ()) +(648 with-interrupts-allowed 643 76 ()) +(649 with-interrupts-inhibited 643 88 ()) +(650 with-interrupts 643 100 ()) +(651 #f 650 20 ()) +(652 set-interrupt-handler! 643 112 ()) +(653 initialize-interrupts! 643 124 ()) +(654 #f 653 14 ()) +(655 #f 654 48 ()) +(656 #f 655 38 ()) +(657 #f 654 102 ()) +(658 #f 657 12 ()) +(659 post-gc-handler 643 136 ()) +(660 #f 659 13 ()) +(661 #f 660 49 ()) +(662 #f 660 72 ()) +(663 #f 662 8 ()) +(664 #f 662 23 ()) +(665 enabled-interrupts 643 148 ()) +(666 #f 643 224 ()) +(667 wind #f #f ()) +(668 call-with-current-continuation 667 8 ()) +(669 #f 668 13 ()) +(670 continuation->procedure 667 20 ()) +(671 #f 670 15 ()) +(672 #f 671 67 ()) +(673 travel-to-point! 667 32 ()) +(674 dynamic-wind 667 44 ()) +(675 make-point 667 80 ()) +(676 point-parent 667 92 ()) +(677 point-dynamic-env 667 104 ()) +(678 point-out 667 116 ()) +(679 point-in 667 128 ()) +(680 point-depth 667 140 ()) +(681 templates #f #f ()) +(682 set-template-id! 681 18 ()) +(683 set-template-info! 681 30 ()) +(684 set-template-code! 681 42 ()) +(685 template-id 681 54 ()) +(686 template-info 681 66 ()) +(687 template-code 681 78 ()) +(688 more-types #f #f ()) +(689 &disclose 688 319 ()) +(690 &disclose 688 431 ()) +(691 &disclose 688 615 ()) +(692 continuations #f #f ()) +(693 continuation-parent 692 18 ()) +(694 #f 693 121 ()) +(695 continuation-arg-count 692 30 ()) +(696 continuation-arg 692 42 ()) +(697 continuation-template 692 54 ()) +(698 continuation-pc 692 66 ()) +(699 exception-continuation? 692 78 ()) +(700 exception-continuation-exception 692 90 ()) +(701 exception-continuation-template 692 102 ()) +(702 exception-continuation-pc 692 114 ()) +(703 continuation-env 692 126 ()) +(704 real-continuation-template 692 138 ()) +(705 real-continuation-pc 692 150 ()) +(706 continuation-cont 692 162 ()) +(707 &disclose 692 268 ()) +(708 exceptions #f #f ()) +(709 define-exception-handler 708 8 ()) +(710 signal-exception 708 20 ()) +(711 #f 708 52 ()) +(712 extend-opcode! 708 68 ()) +(713 except 712 13 ()) +(714 #f 712 46 ()) +(715 really-signal-condition 708 80 ()) +(716 #f 715 45 ()) +(717 #f 716 19 ()) +(718 with-handler 708 92 ()) +(719 initialize-exceptions! 708 122 ()) +(720 #f 719 15 ()) +(721 last-resort-condition-handler 708 134 ()) +(722 #f 721 37 ()) +(723 #f 722 36 ()) +(724 report-utter-lossage 708 146 ()) +(725 #f 724 193 ()) +(726 continuation-preview 708 158 ()) +(727 ignore-errors 708 170 ()) +(728 #f 727 13 ()) +(729 #f 728 13 ()) +(730 report-errors-as-warnings 708 182 ()) +(731 #f 730 19 ()) +(732 &disclose 708 239 ()) +(733 &disclose 708 309 ()) +(734 threads #f #f ()) +(735 wake-some-threads 734 48 ()) +(736 #f 735 62 ()) +(737 sleep 734 60 ()) +(738 #f 737 72 ()) +(739 insert 734 72 ()) +(740 terminate-current-thread 734 84 ()) +(741 with-threads 734 96 ()) +(742 #f 741 17 ()) +(743 #f 742 4 ()) +(744 #f 742 16 ()) +(745 #f 742 22 ()) +(746 start-multitasking 734 108 ()) +(747 #f 746 13 ()) +(748 #f 747 13 ()) +(749 #f 747 28 ()) +(750 #f 749 15 ()) +(751 #f 750 13 ()) +(752 #f 750 26 ()) +(753 real-time 734 120 ()) +(754 cancel-timer-interrupt! 734 132 ()) +(755 make-ready 734 144 ()) +(756 spawn-on-root 734 156 ()) +(757 root-scheduler 734 168 ()) +(758 spawn 734 180 ()) +(759 spawn-on-scheduler 734 192 ()) +(760 show-running 734 204 ()) +(761 #f 760 29 ()) +(762 schedule-event 734 216 ()) +(763 schedule-wakeup 734 228 ()) +(764 get-next-event! 734 240 ()) +(765 kill-thread! 734 252 ()) +(766 #f 765 10 ()) +(767 upcall 734 264 ()) +(768 propogate-upcall 734 276 ()) +(769 #f 768 70 ()) +(770 interrupt-thread 734 288 ()) +(771 running? 734 300 ()) +(772 #f 771 41 ()) +(773 relinquish-timeslice 734 312 ()) +(774 block 734 324 ()) +(775 waiting? 734 336 ()) +(776 wait 734 348 ()) +(777 exit 734 360 ()) +(778 handle-timer-interrupt 734 372 ()) +(779 run 734 384 ()) +(780 find-and-run-next-thread 734 396 ()) +(781 #f 780 48 ()) +(782 debit-thread-times-and-run! 734 408 ()) +(783 #f 782 57 ()) +(784 run-next-thread 734 420 ()) +(785 schedule-interrupt! 734 432 ()) +(786 min 734 444 ()) +(787 event-pending? 734 456 ()) +(788 remove-thread-from-queue! 734 468 ()) +(789 dequeue-thread! 734 480 ()) +(790 enqueue-thread! 734 492 ()) +(791 add-event! 734 504 ()) +(792 thread-uid->thread 734 516 ()) +(793 #f 792 46 ()) +(794 all-threads 734 528 ()) +(795 make-thread 734 540 ()) +(796 thread-top-level 734 552 ()) +(797 #f 796 13 ()) +(798 #f 797 4 ()) +(799 suspend 734 564 ()) +(800 suspend-to 734 576 ()) +(801 switch-to-thread 734 588 ()) +(802 #f 801 14 ()) +(803 run-thread 734 600 ()) +(804 #f 803 52 ()) +(805 debit-down! 734 612 ()) +(806 #f 805 44 ()) +(807 interrupt-timer-time 734 624 ()) +(808 thunk->continuation 734 636 ()) +(809 compose-continuation 734 648 ()) +(810 #f 809 14 ()) +(811 #f 810 37 ()) +(812 #f 811 17 ()) +(813 #f 812 10 ()) +(814 #f 813 16 ()) +(815 thread? 734 660 ()) +(816 really-make-thread 734 696 ()) +(817 thread-name 734 708 ()) +(818 thread-uid 734 720 ()) +(819 thread-current-task 734 732 ()) +(820 set-thread-current-task! 734 744 ()) +(821 thread-events 734 756 ()) +(822 set-thread-events! 734 768 ()) +(823 thread-data 734 780 ()) +(824 set-thread-data! 734 792 ()) +(825 thread-scheduler 734 804 ()) +(826 set-thread-scheduler! 734 816 ()) +(827 thread-time 734 828 ()) +(828 set-thread-time! 734 840 ()) +(829 thread-arguments 734 852 ()) +(830 set-thread-arguments! 734 864 ()) +(831 thread-queue 734 876 ()) +(832 set-thread-queue! 734 888 ()) +(833 thread-continuation 734 900 ()) +(834 set-thread-continuation! 734 912 ()) +(835 thread-dynamic-point 734 924 ()) +(836 set-thread-dynamic-point! 734 936 ()) +(837 thread-dynamic-env 734 948 ()) +(838 #f 734 964 ()) +(839 locks #f #f ()) +(840 release-lock 839 18 ()) +(841 #f 840 17 ()) +(842 maybe-obtain-lock 839 30 ()) +(843 #f 842 17 ()) +(844 obtain-lock 839 42 ()) +(845 #f 844 17 ()) +(846 make-lock 839 54 ()) +(847 lock? 839 66 ()) +(848 really-make-lock 839 102 ()) +(849 lock-uid 839 114 ()) +(850 lock-queue 839 126 ()) +(851 lock-owner-uid 839 138 ()) +(852 set-lock-owner-uid! 839 150 ()) +(853 i/o #f #f ()) +(854 newline 853 38 ()) +(855 output-port-option 853 50 ()) +(856 silently 853 62 ()) +(857 call-with-current-noise-port 853 74 ()) +(858 call-with-current-output-port 853 86 ()) +(859 call-with-current-input-port 853 98 ()) +(860 initialize-i/o 853 110 ()) +(861 with-current-ports 853 122 ()) +(862 current-noise-port 853 134 ()) +(863 current-error-port 853 146 ()) +(864 current-output-port 853 158 ()) +(865 output-port-forcers 853 170 ()) +(866 #f 865 46 ()) +(867 make-forcing-thunk 853 182 ()) +(868 #f 867 13 ()) +(869 #f 868 14 ()) +(870 #f 868 60 ()) +(871 periodically-force-output! 853 194 ()) +(872 initialize-output-port-list! 853 206 ()) +(873 make-null-output-port 853 218 ()) +(874 make-unbuffered-output-port 853 230 ()) +(875 make-output-port 853 242 ()) +(876 make-input-port 853 254 ()) +(877 okay-buffer? 853 266 ()) +(878 force-output 853 278 ()) +(879 write-string 853 290 ()) +(880 write-block 853 302 ()) +(881 write-buffered-block 853 314 ()) +(882 write-unbuffered-block 853 326 ()) +(883 #f 882 63 ()) +(884 read-block 853 338 ()) +(885 really-read-block 853 350 ()) +(886 buffer-length 853 362 ()) +(887 read-more 853 374 ()) +(888 okay-limits? 853 386 ()) +(889 real-char-ready? 853 398 ()) +(890 char-ready? 853 410 ()) +(891 input-port-option 853 422 ()) +(892 current-input-port 853 434 ()) +(893 open-port? 853 446 ()) +(894 close-output-port 853 458 ()) +(895 make-output-port-closed! 853 470 ()) +(896 really-force-output 853 482 ()) +(897 open-output-port? 853 494 ()) +(898 close-input-port 853 506 ()) +(899 make-input-port-closed! 853 518 ()) +(900 open-input-port? 853 530 ()) +(901 initialize-i/o-handlers! 853 542 ()) +(902 write-char-handler 853 554 ()) +(903 empty-port-buffer! 853 566 ()) +(904 two-arg-proc->handler 853 578 ()) +(905 #f 904 14 ()) +(906 read-char-handler 853 590 ()) +(907 #f 906 13 ()) +(908 fill-port-buffer! 853 602 ()) +(909 one-arg-proc->handler 853 614 ()) +(910 #f 909 14 ()) +(911 release-port-lock 853 626 ()) +(912 maybe-obtain-port-lock 853 638 ()) +(913 obtain-port-lock 853 650 ()) +(914 disclose-port 853 662 ()) +(915 port-handler? 853 674 ()) +(916 make-port-handler 853 710 ()) +(917 port-handler-buffer-proc 853 722 ()) +(918 port-handler-close 853 734 ()) +(919 port-handler-discloser 853 746 ()) +(920 &disclose 853 803 ()) +(921 &disclose 853 877 ()) +(922 #f 853 1045 ()) +(923 #f 853 1051 ()) +(924 #f 853 1057 ()) +(925 writing #f #f ()) +(926 write 925 8 ()) +(927 #f 926 52 ()) +(928 recurring-write 925 20 ()) +(929 write-boolean 925 32 ()) +(930 write-number 925 44 ()) +(931 write-char-literal 925 56 ()) +(932 character-name 925 68 ()) +(933 write-string-literal 925 80 ()) +(934 #f 933 46 ()) +(935 write-list 925 92 ()) +(936 #f 935 109 ()) +(937 quotation? 925 104 ()) +(938 write-vector 925 116 ()) +(939 #f 938 97 ()) +(940 write-other 925 128 ()) +(941 #f 940 81 ()) +(942 display-type-name 925 140 ()) +(943 #f 942 112 ()) +(944 display 925 152 ()) +(945 #f 944 52 ()) +(946 reading #f #f ()) +(947 parse-token 946 28 ()) +(948 sub-read-token 946 40 ()) +(949 #f 948 58 ()) +(950 preferred-case 946 52 ()) +(951 define-sharp-macro 946 64 ()) +(952 gobble-line 946 76 ()) +(953 #f 952 31 ()) +(954 sub-read-list 946 88 ()) +(955 #f 954 72 ()) +(956 set-standard-read-macro! 946 100 ()) +(957 set-standard-syntax! 946 112 ()) +(958 make-reader-token 946 124 ()) +(959 sub-read-carefully 946 136 ()) +(960 read 946 148 ()) +(961 #f 960 49 ()) +(962 sub-read 946 160 ()) +(963 reading-error 946 172 ()) +(964 reader-token? 946 184 ()) +(965 #f 946 254 ()) +(966 sub-read-whitespace 946 284 ()) +(967 #f 946 299 ()) +(968 sub-read-constituent 946 319 ()) +(969 #f 946 334 ()) +(970 #f 946 408 ()) +(971 #f 946 432 ()) +(972 #f 946 456 ()) +(973 #f 946 480 ()) +(974 #f 946 504 ()) +(975 #f 974 41 ()) +(976 #f 946 528 ()) +(977 #f 946 550 ()) +(978 #f 946 570 ()) +(979 #f 946 590 ()) +(980 #f 946 610 ()) +(981 #f 946 630 ()) +(982 number-sharp-macro 946 646 ()) +(983 #f 946 661 ()) +(984 #f 946 744 ()) +(985 channel-i/o #f #f ()) +(986 #f 985 12 ()) +(987 #f 985 18 ()) +(988 #f 985 24 ()) +(989 input-channel->port 985 39 ()) +(990 #f 985 55 ()) +(991 #f 985 61 ()) +(992 #f 985 67 ()) +(993 make-unbuffered-output-channel-handler 985 82 ()) +(994 #f 993 20 ()) +(995 #f 993 26 ()) +(996 #f 993 38 ()) +(997 output-channel->port 985 94 ()) +(998 maybe-force-output 985 106 ()) +(999 #f 998 35 ()) +(1000 maybe-open-file 985 118 ()) +(1001 open-input-file 985 130 ()) +(1002 open-output-file 985 142 ()) +(1003 call-with-input-file 985 154 ()) +(1004 #f 1003 44 ()) +(1005 call-with-output-file 985 166 ()) +(1006 #f 1005 44 ()) +(1007 with-input-from-file 985 178 ()) +(1008 #f 1007 16 ()) +(1009 with-output-to-file 985 190 ()) +(1010 #f 1009 16 ()) +(1011 steal-channel-port! 985 202 ()) +(1012 really-steal-channel-port! 985 214 ()) +(1013 #f 1012 162 ()) +(1014 initialize-channel-i/o! 985 226 ()) +(1015 i/o-completion-handler 985 238 ()) +(1016 waiting-for-i/o? 985 250 ()) +(1017 wait-for-channel 985 262 ()) +(1018 steal-channel! 985 274 ()) +(1019 #f 985 290 ()) +(1020 #f 985 310 ()) +(1021 i/o-wait-count 985 346 ()) +(1022 increment-i/o-wait-count! 985 358 ()) +(1023 decrement-i/o-wait-count! 985 370 ()) +(1024 i/o-wait-queue 985 400 ()) +(1025 make-i/o-wait-queues 985 412 ()) +(1026 #f 1025 26 ()) +(1027 #f 1026 94 ()) +(1028 #f 1026 138 ()) +(1029 scheme-level-2 #f #f ()) +(1030 features #f #f ()) +(1031 tables #f #f ()) +(1032 symbol-hash 1031 28 ()) +(1033 default-table-hash-function 1031 40 ()) +(1034 table->entry-list 1031 52 ()) +(1035 #f 1034 33 ()) +(1036 make-table-immutable! 1031 64 ()) +(1037 table-walk 1031 76 ()) +(1038 #f 1037 13 ()) +(1039 really-table-walk 1031 88 ()) +(1040 #f 1039 82 ()) +(1041 alist-walk 1031 100 ()) +(1042 #f 1041 27 ()) +(1043 make-table-maker 1031 112 ()) +(1044 #f 1043 86 ()) +(1045 make-assoc 1031 124 ()) +(1046 #f 1045 27 ()) +(1047 #f 1046 37 ()) +(1048 make-linear-table-ref 1031 136 ()) +(1049 #f 1048 13 ()) +(1050 make->hash-table 1031 148 ()) +(1051 #f 1050 49 ()) +(1052 make-hash-table-set! 1031 160 ()) +(1053 #f 1052 14 ()) +(1054 expand-hash-table! 1031 172 ()) +(1055 #f 1054 71 ()) +(1056 make-hash-table-ref 1031 184 ()) +(1057 #f 1056 14 ()) +(1058 table-enter-alist! 1031 196 ()) +(1059 #f 1058 45 ()) +(1060 table-expand-table! 1031 208 ()) +(1061 make-linear-table-set! 1031 220 ()) +(1062 #f 1061 14 ()) +(1063 new-entry 1031 232 ()) +(1064 delete-entry! 1031 244 ()) +(1065 #f 1064 56 ()) +(1066 next-table-size 1031 256 ()) +(1067 table-set! 1031 268 ()) +(1068 table-ref 1031 280 ()) +(1069 table? 1031 292 ()) +(1070 really-make-table 1031 328 ()) +(1071 table-set!-procedure 1031 340 ()) +(1072 set-table-set!-procedure! 1031 352 ()) +(1073 table-ref-procedure 1031 364 ()) +(1074 set-table-ref-procedure! 1031 376 ()) +(1075 table-data 1031 388 ()) +(1076 set-table-data! 1031 400 ()) +(1077 table-size 1031 412 ()) +(1078 set-table-size! 1031 424 ()) +(1079 make-table 1031 497 ()) +(1080 weak #f #f ()) +(1081 make-population 1080 8 ()) +(1082 add-to-population! 1080 20 ()) +(1083 weak-memq 1080 32 ()) +(1084 population-reduce 1080 44 ()) +(1085 #f 1084 27 ()) +(1086 population->list 1080 56 ()) +(1087 walk-population 1080 68 ()) +(1088 #f 1087 13 ()) +(1089 meta-types #f #f ()) +(1090 compatible-types? 1089 38 ()) +(1091 variable-type? 1089 50 ()) +(1092 variable-type 1089 62 ()) +(1093 procedure-type-argument-types 1089 74 ()) +(1094 #f 1093 44 ()) +(1095 procedure-type-arity 1089 86 ()) +(1096 #f 1095 27 ()) +(1097 fixed-arity-procedure-type? 1089 98 ()) +(1098 #f 1097 56 ()) +(1099 make-some-values-type 1089 110 ()) +(1100 type->sexp 1089 122 ()) +(1101 #f 1100 148 ()) +(1102 rail-type->sexp 1089 134 ()) +(1103 #f 1102 38 ()) +(1104 atomic-type->sexp 1089 146 ()) +(1105 disjoin-type 1089 158 ()) +(1106 #f 1105 278 ()) +(1107 disjoin-rest 1089 170 ()) +(1108 sexp->type 1089 182 ()) +(1109 #f 1108 292 ()) +(1110 #f 1108 363 ()) +(1111 sexp->values-type 1089 194 ()) +(1112 procedure-type 1089 206 ()) +(1113 join-type 1089 218 ()) +(1114 join-rail 1089 230 ()) +(1115 join-procedure 1089 242 ()) +(1116 procedure-type? 1089 254 ()) +(1117 meet? 1089 266 ()) +(1118 meet-procedure? 1089 278 ()) +(1119 subtype? 1089 290 ()) +(1120 meet-type 1089 302 ()) +(1121 meet-rail 1089 314 ()) +(1122 meet-procedure 1089 326 ()) +(1123 procedure-type-codomain 1089 338 ()) +(1124 procedure-type-domain 1089 350 ()) +(1125 make-procedure-type 1089 362 ()) +(1126 restrictive? 1089 374 ()) +(1127 other-type-info 1089 386 ()) +(1128 value-type? 1089 398 ()) +(1129 tail-type 1089 410 ()) +(1130 head-type-really 1089 422 ()) +(1131 make-rest-type 1089 434 ()) +(1132 make-optional-type 1089 446 ()) +(1133 rail-type 1089 458 ()) +(1134 optional-type? 1089 470 ()) +(1135 head-type 1089 482 ()) +(1136 same-type? 1089 494 ()) +(1137 rest-type? 1089 506 ()) +(1138 empty-rail-type? 1089 518 ()) +(1139 named-atomic-type 1089 530 ()) +(1140 new-atomic-type 1089 542 ()) +(1141 bottom-type? 1089 554 ()) +(1142 mask->type 1089 566 ()) +(1143 new-type-bit 1089 578 ()) +(1144 name->type 1089 590 ()) +(1145 make-other-type 1089 602 ()) +(1146 set-type-name! 1089 614 ()) +(1147 make-type 1089 626 ()) +(1148 meta-type? 1089 638 ()) +(1149 really-make-type 1089 674 ()) +(1150 type-info 1089 686 ()) +(1151 type-more 1089 698 ()) +(1152 type-mask 1089 710 ()) +(1153 #f 1089 726 ()) +(1154 #f 1089 1122 ()) +(1155 interfaces #f #f ()) +(1156 note-interface-name! 1155 8 ()) +(1157 make-compound-interface 1155 20 ()) +(1158 #f 1157 19 ()) +(1159 #f 1158 34 ()) +(1160 #f 1157 31 ()) +(1161 #f 1160 13 ()) +(1162 #f 1157 59 ()) +(1163 make-simple-interface 1155 32 ()) +(1164 #f 1163 30 ()) +(1165 #f 1164 76 ()) +(1166 really-make-simple-interface 1155 44 ()) +(1167 #f 1166 13 ()) +(1168 #f 1166 25 ()) +(1169 make-interface 1155 56 ()) +(1170 note-reference-to-interface! 1155 68 ()) +(1171 for-each-declaration 1155 80 ()) +(1172 interface-ref 1155 92 ()) +(1173 interface? 1155 104 ()) +(1174 really-make-interface 1155 140 ()) +(1175 interface-name 1155 152 ()) +(1176 set-interface-name! 1155 164 ()) +(1177 interface-clients 1155 176 ()) +(1178 walk-method 1155 188 ()) +(1179 ref-method 1155 200 ()) +(1180 #f 1155 212 ()) +(1181 bindings #f #f ()) +(1182 maybe-fix-place! 1181 8 ()) +(1183 follow-forwarding-pointers 1181 20 ()) +(1184 same-denotation? 1181 32 ()) +(1185 forget-integration 1181 44 ()) +(1186 impose-type 1181 56 ()) +(1187 clobber-binding! 1181 68 ()) +(1188 add-path 1181 80 ()) +(1189 make-binding 1181 92 ()) +(1190 set-binding-place! 1181 104 ()) +(1191 binding-path 1181 116 ()) +(1192 binding-static 1181 128 ()) +(1193 binding-place 1181 140 ()) +(1194 binding-type 1181 152 ()) +(1195 names #f #f ()) +(1196 apply-inline-transform 1195 18 ()) +(1197 maybe-apply-macro-transform 1195 30 ()) +(1198 bind-aliases 1195 42 ()) +(1199 #f 1198 47 ()) +(1200 make-name-generator 1195 54 ()) +(1201 #f 1200 34 ()) +(1202 make-keyword-comparator 1195 66 ()) +(1203 #f 1202 13 ()) +(1204 name->source-name 1195 78 ()) +(1205 make-transform 1195 90 ()) +(1206 name->qualified 1195 102 ()) +(1207 qualify-parent 1195 114 ()) +(1208 #f 1207 34 ()) +(1209 transform? 1195 126 ()) +(1210 lookup 1195 138 ()) +(1211 qualified-symbol 1195 150 ()) +(1212 qualified-parent-name 1195 162 ()) +(1213 qualified? 1195 174 ()) +(1214 make-qualified 1195 186 ()) +(1215 desyntaxify 1195 198 ()) +(1216 #f 1215 286 ()) +(1217 name-hash 1195 210 ()) +(1218 name->symbol 1195 222 ()) +(1219 generated-uid 1195 234 ()) +(1220 generate-name 1195 246 ()) +(1221 name? 1195 258 ()) +(1222 generated? 1195 270 ()) +(1223 make-generated 1195 306 ()) +(1224 generated-parent-name 1195 318 ()) +(1225 generated-env 1195 330 ()) +(1226 generated-token 1195 342 ()) +(1227 generated-symbol 1195 354 ()) +(1228 #f 1195 370 ()) +(1229 really-make-transform 1195 434 ()) +(1230 transform-id 1195 446 ()) +(1231 transform-source 1195 458 ()) +(1232 transform-aux-names 1195 470 ()) +(1233 transform-type 1195 482 ()) +(1234 transform-env 1195 494 ()) +(1235 transform-procedure 1195 506 ()) +(1236 #f 1195 518 ()) +(1237 compiler-envs #f #f ()) +(1238 source-file-name 1237 8 ()) +(1239 bind-source-file-name 1237 20 ()) +(1240 extract-package-from-environment 1237 32 ()) +(1241 environment-define! 1237 44 ()) +(1242 environment-macro-eval 1237 56 ()) +(1243 make-compiler-env 1237 68 ()) +(1244 #f 1243 16 ()) +(1245 bindrec 1237 80 ()) +(1246 #f 1245 36 ()) +(1247 bind 1237 92 ()) +(1248 bind1 1237 104 ()) +(1249 #f 1248 15 ()) +(1250 lookup 1237 116 ()) +(1251 thingies #f #f ()) +(1252 thingie? 1251 8 ()) +(1253 make-thingie 1251 44 ()) +(1254 thingie-want-type 1251 56 ()) +(1255 thingie-name 1251 68 ()) +(1256 thingie-binding 1251 80 ()) +(1257 packages #f #f ()) +(1258 location-on-demand 1257 28 ()) +(1259 #f 1258 13 ()) +(1260 link! 1257 40 ()) +(1261 #f 1260 22 ()) +(1262 really-link! 1257 52 ()) +(1263 #f 1262 28 ()) +(1264 get-location 1257 64 ()) +(1265 get-location-for-undefined 1257 76 ()) +(1266 #f 1265 106 ()) +(1267 location-for-reference 1257 88 ()) +(1268 #f 1267 45 ()) +(1269 note-caching! 1257 100 ()) +(1270 package-note-caching! 1257 112 ()) +(1271 #f 1270 97 ()) +(1272 get-location-for-unassignable 1257 124 ()) +(1273 #f 1272 108 ()) +(1274 #f 1272 120 ()) +(1275 cenv->package 1257 136 ()) +(1276 noting-undefined-variables 1257 148 ()) +(1277 add-name 1276 29 ()) +(1278 #f 1276 48 ()) +(1279 #f 1276 64 ()) +(1280 #f 1279 4 ()) +(1281 #f 1279 20 ()) +(1282 #f 1281 10 ()) +(1283 print-undefined-names 1257 160 ()) +(1284 #f 1283 17 ()) +(1285 #f 1283 192 ()) +(1286 flush-location-names 1257 172 ()) +(1287 make-new-location 1257 184 ()) +(1288 for-each-definition 1257 196 ()) +(1289 #f 1288 13 ()) +(1290 package-refine-type! 1257 208 ()) +(1291 package-add-static! 1257 220 ()) +(1292 make-simple-package 1257 232 ()) +(1293 #f 1292 72 ()) +(1294 #f 1292 78 ()) +(1295 package-opens 1257 244 ()) +(1296 package-name 1257 256 ()) +(1297 lazy-table-accessor 1257 268 ()) +(1298 #f 1297 14 ()) +(1299 make-package 1257 280 ()) +(1300 new-package-uid 1257 292 ()) +(1301 really-package->environment 1257 304 ()) +(1302 #f 1301 13 ()) +(1303 #f 1301 25 ()) +(1304 for-each-export 1257 316 ()) +(1305 #f 1304 30 ()) +(1306 real-structure-lookup 1257 328 ()) +(1307 really-package-lookup 1257 340 ()) +(1308 generic-lookup 1257 352 ()) +(1309 package-lookup 1257 364 ()) +(1310 structure-lookup 1257 376 ()) +(1311 search-opens 1257 388 ()) +(1312 #f 1311 35 ()) +(1313 package-definition 1257 400 ()) +(1314 initialize-package-if-necessary! 1257 412 ()) +(1315 initialize-package! 1257 424 ()) +(1316 #f 1315 52 ()) +(1317 #f 1315 73 ()) +(1318 package-accesses 1257 436 ()) +(1319 package-define! 1257 448 ()) +(1320 get-new-location 1257 460 ()) +(1321 structure-unstable? 1257 472 ()) +(1322 make-structure 1257 484 ()) +(1323 #f 1322 92 ()) +(1324 note-structure-name! 1257 496 ()) +(1325 note-package-name! 1257 508 ()) +(1326 package? 1257 520 ()) +(1327 structure-interface 1257 532 ()) +(1328 initialize-structure! 1257 544 ()) +(1329 structure? 1257 556 ()) +(1330 really-make-structure 1257 592 ()) +(1331 structure-name 1257 604 ()) +(1332 set-structure-name! 1257 616 ()) +(1333 structure-clients 1257 628 ()) +(1334 structure-package 1257 640 ()) +(1335 structure-interface-really 1257 652 ()) +(1336 set-structure-interface! 1257 664 ()) +(1337 structure-interface-thunk 1257 676 ()) +(1338 #f 1257 692 ()) +(1339 really-make-package 1257 732 ()) +(1340 package-cached 1257 744 ()) +(1341 package-clients 1257 756 ()) +(1342 package-real-undefined-but-assigneds 1257 768 ()) +(1343 set-package-undefined-but-assigneds! 1257 780 ()) +(1344 package-real-undefineds 1257 792 ()) +(1345 set-package-undefineds! 1257 804 ()) +(1346 package-accesses-thunk 1257 816 ()) +(1347 package-opens-thunk 1257 828 ()) +(1348 set-package-opens-thunk! 1257 840 ()) +(1349 package->environment 1257 852 ()) +(1350 set-package->environment! 1257 864 ()) +(1351 package-loaded? 1257 876 ()) +(1352 set-package-loaded?! 1257 888 ()) +(1353 package-clauses 1257 900 ()) +(1354 package-file-name 1257 912 ()) +(1355 package-get-location 1257 924 ()) +(1356 set-package-get-location! 1257 936 ()) +(1357 package-integrate? 1257 948 ()) +(1358 set-package-integrate?! 1257 960 ()) +(1359 package-unstable? 1257 972 ()) +(1360 package-definitions 1257 984 ()) +(1361 package-opens-really 1257 996 ()) +(1362 set-package-opens! 1257 1008 ()) +(1363 package-uid 1257 1020 ()) +(1364 #f 1257 1036 ()) +(1365 #f 1257 1196 ()) +(1366 environments #f #f ()) +(1367 environment-ref 1366 8 ()) +(1368 #f 1367 30 ()) +(1369 environment-set! 1366 20 ()) +(1370 #f 1369 122 ()) +(1371 environment-define! 1366 32 ()) +(1372 *structure-ref 1366 44 ()) +(1373 carefully 1366 56 ()) +(1374 interaction-environment 1366 86 ()) +(1375 set-interaction-environment! 1366 98 ()) +(1376 with-interaction-environment 1366 110 ()) +(1377 scheme-report-environment 1366 122 ()) +(1378 set-scheme-report-environment! 1366 160 ()) +(1379 null-environment 1366 172 ()) +(1380 make-reflective-tower 1366 184 ()) +(1381 #f 1380 37 ()) +(1382 #f 1381 19 ()) +(1383 set-reflective-tower-maker! 1366 223 ()) +(1384 filenames #f #f ()) +(1385 namestring 1384 8 ()) +(1386 #f 1385 193 ()) +(1387 namestring-component 1384 40 ()) +(1388 file-name-directory 1384 82 ()) +(1389 file-name-nondirectory 1384 94 ()) +(1390 file-nondirectory-position 1384 106 ()) +(1391 #f 1390 40 ()) +(1392 string-posq 1384 118 ()) +(1393 #f 1392 36 ()) +(1394 translations 1384 140 ()) +(1395 set-translation! 1384 152 ()) +(1396 translate 1384 164 ()) +(1397 #f 1396 45 ()) +(1398 reading-forms #f #f ()) +(1399 #f 1398 12 ()) +(1400 read-forms 1398 30 ()) +(1401 #f 1400 60 ()) +(1402 really-read-forms 1398 42 ()) +(1403 #f 1402 35 ()) +(1404 nodes #f #f ()) +(1405 schemify-lambda 1404 28 ()) +(1406 schemify-formals 1404 40 ()) +(1407 define-schemifier 1404 52 ()) +(1408 schemify-nodes 1404 64 ()) +(1409 #f 1408 13 ()) +(1410 schemify 1404 76 ()) +(1411 schemify-sexp 1404 88 ()) +(1412 #f 1411 166 ()) +(1413 schemify-node 1404 100 ()) +(1414 force-node 1404 112 ()) +(1415 make-similar-node 1404 124 ()) +(1416 node-predicate 1404 136 ()) +(1417 #f 1416 44 ()) +(1418 node-operator 1404 148 ()) +(1419 node-set! 1404 160 ()) +(1420 #f 1419 120 ()) +(1421 node-ref 1404 172 ()) +(1422 make-node 1404 184 ()) +(1423 node? 1404 196 ()) +(1424 operator-define! 1404 208 ()) +(1425 operator-lookup 1404 220 ()) +(1426 make-operator-table 1404 232 ()) +(1427 get-operator 1404 244 ()) +(1428 operator? 1404 256 ()) +(1429 make-operator 1404 292 ()) +(1430 operator-name 1404 304 ()) +(1431 operator-uid 1404 316 ()) +(1432 operator-nargs 1404 328 ()) +(1433 operator-type 1404 340 ()) +(1434 set-operator-type! 1404 352 ()) +(1435 #f 1404 368 ()) +(1436 really-make-node 1404 478 ()) +(1437 node-plist 1404 490 ()) +(1438 set-node-plist! 1404 502 ()) +(1439 node-form 1404 514 ()) +(1440 node-operator-id 1404 526 ()) +(1441 #f 1404 542 ()) +(1442 #f 1404 562 ()) +(1443 #f 1404 588 ()) +(1444 #f 1404 616 ()) +(1445 #f 1404 644 ()) +(1446 #f 1445 13 ()) +(1447 #f 1404 724 ()) +(1448 #f 1447 36 ()) +(1449 #f 1447 71 ()) +(1450 #f 1404 752 ()) +(1451 #f 1404 776 ()) +(1452 var-utilities #f #f ()) +(1453 number-of-required-args 1452 8 ()) +(1454 #f 1453 24 ()) +(1455 n-ary? 1452 20 ()) +(1456 normalize-formals 1452 32 ()) +(1457 syntactic #f #f ()) +(1458 syntax? 1457 8 ()) +(1459 specs? 1457 20 ()) +(1460 expand-lambda 1457 32 ()) +(1461 #f 1460 13 ()) +(1462 #f 1460 30 ()) +(1463 bind-names 1457 44 ()) +(1464 #f 1463 42 ()) +(1465 unspecific-node 1457 56 ()) +(1466 define-expander 1457 68 ()) +(1467 expand-body 1457 80 ()) +(1468 #f 1467 34 ()) +(1469 #f 1467 51 ()) +(1470 expand-letrec 1457 92 ()) +(1471 #f 1470 17 ()) +(1472 scan-body-forms 1457 104 ()) +(1473 #f 1472 242 ()) +(1474 #f 1472 262 ()) +(1475 body-lossage 1457 116 ()) +(1476 make-operator-predicate 1457 128 ()) +(1477 #f 1476 33 ()) +(1478 static-value 1457 140 ()) +(1479 expand-form 1457 152 ()) +(1480 expand-define 1457 164 ()) +(1481 scan-forms 1457 176 ()) +(1482 #f 1481 38 ()) +(1483 expand-head 1457 188 ()) +(1484 expand-macro-application 1457 200 ()) +(1485 #f 1484 15 ()) +(1486 #f 1484 33 ()) +(1487 expand 1457 212 ()) +(1488 expand-call 1457 224 ()) +(1489 expand-list 1457 236 ()) +(1490 #f 1489 13 ()) +(1491 expand-literal 1457 248 ()) +(1492 literal? 1457 260 ()) +(1493 expand-operator-form 1457 272 ()) +(1494 expand-name 1457 284 ()) +(1495 scan-define-syntax 1457 296 ()) +(1496 process-syntax 1457 308 ()) +(1497 this-long? 1457 320 ()) +(1498 scan-define 1457 332 ()) +(1499 destructure-define 1457 344 ()) +(1500 names? 1457 356 ()) +(1501 at-least-this-long? 1457 368 ()) +(1502 #f 1457 444 ()) +(1503 #f 1457 470 ()) +(1504 #f 1457 498 ()) +(1505 #f 1457 526 ()) +(1506 #f 1457 554 ()) +(1507 #f 1457 582 ()) +(1508 lose 1507 40 ()) +(1509 #f 1457 610 ()) +(1510 #f 1457 638 ()) +(1511 #f 1457 666 ()) +(1512 #f 1457 694 ()) +(1513 #f 1512 88 ()) +(1514 #f 1457 722 ()) +(1515 #f 1457 750 ()) +(1516 #f 1515 115 ()) +(1517 #f 1457 778 ()) +(1518 #f 1517 111 ()) +(1519 #f 1518 13 ()) +(1520 #f 1457 806 ()) +(1521 #f 1520 121 ()) +(1522 primops #f #f ()) +(1523 get-primop 1522 8 ()) +(1524 define-compiler-primitive 1522 20 ()) +(1525 walk-primops 1522 32 ()) +(1526 #f 1525 13 ()) +(1527 primop? 1522 44 ()) +(1528 make-primop 1522 80 ()) +(1529 primop-compilator 1522 92 ()) +(1530 primop-closed 1522 104 ()) +(1531 primop-type 1522 116 ()) +(1532 primop-name 1522 128 ()) +(1533 #f 1522 144 ()) +(1534 debug-data #f #f ()) +(1535 debug-data? 1534 8 ()) +(1536 make-debug-data 1534 44 ()) +(1537 debug-data-source 1534 56 ()) +(1538 set-debug-data-source! 1534 68 ()) +(1539 debug-data-env-maps 1534 80 ()) +(1540 set-debug-data-env-maps! 1534 92 ()) +(1541 debug-data-pc-in-parent 1534 104 ()) +(1542 debug-data-parent 1534 116 ()) +(1543 debug-data-name 1534 128 ()) +(1544 debug-data-uid 1534 140 ()) +(1545 #f 1534 152 ()) +(1546 stack-check #f #f ()) +(1547 stack-function 1546 8 ()) +(1548 #f 1547 35 ()) +(1549 arg-spec-size 1546 20 ()) +(1550 do-make-cont 1546 32 ()) +(1551 #f 1550 13 ()) +(1552 get-offset 1546 44 ()) +(1553 continuer 1546 56 ()) +(1554 #f 1553 13 ()) +(1555 continue 1546 68 ()) +(1556 pusher 1546 80 ()) +(1557 #f 1556 14 ()) +(1558 imax 1546 92 ()) +(1559 popper 1546 104 ()) +(1560 #f 1559 14 ()) +(1561 nothing 1546 116 ()) +(1562 #f 1561 13 ()) +(1563 maximum-stack-use 1546 128 ()) +(1564 #f 1563 90 ()) +(1565 protocol-skip 1546 140 ()) +(1566 stack-max 1546 152 ()) +(1567 #f 1546 535 ()) +(1568 #f 1546 550 ()) +(1569 #f 1546 565 ()) +(1570 #f 1546 580 ()) +(1571 #f 1546 595 ()) +(1572 #f 1571 87 ()) +(1573 #f 1546 656 ()) +(1574 #f 1546 671 ()) +(1575 #f 1546 686 ()) +(1576 #f 1575 71 ()) +(1577 #f 1546 710 ()) +(1578 segments #f #f ()) +(1579 note-environment 1578 38 ()) +(1580 #f 1579 39 ()) +(1581 note-source-code 1578 50 ()) +(1582 #f 1581 27 ()) +(1583 attach-label 1578 62 ()) +(1584 #f 1583 27 ()) +(1585 #f 1584 45 ()) +(1586 computed-goto-instruction 1578 74 ()) +(1587 #f 1586 81 ()) +(1588 #f 1587 90 ()) +(1589 instruction-using-label 1578 86 ()) +(1590 #f 1589 59 ()) +(1591 insert-label! 1578 98 ()) +(1592 make-label 1578 110 ()) +(1593 instruction-with-location 1578 122 ()) +(1594 #f 1593 20 ()) +(1595 instruction-with-literal 1578 134 ()) +(1596 #f 1595 39 ()) +(1597 #f 1596 167 ()) +(1598 sequentially 1578 146 ()) +(1599 #f 1598 118 ()) +(1600 #f 1598 141 ()) +(1601 #f 1600 34 ()) +(1602 sequentially-2 1578 158 ()) +(1603 #f 1602 67 ()) +(1604 instruction 1578 170 ()) +(1605 #f 1604 38 ()) +(1606 #f 1605 29 ()) +(1607 segment->template 1578 182 ()) +(1608 #f 1607 140 ()) +(1609 segment-data->template 1578 194 ()) +(1610 #f 1609 94 ()) +(1611 template 1578 206 ()) +(1612 #f 1611 18 ()) +(1613 make-astate 1578 218 ()) +(1614 emit-with-environment-maps! 1578 230 ()) +(1615 #f 1614 22 ()) +(1616 emit-segment! 1578 242 ()) +(1617 check-stack-use 1578 254 ()) +(1618 #f 1617 99 ()) +(1619 code-vector-set2! 1578 266 ()) +(1620 emit-literal! 1578 278 ()) +(1621 literal->index 1578 290 ()) +(1622 low-byte 1578 302 ()) +(1623 emit-byte! 1578 314 ()) +(1624 high-byte 1578 326 ()) +(1625 new-debug-data 1578 338 ()) +(1626 get-debug-data 1578 350 ()) +(1627 debug-data->info 1578 362 ()) +(1628 note-debug-data! 1578 374 ()) +(1629 with-fresh-compiler-state 1578 386 ()) +(1630 #f 1629 52 ()) +(1631 #f 1630 4 ()) +(1632 #f 1630 10 ()) +(1633 saving-and-restoring 1578 398 ()) +(1634 swap 1633 24 ()) +(1635 debug-flag-modifier 1578 410 ()) +(1636 #f 1635 33 ()) +(1637 debug-flag-accessor 1578 422 ()) +(1638 #f 1637 33 ()) +(1639 set-template-uid! 1578 434 ()) +(1640 template-uid 1578 446 ()) +(1641 new-template-uid 1578 458 ()) +(1642 make-assembly-state 1578 740 ()) +(1643 astate-literals 1578 752 ()) +(1644 set-astate-literals! 1578 764 ()) +(1645 astate-count 1578 776 ()) +(1646 set-astate-count! 1578 788 ()) +(1647 astate-pc 1578 800 ()) +(1648 set-astate-pc! 1578 812 ()) +(1649 astate-code-vector 1578 824 ()) +(1650 #f 1578 844 ()) +(1651 optimizer #f #f ()) +(1652 set-optimizer! 1651 24 ()) +(1653 get-optimizer 1651 36 ()) +(1654 #f 1653 13 ()) +(1655 #f 1654 11 ()) +(1656 #f 1655 56 ()) +(1657 apply-optimizers 1651 48 ()) +(1658 #f 1657 13 ()) +(1659 default-standard-optimizer 1651 70 ()) +(1660 set-standard-optimizers! 1651 92 ()) +(1661 get-optimizers 1651 104 ()) +(1662 #f 1661 7 ()) +(1663 make-standard-optimizer 1651 116 ()) +(1664 #f 1663 29 ()) +(1665 flatten #f #f ()) +(1666 flatten-form 1665 8 ()) +(1667 #f 1666 74 ()) +(1668 #f 1666 90 ()) +(1669 #f 1666 117 ()) +(1670 #f 1666 133 ()) +(1671 flatten-node 1665 20 ()) +(1672 #f 1665 36 ()) +(1673 #f 1672 13 ()) +(1674 #f 1672 29 ()) +(1675 define-flattener 1665 50 ()) +(1676 flatten-list 1665 62 ()) +(1677 #f 1676 39 ()) +(1678 #f 1677 51 ()) +(1679 #f 1677 67 ()) +(1680 no-free-vars 1665 74 ()) +(1681 #f 1665 162 ()) +(1682 flatten-lambda 1665 178 ()) +(1683 #f 1682 32 ()) +(1684 #f 1682 48 ()) +(1685 convert-lambda-body 1665 190 ()) +(1686 #f 1685 54 ()) +(1687 #f 1685 70 ()) +(1688 add-cells 1665 202 ()) +(1689 #f 1688 27 ()) +(1690 #f 1665 218 ()) +(1691 #f 1665 238 ()) +(1692 #f 1691 47 ()) +(1693 #f 1691 63 ()) +(1694 #f 1665 258 ()) +(1695 #f 1694 31 ()) +(1696 #f 1695 17 ()) +(1697 #f 1695 33 ()) +(1698 #f 1694 47 ()) +(1699 #f 1665 278 ()) +(1700 #f 1699 31 ()) +(1701 #f 1699 47 ()) +(1702 #f 1665 298 ()) +(1703 #f 1702 86 ()) +(1704 #f 1702 107 ()) +(1705 #f 1704 120 ()) +(1706 #f 1702 126 ()) +(1707 assigned? 1665 314 ()) +(1708 mark-set-variables! 1665 326 ()) +(1709 #f 1665 342 ()) +(1710 define-set-marker 1665 356 ()) +(1711 no-sets 1665 368 ()) +(1712 #f 1665 474 ()) +(1713 #f 1665 494 ()) +(1714 #f 1665 514 ()) +(1715 #f 1665 534 ()) +(1716 #f 1665 554 ()) +(1717 #f 1716 26 ()) +(1718 make-cell 1665 570 ()) +(1719 make-unassigned-cell 1665 582 ()) +(1720 make-cell-ref 1665 594 ()) +(1721 make-cell-set! 1665 606 ()) +(1722 make-primop-call 1665 618 ()) +(1723 make-cell-primop 1665 818 ()) +(1724 cell-ref-primop 1665 838 ()) +(1725 cell-set!-primop 1665 858 ()) +(1726 union 1665 870 ()) +(1727 #f 1726 47 ()) +(1728 set-difference 1665 882 ()) +(1729 #f 1728 34 ()) +(1730 reconstruction #f #f ()) +(1731 node-type 1730 8 ()) +(1732 reconstruct-type 1730 20 ()) +(1733 reconstruct 1730 32 ()) +(1734 examine 1730 44 ()) +(1735 #f 1730 60 ()) +(1736 define-reconstructor 1730 74 ()) +(1737 #f 1730 94 ()) +(1738 #f 1730 118 ()) +(1739 reconstruct-lambda 1730 134 ()) +(1740 #f 1739 72 ()) +(1741 careful-codomain 1730 146 ()) +(1742 #f 1730 166 ()) +(1743 reconstruct-name 1730 182 ()) +(1744 #f 1730 202 ()) +(1745 proc->reconstructor 1730 218 ()) +(1746 reconstruct-call 1730 230 ()) +(1747 lose 1746 122 ()) +(1748 #f 1747 10 ()) +(1749 #f 1746 205 ()) +(1750 #f 1730 250 ()) +(1751 #f 1730 274 ()) +(1752 #f 1730 296 ()) +(1753 #f 1730 318 ()) +(1754 #f 1730 342 ()) +(1755 #f 1754 154 ()) +(1756 fork-constraints 1730 358 ()) +(1757 #f 1756 14 ()) +(1758 #f 1730 381 ()) +(1759 #f 1758 28 ()) +(1760 #f 1730 405 ()) +(1761 #f 1730 429 ()) +(1762 #f 1761 67 ()) +(1763 #f 1730 453 ()) +(1764 node->type 1730 469 ()) +(1765 #f 1730 489 ()) +(1766 #f 1730 513 ()) +(1767 define-primop-reconstructor 1730 617 ()) +(1768 #f 1730 637 ()) +(1769 #f 1730 657 ()) +(1770 #f 1769 17 ()) +(1771 #f 1730 677 ()) +(1772 reconstruct-apply 1730 693 ()) +(1773 #f 1772 63 ()) +(1774 constant-type 1730 741 ()) +(1775 compiler #f #f ()) +(1776 make-startup-procedure 1775 18 ()) +(1777 #f 1776 45 ()) +(1778 compile-forms 1775 30 ()) +(1779 #f 1778 102 ()) +(1780 compile-form 1775 42 ()) +(1781 compile-definition 1775 54 ()) +(1782 make-dispatch-protocol 1775 66 ()) +(1783 call-on-args 1775 78 ()) +(1784 do-arg 1783 15 ()) +(1785 #f 1783 81 ()) +(1786 call-on-arg-and-id 1775 90 ()) +(1787 define-n-ary-compiler-primitive 1775 102 ()) +(1788 n-ary-primitive-compilator 1775 114 ()) +(1789 #f 1788 14 ()) +(1790 define-vector-primitives 1775 126 ()) +(1791 def-prim 1790 33 ()) +(1792 define-data-struct-primitives 1775 138 ()) +(1793 def-prim 1792 9 ()) +(1794 #f 1792 213 ()) +(1795 define-stob-predicate 1775 150 ()) +(1796 symbol-append 1775 162 ()) +(1797 define-simple-primitive 1775 174 ()) +(1798 simple-closed-compilator 1775 186 ()) +(1799 #f 1798 14 ()) +(1800 simple-compilator 1775 198 ()) +(1801 #f 1800 13 ()) +(1802 get-primop-type 1775 210 ()) +(1803 #f 1802 17 ()) +(1804 nargs->domain 1775 222 ()) +(1805 #f 1804 24 ()) +(1806 direct-closed-compilator 1775 234 ()) +(1807 #f 1806 13 ()) +(1808 direct-compilator 1775 246 ()) +(1809 #f 1808 13 ()) +(1810 push-all-but-last 1775 258 ()) +(1811 #f 1810 42 ()) +(1812 set-type-check?! 1775 270 ()) +(1813 ignore-values-cont 1775 282 ()) +(1814 fall-through-cont? 1775 294 ()) +(1815 compile-flat-lambda 1775 306 ()) +(1816 #f 1815 27 ()) +(1817 #f 1815 368 ()) +(1818 get-variables-offsets 1775 318 ()) +(1819 #f 1818 38 ()) +(1820 sort-list 1775 330 ()) +(1821 #f 1820 27 ()) +(1822 #f 1820 62 ()) +(1823 variable-env-data 1775 342 ()) +(1824 #f 1823 39 ()) +(1825 #f 1824 83 ()) +(1826 #f 1825 134 ()) +(1827 compile-lambda 1775 354 ()) +(1828 compile-call 1775 366 ()) +(1829 compile-redex 1775 378 ()) +(1830 #f 1829 128 ()) +(1831 cont-name 1775 390 ()) +(1832 compile-lambda-code 1775 402 ()) +(1833 return-cont 1775 414 ()) +(1834 name-node->symbol 1775 426 ()) +(1835 set-lexical-offsets! 1775 438 ()) +(1836 #f 1835 38 ()) +(1837 push-all-with-names 1775 450 ()) +(1838 named-cont 1775 462 ()) +(1839 generate-trap 1775 474 ()) +(1840 compile-name-call 1775 486 ()) +(1841 name-node-binding 1775 498 ()) +(1842 compile-unknown-call 1775 510 ()) +(1843 push-arguments 1775 522 ()) +(1844 #f 1843 54 ()) +(1845 fall-through-cont 1775 534 ()) +(1846 make-cont 1775 546 ()) +(1847 maybe-push-continuation 1775 558 ()) +(1848 fixup-source 1775 570 ()) +(1849 return-cont? 1775 582 ()) +(1850 compile-constant 1775 594 ()) +(1851 deliver-value 1775 606 ()) +(1852 ignore-values-cont? 1775 618 ()) +(1853 define-compilator 1775 630 ()) +(1854 compile-expression 1775 642 ()) +(1855 compile 1775 654 ()) +(1856 type-check 1775 666 ()) +(1857 #f 1856 122 ()) +(1858 diagnose-call-error 1775 678 ()) +(1859 #f 1858 174 ()) +(1860 #f 1775 694 ()) +(1861 #f 1775 720 ()) +(1862 #f 1775 770 ()) +(1863 #f 1775 820 ()) +(1864 #f 1775 848 ()) +(1865 #f 1775 876 ()) +(1866 #f 1775 904 ()) +(1867 #f 1775 932 ()) +(1868 #f 1775 960 ()) +(1869 #f 1868 110 ()) +(1870 #f 1775 1014 ()) +(1871 #f 1775 1042 ()) +(1872 #f 1775 1070 ()) +(1873 #f 1872 74 ()) +(1874 #f 1872 159 ()) +(1875 #f 1775 1158 ()) +(1876 #f 1775 1354 ()) +(1877 #f 1775 2517 ()) +(1878 #f 1775 2577 ()) +(1879 #f 1775 2830 ()) +(1880 #f 1775 2954 ()) +(1881 #f 1775 2960 ()) +(1882 #f 1775 3040 ()) +(1883 #f 1775 3046 ()) +(1884 #f 1775 3128 ()) +(1885 #f 1775 3140 ()) +(1886 #f 1775 3166 ()) +(1887 #f 1775 3172 ()) +(1888 #f 1775 3231 ()) +(1889 #f 1888 119 ()) +(1890 #f 1775 3243 ()) +(1891 #f 1775 3273 ()) +(1892 n-ary-constructor 1775 3289 ()) +(1893 #f 1892 23 ()) +(1894 #f 1892 35 ()) +(1895 define-char-io 1775 3338 ()) +(1896 #f 1895 19 ()) +(1897 #f 1895 31 ()) +(1898 define-char-io 1775 3481 ()) +(1899 #f 1898 19 ()) +(1900 #f 1898 31 ()) +(1901 define+* 1775 3571 ()) +(1902 #f 1901 51 ()) +(1903 #f 1901 64 ()) +(1904 define=< 1775 3705 ()) +(1905 #f 1904 80 ()) +(1906 #f 1904 92 ()) +(1907 define-one-or-two 1775 3839 ()) +(1908 #f 1907 81 ()) +(1909 #f 1907 94 ()) +(1910 define-one-or-two 1775 3890 ()) +(1911 #f 1910 20 ()) +(1912 #f 1910 33 ()) +(1913 #f 1775 4292 ()) +(1914 evaluation #f #f ()) +(1915 eval 1914 8 ()) +(1916 load-into 1914 20 ()) +(1917 eval-from-file 1914 32 ()) +(1918 load 1914 44 ()) +(1919 really-load-into 1914 56 ()) +(1920 compile-and-run 1914 68 ()) +(1921 #f 1920 68 ()) +(1922 #f 1921 16 ()) +(1923 scheme #f #f ()) +(1924 display-conditions #f #f ()) +(1925 display-condition 1924 30 ()) +(1926 #f 1925 21 ()) +(1927 really-display-condition 1924 43 ()) +(1928 #f 1927 256 ()) +(1929 &disclose-condition 1924 159 ()) +(1930 limited-write 1924 188 ()) +(1931 #f 1930 40 ()) +(1932 #f 1931 158 ()) +(1933 #f 1932 49 ()) +(1934 mini-command #f #f ()) +(1935 command-processor 1934 8 ()) +(1936 #f 1935 96 ()) +(1937 #f 1936 18 ()) +(1938 #f 1937 18 ()) +(1939 #f 1938 67 ()) +(1940 #f 1937 36 ()) +(1941 #f 1940 75 ()) +(1942 #f 1940 208 ()) +(1943 #f 1940 262 ()) +(1944 #f 1943 19 ()) +(1945 #f 1940 278 ()) +(1946 mini-load 1934 20 ()) +(1947 read-string 1934 32 ()) +(1948 #f 1947 40 ()) +(1949 enum-case #f #f ()) +(1950 scheduler #f #f ()) +(1951 run-threads 1950 8 ()) +(1952 #f 1951 13 ()) +(1953 #f 1952 42 ()) +(1954 #f 1953 17 ()) +(1955 #f 1954 15 ()) +(1956 #f 1954 37 ()) +(1957 #f 1953 34 ()) +(1958 #f 1951 29 ()) +(1959 run-threads-with-housekeeper 1950 20 ()) +(1960 #f 1959 15 ()) +(1961 #f 1960 47 ()) +(1962 #f 1961 21 ()) +(1963 #f 1962 65 ()) +(1964 #f 1962 87 ()) +(1965 #f 1961 38 ()) +(1966 #f 1959 31 ()) +(1967 round-robin-event-handler 1950 32 ()) +(1968 #f 1967 40 ()) +(1969 #f 1968 128 ()) +(1970 #f 1968 147 ()) +(1971 #f 1967 60 ()) +(1972 #f 1967 83 ()) +(1973 #f 1972 27 ()) +(1974 make-counter 1950 44 ()) +(1975 increment-counter! 1950 66 ()) +(1976 decrement-counter! 1950 78 ()) +(1977 root-scheduler #f #f ()) +(1978 root-scheduler 1977 8 ()) +(1979 #f 1978 34 ()) +(1980 #f 1979 32 ()) +(1981 #f 1979 50 ()) +(1982 make-root-event-handler 1977 20 ()) +(1983 #f 1982 116 ()) +(1984 #f 1982 128 ()) +(1985 root-handler 1977 32 ()) +(1986 cheap-display-condition 1977 44 ()) +(1987 #f 1986 171 ()) +(1988 scheme-exit-now 1977 76 ()) +(1989 root-wait 1977 88 ()) +(1990 #f 1989 29 ()) +(1991 do-some-waiting 1977 125 ()) +(1992 #f 1991 21 ()) +(1993 call-when-deadlocked! 1977 155 ()) +(1994 spawn-output-forcers 1977 167 ()) +(1995 usual-resumer #f #f ()) +(1996 usual-resumer 1995 8 ()) +(1997 #f 1996 13 ()) +(1998 #f 1997 25 ()) +(1999 initialize-rts 1995 20 ()) +(2000 #f 1999 54 ()) +(2001 #f 2000 17 ()) +(2002 #f 2001 53 ()) +(2003 #f 2002 10 ()) +(2004 initial-system #f #f ()) +(2005 start 2004 8 ()) +(2006 #f 2005 13 ()) +(2007 #f 2006 16 ()) +(2008 #f 2007 74 ()) +(2009 make-built-in-structures 2004 20 ()) +(2010 #f 2009 45 ()) +(2011 #f 2009 74 ()) +(2012 initialize-interaction-environment! 2004 32 ()) +(2013 make-initial-package 2004 44 ()) +(2014 #f 2013 24 ()) +(2015 make-tower 2004 56 ()) +(2016 usual-macros #f #f ()) +(2017 define-usual-macro 2016 24 ()) +(2018 usual-transform 2016 36 ()) +(2019 #f 2016 52 ()) +(2020 #f 2016 76 ()) +(2021 #f 2020 103 ()) +(2022 #f 2016 100 ()) +(2023 #f 2022 239 ()) +(2024 do-spec? 2016 120 ()) +(2025 #f 2016 136 ()) +(2026 #f 2016 160 ()) +(2027 specs? 2016 180 ()) +(2028 #f 2016 196 ()) +(2029 #f 2016 220 ()) +(2030 #f 2029 36 ()) +(2031 #f 2029 242 ()) +(2032 case-clause? 2016 240 ()) +(2033 #f 2016 256 ()) +(2034 #f 2033 211 ()) +(2035 #f 2033 228 ()) +(2036 #f 2033 250 ()) +(2037 #f 2033 270 ()) +(2038 #f 2037 30 ()) +(2039 #f 2038 30 ()) +(2040 #f 2033 289 ()) +(2041 #f 2040 34 ()) +(2042 #f 2033 306 ()) +(2043 #f 2016 280 ()) +(2044 process-rules 2016 300 ()) +(2045 #f 2044 528 ()) +(2046 #f 2044 551 ()) +(2047 #f 2046 130 ()) +(2048 #f 2044 582 ()) +(2049 #f 2044 599 ()) +(2050 #f 2044 624 ()) +(2051 #f 2050 113 ()) +(2052 #f 2044 648 ()) +(2053 #f 2044 668 ()) +(2054 #f 2044 685 ()) +(2055 segment-pattern? 2016 312 ()) +(2056 segment-template? 2016 324 ()) +(2057 find-free-names-in-syntax-rules 2016 366 ()) +(2058 #f 2057 32 ()) +(2059 #f 2057 49 ()) +(2060 #f 2057 78 ()) +(2061 strong #f #f ()) +(2062 strongly-connected-components 2061 8 ()) +(2063 #f 2062 70 ()) +(2064 #f 2063 46 ()) +(2065 #f 2063 73 ()) +(2066 #f 2063 97 ()) +(2067 find-next-vertex 2061 20 ()) +(2068 #f 2067 27 ()) +(2069 really-make-vertex 2061 56 ()) +(2070 vertex-lowpoint 2061 68 ()) +(2071 set-vertex-lowpoint! 2061 80 ()) +(2072 vertex-parent 2061 92 ()) +(2073 set-vertex-parent! 2061 104 ()) +(2074 vertex-index 2061 116 ()) +(2075 set-vertex-index! 2061 128 ()) +(2076 vertex-stack 2061 140 ()) +(2077 set-vertex-stack! 2061 152 ()) +(2078 vertex-edges 2061 164 ()) +(2079 set-vertex-edges! 2061 176 ()) +(2080 vertex-data 2061 188 ()) +(2081 vertex? 2061 200 ()) +(2082 make-vertex 2061 212 ()) +(2083 make-vertices 2061 224 ()) +(2084 maybe-slot 2083 13 ()) +(2085 #f 2083 32 ()) +(2086 #f 2083 61 ()) +(2087 do-vertex 2061 236 ()) +(2088 get-strong 2061 248 ()) +(2089 end-vertex 2061 260 ()) +(2090 #f 2089 14 ()) +(2091 #f 2089 32 ()) +(2092 unwind-stack 2061 272 ()) +(2093 #f 2092 39 ()) +(2094 follow-edge 2061 284 ()) +(2095 pop-vertex-edge! 2061 296 ()) +(2096 usages #f #f ()) +(2097 find-usages 2096 8 ()) +(2098 #f 2097 30 ()) +(2099 #f 2097 55 ()) +(2100 #f 2099 31 ()) +(2101 #f 2097 80 ()) +(2102 maybe-update-known-type 2096 20 ()) +(2103 find-node-usages 2096 32 ()) +(2104 #f 2103 37 ()) +(2105 #f 2103 52 ()) +(2106 analyze 2096 44 ()) +(2107 analyze-nodes 2096 56 ()) +(2108 #f 2107 13 ()) +(2109 #f 2096 72 ()) +(2110 define-usage-analyzer 2096 86 ()) +(2111 nothing 2096 98 ()) +(2112 #f 2096 220 ()) +(2113 add-if-free 2096 236 ()) +(2114 #f 2096 254 ()) +(2115 #f 2096 278 ()) +(2116 #f 2115 42 ()) +(2117 #f 2096 302 ()) +(2118 #f 2117 58 ()) +(2119 #f 2096 326 ()) +(2120 #f 2096 350 ()) +(2121 #f 2096 374 ()) +(2122 #f 2096 398 ()) +(2123 #f 2096 422 ()) +(2124 #f 2096 446 ()) +(2125 really-make-usage 2096 486 ()) +(2126 usage-assignment-count 2096 498 ()) +(2127 set-assignment! 2096 510 ()) +(2128 usage-operator-count 2096 522 ()) +(2129 set-operator! 2096 534 ()) +(2130 usage-reference-count 2096 546 ()) +(2131 set-reference! 2096 558 ()) +(2132 usage-name-node 2096 570 ()) +(2133 usage? 2096 582 ()) +(2134 make-usage 2096 594 ()) +(2135 make-package-usage 2096 606 ()) +(2136 package-usage? 2096 618 ()) +(2137 usage-incrementator 2096 630 ()) +(2138 #f 2137 14 ()) +(2139 sort-forms 2096 842 ()) +(2140 #f 2139 86 ()) +(2141 #f 2139 125 ()) +(2142 stuff-count 2096 854 ()) +(2143 #f 2142 11 ()) +(2144 maybe-make-aliased 2096 866 ()) +(2145 topologically-sort 2096 878 ()) +(2146 #f 2145 20 ()) +(2147 #f 2146 7 ()) +(2148 #f 2146 23 ()) +(2149 really-make-form 2096 914 ()) +(2150 form-temp 2096 926 ()) +(2151 set-form-temp! 2096 938 ()) +(2152 form-free 2096 950 ()) +(2153 set-form-free! 2096 962 ()) +(2154 form-unaliased? 2096 974 ()) +(2155 set-form-unaliased?! 2096 986 ()) +(2156 form-aliases 2096 998 ()) +(2157 set-form-aliases! 2096 1010 ()) +(2158 form-node 2096 1022 ()) +(2159 form? 2096 1034 ()) +(2160 #f 2096 1050 ()) +(2161 make-form 2096 1066 ()) +(2162 insert-aliases 2096 1078 ()) +(2163 #f 2162 35 ()) +(2164 inline #f #f ()) +(2165 make-inline-transform 2164 8 ()) +(2166 #f 2165 48 ()) +(2167 #f 2165 104 ()) +(2168 #f 2167 24 ()) +(2169 clean-node 2164 20 ()) +(2170 #f 2169 139 ()) +(2171 #f 2169 310 ()) +(2172 clean-lambda 2164 32 ()) +(2173 #f 2172 42 ()) +(2174 #f 2172 108 ()) +(2175 clean-lookup 2164 44 ()) +(2176 unused-name 2164 56 ()) +(2177 #f 2176 65 ()) +(2178 #f 2177 17 ()) +(2179 inline-transform 2164 68 ()) +(2180 #f 2179 71 ()) +(2181 #f 2179 86 ()) +(2182 make-substitution 2164 80 ()) +(2183 #f 2182 39 ()) +(2184 reconstitute 2164 92 ()) +(2185 #f 2184 35 ()) +(2186 reconstitute-name 2164 104 ()) +(2187 qualified->name 2164 156 ()) +(2188 #f 2187 34 ()) +(2189 get-qualified-env 2164 168 ()) +(2190 for-reification #f #f ()) +(2191 operator 2190 8 ()) +(2192 primop 2190 20 ()) +(2193 simple-interface 2190 32 ()) +(2194 #f 2193 13 ()) +(2195 package 2190 44 ()) +(2196 #f 2195 95 ()) +(2197 transform 2190 56 ()) +(2198 package-define-static! 2190 68 ()) +(2199 types #f #f ()) +(2200 procedure 2199 48 ()) +(2201 defpackage #f #f ()) +(2202 make-a-package 2201 8 ()) +(2203 loser 2201 20 ()) +(2204 *verify-later!* 2201 42 ()) +(2205 verify-later! 2201 54 ()) +(2206 set-verify-later! 2201 66 ()) +(2207 note-name! 2201 78 ()) +(2208 scan-package #f #f ()) +(2209 collect-packages 2208 8 ()) +(2210 #f 2209 74 ()) +(2211 #f 2210 171 ()) +(2212 package-source 2208 20 ()) +(2213 #f 2212 59 ()) +(2214 read-files 2208 32 ()) +(2215 #f 2214 38 ()) +(2216 package-optimizer-names 2208 44 ()) +(2217 #f 2216 37 ()) +(2218 #f 2216 77 ()) +(2219 check-structure 2208 56 ()) +(2220 #f 2219 36 ()) +(2221 compile-packages #f #f ()) +(2222 compile-package 2221 8 ()) +(2223 expand-package 2221 20 ()) +(2224 #f 2223 28 ()) +(2225 #f 2224 17 ()) +(2226 #f 2224 42 ()) +(2227 #f 2224 97 ()) +(2228 #f 2227 22 ()) +(2229 #f 2228 16 ()) +(2230 #f 2223 44 ()) +(2231 define-usual-transform 2221 32 ()) +(2232 define-primitives 2221 44 ()) +(2233 #f 2232 33 ()) +(2234 #f 2232 62 ()) +(2235 make-define-primitive-node 2221 56 ()) +(2236 module-system #f #f ()) +(2237 analysis #f #f ()) +(2238 #f 2237 12 ()) +(2239 analyze-forms 2237 28 ()) +(2240 #f 2239 36 ()) +(2241 analyze-form 2237 40 ()) +(2242 inlinable-rhs? 2237 52 ()) +(2243 simple-lambda? 2237 64 ()) +(2244 #f 2243 129 ()) +(2245 simple? 2237 100 ()) +(2246 simple-list? 2237 112 ()) +(2247 #f 2237 128 ()) +(2248 define-analyzer 2237 142 ()) +(2249 #f 2237 158 ()) +(2250 #f 2237 178 ()) +(2251 #f 2237 198 ()) +(2252 #f 2237 218 ()) +(2253 #f 2237 238 ()) +(2254 #f 2237 258 ()) +(2255 #f 2237 278 ()) +(2256 #f 2237 298 ()) +(2257 #f 2237 318 ()) +(2258 #f 2237 338 ()) +(2259 #f 2237 358 ()) +(2260 #f 2259 37 ()) +(2261 #f 2237 378 ()) +(2262 static-value 2237 394 ()) +(2263 really-simple-call? 2237 406 ()) +(2264 lexical-node? 2237 418 ()) +(2265 simple-literal? 2237 448 ()) +(2266 require 2237 460 ()) +(2267 package-lookup-type 2237 480 ()) +(2268 ensures-loaded #f #f ()) +(2269 ensure-loaded 2268 8 ()) +(2270 #f 2269 56 ()) +(2271 #f 2270 63 ()) +(2272 #f 2269 69 ()) +(2273 #f #f #f ()) +(2274 #f 2273 4 ()) +(2275 get-location 2274 4 ()) +(2276 #f 2274 11622 ()) +(2277 #f 2274 11678 ()) +(2278 #f 2274 11810 ()) +(2279 #f 2274 11944 ()) +(2280 #f 2274 12038 ()) +(2281 conc 2280 43 ()) +(2282 #f 2281 17 ()) +(2283 #f 2274 13703 ()) +(2284 #f 2283 128 ()) +(2285 #f 2283 217 ()) +(2286 #f 2283 249 ()) +(2287 #f 2283 436 ()) +(2288 #f 2283 495 ()) +(2289 #f 2274 14131 ()) +(2290 #f 2289 216 ()) +(2291 #f 2289 233 ()) +(2292 #f 2289 254 ()) +(2293 #f 2289 331 ()) +(2294 #f 2274 14349 ()) +(2295 #f 2294 84 ()) +(2296 #f 2274 14405 ()) +(2297 #f 2274 16373 ()) +(2298 #f 2274 24166 ()) +(2299 #f 2298 469 ()) +(2300 #f 2274 25236 ()) +(2301 #f 2300 118 ()) +(2302 #f 2274 25424 ()) +(2303 #f 2302 118 ()) +(2304 #f 2274 25574 ()) +(2305 #f 2304 118 ()) +(2306 #f 2274 25686 ()) +(2307 #f 2306 118 ()) +(2308 #f 2274 25798 ()) +(2309 #f 2308 118 ()) +(2310 #f 2274 25910 ()) +(2311 #f 2310 118 ()) +(2312 #f 2274 26022 ()) +(2313 #f 2312 118 ()) +(2314 #f 2274 26134 ()) +(2315 #f 2314 118 ()) +(2316 #f 2274 26246 ()) +(2317 #f 2316 118 ()) +(2318 #f 2274 27045 ()) +(2319 #f 2318 118 ()) +(2320 #f 2274 29391 ()) +(2321 #f 2274 29573 ()) +(2322 #f 2274 29629 ()) +(2323 #f 2274 29685 ()) +(2324 #f 2274 29855 ()) +(2325 #f 2274 30107 ()) +(2326 #f 2274 33342 ()) +(2327 #f 2274 33564 ()) +(2328 #f 2274 33620 ()) +(2329 #f 2274 33676 ()) +(2330 #f 2329 153 ()) +(2331 #f 2274 33732 ()) +(2332 #f 2331 336 ()) +(2333 #f 2331 417 ()) +(2334 #f 2274 34154 ()) +(2335 #f 2274 34210 ()) +(2336 #f 2335 183 ()) +(2337 #f 2274 34281 ()) +(2338 #f 2337 97 ()) +(2339 #f 2274 34295 ()) +(2340 #f 2339 45 ()) +(2341 #f 2340 154 ()) +(2342 #f 2339 68 ()) +(2343 #f 2274 34588 ()) +(2344 #f 2274 34644 ()) +(2345 #f 2344 51 ()) +(2346 #f 2274 34776 ()) +(2347 #f 2274 34870 ()) +(2348 #f 2274 34964 ()) +(2349 #f 2348 64 ()) +(2350 #f 2348 105 ()) +(2351 #f 2348 130 ()) +(2352 #f 2274 35058 ()) +(2353 #f 2274 36496 ()) +(2354 #f 2274 36651 ()) +(2355 #f #f #f ()) +- diff --git a/build/initial.image b/build/initial.image new file mode 100644 index 0000000..d117a52 Binary files /dev/null and b/build/initial.image differ diff --git a/build/initial.scm b/build/initial.scm new file mode 100644 index 0000000..07a6a18 --- /dev/null +++ b/build/initial.scm @@ -0,0 +1,60 @@ +; Copyright (c) 1993, 1994 by Richard Kelsey and Jonathan Rees. +; Copyright (c) 1996 by NEC Research Institute, Inc. See file COPYING. + + +; Link script. + +(define (link-initial-system) + (let ((structures-to-open ;Structures to open for the initial + (struct-list scheme ;system's read-eval-print loop. + environments + module-system + ensures-loaded + packages + packages-internal))) ; package-for-syntax + (link-reified-system (append (desirable-structures) + structures-to-open) + '(build initial) + ;; The expression that evaluates to the + ;; procedure that maps the reified-structure alist + ;; to the startup procedure: + `(start ',(map car structures-to-open)) + ;; Structures to open for evaluating that + ;; expression and the expression that + ;; evaluates to the reified-structure alist: + initial-system + for-reification + ;; scheme-level-1 + ))) + +(define (desirable-structures) + (let ((env (interaction-environment)) + (l '())) + (for-each (lambda (int) + (for-each-declaration + (lambda (name type) + (if (not (assq name l)) + (let ((s (eval name env))) + (if (structure? s) + (set! l (cons (cons name s) l)))))) + int)) + (list low-structures-interface + run-time-structures-interface + features-structures-interface + run-time-internals-structures-interface + compiler-structures-interface + initial-structures-interface)) + (reverse l))) + + +; Your choice of evaluators: + +(define scheme (make-scheme environments evaluation)) +; (define scheme (make-scheme mini-environments mini-eval)) +; (define scheme (make-scheme environments run)) +; etc. + +; Your choice of command processors. + +(define initial-system + (make-initial-system scheme (make-mini-command scheme))) diff --git a/build/load-linker.exec b/build/load-linker.exec new file mode 100644 index 0000000..4c56a28 --- /dev/null +++ b/build/load-linker.exec @@ -0,0 +1,88 @@ +; Load the linker. -*- Mode: Scheme; -*- + +; Run this script with ,exec ,load l.exec. +; After the script is loaded, you can, in principle, do whatever +; you might do in the usual linker image. For example, you might do +; (this is from the Makefile) +; +; ,in link-config +; (load-configuration "interfaces.scm") +; (load-configuration "packages.scm") +; (flatload initial-structures) +; (load "initial.scm") +; (link-initial-system) +; +; This is intended to be used to debug new versions of the compiler or +; static linker. + +(config '(run (define :arguments :values))) ;temporary hack + +(translate "=scheme48/" "./") + +(load-package 'flatloading) +(open 'flatloading) + +(define (r x) (config `(run ,x))) + +(r '(define-structure source-file-names (export (%file-name% :syntax)) + (open scheme-level-1 + syntactic + fluids) + (begin (define-syntax %file-name% + (syntax-rules () + ((%file-name%) (fluid $source-file-name))))))) + +(r '(define-structure enumerated enumerated-interface + (open scheme-level-1 signals) + (files (rts defenum scm)))) + +(r '(define-structure architecture architecture-interface + (open scheme-level-1 signals enumerated) + (files (rts arch)))) + +(config '(structure reflective-tower-maker + (export-reflective-tower-maker))) + +; Make the new linker obtain its table, record, etc. structures from +; the currently running Scheme. + +(config '(load "packages.scm")) +(config '(structure %run-time-structures run-time-structures-interface)) +(config '(structure %features-structures features-structures-interface)) + +(r + '(define-structure %linker-structures + (make-linker-structures %run-time-structures + %features-structures + (make-compiler-structures %run-time-structures + %features-structures)))) + +; Load the linker's interface and structure definitions. +(config '(load "interfaces.scm" "more-interfaces.scm")) +(let ((z (config '(run %linker-structures))) + (env (config interaction-environment))) + (config (lambda () (flatload z env)))) + +; Load the linker. +(load-package 'link-config) + +; Initialize +(in 'link-config + '(open scheme packages packages-internal + reflective-tower-maker)) + +(in 'linker '(run (set! *debug-linker?* #t))) +(in 'link-config '(open flatloading)) ; A different one. + +; ,open debuginfo packages-internal compiler scan syntactic meta-types + +; (in 'link-config '(dump "l.image")) + +; ,exec (usual-stuff) + +(define (usual-stuff) + (in 'link-config) + (run '(begin (load-configuration "interfaces.scm") + (load-configuration "packages.scm") + (flatload initial-structures))) + (load "initial.scm")) diff --git a/build/lucid-script.lisp b/build/lucid-script.lisp new file mode 100644 index 0000000..0f142cf --- /dev/null +++ b/build/lucid-script.lisp @@ -0,0 +1,82 @@ + +; Script to load the Scheme 48 linker into Common Lisp. +; Requires Pseudoscheme 2.11. + +(defvar pseudoscheme-directory "../pseudo/") +(load (concatenate 'string pseudoscheme-directory "loadit.lisp")) +; or perhaps (load (merge-pathnames "loadit.lisp" pseudoscheme-directory)) +(load-pseudoscheme pseudoscheme-directory) + +(progn (revised^4-scheme::define-sharp-macro #\. + #'(lambda (c port) + (read-char port) + (eval (let ((*readtable* ps::scheme-readtable)) + (read port))))) + (values)) + +(ps:scheme) +;-------------------- +; Scheme forms + +(benchmark-mode) + +(define config-env ; (interaction-environment) would also work here. + (#.'scheme-translator:make-program-env + '%config + (list #.'scheme-translator:revised^4-scheme-structure))) + +(load "bcomp/module-language" config-env) +(load "alt/config" config-env) +(load "env/flatload" config-env) +(eval '(set! *load-file-type* #f) config-env) + +(define load-config + (let ((load-config (eval 'load-configuration config-env))) + (lambda (filename) + (load-config filename config-env)))) + +(load-config "packages") + +(define flatload-package (eval 'flatload config-env)) + +(flatload-package (eval 'linker-structures config-env) config-env) + +(let ((#.'clever-load:*compile-if-necessary-p* #t)) + (let ((#.'ps:*scheme-read* #.'#'ps::scheme-read-using-commonlisp-reader)) + (load "alt/pseudoscheme-record") + (load "alt/pseudoscheme-features"))) + +(let ((#.'clever-load:*compile-if-necessary-p* #t)) + (flatload-package (eval 'link-config config-env))) + +(load "alt/init-defpackage.scm") + +(define-syntax struct-list ;not in link.sbin + (syntax-rules () + ((struct-list ?name ...) (list (cons '?name ?name) ...)))) + +;-------------------- +(quit) + +#+Lucid +(defun disksave-restart-function () + (format t "~&Scheme 48 linker.~2%") + ;; (hax:init-interrupt-delivery) - for threads + (ps:scheme) + (terpri)) +#+Lucid +(defun dump-linker () + (lcl:disksave "link/linker-in-lucid" :gc t :full-gc t :verbose t + :restart-function #'disksave-restart-function)) +;(dump-linker) +;(lcl:quit) + + +; Debugging hacks +;(defun enable-lisp-packages () +; (setq *readtable* ps:scheme-readtable) +; (values)) +;(defun disable-lisp-packages () +; (setq *readtable* ps::roadblock-readtable) +; (values)) + diff --git a/build/minor-version-number b/build/minor-version-number new file mode 100644 index 0000000..0bf307b --- /dev/null +++ b/build/minor-version-number @@ -0,0 +1 @@ +52.2 diff --git a/c/event.h b/c/event.h new file mode 100644 index 0000000..f262c2a --- /dev/null +++ b/c/event.h @@ -0,0 +1,19 @@ +enum event_enum { KEYBOARD_INTERRUPT_EVENT, IO_COMPLETION_EVENT, ALARM_EVENT, + ERROR_EVENT, NO_EVENT }; +extern int get_next_event(long *ready_fd, long *status); + +extern bool add_pending_fd(int fd, bool is_input); +extern bool remove_fd(int fd); +extern long schedule_alarm_interrupt(long delta); +extern long run_time(long *mseconds); +extern long real_time(long *mseconds); +extern int wait_for_event(long max_wait, bool is_minutes); + + +/* these are here only for the CHEAP_TIME() macro */ +#define TICKS_PER_SECOND 1000 /* clock resolution */ +#define POLLS_PER_SECOND 20 /* how often we poll */ +#define TICKS_PER_POLL (TICKS_PER_SECOND / POLLS_PER_SECOND) + +extern long current_time; +#define CHEAP_TIME() (current_time * TICKS_PER_POLL) diff --git a/c/extension.c b/c/extension.c new file mode 100644 index 0000000..da968ea --- /dev/null +++ b/c/extension.c @@ -0,0 +1,715 @@ +/*Copyright 1993, 1994 Richard Kelsey and Jonathan Rees. See file COPYING.*/ + + +/* Implementation of the vm-extension opcode. This is completely + optional; nothing in the standard system uses these features. + If you have ANSI C but not POSIX support, try compiling with -DPOSIX=0. + + fdopen: POSIX.1 + getenv: POSIX.1, ANSI C + setuid, setgid: POSIX.1 + popen: POSIX.2 + floating point: POSIX.1, ANSI C (should we be linking with -lM or -lm?) + sprintf: POSIX.1, ANSI C + atof: POSIX.1, ANSI C + chroot: not standard + + */ + +#ifndef POSIX +# define POSIX 2 +#endif + +#include +#include "sysdep.h" +#include "kali.h" /* Kali change */ +#include "socket.h" + +#include +#include +#include +#include +#include /* setuid & setgid */ +#include +#include /* gethostbyname */ /* Kali code */ +#include /* ctime */ /* Kali code */ + +#include +#include + +#if 1 /* Kali hack for non-blocking output (HCC) */ +#include +#endif /* Kali hack for non-blocking output (HCC) */ + + +#define GREATEST_FIXNUM_VALUE ((1 << 29) - 1) +#define LEAST_FIXNUM_VALUE (-1 << 29) +#define CHANNEL_INDEX(x) EXTRACT_FIXNUM(STOB_REF(x, 1)) +#define FOR_INPUT 1 +#define FOR_OUTPUT 2 + +typedef struct { + char b[sizeof(double)]; +} unaligned_double; + +typedef union { + double f; + unaligned_double b; +} float_or_bytes; + +extern long Sextension_valueS; /* how values are returned */ + +/* return status values */ +#define EXT_ST_OKAY 0 +#define EXT_ST_EXCEPTION 1 + +#define EXT_RETURN(value) {Sextension_valueS = (value); return EXT_ST_OKAY; } +#define EXT_EXCEPTION return EXT_ST_EXCEPTION + +/******************************************/ + +scheme_value +extended_vm (long key, scheme_value value) +{ + double x, y; + + switch (key) { + + /* Cases 0 through 19 are reserved for the mobot system. */ + + case 0: /* read jumpers on 68000 board */ + EXT_RETURN(ENTER_FIXNUM(0)); + +#if defined(HAVE_SOCKET) + case 20: + { extern int internet_stream_socket(); + int s = internet_stream_socket(); + if (s < 0) + EXT_EXCEPTION; + else + EXT_RETURN(ENTER_FIXNUM(s)); + } + + case 21: + { extern int socket_bind(int, int); + int sock, port; + + if (!PAIRP(value) || !FIXNUMP(CAR(value)) || !FIXNUMP(CDR(value))) + EXT_EXCEPTION; + sock = EXTRACT_FIXNUM(CAR(value)); + port = EXTRACT_FIXNUM(CDR(value)); + port = socket_bind(sock, port); + if (port < 0) + EXT_EXCEPTION; + else + EXT_RETURN(ENTER_FIXNUM(port)); + } + + case 22: + { extern int socket_accept(int); + int sock, fd; + + if (!FIXNUMP(value)) + EXT_EXCEPTION; + + sock = EXTRACT_FIXNUM(value); + + if (sock < 0) + EXT_EXCEPTION; + fd = socket_accept(sock); + if (fd >= 0) + EXT_RETURN(ENTER_FIXNUM(fd)) + else if (fd == -2) + EXT_RETURN(ENTER_FIXNUM(-1)) + else + EXT_EXCEPTION; + } + + case 23: { + int sock; + char *mach; + int port, + res; + + if (! (PAIRP(value) && FIXNUMP(CAR(value)) + && PAIRP(CDR(value)) && STRINGP(CAR(CDR(value))) + && FIXNUMP(CDR(CDR(value))))) + EXT_EXCEPTION; + sock = EXTRACT_FIXNUM(CAR(value)); + mach = &STRING_REF(CAR(CDR(value)), 0); + port = EXTRACT_FIXNUM(CDR(CDR(value))); + res = socket_connect(sock, mach, port); + if (res >= 0) + EXT_RETURN(ENTER_FIXNUM(res)) + else if (res == -2) + EXT_RETURN(ENTER_FIXNUM(-1)) + else + EXT_EXCEPTION; + } + +#endif + + /* getenv() */ + case 26: { + scheme_value env_var, result_buffer; + char *result; + size_t result_len; + + if (!PAIRP(value)) EXT_EXCEPTION; + env_var = CAR(value); + result_buffer = CDR(value); + if (!STRINGP(env_var) || !STRINGP(result_buffer)) EXT_EXCEPTION; + result = getenv(&STRING_REF(env_var, 0)); + if (result == NULL) + EXT_RETURN(SCHFALSE); + result_len = strlen(result); + if (result_len > STRING_LENGTH(result_buffer)) + EXT_EXCEPTION; + strncpy(&STRING_REF(result_buffer, 0), result, result_len); + EXT_RETURN(ENTER_FIXNUM(result_len)); + } + +#if POSIX + case 27: { + /* This is intended for use by HTTP scripts... */ + if (!PAIRP(value) || !FIXNUMP(CAR(value)) || !FIXNUMP(CDR(value))) + EXT_EXCEPTION; + if (setgid(EXTRACT_FIXNUM(CDR(value))) != 0) { + perror("setgid"); + EXT_RETURN(SCHFALSE); } + if (setuid(EXTRACT_FIXNUM(CAR(value))) != 0) { + perror("setuid"); + EXT_RETURN(SCHFALSE); } + else + EXT_RETURN(SCHTRUE); + } +#endif + +#if defined(HAVE_CHROOT) + case 28: { + if (!STRINGP(value)) + EXT_EXCEPTION; + else if (chroot(&STRING_REF(value, 0)) != 0) { + perror("chroot"); + EXT_RETURN(SCHFALSE); } + else + EXT_RETURN(SCHTRUE); + } +#endif + + /* dup() support */ + case 29: + { long fd = dup(EXTRACT_FIXNUM(value)); + if (fd < 0) + EXT_EXCEPTION; + else + EXT_RETURN(ENTER_FIXNUM(fd)); + } + + /* extract file descriptor from channel */ + case 30: + { int fd; + + if (!FIXNUMP(value)) + EXT_EXCEPTION; + + fd = EXTRACT_FIXNUM(value); + + if (fd < 0) + EXT_EXCEPTION; + else + EXT_RETURN(ENTER_FIXNUM(fd)); + } + + /* Begin Kali code */ + case 31: + { + int status; + + if (!STRINGP(value)) + EXT_EXCEPTION; + + status = gethostname(&STRING_REF(value, 0), STRING_LENGTH(value)); + + if (status != 0) + EXT_EXCEPTION; + else + EXT_RETURN(ENTER_FIXNUM(strlen(&STRING_REF(value, 0)))); + } + + case 32: + { + int i; + struct hostent *hostdata; + + if (!STRINGP(value)) + EXT_EXCEPTION; + + hostdata = gethostbyname(&STRING_REF(value, 0)); + if (hostdata == NULL) { + fprintf(stderr, "gethostbyname() failed on %s: ", &STRING_REF(value, 0)); + herror(""); + fprintf(stderr, "\n"); + EXT_EXCEPTION; }; + + if (hostdata->h_length > STRING_LENGTH(value)) { + fprintf(stderr, "buffer for gethostbyname() is too small\n"); + EXT_EXCEPTION; }; + + for(i = 0; i < hostdata->h_length; i++) + STRING_REF(value, i) = hostdata->h_addr_list[0][i]; + + EXT_RETURN(ENTER_FIXNUM(hostdata->h_length)); + } + + case 33: + { + int i, len, status; + time_t the_time; + char *time_string; + + if (!STRINGP(value)) + EXT_EXCEPTION; + + status = time(&the_time); + + if (status == -1) { + fprintf(stderr, "time() failed"); + herror(""); + fprintf(stderr, "\n"); + EXT_EXCEPTION; }; + + time_string = ctime(&the_time); + + len = strlen(time_string) - 1; /* drop the newline */ + + if (len > STRING_LENGTH(value)) + len = STRING_LENGTH(value); + + for (i = 0; i < len; i++) + STRING_REF(value, i) = time_string[i]; + + EXT_RETURN(ENTER_FIXNUM(len)); + } + + /* End Kali code */ + + /* system() is supposedly POSIX.2 and ANSI C */ + +#if POSIX >= 2 + case 96: { + int status; + if (!STRINGP(value)) + EXT_EXCEPTION; + status = system(&STRING_REF(value, 0)); + if (status == -1) { + perror("chroot"); + EXT_EXCEPTION; } + else + EXT_RETURN(ENTER_FIXNUM(status)); /* cf. waitpid() */ + } +#endif /* POSIX.2 */ + + + /* Floating point */ + +#define FLOP 100 +#define FLOP2(i) case FLOP+(i): \ + if (!STOBP(value) || STOB_LLENGTH(value) != 2) \ + EXT_EXCEPTION; +#define FLOP3(i) case FLOP+(i): \ + if (!STOBP(value) || STOB_LLENGTH(value) != 3) \ + EXT_EXCEPTION; + +#define get_arg(args,i) STOB_REF(args,(i)) +#define get_string_arg(args,i) (&STRING_REF(get_arg(args,i), 0)) + +#define get_float_arg(args, i, var) EXTRACT_FLOAT(get_arg(args, i), var) +#define set_float_arg(args, i, val) SET_FLOAT(get_arg(args, i), val) + +#define EXTRACT_FLOAT(stob, var) \ + { scheme_value temp_ = (stob); \ + float_or_bytes loser_; \ + if (!STOBP(temp_)) EXT_EXCEPTION; \ + loser_.b = *(unaligned_double*)(&STOB_REF(temp_, 0)); \ + (var) = loser_.f; } + +#define SET_FLOAT(stob, val) \ + { scheme_value temp_ = (stob); \ + float_or_bytes loser_; \ + if (!STOBP(temp_)) EXT_EXCEPTION; \ + loser_.f = (double)(val); \ + *(unaligned_double*)(&STOB_REF(temp_, 0)) = loser_.b; } + + FLOP3(0) { + get_float_arg(value, 0, x); + get_float_arg(value, 1, y); + set_float_arg(value, 2, x + y); + EXT_RETURN(UNSPECIFIC);} + FLOP3(1) { + get_float_arg(value, 0, x); + get_float_arg(value, 1, y); + set_float_arg(value, 2, x - y); + EXT_RETURN(UNSPECIFIC);} + FLOP3(2) { + get_float_arg(value, 0, x); + get_float_arg(value, 1, y); + set_float_arg(value, 2, x * y); + EXT_RETURN(UNSPECIFIC);} + FLOP3(3) { + get_float_arg(value, 0, x); + get_float_arg(value, 1, y); + if (y == 0.0) EXT_EXCEPTION; + set_float_arg(value, 2, x / y); + EXT_RETURN(UNSPECIFIC);} + FLOP2(4) { + get_float_arg(value, 0, x); + get_float_arg(value, 1, y); + EXT_RETURN(ENTER_BOOLEAN(x == y));} + FLOP2(5) { + get_float_arg(value, 0, x); + get_float_arg(value, 1, y); + EXT_RETURN(ENTER_BOOLEAN(x < y));} + FLOP2(6) { /* fixnum->float */ + scheme_value arg = get_arg(value, 0); + if (!FIXNUMP(arg)) EXT_RETURN(SCHFALSE); + set_float_arg(value, 1, EXTRACT_FIXNUM(arg)); + EXT_RETURN(SCHTRUE);} + FLOP2(7) { /* string->float */ + char *str = get_string_arg(value, 0); + set_float_arg(value, 1, atof(str)); + EXT_RETURN(UNSPECIFIC);} + FLOP2(8) { /* float->string */ + size_t len; + char *str = get_string_arg(value,1); + get_float_arg(value, 0, x); + sprintf(str, "%g", x); + len = strlen(str); + if (len > STRING_LENGTH(get_arg(value,1))) + /* unlikely but catastrophic */ + fprintf(stderr, "printing float: output too long: %s\n", + str); + EXT_RETURN(ENTER_FIXNUM(len));} + + /* exp log sin cos tan asin acos atan sqrt */ + + FLOP2(9) { + get_float_arg(value, 0, x); + set_float_arg(value, 1, exp(x)); + EXT_RETURN(UNSPECIFIC);} + FLOP2(10) { + get_float_arg(value, 0, x); + set_float_arg(value, 1, log(x)); + EXT_RETURN(UNSPECIFIC);} + FLOP2(11) { + get_float_arg(value, 0, x); + set_float_arg(value, 1, sin(x)); + EXT_RETURN(UNSPECIFIC);} + FLOP2(12) { + get_float_arg(value, 0, x); + set_float_arg(value, 1, cos(x)); + EXT_RETURN(UNSPECIFIC);} + FLOP2(13) { + get_float_arg(value, 0, x); + set_float_arg(value, 1, tan(x)); + EXT_RETURN(UNSPECIFIC);} + FLOP2(14) { + get_float_arg(value, 0, x); + set_float_arg(value, 1, asin(x)); + EXT_RETURN(UNSPECIFIC);} + FLOP2(15) { + get_float_arg(value, 0, x); + set_float_arg(value, 1, acos(x)); + EXT_RETURN(UNSPECIFIC);} + FLOP3(16) { /* atan */ + get_float_arg(value, 0, y); + get_float_arg(value, 1, x); + set_float_arg(value, 2, atan2(y, x)); + EXT_RETURN(UNSPECIFIC);} + FLOP2(17) { + get_float_arg(value, 0, x); + set_float_arg(value, 1, sqrt(x)); + EXT_RETURN(UNSPECIFIC);} + + FLOP2(18) { /* floor */ + get_float_arg(value, 0, x); + set_float_arg(value, 1, floor(x)); + EXT_RETURN(UNSPECIFIC);} + case FLOP+19: { /* integer? */ + EXTRACT_FLOAT(value, x); + EXT_RETURN(ENTER_BOOLEAN(fmod(x, 1.0) == 0.0)); } + case FLOP+20: { /* float->fixnum */ + EXTRACT_FLOAT(value, x); + if (x <= (double)GREATEST_FIXNUM_VALUE + && x >= (double)LEAST_FIXNUM_VALUE) + { + EXT_RETURN(ENTER_FIXNUM((long)x)); } + else + EXT_RETURN(SCHFALSE);} + FLOP3(21) { /* quotient */ + double z; + get_float_arg(value, 0, x); + get_float_arg(value, 1, y); + if (fmod(x, 1.0) != 0.0 || fmod(y, 1.0) != 0.0) EXT_EXCEPTION; + if (y == 0.0) EXT_EXCEPTION; + z = x / y; + set_float_arg(value, 2, z < 0.0 ? ceil(z) : floor(z)); + EXT_RETURN(UNSPECIFIC);} + FLOP3(22) { /* remainder */ + get_float_arg(value, 0, x); + get_float_arg(value, 1, y); + if (fmod(x, 1.0) != 0.0 || fmod(y, 1.0) != 0.0) EXT_EXCEPTION; + if (y == 0.0) EXT_EXCEPTION; + + /* "fmod(double x, double y) returns the floating-point remainder + (f) of the division of x by y, where f has the same sign as x, + such that x=iy+f for some integer i, and |f| < |y|." */ + + set_float_arg(value, 2, fmod(x, y)); + EXT_RETURN(UNSPECIFIC);} + +#if 1 /* Kali hack for non-blocking output (HCC) */ + case 214: /* make file descriptor non-blocking */ + { + int fd; + + if (! FIXNUMP(value)) + EXT_EXCEPTION; + fd = EXTRACT_FIXNUM(value); + if (fd < 0) + EXT_EXCEPTION; + if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) + EXT_EXCEPTION; + EXT_RETURN(UNSPECIFIC); + } +#endif /* Kali hack for non-blocking output (HCC) */ + +#if 1 /* Kali hack for TCP_NODELAY extension on sockets (HCC) */ + + /* + * Given a file descriptor (which must be associated to a TCP/IP + * socket) and a flag, set the TCP_NODELAY attribute to the flag + * (i.e., nodelay unless the flag is #F). + */ + case 300: + { + int fd, + nodelay; + + if ((! PAIRP(value)) + || (! FIXNUMP(CAR(value)))) + EXT_EXCEPTION; + fd = EXTRACT_FIXNUM(CAR(value)); + nodelay = EXTRACT_BOOLEAN(CDR(value)); + if (! socket_nodelay(fd, nodelay)) + EXT_EXCEPTION; + EXT_RETURN (UNSPECIFIC); + } + +#endif /* Kali hack for TCP_NODELAY extension on sockets (HCC) */ + + default: + EXT_EXCEPTION; + } +} + + +/* -------------------------------------------------- + Entry points intended for use with (external-call ...). + The actual arguments are argv[n-1], argv[n-2], ..., argv[0]. + For Unix system calls, a return value of #f means success, #t means + invalid argument, and integer means Unixoid error. + + Missing, among others: + chdir chmod mkdir rmdir stat fstat link unlink seek tell getpid getppid + environ + */ + +/* (let ((results (cons 0 0))) + (let ((errno (external-call s48-pipe results))) + (if errno + (error ... errno) + (values (car results) (cdr results))))) */ + +scheme_value s48_pipe(long argc, scheme_value *argv) +{ + int fd[2]; + scheme_value result; + + if (argc != 1) return SCHTRUE; + result = argv[0]; + if (!PAIRP(result)) return SCHTRUE; + + if (pipe(&fd[0]) == -1) return ENTER_FIXNUM(errno); + + CAR(result) = ENTER_FIXNUM(fd[0]); + CDR(result) = ENTER_FIXNUM(fd[1]); + return SCHFALSE; +} + +/* (let* ((results (cons 0 0)) + (errno (external-call s48-waitpid results pid options))) + (if errno + (interpret-syscall-error errno) + (values (car results) (cdr results)))) */ + +scheme_value s48_waitpid(long argc, scheme_value *argv) +{ + int pid, status; + scheme_value result, pidf, optf; + + if (argc != 3) return SCHTRUE; + result = argv[2]; + pidf = argv[1]; + optf = argv[0]; + if (!PAIRP(result) || !FIXNUMP(pidf) || !FIXNUMP(optf)) + return SCHTRUE; + + if ((pid = waitpid(EXTRACT_FIXNUM(pidf), + &status, + EXTRACT_FIXNUM(optf))) + == -1) + return ENTER_FIXNUM(errno); + + CAR(result) = ENTER_FIXNUM(pid); + CDR(result) = ENTER_FIXNUM(status); + return SCHFALSE; +} + +/* (let ((results (cons 0 0))) + (let ((errno (external-call s48-fork results))) + (if errno + (decode-syscall-error errno) + (car results)))) ;child pid or zero */ + +scheme_value s48_fork(long argc, scheme_value *argv) +{ + int pid; + scheme_value result; + + if (argc != 1) return SCHTRUE; + result = argv[0]; + if (!PAIRP(result)) return SCHTRUE; + + if ((pid = fork()) == -1) + return ENTER_FIXNUM(errno); + + CAR(result) = ENTER_FIXNUM(pid); + return SCHFALSE; +} + +/* exit(status) */ +scheme_value s48_exit(long argc, scheme_value *argv) +{ + exit(EXTRACT_FIXNUM(argv[0])); +} + +/* close(fd) */ +scheme_value s48_close(long argc, scheme_value *argv) +{ + scheme_value fd; + + if (argc != 1) return SCHTRUE; + fd = argv[0]; + if (!FIXNUMP(fd)) return SCHTRUE; + + if (close(EXTRACT_FIXNUM(fd)) == -1) + return ENTER_FIXNUM(errno); + + return SCHFALSE; +} + +/* dup(fd) -> result */ +scheme_value s48_dup(long argc, scheme_value *argv) +{ + scheme_value result, fd; + int new; + + if (argc != 2) return SCHTRUE; + result = argv[1]; + fd = argv[0]; + if (!FIXNUMP(fd) || !PAIRP(result)) return SCHTRUE; + + if ((new = dup(EXTRACT_FIXNUM(fd))) == -1) + return ENTER_FIXNUM(errno); + + CAR(result) = ENTER_FIXNUM(new); + return SCHFALSE; +} + +/* kill(pid, sig) */ +scheme_value s48_kill(long argc, scheme_value *argv) +{ + scheme_value pid, sig; + + if (argc != 2) return SCHTRUE; + pid = argv[1]; + sig = argv[0]; + if (!FIXNUMP(pid) || !FIXNUMP(sig)) return SCHTRUE; + + if (kill(EXTRACT_FIXNUM(pid), EXTRACT_FIXNUM(sig)) == -1) + return ENTER_FIXNUM(errno); + + return SCHFALSE; +} + + +/* dup(fd) */ + +/* execv(path, argv) */ +scheme_value s48_execv(long argc, scheme_value *argv) +{ + scheme_value prog, arg_vec, result; + int unix_argc; + char **unix_argv; + + if (argc != 2) return SCHTRUE; + prog = argv[1]; + arg_vec = argv[0]; + if (!STRINGP(prog) || !VECTORP(arg_vec)) return SCHTRUE; + unix_argc = VECTOR_LENGTH(arg_vec); + + unix_argv = malloc((argc+1) * sizeof(char *)); + + { int i; + for(i = 0; i < unix_argc; i++) { + scheme_value arg = VECTOR_REF(arg_vec, i); + if (!STRINGP(arg)) return SCHFALSE; + unix_argv[i] = &STRING_REF(arg, 0); + } + unix_argv[i] = (char *)0; + } + + if (execv(&STRING_REF(prog, 0), unix_argv) == -1) + result = ENTER_FIXNUM(errno); + result = SCHFALSE; + free(unix_argv); + return result; +} + + + +/* (let ((s (make-string 100))) + (substring s 0 (or (external-call s48_strerror s errno) + (error "?")))) + */ + +scheme_value s48_strerror(long argc, scheme_value *argv) +{ + scheme_value result, err; + int result_len; + char *err_string; + + if (argc != 2) return SCHFALSE; + result = argv[1]; + err = argv[0]; + if (!STRINGP(result) || !FIXNUMP(err)) return SCHFALSE; + + err_string = strerror(EXTRACT_FIXNUM(err)); + result_len = strlen(err_string); + if (result_len > STRING_LENGTH(result)) + return SCHFALSE; + strncpy(&STRING_REF(result, 0), err_string, result_len); + + return ENTER_FIXNUM(result_len); +} diff --git a/c/fake/sigact.h b/c/fake/sigact.h new file mode 100644 index 0000000..e12edcb --- /dev/null +++ b/c/fake/sigact.h @@ -0,0 +1,15 @@ +/* + * If we don't have sigaction, we fake it using signal. + */ +#if ! defined(HAVE_SIGACTION) + +struct sigaction { + void (*sa_handler)(); + int sa_mask; + int sa_flags; +}; + +#define sigaction(sig, act, oact) signal((sig), (act)->sa_handler) +#define sigemptyset(ign) 0 + +#endif diff --git a/c/fake/strerror.c b/c/fake/strerror.c new file mode 100644 index 0000000..fe1ec7e --- /dev/null +++ b/c/fake/strerror.c @@ -0,0 +1,22 @@ +/* + * If the system doesn't have a strerror procedure, we provide our own. + * Note, this depends on sys_nerr and sys_errlist being provided. + * If your system doesn't provide that either, you can replace this + * procedure with one that always returns "Unknown error". + */ +#include "sysdep.h" + + +extern int sys_nerr; +extern char *sys_errlist[]; + + +char * +strerror(int errnum) +{ + if ((0 <= errnum) + && (errnum < sys_nerr)) + return (sys_errlist[errnum]); + else + return ("Unknown error"); +} diff --git a/c/fake/strerror.h b/c/fake/strerror.h new file mode 100644 index 0000000..670e683 --- /dev/null +++ b/c/fake/strerror.h @@ -0,0 +1,8 @@ +/* + * If we don't have strerror(), we fake it using sys_nerr and sys_errlist. + */ +#if ! defined(HAVE_STRERROR) + +extern char *strerror(int errnum); + +#endif diff --git a/c/fake/sys-select.h b/c/fake/sys-select.h new file mode 100644 index 0000000..d5dc08c --- /dev/null +++ b/c/fake/sys-select.h @@ -0,0 +1,9 @@ +/* + * If we have a sys/select.h, then include it. + */ +#if defined(HAVE_SYS_SELECT_H) + +#include +#include + +#endif diff --git a/c/fd-io.h b/c/fd-io.h new file mode 100644 index 0000000..19255c0 --- /dev/null +++ b/c/fd-io.h @@ -0,0 +1,16 @@ + +#define STDIN_FD() 0 +#define STDOUT_FD() 1 +#define STDERR_FD() 2 + +extern int ps_open_fd(char *in_filename, bool is_input, long *status); + +extern int ps_close_fd(long fd_as_long); + +extern long ps_read_fd(long fd_as_long, char *buf_as_long, long max, bool waitp, + bool *eofp, bool *pending, long *status); + +extern long ps_write_fd(long fd_as_long, char *buf_as_long, long max, + bool *pending, long *status); + +extern long ps_abort_fd_op(long fd_as_long); diff --git a/c/io.h b/c/io.h new file mode 100644 index 0000000..8357210 --- /dev/null +++ b/c/io.h @@ -0,0 +1,12 @@ +extern FILE *ps_open_input_file(char *, long *); +extern FILE *ps_open_output_file(char *, long *); +extern long ps_close(FILE *); +extern char ps_read_char(FILE *, char *, long *, char); +extern long ps_read_integer(FILE *, char *, long *); +extern long ps_write_char(char, FILE *); +extern long ps_write_integer(long, FILE *); +extern long ps_write_string(char *, FILE *); +extern long ps_read_block(FILE *, char *, long, char *, long *); +extern long ps_write_block(FILE *, char *, long); +extern char *ps_error_string(long); +extern void ps_error(char *, long count, ...); diff --git a/c/kali.h b/c/kali.h new file mode 100644 index 0000000..dc9051a --- /dev/null +++ b/c/kali.h @@ -0,0 +1,129 @@ +typedef long scheme_value; + +#define FIXNUM_TAG 0 +#define FIXNUMP(x) (((long)(x) & 3L) == FIXNUM_TAG) +#define IMMEDIATE_TAG 1 +#define IMMEDIATEP(x) (((long)(x) & 3L) == IMMEDIATE_TAG) +#define HEADER_TAG 2 +#define HEADERP(x) (((long)(x) & 3L) == HEADER_TAG) +#define STOB_TAG 3 +#define STOBP(x) (((long)(x) & 3L) == STOB_TAG) + +#define ENTER_FIXNUM(n) ((scheme_value)((n) << 2)) +#define EXTRACT_FIXNUM(x) ((long)(x) >> 2) + +#define MISC_IMMEDIATE(n) (scheme_value)(IMMEDIATE_TAG | ((n) << 2)) +#define SCHFALSE MISC_IMMEDIATE(0) +#define SCHTRUE MISC_IMMEDIATE(1) +#define SCHCHAR MISC_IMMEDIATE(2) +#define SCHUNSPECIFIC MISC_IMMEDIATE(3) +#define SCHUNDEFINED MISC_IMMEDIATE(4) +#define SCHEOF MISC_IMMEDIATE(5) +#define SCHNULL MISC_IMMEDIATE(6) +#define UNDEFINED SCHUNDEFINED +#define UNSPECIFIC SCHUNSPECIFIC + +#define ENTER_BOOLEAN(n) ((n) ? SCHTRUE : SCHFALSE) +#define EXTRACT_BOOLEAN(x) ((x) != SCHFALSE) + +#define ENTER_CHAR(c) (SCHCHAR | ((c) << 8)) +#define EXTRACT_CHAR(x) ((x) >> 8) +#define CHARP(x) ((((long) (x)) & 0xff) == SCHCHAR) + +#define ADDRESS_AFTER_HEADER(x, type) ((type *)((x) - STOB_TAG)) +#define STOB_REF(x, i) ((ADDRESS_AFTER_HEADER(x, long))[i]) +#define STOB_TYPE(x) ((STOB_HEADER(x)>>2)&31) +#define STOB_HEADER(x) (STOB_REF((x),-1)) +#define STOB_BLENGTH(x) (STOB_HEADER(x) >> 8) +#define STOB_LLENGTH(x) (STOB_HEADER(x) >> 10) + +#define STOBTYPE_PAIR 0 +#define PAIRP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_PAIR)) +#define STOBTYPE_SYMBOL 1 +#define SYMBOLP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_SYMBOL)) +#define STOBTYPE_VECTOR 2 +#define VECTORP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_VECTOR)) +#define STOBTYPE_CLOSURE 3 +#define CLOSUREP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_CLOSURE)) +#define STOBTYPE_LOCATION 4 +#define LOCATIONP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_LOCATION)) +#define STOBTYPE_CHANNEL 5 +#define CHANNELP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_CHANNEL)) +#define STOBTYPE_PORT 6 +#define PORTP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_PORT)) +#define STOBTYPE_RATNUM 7 +#define RATNUMP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_RATNUM)) +#define STOBTYPE_RECORD 8 +#define RECORDP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_RECORD)) +#define STOBTYPE_CONTINUATION 9 +#define CONTINUATIONP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_CONTINUATION)) +#define STOBTYPE_EXTENDED_NUMBER 10 +#define EXTENDED_NUMBERP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_EXTENDED_NUMBER)) +#define STOBTYPE_TEMPLATE 11 +#define TEMPLATEP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_TEMPLATE)) +#define STOBTYPE_WEAK_POINTER 12 +#define WEAK_POINTERP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_WEAK_POINTER)) +#define STOBTYPE_EXTERNAL 13 +#define EXTERNALP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_EXTERNAL)) +#define STOBTYPE_PROXY 14 +#define PROXYP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_PROXY)) +#define STOBTYPE_PROXY_DATA 15 +#define PROXY_DATAP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_PROXY_DATA)) +#define STOBTYPE_ADDRESS_SPACE 16 +#define ADDRESS_SPACEP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_ADDRESS_SPACE)) +#define STOBTYPE_UNUSED_D_HEADER1 17 +#define UNUSED_D_HEADER1P(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_UNUSED_D_HEADER1)) +#define STOBTYPE_UNUSED_D_HEADER2 18 +#define UNUSED_D_HEADER2P(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_UNUSED_D_HEADER2)) +#define STOBTYPE_STRING 19 +#define STRINGP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_STRING)) +#define STOBTYPE_CODE_VECTOR 20 +#define CODE_VECTORP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_CODE_VECTOR)) +#define STOBTYPE_DOUBLE 21 +#define DOUBLEP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_DOUBLE)) +#define STOBTYPE_BIGNUM 22 +#define BIGNUMP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_BIGNUM)) + +#define CAR(x) STOB_REF(x, 0) +#define CDR(x) STOB_REF(x, 1) +#define SYMBOL_UID(x) STOB_REF(x, 0) +#define SYMBOL_TO_STRING(x) STOB_REF(x, 1) +#define LOCATION_UID(x) STOB_REF(x, 0) +#define LOCATION_ID(x) STOB_REF(x, 1) +#define CONTENTS(x) STOB_REF(x, 2) +#define CLOSURE_TEMPLATE(x) STOB_REF(x, 0) +#define CLOSURE_ENV(x) STOB_REF(x, 1) +#define WEAK_POINTER_REF(x) STOB_REF(x, 0) +#define EXTERNAL_NAME(x) STOB_REF(x, 0) +#define EXTERNAL_VALUE(x) STOB_REF(x, 1) +#define EXTERNAL_UID(x) STOB_REF(x, 2) +#define PORT_HANDLER(x) STOB_REF(x, 0) +#define PORT_STATUS(x) STOB_REF(x, 1) +#define PORT_LOCK(x) STOB_REF(x, 2) +#define PORT_LOCKEDP(x) STOB_REF(x, 3) +#define PORT_DATA(x) STOB_REF(x, 4) +#define PORT_BUFFER(x) STOB_REF(x, 5) +#define PORT_INDEX(x) STOB_REF(x, 6) +#define PORT_LIMIT(x) STOB_REF(x, 7) +#define PORT_PENDING_EOFP(x) STOB_REF(x, 8) +#define CHANNEL_STATUS(x) STOB_REF(x, 0) +#define CHANNEL_ID(x) STOB_REF(x, 1) +#define CHANNEL_OS_INDEX(x) STOB_REF(x, 2) +#define PROXY_DATA(x) STOB_REF(x, 0) +#define PROXY_DATA_UID(x) STOB_REF(x, 0) +#define PROXY_DATA_OWNER(x) STOB_REF(x, 1) +#define PROXY_DATA_VALUE(x) STOB_REF(x, 2) +#define PROXY_DATA_REFERENCE_COUNT(x) STOB_REF(x, 3) +#define PROXY_DATA_SELF(x) STOB_REF(x, 4) +#define PROXY_DATA_WAITERS(x) STOB_REF(x, 5) +#define ADDRESS_SPACE_UID(x) STOB_REF(x, 0) +#define ADDRESS_SPACE_DECODE_VECTOR(x) STOB_REF(x, 1) +#define ADDRESS_SPACE_PROXY_VECTOR(x) STOB_REF(x, 2) +#define ADDRESS_SPACE_DATA(x) STOB_REF(x, 3) + +#define VECTOR_LENGTH(x) STOB_LLENGTH(x) +#define VECTOR_REF(x, i) STOB_REF(x, i) +#define CODE_VECTOR_LENGTH(x) STOB_BLENGTH(x) +#define CODE_VECTOR_REF(x, i) (ADDRESS_AFTER_HEADER(x, unsigned char)[i]) +#define STRING_LENGTH(x) (STOB_BLENGTH(x)-1) +#define STRING_REF(x, i) (ADDRESS_AFTER_HEADER(x, char)[i]) diff --git a/c/main.c b/c/main.c new file mode 100644 index 0000000..6fb9d44 --- /dev/null +++ b/c/main.c @@ -0,0 +1,174 @@ +/* Copyright (c) 1993, 1994 Richard Kelsey and Jonathan Rees. + See file COPYING. */ + +#include +#include +#include + +#if !defined(DEFAULT_HEAP_SIZE) +/* 2 mega cells = 8 megabytes (4 per semispace), enlarged for Kali */ +#define DEFAULT_HEAP_SIZE 2000000L +#endif + +#if !defined(DEFAULT_STACK_SIZE) +/* 2500 cells = 10000 bytes */ +#define DEFAULT_STACK_SIZE 2500L +#endif + +#if defined(STATIC_AREAS) +#define DEFAULT_IMAGE_NAME NULL +#else + +/* DEFAULT_IMAGE_NAME should be defined using the -D switch to cc. */ +#if !defined(DEFAULT_IMAGE_NAME) +#define DEFAULT_IMAGE_NAME "scheme48.image" +#endif + +#endif /* STATIC_AREAS */ + + +char *object_file; /* specified via a command line argument */ +char *reloc_file; /* dynamic loading will set this */ + + +extern void scheme48_init(void); +extern void sysdep_init(void); +extern void s48_heap_init(void); +extern long required_init_space(unsigned char **, long); +extern void initialize_heap(long, long); +extern void initialize_vm(long, long); +extern long call_startup_procedure(long, char **, long); +extern long check_image_header(unsigned char *); +extern long read_image(long); +extern void register_static_areas(unsigned char, long *, long *, unsigned char, long *, long *); + +int +main(argc, argv) + int argc; char **argv; +{ + char *image_name = DEFAULT_IMAGE_NAME; + long heap_size = DEFAULT_HEAP_SIZE; /* in numbers of cells */ + long stack_size = DEFAULT_STACK_SIZE; /* in numbers of cells */ + int errors = 0; + long return_value; + void *heap, *stack; + long required_heap_size, startup_proc; + +#if defined(STATIC_AREAS) + extern long entry; + extern long p_count, *p_areas[], p_sizes[]; + extern long i_count, *i_areas[], i_sizes[]; +#endif + + long vm_argc = 0; + char *me = *argv; /* Save program name. */ + + object_file = reloc_file = NULL; + + argv++; argc--; /* Skip program name. */ + + for (; argc > 0; argc--, argv++) + if (argv[0][0] == '-') + switch (argv[0][1]) { + case 'h': + argc--; argv++; + if (argc == 0) { errors++; break; } + heap_size = atoi(*argv); + if (heap_size <= 0) errors++; + break; + case 's': + argc--; argv++; + if (argc == 0) { errors++; break; } + stack_size = atoi(*argv); + if (stack_size <= 0) errors++; + break; + case 'i': + argc--; argv++; + if (argc == 0) { errors++; break; } + image_name = *argv; + break; + case 'a': + argc--; + vm_argc = argc; /* remaining args are passed to the VM */ + argc = 0; + break; + case 'o': + argc--; argv++; + if (argc == 0) { errors++; break; } + object_file = *argv; + break; + default: + fprintf(stderr, "Invalid argument: %s\n", *argv); + errors++; + } + else + if (argv[0][0] != '\0') + { fprintf(stderr, "Invalid argument: %s\n", *argv); + errors++; } + if (errors != 0) { + fprintf(stderr, +"Usage: %s [options] [-a arguments]\n\ +Options: -h \n\ + -s \n\ + -i \n\ + -o \n", + me); + return 1; + } + + sysdep_init(); + s48_heap_init(); + scheme48_init(); + + if (image_name == NULL) + required_heap_size = 0; + else { + /* check_image_header returns number of bytes; required_heap_size + is number of cells. */ + required_heap_size = check_image_header((unsigned char *)image_name) >> 2; + if (-1 == required_heap_size) { + fprintf(stderr, "Image file \"%s\" is unusable.\n", image_name); + return 1; } + } + + required_heap_size += required_init_space((unsigned char **)argv, vm_argc); + + /* two semi-spaces, plus we want some room to maneuver */ + if (heap_size < 4 * required_heap_size) { + fprintf(stderr, "heap size %ld is too small, using %ld\n", + heap_size, 4 * required_heap_size); + heap_size = 4 * required_heap_size; } + + heap = (void *) malloc(heap_size * sizeof(long)); + stack = (void *) malloc(stack_size * sizeof(long)); + + if (!heap || !stack) { + fprintf(stderr, "system is out of memory\n"); + return 1; } + + initialize_heap((long)heap, heap_size); + initialize_vm((long)stack, stack_size); + +#if defined(STATIC_AREAS) + if (image_name == NULL) { + register_static_areas(p_count, p_areas, p_sizes, + i_count, i_areas, i_sizes); + startup_proc = entry; + } else + startup_proc = read_image((long)0); +#else + startup_proc = read_image((long)0); +#endif + + if (startup_proc == -1) { + fprintf(stderr, "Image file \"%s\" is unusable.\n", image_name); + return 1; } + + return_value = call_startup_procedure(startup_proc, argv, vm_argc); + + if (reloc_file != NULL) + if (0 != unlink(reloc_file)) + fprintf(stderr, "unable to delete file %s\n", reloc_file); + + return(return_value); +} diff --git a/c/prescheme.h b/c/prescheme.h new file mode 100644 index 0000000..cc8bfdc --- /dev/null +++ b/c/prescheme.h @@ -0,0 +1,59 @@ +#include +#include "io.h" + +#define PS_READ_CHAR(PORT,RESULT,EOFP,STATUS) \ +{ \ + FILE * TTport = PORT; \ + int TTchar; \ + if (EOF == (TTchar = getc(TTport))) \ + RESULT = ps_read_char(TTport, &EOFP, &STATUS, 0==1);\ + else { \ + RESULT = TTchar; \ + EOFP = 0; \ + STATUS = 0; } \ +} + +#define PS_PEEK_CHAR(PORT,RESULT,EOFP,STATUS) \ +{ \ + FILE * TTport = PORT; \ + int TTchar; \ + if (EOF == (TTchar = getc(TTport))) \ + RESULT = ps_read_char(TTport, &EOFP, &STATUS, 0==0);\ + else { \ + RESULT = TTchar; \ + ungetc(RESULT, TTport); \ + EOFP = 0; \ + STATUS = 0; } \ +} + +#define PS_READ_INTEGER(PORT,RESULT,EOFP,STATUS) \ +RESULT = ps_read_integer(PORT,&EOFP,&STATUS); + +#define PS_WRITE_CHAR(CHAR,PORT,STATUS) \ +{ \ + FILE * TTport = PORT; \ + char TTchar = CHAR; \ + if (EOF == putc(TTchar,TTport)) \ + STATUS = ps_write_char(TTchar,TTport); \ + else { \ + STATUS = 0; } \ +} + + +/* C shifts may not work if the amount is greater than the machine word size */ +/* Patched by JAR 6/6/93 */ + +#define PS_SHIFT_RIGHT(X,Y,RESULT) \ +{ \ + long TTx = X, TTy = Y; \ + RESULT = TTy >= 32 ? (TTx < 0 ? -1 : 0) : TTx >> TTy; \ +} + +#define PS_SHIFT_LEFT(X,Y,RESULT) \ +{ \ + long TTy = Y; \ + RESULT = TTy >= 32 ? 0 : X << TTy; \ +} + +extern long TTreturn_value, TTrun_machine(); + diff --git a/c/scheme48.h b/c/scheme48.h new file mode 100644 index 0000000..e722fed --- /dev/null +++ b/c/scheme48.h @@ -0,0 +1,109 @@ +typedef long scheme_value; + +#define FIXNUM_TAG 0 +#define FIXNUMP(x) (((long)(x) & 3L) == FIXNUM_TAG) +#define IMMEDIATE_TAG 1 +#define IMMEDIATEP(x) (((long)(x) & 3L) == IMMEDIATE_TAG) +#define HEADER_TAG 2 +#define HEADERP(x) (((long)(x) & 3L) == HEADER_TAG) +#define STOB_TAG 3 +#define STOBP(x) (((long)(x) & 3L) == STOB_TAG) + +#define ENTER_FIXNUM(n) ((scheme_value)((n) << 2)) +#define EXTRACT_FIXNUM(x) ((long)(x) >> 2) + +#define MISC_IMMEDIATE(n) (scheme_value)(IMMEDIATE_TAG | ((n) << 2)) +#define SCHFALSE MISC_IMMEDIATE(0) +#define SCHTRUE MISC_IMMEDIATE(1) +#define SCHCHAR MISC_IMMEDIATE(2) +#define SCHUNSPECIFIC MISC_IMMEDIATE(3) +#define SCHUNDEFINED MISC_IMMEDIATE(4) +#define SCHEOF MISC_IMMEDIATE(5) +#define SCHNULL MISC_IMMEDIATE(6) +#define UNDEFINED SCHUNDEFINED +#define UNSPECIFIC SCHUNSPECIFIC + +#define ENTER_BOOLEAN(n) ((n) ? SCHTRUE : SCHFALSE) +#define EXTRACT_BOOLEAN(x) ((x) != SCHFALSE) + +#define ENTER_CHAR(c) (SCHCHAR | ((c) << 8)) +#define EXTRACT_CHAR(x) ((x) >> 8) +#define CHARP(x) ((((long) (x)) & 0xff) == SCHCHAR) + +#define ADDRESS_AFTER_HEADER(x, type) ((type *)((x) - STOB_TAG)) +#define STOB_REF(x, i) ((ADDRESS_AFTER_HEADER(x, long))[i]) +#define STOB_TYPE(x) ((STOB_HEADER(x)>>2)&31) +#define STOB_HEADER(x) (STOB_REF((x),-1)) +#define STOB_BLENGTH(x) (STOB_HEADER(x) >> 8) +#define STOB_LLENGTH(x) (STOB_HEADER(x) >> 10) + +#define STOBTYPE_PAIR 0 +#define PAIRP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_PAIR)) +#define STOBTYPE_SYMBOL 1 +#define SYMBOLP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_SYMBOL)) +#define STOBTYPE_VECTOR 2 +#define VECTORP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_VECTOR)) +#define STOBTYPE_CLOSURE 3 +#define CLOSUREP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_CLOSURE)) +#define STOBTYPE_LOCATION 4 +#define LOCATIONP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_LOCATION)) +#define STOBTYPE_CHANNEL 5 +#define CHANNELP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_CHANNEL)) +#define STOBTYPE_PORT 6 +#define PORTP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_PORT)) +#define STOBTYPE_RATNUM 7 +#define RATNUMP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_RATNUM)) +#define STOBTYPE_RECORD 8 +#define RECORDP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_RECORD)) +#define STOBTYPE_CONTINUATION 9 +#define CONTINUATIONP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_CONTINUATION)) +#define STOBTYPE_EXTENDED_NUMBER 10 +#define EXTENDED_NUMBERP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_EXTENDED_NUMBER)) +#define STOBTYPE_TEMPLATE 11 +#define TEMPLATEP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_TEMPLATE)) +#define STOBTYPE_WEAK_POINTER 12 +#define WEAK_POINTERP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_WEAK_POINTER)) +#define STOBTYPE_EXTERNAL 13 +#define EXTERNALP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_EXTERNAL)) +#define STOBTYPE_UNUSED_D_HEADER1 14 +#define UNUSED_D_HEADER1P(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_UNUSED_D_HEADER1)) +#define STOBTYPE_UNUSED_D_HEADER2 15 +#define UNUSED_D_HEADER2P(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_UNUSED_D_HEADER2)) +#define STOBTYPE_STRING 16 +#define STRINGP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_STRING)) +#define STOBTYPE_CODE_VECTOR 17 +#define CODE_VECTORP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_CODE_VECTOR)) +#define STOBTYPE_DOUBLE 18 +#define DOUBLEP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_DOUBLE)) +#define STOBTYPE_BIGNUM 19 +#define BIGNUMP(x) (STOBP(x) && (STOB_TYPE(x) == STOBTYPE_BIGNUM)) + +#define CAR(x) STOB_REF(x, 0) +#define CDR(x) STOB_REF(x, 1) +#define SYMBOL_TO_STRING(x) STOB_REF(x, 0) +#define LOCATION_ID(x) STOB_REF(x, 0) +#define CONTENTS(x) STOB_REF(x, 1) +#define CLOSURE_TEMPLATE(x) STOB_REF(x, 0) +#define CLOSURE_ENV(x) STOB_REF(x, 1) +#define WEAK_POINTER_REF(x) STOB_REF(x, 0) +#define EXTERNAL_NAME(x) STOB_REF(x, 0) +#define EXTERNAL_VALUE(x) STOB_REF(x, 1) +#define PORT_HANDLER(x) STOB_REF(x, 0) +#define PORT_STATUS(x) STOB_REF(x, 1) +#define PORT_LOCK(x) STOB_REF(x, 2) +#define PORT_LOCKEDP(x) STOB_REF(x, 3) +#define PORT_DATA(x) STOB_REF(x, 4) +#define PORT_BUFFER(x) STOB_REF(x, 5) +#define PORT_INDEX(x) STOB_REF(x, 6) +#define PORT_LIMIT(x) STOB_REF(x, 7) +#define PORT_PENDING_EOFP(x) STOB_REF(x, 8) +#define CHANNEL_STATUS(x) STOB_REF(x, 0) +#define CHANNEL_ID(x) STOB_REF(x, 1) +#define CHANNEL_OS_INDEX(x) STOB_REF(x, 2) + +#define VECTOR_LENGTH(x) STOB_LLENGTH(x) +#define VECTOR_REF(x, i) STOB_REF(x, i) +#define CODE_VECTOR_LENGTH(x) STOB_BLENGTH(x) +#define CODE_VECTOR_REF(x, i) (ADDRESS_AFTER_HEADER(x, unsigned char)[i]) +#define STRING_LENGTH(x) (STOB_BLENGTH(x)-1) +#define STRING_REF(x, i) (ADDRESS_AFTER_HEADER(x, char)[i]) diff --git a/c/scheme48heap.c b/c/scheme48heap.c new file mode 100644 index 0000000..c43059a --- /dev/null +++ b/c/scheme48heap.c @@ -0,0 +1,1832 @@ +#include +#include "prescheme.h" +#include "scheme48vm.h" + +static long copy_weak_pointer(long, char *, char **); +static long real_copy_object(long, char *, char **); +static void clean_weak_pointers(void); +void write_barrier(char *, long); +char * heap_pointer(void); +void set_heap_pointerB(char *); +long heap_size(void); +char * heap_limits(char **, char **, char **, char **); +long preallocate_space(long); +void register_static_areas(long, char **, long*, long, char **, long*); +char image_writing_okayP(void); +long gc_count(void); +void end_collection(void); +void initialize_heap(char *, long); +char availableP(long); +void begin_collection(void); +char * allocate_space(long, long, long); +long available(void); +long check_image_header(char*); +long trace_locationsB(char *, char *); +long find_all(long); +long trace_stob_contentsB(long); +long trace_value(long); +long find_all_records(long); +long read_image(long); +long write_image(long, FILE *, void(*)(void)); +long do_gc(long, long*); +static char * Snewspace_beginS; +static char * Snewspace_endS; +static char * Soldspace_beginS; +static char * Soldspace_endS; +static char * *Spure_areasS; +static char * *Simpure_areasS; +static long *Spure_sizesS; +static long *Simpure_sizesS; +static long Spure_area_countS; +static long Simpure_area_countS; +static long Sfinding_typeS; +static long SstatusS; +static char SeofPS; +static FILE * Simage_portS; +static char * Sold_beginS; +static char * Sold_hpS; +static long Sstartup_procS; +static long Sgc_countS; +static char * Ssaved_hpS; +static char * Ssaved_limitS; +static char * Sweak_pointer_hpS; +static char * Sweak_pointer_limitS; +static long Hthe_record_type8040; +char * ShpS; +char * SlimitS; + +static long copy_weak_pointer(long weak_1X, char * frontier_2X, char * *TT0) +{ + char * arg0K0; + long new_7X; + char * frontier_6X; + char * new_frontier_5X; + char * old_4X; + char * x_3X; + { x_3X = Sweak_pointer_hpS; + if ((x_3X == NULL)) { + goto L1918;} + else { + if (((Sweak_pointer_hpS) < (Sweak_pointer_limitS))) { + arg0K0 = frontier_2X; + goto L1923;} + else { + goto L1918;}}} + L1918: { + old_4X = Sweak_pointer_hpS; + new_frontier_5X = frontier_2X + 1024; + Sweak_pointer_hpS = frontier_2X; + Sweak_pointer_limitS = new_frontier_5X; + *((long *) (Sweak_pointer_hpS)) = 261202; + *((long *) ((Sweak_pointer_hpS) + 8)) = (((long) old_4X)); + arg0K0 = new_frontier_5X; + goto L1923;} + L1923: { + frontier_6X = arg0K0; + new_7X = 3 + (((long) ((Sweak_pointer_hpS) + 4))); + *((long *) ((Sweak_pointer_hpS) + 4)) = (*((long *) (((char *) (-3 + weak_1X))))); + Sweak_pointer_hpS = ((Sweak_pointer_hpS) + 8); + *((long *) ((((char *) (-3 + weak_1X))) + -4)) = new_7X; + *TT0 = frontier_6X; + return new_7X;} +} +static long real_copy_object(long thing_8X, char * frontier_9X, char * *TT0) +{ + long new_14X; + char * data_addr_13X; + char * a_12X; + long descriptor_11X; + long h_10X; + { h_10X = *((long *) ((((char *) (-3 + thing_8X))) + -4)); + if ((3 == (3 & h_10X))) { + *TT0 = frontier_9X; + return h_10X;} + else { + if ((1074 == h_10X)) { + descriptor_11X = *((long *) (((char *) (-3 + thing_8X)))); + if ((3 == (3 & descriptor_11X))) { + a_12X = ((char *) (-3 + descriptor_11X)); + if ((a_12X < (Soldspace_beginS))) { + goto L3073;} + else { + if ((a_12X < (Soldspace_endS))) { + return copy_weak_pointer(thing_8X, frontier_9X, TT0);} + else { + goto L3073;}}} + else { + goto L3073;}} + else { + goto L3073;}}} + L3073: { + *((long *) frontier_9X) = h_10X; + data_addr_13X = frontier_9X + 4; + new_14X = 3 + (((long) data_addr_13X)); + *((long *) ((((char *) (-3 + thing_8X))) + -4)) = new_14X; + memcpy((void *)data_addr_13X, (void *)(((char *) (-3 + thing_8X))),((long)(((unsigned long)h_10X)>>8))); + *TT0 = (data_addr_13X + (-4 & (3 + ((long)(((unsigned long)h_10X)>>8))))); + return new_14X;} +} +static void clean_weak_pointers(void) +{ + char * arg0K1; + char * arg0K0; + long arg1K0; + long x2_24X; + long h_23X; + char * a_22X; + long value_21X; + char * scan_20X; + char * next_19X; + char * end_18X; + char * start_17X; + char * end_16X; + char * x_15X; + { if (((Sweak_pointer_hpS) == NULL)) { + return;} + else { + x_15X = Sweak_pointer_limitS; + end_16X = Sweak_pointer_hpS; + arg0K0 = (x_15X + -1024); + arg0K1 = end_16X; + goto L3730;}} + L3730: { + start_17X = arg0K0; + end_18X = arg0K1; + next_19X = ((char *) (*((long *) (start_17X + 8)))); + arg0K0 = start_17X; + goto L2029;} + L2029: { + scan_20X = arg0K0; + if ((scan_20X < end_18X)) { + *((long *) scan_20X) = 1074; + value_21X = *((long *) (scan_20X + 4)); + if ((3 == (3 & value_21X))) { + a_22X = ((char *) (-3 + value_21X)); + if ((a_22X < (Soldspace_beginS))) { + goto L2075;} + else { + if ((a_22X < (Soldspace_endS))) { + if ((3 == (3 & value_21X))) { + h_23X = *((long *) ((((char *) (-3 + value_21X))) + -4)); + if ((3 == (3 & h_23X))) { + arg1K0 = h_23X; + goto L2070;} + else { + arg1K0 = 1; + goto L2070;}} + else { + goto L2075;}} + else { + goto L2075;}}} + else { + goto L2075;}} + else { + if ((next_19X == NULL)) { + if ((end_16X < (Sweak_pointer_limitS))) { + *((long *) end_16X) = (82 + ((((-4 & ((Sweak_pointer_limitS) - (end_16X + 4))))<<8))); + return;} + else { + return;}} + else { + arg0K0 = (next_19X + -1024); + arg0K1 = next_19X; + goto L3730;}}} + L2075: { + arg0K0 = (scan_20X + 8); + goto L2029;} + L2070: { + x2_24X = arg1K0; + *((long *) (scan_20X + 4)) = x2_24X; + goto L2075;} +} +void write_barrier(char * address_25X, long value_26X) +{ + + { return;} +} +char * heap_pointer(void) +{ + + { return (ShpS);} +} +void set_heap_pointerB(char * value_27X) +{ + + { ShpS = value_27X; + return;} +} +long heap_size(void) +{ + + { return ((Snewspace_endS) - (Snewspace_beginS));} +} +char * heap_limits(char * *TT0, char * *TT1, char * *TT2, char * *TT3) +{ + + { *TT0 = (Snewspace_beginS); + *TT1 = (Snewspace_endS); + *TT2 = (Soldspace_beginS); + *TT3 = (Soldspace_endS); + return (ShpS);} +} +long preallocate_space(long cells_28X) +{ + + { return 0;} +} +void register_static_areas(long pure_count_29X, char * *pure_areas_30X, long *pure_sizes_31X, long impure_count_32X, char * *impure_areas_33X, long *impure_sizes_34X) +{ + + { Spure_area_countS = pure_count_29X; + Spure_areasS = pure_areas_30X; + Spure_sizesS = pure_sizes_31X; + Simpure_area_countS = impure_count_32X; + Simpure_areasS = impure_areas_33X; + Simpure_sizesS = impure_sizes_34X; + return;} +} +char image_writing_okayP(void) +{ + + { if ((0 == (Spure_area_countS))) { + return (0 == (Simpure_area_countS));} + else { + return 0;}} +} +long gc_count(void) +{ + + { return (Sgc_countS);} +} +void end_collection(void) +{ + + { Sgc_countS = (1 + (Sgc_countS)); + return;} +} +void initialize_heap(char * start_35X, long size_36X) +{ + long semisize_38X; + long cells_37X; + { cells_37X = size_36X / 2; + semisize_38X = ((cells_37X)<<2); + Snewspace_beginS = start_35X; + Snewspace_endS = ((Snewspace_beginS) + semisize_38X); + Soldspace_beginS = (Snewspace_endS); + Soldspace_endS = ((Soldspace_beginS) + semisize_38X); + ShpS = (Snewspace_beginS); + SlimitS = (Snewspace_endS); + return;} +} +char availableP(long cells_39X) +{ + + { return (((ShpS) + (((cells_39X)<<2))) < (SlimitS));} +} +void begin_collection(void) +{ + char * e_41X; + char * b_40X; + { b_40X = Snewspace_beginS; + Snewspace_beginS = (Soldspace_beginS); + Soldspace_beginS = b_40X; + e_41X = Snewspace_endS; + Snewspace_endS = (Soldspace_endS); + Soldspace_endS = e_41X; + Ssaved_limitS = (SlimitS); + Ssaved_hpS = (ShpS); + SlimitS = (Snewspace_endS); + ShpS = (Snewspace_beginS); + Sweak_pointer_hpS = NULL; + return;} +} +char * allocate_space(long type_42X, long len_43X, long key_44X) +{ + char * new_45X; + { new_45X = ShpS; + ShpS = ((ShpS) + (-4 & (3 + len_43X))); + return new_45X;} +} +long available(void) +{ + + { return (((((SlimitS) - (ShpS)))>>2));} +} +long check_image_header(char *filename_46X) +{ + long arg1K0; + long arg1K2; + long arg1K1; + char arg2K1; + char arg2K0; + long status_91X; + char eofP_90X; + long status_89X; + long status_88X; + long status_87X; + long status_86X; + long status_85X; + char eofP_84X; + char ch_83X; + long v_82X; + long status_81X; + char eofP_80X; + long thing_79X; + long cells_78X; + long status_77X; + char eofP_76X; + long thing_75X; + long cells_74X; + long status_73X; + char eofP_72X; + char thing_71X; + long status_70X; + char eofP_69X; + long thing_68X; + long old_bytes_per_cell_67X; + long status_66X; + char eofP_65X; + long status_64X; + char eofP_63X; + char ch_62X; + long i_61X; + long status_60X; + char eofP_59X; + long thing_58X; + char same_versionP_57X; + long status_56X; + char eofP_55X; + long status_54X; + char eofP_53X; + char ch_52X; + long status_51X; + char eofP_50X; + char ch_49X; + long status_48X; + FILE * port_47X; + { port_47X = ps_open_input_file(filename_46X, &status_48X); + if ((status_48X == NO_ERRORS)) { + SstatusS = NO_ERRORS; + SeofPS = 0; + if ((SeofPS)) { + goto L2250;} + else { + goto L2823;}} + else { + ps_write_string("Can't open heap image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + ps_write_string((ps_error_string(status_48X)), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L2250: { + if ((SeofPS)) { + goto L2283;} + else { + goto L2787;}} + L2823: { + PS_READ_CHAR(port_47X, ch_49X, eofP_50X, status_51X) + if (eofP_50X) { + arg2K0 = eofP_50X; + arg1K1 = status_51X; + goto L2228;} + else { + if ((status_51X == NO_ERRORS)) { + if ((12 == ch_49X)) { + arg2K0 = 0; + arg1K1 = status_51X; + goto L2228;} + else { + goto L2823;}} + else { + arg2K0 = eofP_50X; + arg1K1 = status_51X; + goto L2228;}}} + L2283: { + if ((SeofPS)) { + arg2K0 = 0; + goto L2316;} + else { + arg1K0 = 0; + goto L2763;}} + L2787: { + PS_READ_CHAR(port_47X, ch_52X, eofP_53X, status_54X) + if (eofP_53X) { + arg2K0 = eofP_53X; + arg1K1 = status_54X; + goto L2261;} + else { + if ((status_54X == NO_ERRORS)) { + if ((10 == ch_52X)) { + arg2K0 = 0; + arg1K1 = status_54X; + goto L2261;} + else { + goto L2787;}} + else { + arg2K0 = eofP_53X; + arg1K1 = status_54X; + goto L2261;}}} + L2228: { + eofP_55X = arg2K0; + status_56X = arg1K1; + if (eofP_55X) { + SeofPS = 1; + goto L2250;} + else { + if (((SstatusS) == NO_ERRORS)) { + goto L2250;} + else { + SeofPS = 1; + SstatusS = status_56X; + goto L2250;}}} + L2316: { + same_versionP_57X = arg2K0; + if ((SeofPS)) { + arg1K0 = -1; + goto L2351;} + else { + PS_READ_INTEGER(port_47X, thing_58X, eofP_59X, status_60X) + if (eofP_59X) { + SeofPS = 1; + arg1K0 = -1; + goto L2351;} + else { + if (((SstatusS) == NO_ERRORS)) { + arg1K0 = thing_58X; + goto L2351;} + else { + SeofPS = 1; + SstatusS = status_60X; + arg1K0 = -1; + goto L2351;}}}} + L2763: { + i_61X = arg1K0; + PS_READ_CHAR(port_47X, ch_62X, eofP_63X, status_64X) + if (eofP_63X) { + arg2K0 = 0; + arg2K1 = eofP_63X; + arg1K2 = status_64X; + goto L2294;} + else { + if ((status_64X == NO_ERRORS)) { + if ((i_61X == (strlen((char *) "Kali 19")))) { + arg2K0 = (10 == ch_62X); + arg2K1 = 0; + arg1K2 = status_64X; + goto L2294;} + else { + if ((ch_62X == (*("Kali 19" + i_61X)))) { + arg1K0 = (1 + i_61X); + goto L2763;} + else { + arg2K0 = 0; + arg2K1 = 0; + arg1K2 = status_64X; + goto L2294;}}} + else { + arg2K0 = 0; + arg2K1 = eofP_63X; + arg1K2 = status_64X; + goto L2294;}}} + L2261: { + eofP_65X = arg2K0; + status_66X = arg1K1; + if (eofP_65X) { + SeofPS = 1; + goto L2283;} + else { + if (((SstatusS) == NO_ERRORS)) { + goto L2283;} + else { + SeofPS = 1; + SstatusS = status_66X; + goto L2283;}}} + L2351: { + old_bytes_per_cell_67X = arg1K0; + if ((SeofPS)) { + arg1K0 = -1; + goto L2386;} + else { + PS_READ_INTEGER(port_47X, thing_68X, eofP_69X, status_70X) + if (eofP_69X) { + SeofPS = 1; + arg1K0 = -1; + goto L2386;} + else { + if (((SstatusS) == NO_ERRORS)) { + arg1K0 = thing_68X; + goto L2386;} + else { + SeofPS = 1; + SstatusS = status_70X; + arg1K0 = -1; + goto L2386;}}}} + L2294: { + thing_71X = arg2K0; + eofP_72X = arg2K1; + status_73X = arg1K2; + if (eofP_72X) { + SeofPS = 1; + arg2K0 = 0; + goto L2316;} + else { + if (((SstatusS) == NO_ERRORS)) { + arg2K0 = thing_71X; + goto L2316;} + else { + SeofPS = 1; + SstatusS = status_73X; + arg2K0 = 0; + goto L2316;}}} + L2386: { + cells_74X = arg1K0; + Sold_beginS = (((char *) (((cells_74X)<<2)))); + if ((SeofPS)) { + arg1K0 = -1; + goto L2424;} + else { + PS_READ_INTEGER(port_47X, thing_75X, eofP_76X, status_77X) + if (eofP_76X) { + SeofPS = 1; + arg1K0 = -1; + goto L2424;} + else { + if (((SstatusS) == NO_ERRORS)) { + arg1K0 = thing_75X; + goto L2424;} + else { + SeofPS = 1; + SstatusS = status_77X; + arg1K0 = -1; + goto L2424;}}}} + L2424: { + cells_78X = arg1K0; + Sold_hpS = (((char *) (((cells_78X)<<2)))); + if ((SeofPS)) { + arg1K0 = -1; + goto L2462;} + else { + PS_READ_INTEGER(port_47X, thing_79X, eofP_80X, status_81X) + if (eofP_80X) { + SeofPS = 1; + arg1K0 = -1; + goto L2462;} + else { + if (((SstatusS) == NO_ERRORS)) { + arg1K0 = thing_79X; + goto L2462;} + else { + SeofPS = 1; + SstatusS = status_81X; + arg1K0 = -1; + goto L2462;}}}} + L2462: { + v_82X = arg1K0; + Sstartup_procS = v_82X; + Simage_portS = port_47X; + if ((SeofPS)) { + goto L2501;} + else { + goto L2710;}} + L2501: { + if (((SstatusS) == NO_ERRORS)) { + if ((SeofPS)) { + SstatusS = EDOM; + ps_write_string("Premature EOF when reading image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L2582;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L2582;}} + else { + if (same_versionP_57X) { + if ((4 == old_bytes_per_cell_67X)) { + return ((Sold_hpS) - (Sold_beginS));} + else { + ps_write_string("Incompatible bytes-per-cell in image", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L2642;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L2642;}}} + else { + ps_write_string("Format of image is incompatible with this version of system", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L2612;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L2612;}}}} + else { + ps_write_string("Error reading from image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L2557;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L2557;}}} + L2710: { + PS_READ_CHAR(port_47X, ch_83X, eofP_84X, status_85X) + if (eofP_84X) { + arg2K0 = eofP_84X; + arg1K1 = status_85X; + goto L2479;} + else { + if ((status_85X == NO_ERRORS)) { + if ((12 == ch_83X)) { + arg2K0 = 0; + arg1K1 = status_85X; + goto L2479;} + else { + goto L2710;}} + else { + arg2K0 = eofP_84X; + arg1K1 = status_85X; + goto L2479;}}} + L2582: { + status_86X = ps_close(port_47X); + if ((status_86X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L2642: { + status_87X = ps_close(port_47X); + if ((status_87X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L2612: { + status_88X = ps_close(port_47X); + if ((status_88X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L2557: { + status_89X = ps_close(port_47X); + if ((status_89X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L2479: { + eofP_90X = arg2K0; + status_91X = arg1K1; + if (eofP_90X) { + SeofPS = 1; + goto L2501;} + else { + if (((SstatusS) == NO_ERRORS)) { + goto L2501;} + else { + SeofPS = 1; + SstatusS = status_91X; + goto L2501;}}} +} +long trace_locationsB(char * start_92X, char * end_93X) +{ + char * arg0K0; + char * arg0K1; + long arg1K0; + long new_107X; + char * data_addr_106X; + char * frontier_105X; + long new_thing_104X; + char * frontier_103X; + long new_thing_102X; + char * a_101X; + long descriptor_100X; + long h_99X; + char * a_98X; + char * next_97X; + long thing_96X; + char * frontier_95X; + char * addr_94X; + { arg0K0 = start_92X; + arg0K1 = (ShpS); + goto L3822;} + L3822: { + addr_94X = arg0K0; + frontier_95X = arg0K1; + if ((addr_94X < end_93X)) { + thing_96X = *((long *) addr_94X); + next_97X = addr_94X + 4; + if ((2 == (3 & thing_96X))) { + if (((31 & (((thing_96X)>>2))) < 19)) { + goto L3836;} + else { + arg0K0 = (next_97X + (-4 & (3 + ((long)(((unsigned long)thing_96X)>>8))))); + arg0K1 = frontier_95X; + goto L3822;}} + else { + goto L3836;}} + else { + ShpS = frontier_95X; + return 0;}} + L3836: { + if ((3 == (3 & thing_96X))) { + a_98X = ((char *) (-3 + thing_96X)); + if ((a_98X < (Soldspace_beginS))) { + arg0K0 = next_97X; + arg0K1 = frontier_95X; + goto L3822;} + else { + if ((a_98X < (Soldspace_endS))) { + h_99X = *((long *) ((((char *) (-3 + thing_96X))) + -4)); + if ((3 == (3 & h_99X))) { + arg1K0 = h_99X; + arg0K1 = frontier_95X; + goto L3843;} + else { + if ((1074 == h_99X)) { + descriptor_100X = *((long *) (((char *) (-3 + thing_96X)))); + if ((3 == (3 & descriptor_100X))) { + a_101X = ((char *) (-3 + descriptor_100X)); + if ((a_101X < (Soldspace_beginS))) { + goto L5360;} + else { + if ((a_101X < (Soldspace_endS))) { + new_thing_102X = copy_weak_pointer(thing_96X, frontier_95X, &frontier_103X); + arg1K0 = new_thing_102X; + arg0K1 = frontier_103X; + goto L3843;} + else { + goto L5360;}}} + else { + goto L5360;}} + else { + goto L5360;}}} + else { + arg0K0 = next_97X; + arg0K1 = frontier_95X; + goto L3822;}}} + else { + arg0K0 = next_97X; + arg0K1 = frontier_95X; + goto L3822;}} + L3843: { + new_thing_104X = arg1K0; + frontier_105X = arg0K1; + *((long *) addr_94X) = new_thing_104X; + arg0K0 = next_97X; + arg0K1 = frontier_105X; + goto L3822;} + L5360: { + *((long *) frontier_95X) = h_99X; + data_addr_106X = frontier_95X + 4; + new_107X = 3 + (((long) data_addr_106X)); + *((long *) ((((char *) (-3 + thing_96X))) + -4)) = new_107X; + memcpy((void *)data_addr_106X, (void *)(((char *) (-3 + thing_96X))),((long)(((unsigned long)h_99X)>>8))); + arg1K0 = new_107X; + arg0K1 = (data_addr_106X + (-4 & (3 + ((long)(((unsigned long)h_99X)>>8))))); + goto L3843;} +} +long find_all(long type_108X) +{ + char * arg0K0; + long arg1K0; + char * merged_arg0K1; + char * merged_arg0K0; + + int Hproc801109_return_tag; + char Hproc8011090_return_value; + char * start_110X; + char * end_111X; + long d_126X; + char * addr_125X; + long type_124X; + char v_123X; + long i_122X; + long count_121X; + long *sizes_120X; + char * *areas_119X; + char v_118X; + long i_117X; + long count_116X; + long *sizes_115X; + char * *areas_114X; + char v_113X; + char * start_hp_112X; + { Sfinding_typeS = type_108X; + start_hp_112X = ShpS; + *((long *) (ShpS)) = 0; + ShpS = ((ShpS) + 4); + merged_arg0K0 = (Snewspace_beginS); + merged_arg0K1 = start_hp_112X; + Hproc801109_return_tag = 0; + goto Hproc801109; + Hproc801109_return_0: + v_113X = Hproc8011090_return_value; + if (v_113X) { + areas_114X = Simpure_areasS; + sizes_115X = Simpure_sizesS; + count_116X = Simpure_area_countS; + arg1K0 = 0; + goto L4041;} + else { + goto L4001;}} + L4041: { + i_117X = arg1K0; + if ((i_117X < count_116X)) { + merged_arg0K0 = (*(areas_114X + i_117X)); + merged_arg0K1 = ((*(areas_114X + i_117X)) + (*(sizes_115X + i_117X))); + Hproc801109_return_tag = 1; + goto Hproc801109; + Hproc801109_return_1: + v_118X = Hproc8011090_return_value; + if (v_118X) { + arg1K0 = (1 + i_117X); + goto L4041;} + else { + goto L4001;}} + else { + areas_119X = Spure_areasS; + sizes_120X = Spure_sizesS; + count_121X = Spure_area_countS; + arg1K0 = 0; + goto L4060;}} + L4001: { + ShpS = start_hp_112X; + return 1;} + L4060: { + i_122X = arg1K0; + if ((i_122X < count_121X)) { + merged_arg0K0 = (*(areas_119X + i_122X)); + merged_arg0K1 = ((*(areas_119X + i_122X)) + (*(sizes_120X + i_122X))); + Hproc801109_return_tag = 2; + goto Hproc801109; + Hproc801109_return_2: + v_123X = Hproc8011090_return_value; + if (v_123X) { + arg1K0 = (1 + i_122X); + goto L4060;} + else { + goto L4001;}} + else { + *((long *) start_hp_112X) = (10 + (((((ShpS) - (start_hp_112X + 4)))<<8))); + return (3 + (((long) (start_hp_112X + 4))));}} + Hproc801109: { + start_110X = merged_arg0K0; + end_111X = merged_arg0K1;{ + type_124X = Sfinding_typeS; + arg0K0 = start_110X; + goto L3189;} + L3189: { + addr_125X = arg0K0; + if ((addr_125X < end_111X)) { + d_126X = *((long *) addr_125X); + if ((2 == (3 & d_126X))) { + if ((type_124X == (31 & (((d_126X)>>2))))) { + if ((((ShpS) + 16) < (SlimitS))) { + *((long *) (ShpS)) = (3 + (((long) (addr_125X + 4)))); + ShpS = ((ShpS) + 4); + goto L3221;} + else { + Hproc8011090_return_value = 0; + goto Hproc801109_return;}} + else { + goto L3221;}} + else { + ps_write_string("heap is in an inconsistent state.", (stderr)); + Hproc8011090_return_value = 0; + goto Hproc801109_return;}} + else { + Hproc8011090_return_value = 1; + goto Hproc801109_return;}} + L3221: { + arg0K0 = (addr_125X + (4 + (-4 & (3 + ((long)(((unsigned long)d_126X)>>8)))))); + goto L3189;} + Hproc801109_return: + switch (Hproc801109_return_tag) { + case 0: goto Hproc801109_return_0; + case 1: goto Hproc801109_return_1; + default: goto Hproc801109_return_2; + }} + +} +long trace_stob_contentsB(long stob_127X) +{ + char * start_129X; + long h_128X; + { h_128X = *((long *) ((((char *) (-3 + stob_127X))) + -4)); + start_129X = ((char *) (-3 + stob_127X)); + return trace_locationsB(start_129X, (start_129X + (-4 & (3 + ((long)(((unsigned long)h_128X)>>8))))));} +} +long trace_value(long stob_130X) +{ + char * new_hp_133X; + long new_thing_132X; + char * a_131X; + { if ((3 == (3 & stob_130X))) { + a_131X = ((char *) (-3 + stob_130X)); + if ((a_131X < (Soldspace_beginS))) { + return stob_130X;} + else { + if ((a_131X < (Soldspace_endS))) { + new_thing_132X = real_copy_object(stob_130X, (ShpS), &new_hp_133X); + ShpS = new_hp_133X; + return new_thing_132X;} + else { + return stob_130X;}}} + else { + return stob_130X;}} +} +long find_all_records(long record_type_134X) +{ + char * arg0K0; + long arg1K0; + char * merged_arg0K1; + char * merged_arg0K0; + + int Hproc807135_return_tag; + char Hproc8071350_return_value; + char * start_136X; + char * end_137X; + long record_153X; + long d_152X; + char * addr_151X; + long type_150X; + char v_149X; + long i_148X; + long count_147X; + long *sizes_146X; + char * *areas_145X; + char v_144X; + long i_143X; + long count_142X; + long *sizes_141X; + char * *areas_140X; + char v_139X; + char * start_hp_138X; + { Hthe_record_type8040 = record_type_134X; + Sfinding_typeS = 8; + start_hp_138X = ShpS; + *((long *) (ShpS)) = 0; + ShpS = ((ShpS) + 4); + merged_arg0K0 = (Snewspace_beginS); + merged_arg0K1 = start_hp_138X; + Hproc807135_return_tag = 0; + goto Hproc807135; + Hproc807135_return_0: + v_139X = Hproc8071350_return_value; + if (v_139X) { + areas_140X = Simpure_areasS; + sizes_141X = Simpure_sizesS; + count_142X = Simpure_area_countS; + arg1K0 = 0; + goto L4188;} + else { + goto L4148;}} + L4188: { + i_143X = arg1K0; + if ((i_143X < count_142X)) { + merged_arg0K0 = (*(areas_140X + i_143X)); + merged_arg0K1 = ((*(areas_140X + i_143X)) + (*(sizes_141X + i_143X))); + Hproc807135_return_tag = 1; + goto Hproc807135; + Hproc807135_return_1: + v_144X = Hproc8071350_return_value; + if (v_144X) { + arg1K0 = (1 + i_143X); + goto L4188;} + else { + goto L4148;}} + else { + areas_145X = Spure_areasS; + sizes_146X = Spure_sizesS; + count_147X = Spure_area_countS; + arg1K0 = 0; + goto L4207;}} + L4148: { + ShpS = start_hp_138X; + return 1;} + L4207: { + i_148X = arg1K0; + if ((i_148X < count_147X)) { + merged_arg0K0 = (*(areas_145X + i_148X)); + merged_arg0K1 = ((*(areas_145X + i_148X)) + (*(sizes_146X + i_148X))); + Hproc807135_return_tag = 2; + goto Hproc807135; + Hproc807135_return_2: + v_149X = Hproc8071350_return_value; + if (v_149X) { + arg1K0 = (1 + i_148X); + goto L4207;} + else { + goto L4148;}} + else { + *((long *) start_hp_138X) = (10 + (((((ShpS) - (start_hp_138X + 4)))<<8))); + return (3 + (((long) (start_hp_138X + 4))));}} + Hproc807135: { + start_136X = merged_arg0K0; + end_137X = merged_arg0K1;{ + type_150X = Sfinding_typeS; + arg0K0 = start_136X; + goto L3336;} + L3336: { + addr_151X = arg0K0; + if ((addr_151X < end_137X)) { + d_152X = *((long *) addr_151X); + if ((2 == (3 & d_152X))) { + if ((type_150X == (31 & (((d_152X)>>2))))) { + record_153X = 3 + (((long) (addr_151X + 4))); + if (((Hthe_record_type8040) == (*((long *) (((char *) (-3 + record_153X))))))) { + if ((((ShpS) + 16) < (SlimitS))) { + *((long *) (ShpS)) = record_153X; + ShpS = ((ShpS) + 4); + goto L3368;} + else { + Hproc8071350_return_value = 0; + goto Hproc807135_return;}} + else { + goto L3368;}} + else { + goto L3368;}} + else { + ps_write_string("heap is in an inconsistent state.", (stderr)); + Hproc8071350_return_value = 0; + goto Hproc807135_return;}} + else { + Hproc8071350_return_value = 1; + goto Hproc807135_return;}} + L3368: { + arg0K0 = (addr_151X + (4 + (-4 & (3 + ((long)(((unsigned long)d_152X)>>8)))))); + goto L3336;} + Hproc807135_return: + switch (Hproc807135_return_tag) { + case 0: goto Hproc807135_return_0; + case 1: goto Hproc807135_return_1; + default: goto Hproc807135_return_2; + }} + +} +long read_image(long startup_space_154X) +{ + FILE * arg4K0; + char *arg3K1; + char arg2K1; + char arg2K0; + char * arg0K0; + long arg1K2; + long arg1K0; + long d_196X; + long descriptor_195X; + char * ptr_194X; + long descriptor_193X; + long status_192X; + long status_191X; + long status_190X; + long status_189X; + char * next_188X; + long value_187X; + long x_186X; + long x_185X; + char * ptr_184X; + long status_183X; + long status_182X; + long status_181X; + char eofP_180X; + char v_179X; + char *string_178X; + char okayP_177X; + long status_176X; + long status_175X; + long status_174X; + char eofP_173X; + long got_172X; + long need_171X; + char * start_170X; + char * new_limit_169X; + char * new_hp_168X; + long delta_167X; + long startup_space_166X; + char reverseP_165X; + FILE * port_164X; + long x_163X; + long x_162X; + char * addr_161X; + char *string_160X; + char okayP_159X; + long status_158X; + char eofP_157X; + long got_156X; + FILE * port_155X; + { port_155X = Simage_portS; + got_156X = ps_read_block(port_155X, ((char *) (ShpS)), 4, &eofP_157X, &status_158X); + if ((status_158X == NO_ERRORS)) { + if (eofP_157X) { + arg2K0 = 0; + arg3K1 = "Premature EOF when reading image file"; + goto L4943;} + else { + if ((got_156X < 4)) { + arg2K0 = 0; + arg3K1 = "Read returned too few bytes"; + goto L4943;} + else { + arg2K0 = 1; + arg3K1 = ""; + goto L4943;}}} + else { + SstatusS = status_158X; + arg2K0 = 0; + arg3K1 = "Error reading from image file"; + goto L4943;}} + L4943: { + okayP_159X = arg2K0; + string_160X = arg3K1; + if (okayP_159X) { + if ((1 == (*((long *) (ShpS))))) { + arg4K0 = port_155X; + arg2K1 = 0; + arg1K2 = startup_space_154X; + goto L4264;} + else { + addr_161X = ShpS; + x_162X = *((unsigned char *) addr_161X); + *((unsigned char *) addr_161X) = (*((unsigned char *) (addr_161X + 3))); + *((unsigned char *) (addr_161X + 3)) = x_162X; + x_163X = *((unsigned char *) (addr_161X + 1)); + *((unsigned char *) (addr_161X + 1)) = (*((unsigned char *) (addr_161X + 2))); + *((unsigned char *) (addr_161X + 2)) = x_163X; + if ((1 == (*((long *) (ShpS))))) { + arg4K0 = port_155X; + arg2K1 = 1; + arg1K2 = startup_space_154X; + goto L4264;} + else { + ps_write_string("Unable to correct byte order", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L5039;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L5039;}}}} + else { + ps_write_string(string_160X, (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L4993;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L4993;}}} + L4264: { + port_164X = arg4K0; + reverseP_165X = arg2K1; + startup_space_166X = arg1K2; + delta_167X = (ShpS) - (Sold_beginS); + new_hp_168X = (Sold_hpS) + delta_167X; + new_limit_169X = Snewspace_endS; + start_170X = ShpS; + if (((new_hp_168X + startup_space_166X) < new_limit_169X)) { + need_171X = (Sold_hpS) - (Sold_beginS); + got_172X = ps_read_block(port_164X, ((char *) (ShpS)), need_171X, &eofP_173X, &status_174X); + if ((status_174X == NO_ERRORS)) { + if (eofP_173X) { + arg2K0 = 0; + arg3K1 = "Premature EOF when reading image file"; + goto L4280;} + else { + if ((got_172X < need_171X)) { + arg2K0 = 0; + arg3K1 = "Read returned too few bytes"; + goto L4280;} + else { + arg2K0 = 1; + arg3K1 = ""; + goto L4280;}}} + else { + SstatusS = status_174X; + arg2K0 = 0; + arg3K1 = "Error reading from image file"; + goto L4280;}} + else { + ps_write_string("Heap not big enough to restore this image", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L4346;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L4346;}}} + L5039: { + status_175X = ps_close(port_155X); + if ((status_175X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L4993: { + status_176X = ps_close(port_155X); + if ((status_176X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L4280: { + okayP_177X = arg2K0; + string_178X = arg3K1; + PS_READ_CHAR(port_164X, v_179X, eofP_180X, status_181X) + if (okayP_177X) { + if ((status_181X == NO_ERRORS)) { + if (eofP_180X) { + status_182X = ps_close(port_164X); + if ((status_182X == NO_ERRORS)) { + if (reverseP_165X) { + ps_write_string("Correcting byte order of resumed image.", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + arg0K0 = start_170X; + goto L3493;} + else { + goto L4318;}} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L4481;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L4481;}}} + else { + ps_write_string("Image file has extraneous data after image", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L4451;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L4451;}}} + else { + ps_write_string("Error reading from image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L4421;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L4421;}}} + else { + ps_write_string(string_178X, (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if (((SstatusS) == NO_ERRORS)) { + goto L4391;} + else { + ps_write_string((ps_error_string((SstatusS))), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + goto L4391;}}} + L4346: { + status_183X = ps_close(port_164X); + if ((status_183X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L3493: { + ptr_184X = arg0K0; + if ((ptr_184X < new_hp_168X)) { + x_185X = *((unsigned char *) ptr_184X); + *((unsigned char *) ptr_184X) = (*((unsigned char *) (ptr_184X + 3))); + *((unsigned char *) (ptr_184X + 3)) = x_185X; + x_186X = *((unsigned char *) (ptr_184X + 1)); + *((unsigned char *) (ptr_184X + 1)) = (*((unsigned char *) (ptr_184X + 2))); + *((unsigned char *) (ptr_184X + 2)) = x_186X; + value_187X = *((long *) ptr_184X); + next_188X = ptr_184X + 4; + if ((2 == (3 & value_187X))) { + if (((31 & (((value_187X)>>2))) < 19)) { + arg0K0 = next_188X; + goto L3493;} + else { + arg0K0 = (next_188X + (-4 & (3 + ((long)(((unsigned long)value_187X)>>8))))); + goto L3493;}} + else { + arg0K0 = next_188X; + goto L3493;}} + else { + goto L4318;}} + L4318: { + if ((0 == delta_167X)) { + goto L4328;} + else { + arg0K0 = start_170X; + goto L3592;}} + L4481: { + status_189X = ps_close(port_164X); + if ((status_189X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L4451: { + status_190X = ps_close(port_164X); + if ((status_190X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L4421: { + status_191X = ps_close(port_164X); + if ((status_191X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L4391: { + status_192X = ps_close(port_164X); + if ((status_192X == NO_ERRORS)) { + return -1;} + else { + ps_write_string("Error closing image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + return -1;}} + L4328: { + ShpS = new_hp_168X; + descriptor_193X = Sstartup_procS; + if ((3 == (3 & descriptor_193X))) { + return (3 + (((long) ((((char *) (-3 + descriptor_193X))) + delta_167X))));} + else { + return descriptor_193X;}} + L3592: { + ptr_194X = arg0K0; + if ((ptr_194X < new_hp_168X)) { + descriptor_195X = *((long *) ptr_194X); + if ((3 == (3 & descriptor_195X))) { + arg1K0 = (3 + (((long) ((((char *) (-3 + descriptor_195X))) + delta_167X)))); + goto L3597;} + else { + arg1K0 = descriptor_195X; + goto L3597;}} + else { + goto L4328;}} + L3597: { + d_196X = arg1K0; + *((long *) ptr_194X) = d_196X; + if ((2 == (3 & d_196X))) { + if (((31 & (((d_196X)>>2))) < 19)) { + goto L3611;} + else { + arg0K0 = (ptr_194X + (4 + (-4 & (3 + ((long)(((unsigned long)d_196X)>>8)))))); + goto L3592;}} + else { + goto L3611;}} + L3611: { + arg0K0 = (ptr_194X + 4); + goto L3592;} +} +long write_image(long resume_proc_197X, FILE * port_198X, void (*mark_traced_channels_closedB_199X)(void)) +{ + char * arg0K0; + long arg1K0; + long h_226X; + long h_225X; + long d_224X; + char * addr_223X; + char * e_222X; + char * b_221X; + long status_220X; + long v_219X; + long v_218X; + long v_217X; + long cells_216X; + long v_215X; + long cells_214X; + long v_213X; + long v_212X; + long v_211X; + long v_210X; + long v_209X; + char * end_208X; + char * start_207X; + char * start_206X; + long resume_proc_205X; + char * new_hp_204X; + long new_thing_203X; + char * a_202X; + char * e_201X; + char * b_200X; + { b_200X = Snewspace_beginS; + Snewspace_beginS = (Soldspace_beginS); + Soldspace_beginS = b_200X; + e_201X = Snewspace_endS; + Snewspace_endS = (Soldspace_endS); + Soldspace_endS = e_201X; + Ssaved_limitS = (SlimitS); + Ssaved_hpS = (ShpS); + SlimitS = (Snewspace_endS); + ShpS = (Snewspace_beginS); + Sweak_pointer_hpS = NULL; + if ((3 == (3 & resume_proc_197X))) { + a_202X = ((char *) (-3 + resume_proc_197X)); + if ((a_202X < (Soldspace_beginS))) { + arg1K0 = resume_proc_197X; + goto L5080;} + else { + if ((a_202X < (Soldspace_endS))) { + new_thing_203X = real_copy_object(resume_proc_197X, (ShpS), &new_hp_204X); + ShpS = new_hp_204X; + arg1K0 = new_thing_203X; + goto L5080;} + else { + arg1K0 = resume_proc_197X; + goto L5080;}}} + else { + arg1K0 = resume_proc_197X; + goto L5080;}} + L5080: { + resume_proc_205X = arg1K0; + start_206X = Snewspace_beginS; + arg0K0 = start_206X; + goto L5132;} + L5132: { + start_207X = arg0K0; + end_208X = ShpS; + trace_locationsB(start_207X, end_208X); + if (((ShpS) < (SlimitS))) { + if ((end_208X < (ShpS))) { + arg0K0 = end_208X; + goto L5132;} + else { + goto L5084;}} + else { + ps_error("GC error: ran out of space in new heap", 0); + goto L5084;}} + L5084: { + clean_weak_pointers(); + (*mark_traced_channels_closedB_199X)(); + SstatusS = NO_ERRORS; + if (((SstatusS) == NO_ERRORS)) { + PS_WRITE_CHAR(10, port_198X, v_209X) + SstatusS = v_209X; + goto L1679;} + else { + goto L1679;}} + L1679: { + if (((SstatusS) == NO_ERRORS)) { + PS_WRITE_CHAR(12, port_198X, v_210X) + SstatusS = v_210X; + goto L1688;} + else { + goto L1688;}} + L1688: { + if (((SstatusS) == NO_ERRORS)) { + PS_WRITE_CHAR(10, port_198X, v_211X) + SstatusS = v_211X; + goto L1697;} + else { + goto L1697;}} + L1697: { + if (((SstatusS) == NO_ERRORS)) { + SstatusS = (ps_write_string("Kali 19", port_198X)); + goto L1704;} + else { + goto L1704;}} + L1704: { + if (((SstatusS) == NO_ERRORS)) { + PS_WRITE_CHAR(10, port_198X, v_212X) + SstatusS = v_212X; + goto L1713;} + else { + goto L1713;}} + L1713: { + if (((SstatusS) == NO_ERRORS)) { + SstatusS = (ps_write_integer(4, port_198X)); + goto L1757;} + else { + goto L1757;}} + L1757: { + if (((SstatusS) == NO_ERRORS)) { + PS_WRITE_CHAR(10, port_198X, v_213X) + SstatusS = v_213X; + goto L1715;} + else { + goto L1715;}} + L1715: { + cells_214X = ((long) (Snewspace_beginS)); + if (((SstatusS) == NO_ERRORS)) { + SstatusS = (ps_write_integer((((cells_214X)>>2)), port_198X)); + goto L1775;} + else { + goto L1775;}} + L1775: { + if (((SstatusS) == NO_ERRORS)) { + PS_WRITE_CHAR(10, port_198X, v_215X) + SstatusS = v_215X; + goto L1719;} + else { + goto L1719;}} + L1719: { + cells_216X = ((long) (ShpS)); + if (((SstatusS) == NO_ERRORS)) { + SstatusS = (ps_write_integer((((cells_216X)>>2)), port_198X)); + goto L1793;} + else { + goto L1793;}} + L1793: { + if (((SstatusS) == NO_ERRORS)) { + PS_WRITE_CHAR(10, port_198X, v_217X) + SstatusS = v_217X; + goto L1723;} + else { + goto L1723;}} + L1723: { + if (((SstatusS) == NO_ERRORS)) { + SstatusS = (ps_write_integer(resume_proc_205X, port_198X)); + goto L1808;} + else { + goto L1808;}} + L1808: { + if (((SstatusS) == NO_ERRORS)) { + PS_WRITE_CHAR(10, port_198X, v_218X) + SstatusS = v_218X; + goto L1725;} + else { + goto L1725;}} + L1725: { + if (((SstatusS) == NO_ERRORS)) { + PS_WRITE_CHAR(12, port_198X, v_219X) + SstatusS = v_219X; + goto L1734;} + else { + goto L1734;}} + L1734: { + *((long *) (ShpS)) = 1; + if (((SstatusS) == NO_ERRORS)) { + SstatusS = (ps_write_block(port_198X, ((char *) (ShpS)), (((ShpS) + 4) - (ShpS)))); + goto L1745;} + else { + goto L1745;}} + L1745: { + if (((SstatusS) == NO_ERRORS)) { + SstatusS = (ps_write_block(port_198X, ((char *) (Snewspace_beginS)), ((ShpS) - (Snewspace_beginS)))); + goto L1752;} + else { + goto L1752;}} + L1752: { + status_220X = SstatusS; + b_221X = Snewspace_beginS; + Snewspace_beginS = (Soldspace_beginS); + Soldspace_beginS = b_221X; + e_222X = Snewspace_endS; + Snewspace_endS = (Soldspace_endS); + Soldspace_endS = e_222X; + SlimitS = (Ssaved_limitS); + ShpS = (Ssaved_hpS); + arg0K0 = (Snewspace_beginS); + goto L2981;} + L2981: { + addr_223X = arg0K0; + if ((addr_223X < (ShpS))) { + d_224X = *((long *) addr_223X); + if ((2 == (3 & d_224X))) { + arg1K0 = d_224X; + goto L3000;} + else { + h_225X = *((long *) ((((char *) (-3 + d_224X))) + -4)); + *((long *) addr_223X) = h_225X; + arg1K0 = h_225X; + goto L3000;}} + else { + return status_220X;}} + L3000: { + h_226X = arg1K0; + arg0K0 = (addr_223X + (4 + (-4 & (3 + ((long)(((unsigned long)h_226X)>>8)))))); + goto L2981;} +} +long do_gc(long finalizer_alist_227X, long *TT0) +{ + char * arg0K0; + char arg2K0; + long arg1K2; + long arg1K1; + long arg1K0; + long thing_259X; + char tracedP_258X; + char * new_hp_257X; + long new_thing_256X; + char * a_255X; + long next_254X; + long thing_253X; + char * new_hp_252X; + long new_thing_251X; + char * new_hp_250X; + long new_thing_249X; + long goners_248X; + long okay_247X; + long alist_246X; + long value_245X; + char * new_hp_244X; + long new_thing_243X; + char * a_242X; + long stob_241X; + char * end_240X; + char * start_239X; + char * start_238X; + long h_237X; + long stob_236X; + long descriptor_235X; + long pair_234X; + char * start_233X; + long alist_232X; + long i_231X; + long count_230X; + long *sizes_229X; + char * *areas_228X; + { areas_228X = Simpure_areasS; + sizes_229X = Simpure_sizesS; + count_230X = Simpure_area_countS; + arg1K0 = 0; + goto L5304;} + L5304: { + i_231X = arg1K0; + if ((i_231X < count_230X)) { + trace_locationsB((*(areas_228X + i_231X)), ((*(areas_228X + i_231X)) + (*(sizes_229X + i_231X)))); + arg1K0 = (1 + i_231X); + goto L5304;} + else { + arg1K0 = finalizer_alist_227X; + goto L5155;}} + L5155: { + alist_232X = arg1K0; + if ((25 == alist_232X)) { + start_233X = Snewspace_beginS; + arg0K0 = start_233X; + goto L5319;} + else { + pair_234X = *((long *) (((char *) (-3 + alist_232X)))); + descriptor_235X = *((long *) ((((char *) (-3 + (*((long *) (((char *) (-3 + pair_234X)))))))) + -4)); + if ((2 == (3 & descriptor_235X))) { + stob_236X = *((long *) (((char *) (-3 + pair_234X)))); + h_237X = *((long *) ((((char *) (-3 + stob_236X))) + -4)); + start_238X = ((char *) (-3 + stob_236X)); + trace_locationsB(start_238X, (start_238X + (-4 & (3 + ((long)(((unsigned long)h_237X)>>8)))))); + goto L5180;} + else { + goto L5180;}}} + L5319: { + start_239X = arg0K0; + end_240X = ShpS; + trace_locationsB(start_239X, end_240X); + if (((ShpS) < (SlimitS))) { + if ((end_240X < (ShpS))) { + arg0K0 = end_240X; + goto L5319;} + else { + goto L5290;}} + else { + ps_error("GC error: ran out of space in new heap", 0); + goto L5290;}} + L5180: { + stob_241X = *((long *) ((((char *) (-3 + pair_234X))) + 4)); + if ((3 == (3 & stob_241X))) { + a_242X = ((char *) (-3 + stob_241X)); + if ((a_242X < (Soldspace_beginS))) { + arg1K0 = stob_241X; + goto L5184;} + else { + if ((a_242X < (Soldspace_endS))) { + new_thing_243X = real_copy_object(stob_241X, (ShpS), &new_hp_244X); + ShpS = new_hp_244X; + arg1K0 = new_thing_243X; + goto L5184;} + else { + arg1K0 = stob_241X; + goto L5184;}}} + else { + arg1K0 = stob_241X; + goto L5184;}} + L5290: { + clean_weak_pointers(); + arg1K0 = finalizer_alist_227X; + arg1K1 = 25; + arg1K2 = 25; + goto L4739;} + L5184: { + value_245X = arg1K0; + *((long *) ((((char *) (-3 + pair_234X))) + 4)) = value_245X; + arg1K0 = (*((long *) ((((char *) (-3 + alist_232X))) + 4))); + goto L5155;} + L4739: { + alist_246X = arg1K0; + okay_247X = arg1K1; + goners_248X = arg1K2; + if ((25 == alist_246X)) { + *TT0 = goners_248X; + return okay_247X;} + else { + new_thing_249X = real_copy_object(alist_246X, (ShpS), &new_hp_250X); + ShpS = new_hp_250X; + new_thing_251X = real_copy_object((*((long *) (((char *) (-3 + new_thing_249X))))), (ShpS), &new_hp_252X); + ShpS = new_hp_252X; + thing_253X = *((long *) (((char *) (-3 + new_thing_251X)))); + next_254X = *((long *) ((((char *) (-3 + new_thing_249X))) + 4)); + if ((3 == (3 & thing_253X))) { + a_255X = ((char *) (-3 + thing_253X)); + if ((a_255X < (Soldspace_beginS))) { + arg2K0 = 1; + arg1K1 = thing_253X; + goto L4783;} + else { + if ((a_255X < (Soldspace_endS))) { + if ((3 == (3 & (*((long *) ((((char *) (-3 + thing_253X))) + -4)))))) { + arg2K0 = 1; + arg1K1 = (*((long *) ((((char *) (-3 + thing_253X))) + -4))); + goto L4783;} + else { + new_thing_256X = real_copy_object(thing_253X, (ShpS), &new_hp_257X); + ShpS = new_hp_257X; + arg2K0 = 0; + arg1K1 = new_thing_256X; + goto L4783;}} + else { + arg2K0 = 1; + arg1K1 = thing_253X; + goto L4783;}}} + else { + arg2K0 = 1; + arg1K1 = thing_253X; + goto L4783;}}} + L4783: { + tracedP_258X = arg2K0; + thing_259X = arg1K1; + *((long *) (((char *) (-3 + new_thing_251X)))) = thing_259X; + *((long *) (((char *) (-3 + new_thing_249X)))) = new_thing_251X; + if (tracedP_258X) { + *((long *) ((((char *) (-3 + new_thing_249X))) + 4)) = okay_247X; + arg1K0 = next_254X; + arg1K1 = new_thing_249X; + arg1K2 = goners_248X; + goto L4739;} + else { + *((long *) ((((char *) (-3 + new_thing_249X))) + 4)) = goners_248X; + arg1K0 = next_254X; + arg1K1 = okay_247X; + arg1K2 = new_thing_249X; + goto L4739;}} +}void +s48_heap_init(void) +{ +Spure_area_countS = 0; +Simpure_area_countS = 0; +Sfinding_typeS = 1; +SstatusS = NO_ERRORS; +SeofPS = 0; +Sgc_countS = 0; +Hthe_record_type8040 = 536870911; +} diff --git a/c/scheme48heap.h b/c/scheme48heap.h new file mode 100644 index 0000000..7ade9eb --- /dev/null +++ b/c/scheme48heap.h @@ -0,0 +1,19 @@ +/* + * Externally visible objects defined in scheme48heap.c. + */ +extern long available(void); +extern void begin_collection(void); +extern long do_gc(long, long*); +extern void end_collection(void); +extern long find_all(long); +extern long find_all_records(long); +extern long gc_count(void); +extern long heap_size(void); +extern char image_writing_okayP(void); +extern long trace_locationsB(char *, char *); +extern long trace_stob_contentsB(long); +extern long trace_value(long); +extern long write_image(long, FILE *, void(*)(void)); + + +extern char * heap_limits(char **, char **, char **, char **); /* Kali Code */ diff --git a/c/scheme48vm.c b/c/scheme48vm.c new file mode 100644 index 0000000..d3096ed --- /dev/null +++ b/c/scheme48vm.c @@ -0,0 +1,12166 @@ +#include +#include "prescheme.h" +#include "scheme48vm.h" + +static void mark_traced_channels_closedB(void); +static long enter_string(char*); +void set_extension_valueB(long); +void note_event(void); +long required_init_space(char**, long); +void initialize_vm(char *, long); +long restart(long); +long call_startup_procedure(long, char**, long); +static long Snumber_of_channelsS; +static long *Svm_channelsS; +static long Spending_channels_headS; +static long Spending_channels_tailS; +static char * Sstack_beginS; +static char * Sstack_endS; +static char * SstackS; +static char * Sstack_limitS; +static long ScontS; +static long Sbottom_of_stackS; +static char Sstack_warningPS; +static long SenvS; +static char * Stransmit_hpS; +static char * Smax_hpS; +static char * SstartS; +static char * Sother_hpS; +static char * Sheartbreak_hotelS; +static long Sour_address_spaceS; +static char * Snew_id_hotelS; +static char * Slosing_proxy_hotelS; +static long Sbad_count_proxiesS; +static long Snew_uidsS; +static long StemplateS; +static char * Scode_pointerS; +static long SvalS; +static long Sexception_handlersS; +static long Sinterrupt_handlersS; +static long Scurrent_threadS; +static long Ssession_dataS; +static long Sfinalizer_alistS; +static long Sfinalize_theseS; +static long Senabled_interruptsS; +static long Spending_interruptsS; +static long Sinterrupted_templateS; +static long Sinterrupt_templateS; +static long Sexception_templateS; +static long Slosing_opcodeS; +static long Sexternal_call_nargsS; +char Spending_interruptPS; +long Sextension_valueS; +char Spending_eventsPS; + +static void mark_traced_channels_closedB(void) +{ + long arg0K0; + char * addr_5X; + char * addr_4X; + long descriptor_3X; + long header_2X; + long channel_1X; + long i_0X; + { arg0K0 = 0; + goto L6712;} + L6712: { + i_0X = arg0K0; + if ((i_0X == (Snumber_of_channelsS))) { + return;} + else { + channel_1X = *((Svm_channelsS) + i_0X); + if ((1 == channel_1X)) { + goto L6772;} + else { + header_2X = *((long *) ((((char *) (-3 + channel_1X))) + -4)); + if ((3 == (3 & header_2X))) { + ps_write_string("Channel closed in dumped image: ", (stderr)); + descriptor_3X = *((long *) ((((char *) (-3 + channel_1X))) + 4)); + if ((0 == (3 & descriptor_3X))) { + ps_write_integer(((((*((long *) ((((char *) (-3 + channel_1X))) + 4))))>>2)), (stderr)); + goto L6758;} + else { + ps_write_string((((char *)(((char *) (-3 + (*((long *) ((((char *) (-3 + channel_1X))) + 4)))))))), (stderr)); + goto L6758;}} + else { + goto L6772;}}}} + L6772: { + arg0K0 = (1 + i_0X); + goto L6712;} + L6758: { + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + addr_4X = ((char *) (-3 + header_2X)); + WRITE_BARRIER(addr_4X, 0); + *((long *) addr_4X) = 0; + addr_5X = (((char *) (-3 + header_2X))) + 8; + WRITE_BARRIER(addr_5X, -4); + *((long *) addr_5X) = -4; + goto L6772;} +} +static long enter_string(char *string_6X) +{ + long arg0K0; + long i_11X; + long string_10X; + char * addr_9X; + long len_8X; + long z_7X; + { z_7X = strlen((char *) string_6X); + len_8X = 1 + z_7X; + addr_9X = ALLOCATE_SPACE(19, (4 + len_8X)); + *((long *) addr_9X) = (78 + (((len_8X)<<8))); + string_10X = 3 + (((long) (addr_9X + 4))); + *((unsigned char *) ((((char *) (-3 + string_10X))) + z_7X)) = 0; + arg0K0 = 0; + goto L9553;} + L9553: { + i_11X = arg0K0; + if ((i_11X < z_7X)) { + *((unsigned char *) ((((char *) (-3 + string_10X))) + i_11X)) = ((*(string_6X + i_11X))); + arg0K0 = (1 + i_11X); + goto L9553;} + else { + return string_10X;}} +} +void set_extension_valueB(long value_12X) +{ + + { Sextension_valueS = value_12X; + return;} +} +void note_event(void) +{ + + { Spending_eventsPS = 1; + Spending_interruptPS = 1; + return;} +} +long required_init_space(char **startup_vector_13X, long startup_vector_length_14X) +{ + long arg0K1; + long arg0K0; + long s_16X; + long i_15X; + { arg0K0 = 0; + arg0K1 = 0; + goto L3948;} + L3948: { + i_15X = arg0K0; + s_16X = arg0K1; + if ((i_15X < startup_vector_length_14X)) { + arg0K0 = (1 + i_15X); + arg0K1 = (1 + (s_16X + ((((4 + (strlen((char *) (*(startup_vector_13X + i_15X))))))>>2)))); + goto L3948;} + else { + return (53 + s_16X);}} +} +void initialize_vm(char * stack_begin_17X, long stack_size_18X) +{ + long arg0K1; + char * arg1K0; + long merged_arg0K1; + long merged_arg0K0; + + int make_template_containing_ops_return_tag; + long make_template_containing_ops0_return_value; + long op1_19X; + long op2_20X; + char * addr_35X; + char * addr_34X; + char * addr_33X; + long code_32X; + long temp_31X; + char * addr_30X; + char * addr_29X; + long v_28X; + long v_27X; + long cont_26X; + long template_25X; + char * a_24X; + long size_23X; + char * start_22X; + char * stack_21X; + { if ((stack_size_18X < 8125)) { + stack_21X = (char *)malloc(32500); + if ((stack_21X == NULL)) { + ps_error("out of memory, unable to continue", 0); + arg1K0 = stack_21X; + arg0K1 = 8125; + goto L12265;} + else { + arg1K0 = stack_21X; + arg0K1 = 8125; + goto L12265;}} + else { + arg1K0 = stack_begin_17X; + arg0K1 = stack_size_18X; + goto L12265;}} + L12265: { + start_22X = arg1K0; + size_23X = arg0K1; + Sstack_beginS = start_22X; + Sstack_endS = (start_22X + (((size_23X)<<2))); + Sstack_limitS = ((Sstack_beginS) + 500); + SstackS = ((Sstack_endS) + -4); + ScontS = 1; + SenvS = 17; + arg1K0 = start_22X; + goto L12297;} + L12297: { + a_24X = arg1K0; + if ((a_24X == (Sstack_endS))) { + merged_arg0K0 = 23; + merged_arg0K1 = 31; + make_template_containing_ops_return_tag = 0; + goto make_template_containing_ops; + make_template_containing_ops_return_0: + template_25X = make_template_containing_ops0_return_value; + SstackS = ((SstackS) + -20); + *((long *) ((SstackS) + 4)) = 4134; + cont_26X = 3 + (((long) ((SstackS) + 8))); + *((long *) ((((char *) (-3 + cont_26X))) + 4)) = 0; + *((long *) ((((char *) (-3 + cont_26X))) + 8)) = template_25X; + *((long *) ((((char *) (-3 + cont_26X))) + 12)) = (SenvS); + *((long *) (((char *) (-3 + cont_26X)))) = (ScontS); + ScontS = cont_26X; + Sbottom_of_stackS = (ScontS); + merged_arg0K0 = 34; + merged_arg0K1 = 141; + make_template_containing_ops_return_tag = 1; + goto make_template_containing_ops; + make_template_containing_ops_return_1: + v_27X = make_template_containing_ops0_return_value; + Sinterrupt_templateS = v_27X; + merged_arg0K0 = 138; + merged_arg0K1 = 124; + make_template_containing_ops_return_tag = 2; + goto make_template_containing_ops; + make_template_containing_ops_return_2: + v_28X = make_template_containing_ops0_return_value; + Sexception_templateS = v_28X; + return;} + else { + *((long *) a_24X) = 252645135; + arg1K0 = (a_24X + 4); + goto L12297;}} + make_template_containing_ops: { + op1_19X = merged_arg0K0; + op2_20X = merged_arg0K1;{ + addr_29X = ALLOCATE_SPACE(20, 6); + *((long *) addr_29X) = 594; + addr_30X = ALLOCATE_SPACE(11, 20); + *((long *) addr_30X) = 4142; + temp_31X = 3 + (((long) (addr_30X + 4))); + code_32X = 3 + (((long) (addr_29X + 4))); + addr_33X = ((char *) (-3 + temp_31X)); + WRITE_BARRIER(addr_33X, code_32X); + *((long *) addr_33X) = code_32X; + addr_34X = (((char *) (-3 + temp_31X))) + 8; + WRITE_BARRIER(addr_34X, 0); + *((long *) addr_34X) = 0; + addr_35X = (((char *) (-3 + temp_31X))) + 12; + WRITE_BARRIER(addr_35X, 1); + *((long *) addr_35X) = 1; + *((unsigned char *) (((char *) (-3 + code_32X)))) = op1_19X; + *((unsigned char *) ((((char *) (-3 + code_32X))) + 1)) = op2_20X; + make_template_containing_ops0_return_value = temp_31X; + goto make_template_containing_ops_return;} + make_template_containing_ops_return: + switch (make_template_containing_ops_return_tag) { + case 0: goto make_template_containing_ops_return_0; + case 1: goto make_template_containing_ops_return_1; + default: goto make_template_containing_ops_return_2; + }} + +} +long restart(long value_36X) +{ + char *arg3K0; + char arg2K3; + char arg2K1; + char arg2K2; + char arg2K0; + char * arg1K1; + char * arg1K0; + char * arg1K4; + char * arg1K3; + long arg0K3; + long arg0K2; + long arg0K1; + long arg0K0; + char *merged_arg3K0; + char merged_arg2K2; + char * merged_arg1K1; + char * merged_arg1K0; + long merged_arg0K3; + long merged_arg0K2; + long merged_arg0K1; + long merged_arg0K0; + + int pop_continuationB_return_tag; + int get_error_string_return_tag; + long get_error_string0_return_value; + int push_continuationB_return_tag; + int push_exception_continuationB_return_tag; + int okay_argument_list_return_tag; + char okay_argument_list0_return_value; + long okay_argument_list1_return_value; + int get_current_port_return_tag; + long get_current_port0_return_value; + int copy_continuation_from_heapB_return_tag; + long copy_continuation_from_heapB0_return_value; + int encode_return_tag; + char encode0_return_value; + int extend_decode_vector_return_tag; + char extend_decode_vector0_return_value; + int encode_object_return_tag; + long encode_object0_return_value; + int real_next_id_return_tag; + long real_next_id0_return_value; + int close_channelB_return_tag; + long close_channelB0_return_value; + int channel_close_error_return_tag; + long channel_close_error0_return_value; + int collect_saving_temp_return_tag; + long collect_saving_temp0_return_value; + int copy_listS_return_tag; + long copy_listS0_return_value; + int pop_args_GlistS_return_tag; + long pop_args_GlistS0_return_value; + int save_env_in_heap_return_tag; + long save_env_in_heap0_return_value; + int copy_env_return_tag; + long copy_env0_return_value; + int really_preserve_continuation_return_tag; + long really_preserve_continuation0_return_value; + int copy_stack_into_heap_return_tag; + int push_list_return_tag; + long push_list0_return_value; + int rest_list_setup_return_tag; + int check_events_return_tag; + char check_events0_return_value; + int loseD0_return_tag; + long status_37X; + char * code_pointer_38X; + long size_39X; + long exception_40X; + long instruction_size_41X; + long list_42X; + long marker_43X; + long cont_44X; + long thing_45X; + long address_space_46X; + long pair_47X; + long address_space_48X; + char proxiesP_49X; + long thing_50X; + long thing_51X; + long decode_vector_52X; + long channel_53X; + long status_54X; + long index_55X; + long id_56X; + long value_57X; + long list_58X; + long length_59X; + long start_60X; + long count_61X; + long env_62X; + long cont_63X; + long key_64X; + long reason_65X; + long env_66X; + long key_67X; + long reason_68X; + long key_69X; + long list_70X; + long count_71X; + long wants_stack_args_72X; + long stack_arg_count_73X; + long list_args_74X; + long list_arg_count_75X; + char *message_76X; + long pc_1278X; + long tem_1277X; + long cont_1276X; + long i_1275X; + long string_1274X; + char * addr_1273X; + long len_1272X; + long len_1271X; + long x_1270X; + char *string_1269X; + long cont_1268X; + long template_1267X; + long pc_1266X; + long v_1265X; + long i_1264X; + char * p_1263X; + long tem_1262X; + long opcode_1261X; + char move_slowP_1260X; + long slow_1259X; + long len_1258X; + long fast_1257X; + long v_1256X; + long v_1255X; + long obj_1254X; + long env_1253X; + long v_1252X; + long v_1251X; + long v_1250X; + long thread_1249X; + long v_1248X; + long new_cont_1247X; + char * top_1246X; + long v_1245X; + long x_1244X; + char * addr_1243X; + long a_1242X; + char v_1241X; + char * addr_1240X; + char * addr_1239X; + long val_1238X; + long data_1237X; + char * ptr_1236X; + char * start_1235X; + char * addr_1234X; + char * addr_1233X; + char * addr_1232X; + char * addr_1231X; + char * addr_1230X; + char * addr_1229X; + char * addr_1228X; + char * addr_1227X; + long temp_1226X; + long thing_1225X; + char * ptr_1224X; + char v_1223X; + char * addr_1222X; + char temp_1221X; + char v_1220X; + char proxy_okayP_1219X; + char * start_1218X; + long y_1217X; + long p_1216X; + long old_decode_1215X; + long old_proxy_1214X; + char * ptr_1213X; + long x2_1212X; + char * ptr_1211X; + char * start_1210X; + char * next_1209X; + long thing_1208X; + char * addr_1207X; + char * start_1206X; + char * end_1205X; + char * start_1204X; + long code_1203X; + char * x_1202X; + char * end_1201X; + char * v_1200X; + char * other_begin_1199X; + char * current_end_1198X; + char * v_1197X; + char * start_hp_1196X; + long v_1195X; + char * addr_1194X; + char is_proxyP_1193X; + char * addr_1192X; + long value_1191X; + char * addr_1190X; + char * addr_1189X; + long i_1188X; + long next_1187X; + long data_1186X; + char * ptr_1185X; + char * addr_1184X; + long value_1183X; + char * start_1182X; + long i_1181X; + long next_uid_1180X; + long old_length_1179X; + long new_length_1178X; + long p_1177X; + long new_vector_1176X; + char * addr_1175X; + long len_1174X; + long new_length_1173X; + char v_1172X; + char v_1171X; + long want_length_1170X; + long x_1169X; + long minimum_new_length_1168X; + long old_length_1167X; + long decode_vector_1166X; + char * addr_1165X; + long val_1164X; + long send_1163X; + long descriptor_1162X; + char * start_1161X; + char * old_1160X; + long count_1159X; + long owner_1158X; + long descriptor_1157X; + char * o_1156X; + char * addr_1155X; + long uid_1154X; + long uid_1153X; + long descriptor_1152X; + long new_1151X; + long uid_1150X; + long p_1149X; + long p_1148X; + long p_1147X; + char * new_hp_1146X; + char * start_1145X; + char * old_1144X; + long new_1143X; + long owner_1142X; + long new_1141X; + long data_1140X; + char * addr_1139X; + long uid_1138X; + long uid_1137X; + char * addr_1136X; + long uid_1135X; + long uid_1134X; + char * addr_1133X; + long uid_1132X; + long uid_1131X; + char * addr_1130X; + long uid_1129X; + long uid_1128X; + char * addr_1127X; + long uid_1126X; + long uid_1125X; + long temp_1124X; + long h_1123X; + char * addr_1122X; + long next_1121X; + char * start_1120X; + char * old_1119X; + char * addr_1118X; + long next_1117X; + long v_1116X; + long extracted_1115X; + long next_available_1114X; + char * addr_1113X; + long status_1112X; + long v_1111X; + long v_1110X; + long v_1109X; + long os_index_1108X; + long v_1107X; + long status_1106X; + long id_1105X; + long new_1104X; + long id_1103X; + long header_1102X; + long channel_1101X; + long tem_1100X; + long i_1099X; + char * addr_1098X; + long l_1097X; + long v_1096X; + long env_1095X; + long l2_1094X; + long sickly_1093X; + long okay_1092X; + long value_1091X; + long env_1090X; + long last_env_1089X; + long cont_1088X; + long env_1087X; + long v_1086X; + long env_1085X; + long p_1084X; + long arg_count_1083X; + long i_1082X; + char * p_1081X; + long unused_1080X; + char * a_1079X; + long v_1078X; + long v_1077X; + long env_1076X; + long v_1075X; + long v_1074X; + long v_1073X; + long v_1072X; + long v_1071X; + long v_1070X; + long v_1069X; + long v_1068X; + long v_1067X; + long v_1066X; + long pc_1065X; + char * addr_1064X; + long x_1063X; + char * addr_1062X; + long a_1061X; + long last_1060X; + long l_1059X; + long x_1058X; + char * addr_1057X; + long a_1056X; + long list_1055X; + long temp_1054X; + char okayP_1053X; + char v_1052X; + long temp_1051X; + char v_1050X; + long space_1049X; + long x_1048X; + char * addr_1047X; + long a_1046X; + long count_1045X; + long args_1044X; + long start_1043X; + long temp_1042X; + char okayP_1041X; + char v_1040X; + long temp_1039X; + char v_1038X; + long space_1037X; + long env_1036X; + long cont_1035X; + char * addr_1034X; + long new_1033X; + long p_1032X; + long env_1031X; + long top_1030X; + char * addr_1029X; + long new_1028X; + char * data_addr_1027X; + char * addr_1026X; + long header_1025X; + long new_1024X; + char * data_addr_1023X; + char * addr_1022X; + long header_1021X; + long p_1020X; + long previous_1019X; + long cont_1018X; + long end_1017X; + long v_1016X; + long p_1015X; + char * arg_1014X; + char * loc_1013X; + long stob_1012X; + char * top_1011X; + long arg_count_1010X; + long i_1009X; + char * p_1008X; + long v_1007X; + long l_1006X; + long i_1005X; + long key_1004X; + char okayP_1003X; + long list_1002X; + char v_1001X; + char v_1000X; + long space_999X; + long x_998X; + long v_997X; + long x_996X; + long v_995X; + long count_994X; + long x_993X; + long v_992X; + char * addr_991X; + char * addr_990X; + long val_989X; + long channel_988X; + long status_987X; + long channel_986X; + long type_985X; + char v_984X; + long template_983X; + char not_firstP_982X; + long cont_981X; + char not_firstP_980X; + FILE * out_979X; + long current_template_978X; + long why_977X; + char * addr_976X; + long x_975X; + char * addr_974X; + long x_973X; + char * addr_972X; + char * addr_971X; + long x_970X; + char * addr_969X; + long x_968X; + char * addr_967X; + char * addr_966X; + long x_965X; + char * addr_964X; + char * addr_963X; + long val_962X; + long thing_961X; + long x_960X; + char * addr_959X; + long b_958X; + char * addr_957X; + long value_956X; + char * addr_955X; + long value_954X; + char * addr_953X; + char * addr_952X; + long value_951X; + char * addr_950X; + long value_949X; + long vector_948X; + char * addr_947X; + char * stob_start_946X; + char * addr_945X; + long count_944X; + long uid_943X; + long aspace_uid_942X; + long x_941X; + long x_940X; + long i_939X; + long status_938X; + long v_937X; + long n_936X; + long x_935X; + char * addr_934X; + long b_933X; + long x_932X; + char * addr_931X; + long b_930X; + long x_929X; + char * addr_928X; + long count_927X; + long proxy_926X; + long thing_925X; + long proxy_vector_924X; + long aspace_923X; + long decode_vector_922X; + long aspace_921X; + long thing_920X; + long x2_919X; + long x_918X; + long status_917X; + char pendingP_916X; + char eofP_915X; + long got_914X; + long length_913X; + long i_912X; + long v_911X; + long reason_910X; + long channel_909X; + long c_908X; + long b_907X; + long v_906X; + long obj_905X; + long decode_vector_904X; + long count_903X; + long uid_902X; + long aspace_uid_901X; + long p_900X; + long p_899X; + long p_898X; + char * data_addr_897X; + long decode_vector_896X; + long uid_895X; + long aspace_uid_894X; + long p_893X; + long p_892X; + char * data_addr_891X; + long decode_vector_890X; + long temp_889X; + long data_888X; + long thing_887X; + char * addr_886X; + char * addr_885X; + long x_884X; + char * addr_883X; + long b_882X; + long reason_881X; + long *new_vm_channels_880X; + long new_count_879X; + long x_878X; + char * addr_877X; + long n_876X; + long a_875X; + long v_874X; + long key_873X; + char okayP_872X; + char v_871X; + char * addr_870X; + long value_869X; + long offset_868X; + long i_867X; + long count_866X; + long y_865X; + long val_864X; + char * addr_863X; + char * addr_862X; + char * addr_861X; + long result_860X; + char * addr_859X; + long low_count_proxies_858X; + long missing_uids_857X; + long thing_856X; + char * next_855X; + long thing_854X; + char * addr_853X; + char * addr_852X; + char * addr_851X; + long symbols_850X; + long table_849X; + char * addr_848X; + long i_847X; + long bucket_846X; + long index_845X; + long h_844X; + long i_843X; + long val_842X; + long x_841X; + long status_840X; + char pendingP_839X; + long got_838X; + long length_837X; + long count_836X; + long start_835X; + char waitP_834X; + long x_833X; + long status_832X; + long channel_831X; + long v_830X; + long v_829X; + long y_828X; + long x_827X; + char temp_826X; + long index_825X; + long a_824X; + long q_823X; + long final_stack_arg_count_822X; + char v_821X; + char v_820X; + long space_819X; + long stack_arg_count_818X; + long stack_slots_817X; + char x_816X; + long channel_815X; + long obj_814X; + long arg_count_813X; + long count_812X; + long i_811X; + long env_810X; + char *v_809X; + long y_808X; + long len_807X; + long s2_806X; + char * addr_805X; + long x_804X; + char * addr_803X; + long x_802X; + char * addr_801X; + long b_800X; + long i_799X; + long l_798X; + char * next_797X; + long value_796X; + long x_795X; + long x_794X; + char * ptr_793X; + long n_792X; + long s_791X; + long v_790X; + long obj_789X; + char v_788X; + long i_787X; + char * addr_786X; + long value_785X; + char * addr_784X; + long value_783X; + long i_782X; + long x_781X; + long status_780X; + long reason_779X; + long reason_778X; + long x_777X; + long obj_776X; + long v_775X; + long v_774X; + long rest_list_773X; + long i_772X; + long n_771X; + long args_770X; + long skip_769X; + long template_768X; + long stack_arg_count_767X; + long skip_766X; + long skip_765X; + long template_764X; + long stack_arg_count_763X; + long skip_762X; + char * addr_761X; + long next_760X; + long channel_759X; + long m_758X; + long i_757X; + long value_756X; + long back_755X; + long env_754X; + long offset_753X; + long i_752X; + long x_751X; + char * addr_750X; + long a_749X; + long env_748X; + long v_747X; + long p_746X; + long key_745X; + long bucket_744X; + long index_743X; + long h_742X; + long i_741X; + long string_740X; + char * addr_739X; + long len_738X; + char * start_737X; + char * limit_736X; + long x_735X; + long obj_734X; + char temp_733X; + char minutesP_732X; + char firstP_731X; + long symbols_730X; + long table_729X; + long x_728X; + char * addr_727X; + char * addr_726X; + long vector_725X; + char * addr_724X; + long map_723X; + long i_722X; + long status_721X; + long status_720X; + long status_719X; + long status_718X; + long status_717X; + long status_716X; + FILE * port_715X; + char x_714X; + long x_713X; + long obj_712X; + long arg3_711X; + long arg2_710X; + long key_709X; + char * addr_708X; + char * addr_707X; + long val_706X; + char v_705X; + long channel_704X; + long count_703X; + long start_702X; + long obj_701X; + long arg4_700X; + long arg3_699X; + long arg2_698X; + long key_697X; + long arg5_696X; + long arg4_695X; + long arg3_694X; + long arg2_693X; + long key_692X; + long x_691X; + long status_690X; + long x_689X; + long obj_688X; + long key_687X; + long mode_686X; + long arg2_685X; + long key_684X; + long i_683X; + long i_682X; + char * addr_681X; + long i_680X; + long i_679X; + long i_678X; + long c_677X; + long b_676X; + long c_675X; + long b_674X; + long c_673X; + long b_672X; + long c_671X; + long mid_c_670X; + long v_669X; + long v_668X; + long lo_c_667X; + long hi_b_666X; + long hi_a_665X; + long lo_b_664X; + long lo_a_663X; + long b_662X; + long v_661X; + long v_660X; + long args_659X; + long next_658X; + long next_op_657X; + long cont_656X; + long index_655X; + long length_654X; + long wants_stack_args_653X; + long skip_652X; + long skip_651X; + long stack_space_650X; + long protocol_649X; + long index_648X; + long length_647X; + long wants_stack_args_646X; + long skip_645X; + long skip_644X; + long stack_space_643X; + long protocol_642X; + long n_641X; + long tem_640X; + long stack_arg_count_639X; + long v_638X; + long v_637X; + long key_636X; + long start_i_635X; + long temp_634X; + char okayP_633X; + long key_632X; + char okayP_631X; + long obj_630X; + long obj_629X; + long type_628X; + long thing_627X; + long stuff_626X; + char * addr_625X; + long val_624X; + long x_623X; + long i_622X; + long b_621X; + long p_620X; + long port_619X; + long Kchar_618X; + long x_617X; + long i_616X; + long b_615X; + long p_614X; + long p_613X; + long port_612X; + char * addr_611X; + long val_610X; + long x_609X; + long i_608X; + long b_607X; + long p_606X; + long p_605X; + long port_604X; + long list_603X; + long head_602X; + char move_slowP_601X; + long slow_600X; + long list_599X; + long n_598X; + long v_597X; + long table_596X; + long obj_595X; + long arg2_594X; + long n_593X; + long arg2_592X; + long h_591X; + long i_590X; + long val_589X; + long arg3_588X; + long arg2_587X; + char v_586X; + long aspace_585X; + long pair_584X; + long thing_583X; + char v_582X; + long x_581X; + char * addr_580X; + long x_579X; + long obj_578X; + long arg2_577X; + long v_576X; + long (*v_575X)(long, char *); + long option_574X; + long mseconds_573X; + long seconds_572X; + long option_571X; + long proc_570X; + long rest_list_569X; + long x_568X; + long tem_567X; + long pc_566X; + long v_565X; + long vector_564X; + long type_563X; + char firstP_562X; + long v_561X; + long symbols_560X; + char firstP_559X; + long table_558X; + long vector_557X; + char firstP_556X; + long x_555X; + char * addr_554X; + long b_553X; + long x_552X; + char * addr_551X; + long x_550X; + long arg2_549X; + long key_548X; + char okayP_547X; + long val_546X; + long y_545X; + long n_544X; + long prev_543X; + long ch_542X; + long val_541X; + long key_540X; + char okayP_539X; + long key_538X; + char okayP_537X; + long key_536X; + char okayP_535X; + long key_534X; + char okayP_533X; + long val_532X; + char * addr_531X; + char * addr_530X; + long val_529X; + long string_528X; + char * addr_527X; + long len_526X; + long vector_525X; + char * addr_524X; + long value_523X; + char * addr_522X; + long len_521X; + long init_520X; + char okayP_519X; + long rest_list_518X; + long stack_nargs_517X; + long new_516X; + char * addr_515X; + long len_514X; + long type_513X; + long new_512X; + char * addr_511X; + long len_510X; + long type_509X; + long value_508X; + long val_507X; + long val_506X; + long val_505X; + long val_504X; + long r_503X; + long n_502X; + long a_501X; + long a_500X; + long val_499X; + long val_498X; + long val_497X; + long val_496X; + long val_495X; + long a_494X; + long a_493X; + long val_492X; + long val_491X; + long delta_490X; + long delta_489X; + long offset_488X; + long key_487X; + char okayP_486X; + char v_485X; + long tem_484X; + long key_483X; + char okayP_482X; + long list_arg_count_481X; + long list_args_480X; + long stack_nargs_479X; + long obj_478X; + char * addr_477X; + long list_args_476X; + long follower_475X; + long list_474X; + long args_473X; + long list_arg_count_472X; + char okayP_471X; + long stack_nargs_470X; + long list_args_469X; + long total_arg_count_468X; + long code_467X; + long obj_466X; + long obj_465X; + long list_arg_count_464X; + long list_args_463X; + long stack_arg_count_462X; + long obj_461X; + char * arg_460X; + char * loc_459X; + long args_458X; + long v_457X; + long v_456X; + long v_455X; + long list_arg_count_454X; + long list_args_453X; + long stack_arg_count_452X; + long exception_451X; + long code_450X; + long stack_arg_count_449X; + char v_448X; + long key_447X; + char okayP_446X; + long key_445X; + char okayP_444X; + char * addr_443X; + long value_442X; + long v_441X; + long new_env_440X; + char * addr_439X; + long len_438X; + char v_437X; + long temp_436X; + char v_435X; + long env_434X; + char v_433X; + char v_432X; + long space_431X; + char * addr_430X; + long value_429X; + long index_428X; + long i_427X; + long env_426X; + long i_425X; + long env_424X; + long i_423X; + long env_422X; + long obj_421X; + long opcode_420X; + long nargs_419X; + FILE * out_418X; + long x_417X; + long v_416X; + long v_415X; + long v_414X; + long v_413X; + long v_412X; + long v_411X; + long count_410X; + long to_index_409X; + long from_index_408X; + long arg5_407X; + long arg4_406X; + long arg3_405X; + long arg2_404X; + char * addr_403X; + long len_402X; + long index_401X; + long x_400X; + long arg4_399X; + long arg3_398X; + long arg2_397X; + long len_396X; + long index_395X; + long arg3_394X; + long arg2_393X; + long x_392X; + long arg2_391X; + char v_390X; + char v_389X; + char v_388X; + char v_387X; + long space_386X; + long n_385X; + long x_384X; + long obj_383X; + long len_382X; + long x_381X; + long obj_380X; + long arg2_379X; + char v_378X; + char v_377X; + long space_376X; + char v_375X; + char v_374X; + long arg2_373X; + long status_372X; + long key_371X; + long x_370X; + long arg2_369X; + long mseconds_368X; + long seconds_367X; + long mseconds_366X; + long seconds_365X; + long x_364X; + long option_363X; + long x_362X; + long arg2_361X; + long rest_list_360X; + long nargs_359X; + char v_358X; + long name_357X; + long value_356X; + long x_355X; + long obj_354X; + long x_353X; + long arg2_352X; + long p_351X; + long p_350X; + long p_349X; + long old_348X; + long temp_347X; + long obj_346X; + long p_345X; + long template_344X; + long p_343X; + long temp_342X; + long obj_341X; + long x_340X; + long x_339X; + long obj_338X; + long type_337X; + char v_336X; + char v_335X; + long x_334X; + long bytes_333X; + long x_332X; + long key_331X; + long x_330X; + long arg2_329X; + char v_328X; + char v_327X; + char v_326X; + char v_325X; + long x_324X; + long value_323X; + long x_322X; + long obj_321X; + long x_320X; + long obj_319X; + char * addr_318X; + long next_317X; + long channel_316X; + long n_315X; + long head_314X; + long channel_313X; + long obj_312X; + char v_311X; + char v_310X; + char v_309X; + char v_308X; + char v_307X; + char v_306X; + char v_305X; + char v_304X; + long x_303X; + long x_302X; + long x_301X; + long arg2_300X; + long descriptor_299X; + long x_298X; + long obj_297X; + long len_296X; + char Kchar_295X; + long index_294X; + long arg3_293X; + long arg2_292X; + long len_291X; + long index_290X; + long arg2_289X; + long obj_288X; + char v_287X; + char v_286X; + long size_285X; + char init_284X; + long len_283X; + long arg2_282X; + long len_281X; + long Kchar_280X; + long index_279X; + long arg3_278X; + long arg2_277X; + long len_276X; + long index_275X; + long arg2_274X; + long obj_273X; + char v_272X; + char v_271X; + long size_270X; + long init_269X; + long len_268X; + long arg2_267X; + char * addr_266X; + long len_265X; + long index_264X; + long x_263X; + long arg3_262X; + long arg2_261X; + char * addr_260X; + long index_259X; + long len_258X; + long type_257X; + long x_256X; + long arg3_255X; + long arg2_254X; + long index_253X; + long len_252X; + long type_251X; + long x_250X; + long arg2_249X; + char v_248X; + long temp_247X; + char v_246X; + long size_245X; + long len_244X; + long type_243X; + long x_242X; + long arg2_241X; + char * addr_240X; + long type_239X; + long offset_238X; + long x_237X; + long arg2_236X; + long type_235X; + long offset_234X; + long x_233X; + char v_232X; + char v_231X; + long space_230X; + long len_229X; + char v_228X; + char v_227X; + long space_226X; + long len_225X; + long type_224X; + long x_223X; + long type_222X; + long x_221X; + long x_220X; + long x_219X; + long x_218X; + long arg2_217X; + long x_216X; + long arg2_215X; + long x_214X; + long x_213X; + long result_212X; + long x_211X; + long x_210X; + long count_209X; + long value_208X; + long x_207X; + long arg2_206X; + long arg2_205X; + long arg2_204X; + long arg2_203X; + long x_202X; + long arg2_201X; + long x_200X; + long arg2_199X; + long x_198X; + long arg2_197X; + long x_196X; + long x_195X; + long x_194X; + long x_193X; + long x_192X; + long x_191X; + long x_190X; + long x_189X; + long x_188X; + long x_187X; + long a_186X; + long x_185X; + long arg2_184X; + long b_183X; + long a_182X; + long x_181X; + long arg2_180X; + long x_179X; + long arg2_178X; + long x_177X; + long arg2_176X; + long x_175X; + long arg2_174X; + long x_173X; + long arg2_172X; + long x_171X; + long arg2_170X; + long b_169X; + long a_168X; + long y_167X; + long arg2_166X; + long z_165X; + long x_164X; + long arg2_163X; + long b_162X; + long a_161X; + long y_160X; + long arg2_159X; + long z_158X; + long x_157X; + long arg2_156X; + long x_155X; + long x_154X; + long x_153X; + long x_152X; + long x_151X; + long x_150X; + long x_149X; + long x_148X; + long arg2_147X; + long rest_list_146X; + long x_145X; + long rest_list_144X; + long stack_nargs_143X; + long arg0_142X; + long arg1_141X; + long rest_list_140X; + long arg0_139X; + long stack_nargs_138X; + long index_137X; + long val_136X; + long max_135X; + long p_134X; + char v_133X; + char v_132X; + long space_131X; + long space_130X; + long index_129X; + long v_128X; + char v_127X; + char v_126X; + long space_125X; + long code_124X; + long tem_123X; + long stack_nargs_122X; + long p_121X; + long obj_120X; + long consumer_119X; + long cont_118X; + long rest_list_117X; + long proc_116X; + long stack_nargs_115X; + long args_114X; + long length_113X; + char okayP_112X; + long list_args_111X; + long stob_110X; + char * top_of_args_109X; + long nargs_108X; + long obj_107X; + long stack_arg_count_106X; + char v_105X; + char v_104X; + long space_103X; + long code_102X; + long template_101X; + long obj_100X; + long stack_arg_count_99X; + long cont_98X; + char v_97X; + char v_96X; + long space_95X; + char v_94X; + char v_93X; + long space_92X; + long total_count_91X; + long p_90X; + long v_89X; + char * addr_88X; + long val_87X; + long location_86X; + long location_85X; + long env_84X; + long back_83X; + long env_82X; + long back_81X; + long env_80X; + long back_79X; + long count_78X; + char * code_pointer_77X; + { SvalS = value_36X; + goto L20074;} + L20074: { + arg1K0 = (Scode_pointerS); + goto L19170;} + L19170: { + code_pointer_77X = arg1K0; + switch ((*((unsigned char *) code_pointer_77X))) { + case 0 : { + merged_arg0K0 = 15; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 0; + goto push_exception_continuationB; + push_exception_continuationB_return_0: + arg0K0 = 0; + goto L17068;} + break; + case 1 : { + count_78X = ((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2))); + *((long *) (SstackS)) = (SenvS); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (1034 + (((count_78X)<<10))); + SstackS = ((SstackS) + -4); + SenvS = (3 + (((long) ((SstackS) + 8)))); + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 2 : { + SvalS = (*((long *) ((((char *) (-3 + (StemplateS)))) + ((((((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))))<<2))))); + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 3 : { + SvalS = (*((long *) ((((char *) (-3 + (StemplateS)))) + ((((*((unsigned char *) ((Scode_pointerS) + 1))))<<2))))); + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 4 : { + back_79X = *((unsigned char *) ((Scode_pointerS) + 1)); + env_80X = SenvS; + arg0K0 = env_80X; + arg0K1 = back_79X; + goto L24647;} + break; + case 5 : { + SvalS = (*((long *) ((((char *) (-3 + (SenvS)))) + ((((*((unsigned char *) ((Scode_pointerS) + 1))))<<2))))); + if ((529 == (SvalS))) { + merged_arg0K0 = 0; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 1; + goto push_exception_continuationB; + push_exception_continuationB_return_1: + arg0K0 = 0; + goto L17068;} + else { + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;}} + break; + case 6 : { + SvalS = (*((long *) ((((char *) (-3 + (*((long *) (((char *) (-3 + (SenvS))))))))) + ((((*((unsigned char *) ((Scode_pointerS) + 1))))<<2))))); + if ((529 == (SvalS))) { + merged_arg0K0 = 0; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 2; + goto push_exception_continuationB; + push_exception_continuationB_return_2: + arg0K0 = 0; + goto L17068;} + else { + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;}} + break; + case 7 : { + SvalS = (*((long *) ((((char *) (-3 + (*((long *) (((char *) (-3 + (*((long *) (((char *) (-3 + (SenvS)))))))))))))) + ((((*((unsigned char *) ((Scode_pointerS) + 1))))<<2))))); + if ((529 == (SvalS))) { + merged_arg0K0 = 0; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 3; + goto push_exception_continuationB; + push_exception_continuationB_return_3: + arg0K0 = 0; + goto L17068;} + else { + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;}} + break; + case 8 : { + back_81X = *((unsigned char *) ((Scode_pointerS) + 1)); + env_82X = SenvS; + arg0K0 = env_82X; + arg0K1 = back_81X; + goto L20936;} + break; + case 9 : { + back_83X = *((unsigned char *) ((Scode_pointerS) + 1)); + env_84X = SenvS; + arg0K0 = env_84X; + arg0K1 = back_83X; + goto L20874;} + break; + case 10 : { + location_85X = *((long *) ((((char *) (-3 + (StemplateS)))) + ((((((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))))<<2)))); + SvalS = (*((long *) ((((char *) (-3 + location_85X))) + 8))); + if ((17 == (255 & (SvalS)))) { + merged_arg0K0 = 1; + merged_arg0K1 = 3; + push_exception_continuationB_return_tag = 4; + goto push_exception_continuationB; + push_exception_continuationB_return_4: + *((long *) (SstackS)) = location_85X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;}} + break; + case 11 : { + location_86X = *((long *) ((((char *) (-3 + (StemplateS)))) + ((((((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))))<<2)))); + if ((273 == (*((long *) ((((char *) (-3 + location_86X))) + 8))))) { + merged_arg0K0 = 1; + merged_arg0K1 = 3; + push_exception_continuationB_return_tag = 5; + goto push_exception_continuationB; + push_exception_continuationB_return_5: + *((long *) (SstackS)) = location_86X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + val_87X = SvalS; + addr_88X = (((char *) (-3 + location_86X))) + 8; + WRITE_BARRIER(addr_88X, val_87X); + *((long *) addr_88X) = val_87X; + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;}} + break; + case 12 : { + v_89X = *((unsigned char *) ((Scode_pointerS) + 4)); + if ((0 == v_89X)) { + p_90X = SenvS; + if ((3 == (3 & p_90X))) { + if ((p_90X < (((long) (Sstack_beginS))))) { + arg0K0 = 0; + goto L21732;} + else { + if (((((long) (Sstack_endS))) < p_90X)) { + arg0K0 = 0; + goto L21732;} + else { + arg0K0 = ((Sstack_endS) - (Sstack_beginS)); + goto L21732;}}} + else { + arg0K0 = 0; + goto L21732;}} + else { + arg0K0 = (SvalS); + goto L21739;}} + break; + case 13 : { + total_count_91X = *((unsigned char *) ((Scode_pointerS) + 2)); + space_92X = 1 + total_count_91X; + v_93X = AVAILABLEp(space_92X); + if (v_93X) { + goto L21535;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 0; + goto collect_saving_temp; + collect_saving_temp_return_0: + v_94X = AVAILABLEp(space_92X); + if (v_94X) { + goto L21535;} + else { + ps_error("Scheme48 heap overflow", 0); + goto L21535;}}} + break; + case 14 : { + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 15 : { + SvalS = (*((long *) ((((char *) (-3 + (SenvS)))) + ((((*((unsigned char *) ((Scode_pointerS) + 1))))<<2))))); + if ((529 == (SvalS))) { + merged_arg0K0 = 0; + merged_arg0K1 = 3; + push_exception_continuationB_return_tag = 6; + goto push_exception_continuationB; + push_exception_continuationB_return_6: + arg0K0 = 0; + goto L17068;} + else { + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;}} + break; + case 16 : { + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + SvalS = (*((long *) ((((char *) (-3 + (SenvS)))) + ((((*((unsigned char *) ((Scode_pointerS) + 2))))<<2))))); + if ((529 == (SvalS))) { + merged_arg0K0 = 0; + merged_arg0K1 = 3; + push_exception_continuationB_return_tag = 7; + goto push_exception_continuationB; + push_exception_continuationB_return_7: + arg0K0 = 0; + goto L17068;} + else { + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;}} + break; + case 17 : { + SstackS = ((SstackS) + 4); + SvalS = (*((long *) (SstackS))); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 18 : { + SvalS = (*((long *) ((SstackS) + (4 + ((((*((unsigned char *) ((Scode_pointerS) + 1))))<<2)))))); + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 19 : { + *((long *) ((SstackS) + (4 + ((((*((unsigned char *) ((Scode_pointerS) + 1))))<<2))))) = (SvalS); + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 20 : { + merged_arg1K0 = ((Scode_pointerS) + (((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2))))); + merged_arg0K1 = (*((unsigned char *) ((Scode_pointerS) + 3))); + push_continuationB_return_tag = 0; + goto push_continuationB; + push_continuationB_return_0: + Scode_pointerS = ((Scode_pointerS) + 4); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 21 : { + merged_arg1K0 = ((Scode_pointerS) + (((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2))))); + merged_arg0K1 = (((((*((unsigned char *) ((Scode_pointerS) + 3))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 4)))); + push_continuationB_return_tag = 1; + goto push_continuationB; + push_continuationB_return_1: + Scode_pointerS = ((Scode_pointerS) + 5); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 22 : { + space_95X = 1 + (((((Sstack_endS) - (SstackS)))>>2)); + v_96X = AVAILABLEp(space_95X); + if (v_96X) { + arg2K0 = 1; + arg0K1 = 0; + goto L21462;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 1; + goto collect_saving_temp; + collect_saving_temp_return_1: + v_97X = AVAILABLEp(space_95X); + if (v_97X) { + arg2K0 = 1; + arg0K1 = 0; + goto L21462;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L21462;}}} + break; + case 23 : { + cont_98X = *((long *) (((char *) (-3 + (Sbottom_of_stackS))))); + if ((3 == (3 & cont_98X))) { + if ((9 == (31 & ((((*((long *) ((((char *) (-3 + cont_98X))) + -4))))>>2))))) { + if ((3 == (3 & cont_98X))) { + if ((9 == (31 & ((((*((long *) ((((char *) (-3 + cont_98X))) + -4))))>>2))))) { + merged_arg0K0 = cont_98X; + copy_continuation_from_heapB_return_tag = 0; + goto copy_continuation_from_heapB; + copy_continuation_from_heapB_return_0: + goto L20534;} + else { + goto L20571;}} + else { + goto L20571;}} + else { + goto L20535;}} + else { + goto L20535;}} + break; + case 24 : { + stack_arg_count_99X = *((unsigned char *) ((Scode_pointerS) + 1)); + obj_100X = SvalS; + if ((3 == (3 & obj_100X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + obj_100X))) + -4))))>>2))))) { + template_101X = *((long *) (((char *) (-3 + (SvalS))))); + code_102X = *((long *) (((char *) (-3 + template_101X)))); + if ((stack_arg_count_99X == (*((unsigned char *) ((((char *) (-3 + code_102X))) + 1))))) { + StemplateS = template_101X; + SenvS = (*((long *) ((((char *) (-3 + (SvalS)))) + 4))); + Scode_pointerS = ((((char *) (-3 + code_102X))) + 2); + if (((SstackS) < (Sstack_limitS))) { + space_103X = 1 + (((((Sstack_endS) - (SstackS)))>>2)); + v_104X = AVAILABLEp(space_103X); + if (v_104X) { + arg2K0 = 1; + arg0K1 = 0; + goto L19938;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 2; + goto collect_saving_temp; + collect_saving_temp_return_2: + v_105X = AVAILABLEp(space_103X); + if (v_105X) { + arg2K0 = 1; + arg0K1 = 0; + goto L19938;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L19938;}}} + else { + goto L19850;}} + else { + arg0K0 = stack_arg_count_99X; + goto L16469;}} + else { + arg0K0 = 3; + arg0K1 = stack_arg_count_99X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + else { + arg0K0 = 3; + arg0K1 = stack_arg_count_99X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + break; + case 25 : { + stack_arg_count_106X = ((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2))); + obj_107X = SvalS; + if ((3 == (3 & obj_107X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + obj_107X))) + -4))))>>2))))) { + arg0K0 = stack_arg_count_106X; + goto L16469;} + else { + arg0K0 = 3; + arg0K1 = stack_arg_count_106X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + else { + arg0K0 = 3; + arg0K1 = stack_arg_count_106X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + break; + case 26 : { + nargs_108X = *((unsigned char *) ((Scode_pointerS) + 1)); + top_of_args_109X = SstackS; + stob_110X = ScontS; + arg1K0 = ((((char *) (-3 + stob_110X))) + -8); + arg1K1 = (top_of_args_109X + (((nargs_108X)<<2))); + goto L18934;} + break; + case 27 : { + SstackS = ((SstackS) + 4); + list_args_111X = *((long *) (SstackS)); + merged_arg0K0 = list_args_111X; + okay_argument_list_return_tag = 0; + goto okay_argument_list; + okay_argument_list_return_0: + okayP_112X = okay_argument_list0_return_value; + length_113X = okay_argument_list1_return_value; + if (okayP_112X) { + arg0K0 = (((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))); + arg0K1 = list_args_111X; + arg0K2 = length_113X; + goto L18972;} + else { + *((long *) (SstackS)) = list_args_111X; + SstackS = ((SstackS) + -4); + merged_arg0K0 = 25; + merged_arg0K1 = (1 + (((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2))))); + pop_args_GlistS_return_tag = 0; + goto pop_args_GlistS; + pop_args_GlistS_return_0: + args_114X = pop_args_GlistS0_return_value; + merged_arg0K0 = 5; + merged_arg0K1 = 0; + push_exception_continuationB_return_tag = 8; + goto push_exception_continuationB; + push_exception_continuationB_return_8: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = args_114X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 28 : { + SstackS = ((SstackS) + 4); + SstackS = ((SstackS) + 4); + stack_nargs_115X = (((*((long *) (SstackS))))>>2); + proc_116X = *((long *) ((SstackS) + (4 + (((stack_nargs_115X)<<2))))); + *((long *) ((SstackS) + (4 + (((stack_nargs_115X)<<2))))) = 1; + SstackS = ((SstackS) + 4); + rest_list_117X = *((long *) (SstackS)); + if ((25 == rest_list_117X)) { + SstackS = ((SstackS) + 4); + arg0K0 = (*((long *) (SstackS))); + arg0K1 = (-2 + stack_nargs_115X); + goto L11608;} + else { + if ((25 == (*((long *) ((((char *) (-3 + rest_list_117X))) + 4))))) { + arg0K0 = (*((long *) (((char *) (-3 + rest_list_117X))))); + arg0K1 = (-1 + stack_nargs_115X); + goto L11608;} + else { + arg0K0 = (*((long *) ((((char *) (-3 + (*((long *) ((((char *) (-3 + rest_list_117X))) + 4)))))) + 4))); + arg0K1 = rest_list_117X; + goto L11649;}}} + break; + case 29 : { + SstackS = ((SstackS) + 4); + cont_118X = *((long *) (SstackS)); + if ((3 == (3 & cont_118X))) { + if ((9 == (31 & ((((*((long *) ((((char *) (-3 + cont_118X))) + -4))))>>2))))) { + merged_arg0K0 = cont_118X; + copy_continuation_from_heapB_return_tag = 1; + goto copy_continuation_from_heapB; + copy_continuation_from_heapB_return_1: + goto L18877;} + else { + goto L18884;}} + else { + goto L18884;}} + break; + case 30 : { + SstackS = ((SstackS) + 4); + consumer_119X = *((long *) (SstackS)); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + SvalS = consumer_119X; + obj_120X = SvalS; + if ((3 == (3 & obj_120X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + obj_120X))) + -4))))>>2))))) { + arg0K0 = 1; + goto L16469;} + else { + arg0K0 = 3; + arg0K1 = 1; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + else { + arg0K0 = 3; + arg0K1 = 1; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + break; + case 31 : { + pop_continuationB_return_tag = 0; + goto pop_continuationB; + pop_continuationB_return_0: + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 32 : { + arg0K0 = (((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))); + arg0K1 = 25; + arg0K2 = 0; + goto L21104;} + break; + case 33 : { + SstackS = ((SstackS) + 4); + p_121X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + stack_nargs_122X = (((*((long *) (SstackS))))>>2); + SstackS = ((SstackS) + 4); + arg0K0 = stack_nargs_122X; + arg0K1 = (*((long *) (SstackS))); + arg0K2 = ((((p_121X)>>2)) - stack_nargs_122X); + goto L21104;} + break; + case 34 : { + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 35 : { + tem_123X = *((long *) ((((char *) (-3 + (StemplateS)))) + ((((((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))))<<2)))); + StemplateS = tem_123X; + Scode_pointerS = (((char *) (-3 + (*((long *) (((char *) (-3 + tem_123X)))))))); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 36 : { + code_124X = *((long *) (((char *) (-3 + (*((long *) ((((char *) (-3 + (StemplateS)))) + ((((((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))))<<2))))))))); + if ((0 == (*((unsigned char *) ((((char *) (-3 + code_124X))) + 1))))) { + if (((SstackS) < (Sstack_limitS))) { + space_125X = 1 + (((((Sstack_endS) - (SstackS)))>>2)); + v_126X = AVAILABLEp(space_125X); + if (v_126X) { + arg2K0 = 1; + arg0K1 = 0; + goto L19676;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 3; + goto collect_saving_temp; + collect_saving_temp_return_3: + v_127X = AVAILABLEp(space_125X); + if (v_127X) { + arg2K0 = 1; + arg0K1 = 0; + goto L19676;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L19676;}}} + else { + goto L19549;}} + else { + v_128X = *((unsigned char *) ((((char *) (-3 + code_124X))) + 1)); + if ((66 == v_128X)) { + if ((0 == (*((unsigned char *) ((((char *) (-3 + code_124X))) + (-3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + code_124X))) + -4))))>>8)))))))) { + index_129X = -2 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + code_124X))) + -4))))>>8)); + space_130X = ((((*((unsigned char *) ((((char *) (-3 + code_124X))) + index_129X))))<<8)) + (*((unsigned char *) ((((char *) (-3 + code_124X))) + (1 + index_129X)))); + if ((space_130X < (64 + (((((SstackS) - (Sstack_limitS)))>>2))))) { + goto L19549;} + else { + space_131X = 1 + (((((Sstack_endS) - (SstackS)))>>2)); + v_132X = AVAILABLEp(space_131X); + if (v_132X) { + arg2K0 = 1; + arg0K1 = 0; + goto L19731;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 4; + goto collect_saving_temp; + collect_saving_temp_return_4: + v_133X = AVAILABLEp(space_131X); + if (v_133X) { + arg2K0 = 1; + arg0K1 = 0; + goto L19731;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L19731;}}}} + else { + goto L19594;}} + else { + goto L19594;}}} + break; + case 37 : { + if ((1 == (SvalS))) { + Scode_pointerS = ((Scode_pointerS) + (((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2))))); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;}} + break; + case 38 : { + Scode_pointerS = ((Scode_pointerS) + (((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2))))); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 39 : { + if ((0 == (3 & (SvalS)))) { + p_134X = SvalS; + max_135X = *((unsigned char *) ((Scode_pointerS) + 1)); + val_136X = ((p_134X)>>2); + if ((val_136X < 0)) { + goto L19450;} + else { + if ((val_136X < max_135X)) { + index_137X = 1 + (((val_136X)<<1)); + arg0K0 = (((((*((unsigned char *) ((Scode_pointerS) + (1 + index_137X)))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + (2 + index_137X))))); + goto L19452;} + else { + goto L19450;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 0; + push_exception_continuationB_return_tag = 9; + goto push_exception_continuationB; + push_exception_continuationB_return_9: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 40 : { + stack_nargs_138X = (((*((long *) ((SstackS) + 4))))>>2); + if ((0 == stack_nargs_138X)) { + arg0_139X = *((long *) ((SstackS) + 12)); + rest_list_140X = *((long *) ((SstackS) + 8)); + *((long *) (SstackS)) = arg0_139X; + SstackS = ((SstackS) + -4); + SvalS = (*((long *) (((char *) (-3 + rest_list_140X))))); + goto L20437;} + else { + arg1_141X = *((long *) ((SstackS) + (4 + (((stack_nargs_138X)<<2))))); + arg0_142X = *((long *) ((SstackS) + (8 + (((stack_nargs_138X)<<2))))); + *((long *) ((SstackS) + (8 + (((stack_nargs_138X)<<2))))) = 1; + *((long *) ((SstackS) + 4)) = (-4 + (((stack_nargs_138X)<<2))); + *((long *) (SstackS)) = arg0_142X; + SstackS = ((SstackS) + -4); + SvalS = arg1_141X; + goto L20437;}} + break; + case 41 : { + stack_nargs_143X = (((*((long *) ((SstackS) + 4))))>>2); + if ((stack_nargs_143X == 0)) { + rest_list_144X = *((long *) ((SstackS) + 8)); + if ((25 == (*((long *) ((((char *) (-3 + rest_list_144X))) + 4))))) { + arg0K0 = 1; + goto L19348;} + else { + *((long *) ((SstackS) + 8)) = (*((long *) ((((char *) (-3 + rest_list_144X))) + 4))); + *((long *) ((SstackS) + 12)) = (SvalS); + arg0K0 = -2; + goto L19348;}} + else { + if ((stack_nargs_143X == 1)) { + if ((25 == (*((long *) ((SstackS) + 8))))) { + arg0K0 = 1; + goto L19348;} + else { + *((long *) ((SstackS) + 4)) = 0; + *((long *) ((SstackS) + 12)) = (SvalS); + arg0K0 = -2; + goto L19348;}} + else { + *((long *) ((SstackS) + (8 + (((stack_nargs_143X)<<2))))) = (SvalS); + arg0K0 = -2; + goto L19348;}}} + break; + case 42 : { + if ((1 == (SvalS))) { + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + x_145X = (((*((long *) ((SstackS) + 4))))>>2); + if ((x_145X == 0)) { + rest_list_146X = *((long *) ((SstackS) + 8)); + if ((25 == (*((long *) ((((char *) (-3 + rest_list_146X))) + 4))))) { + arg0K0 = 1; + goto L20328;} + else { + *((long *) ((SstackS) + 8)) = (*((long *) ((((char *) (-3 + rest_list_146X))) + 4))); + *((long *) ((SstackS) + 12)) = (*((long *) (((char *) (-3 + rest_list_146X))))); + arg0K0 = -2; + goto L20328;}} + else { + if ((x_145X == 1)) { + if ((25 == (*((long *) ((SstackS) + 8))))) { + arg0K0 = 1; + goto L20328;} + else { + *((long *) ((SstackS) + 4)) = 0; + arg0K0 = -2; + goto L20328;}} + else { + arg0K0 = -2; + goto L20328;}}}} + break; + case 43 : { + SstackS = ((SstackS) + 4); + arg2_147X = *((long *) (SstackS)); + x_148X = SvalS; + if ((arg2_147X == x_148X)) { + arg0K0 = 5; + goto L38594;} + else { + arg0K0 = 1; + goto L38594;}} + break; + case 44 : { + x_149X = SvalS; + if ((0 == (3 & x_149X))) { + arg0K0 = 5; + goto L30584;} + else { + if ((3 == (3 & x_149X))) { + if ((22 == (31 & ((((*((long *) ((((char *) (-3 + x_149X))) + -4))))>>2))))) { + arg0K0 = 5; + goto L30584;} + else { + goto L30539;}} + else { + goto L30539;}}} + break; + case 45 : { + x_150X = SvalS; + if ((0 == (3 & x_150X))) { + goto L28870;} + else { + if ((3 == (3 & x_150X))) { + if ((22 == (31 & ((((*((long *) ((((char *) (-3 + x_150X))) + -4))))>>2))))) { + goto L28870;} + else { + goto L28873;}} + else { + goto L28873;}}} + break; + case 46 : { + x_151X = SvalS; + if ((0 == (3 & x_151X))) { + goto L28679;} + else { + if ((3 == (3 & x_151X))) { + if ((22 == (31 & ((((*((long *) ((((char *) (-3 + x_151X))) + -4))))>>2))))) { + goto L28679;} + else { + goto L28662;}} + else { + goto L28662;}}} + break; + case 47 : { + x_152X = SvalS; + if ((0 == (3 & x_152X))) { + goto L28468;} + else { + if ((3 == (3 & x_152X))) { + if ((22 == (31 & ((((*((long *) ((((char *) (-3 + x_152X))) + -4))))>>2))))) { + goto L28468;} + else { + goto L28451;}} + else { + goto L28451;}}} + break; + case 48 : { + x_153X = SvalS; + if ((0 == (3 & x_153X))) { + goto L28257;} + else { + if ((3 == (3 & x_153X))) { + if ((22 == (31 & ((((*((long *) ((((char *) (-3 + x_153X))) + -4))))>>2))))) { + goto L28257;} + else { + goto L28240;}} + else { + goto L28240;}}} + break; + case 49 : { + if ((0 == (3 & (SvalS)))) { + SvalS = 5; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 10; + goto push_exception_continuationB; + push_exception_continuationB_return_10: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 50 : { + if ((0 == (3 & (SvalS)))) { + x_154X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 11; + goto push_exception_continuationB; + push_exception_continuationB_return_11: + *((long *) (SstackS)) = x_154X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 12; + goto push_exception_continuationB; + push_exception_continuationB_return_12: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 51 : { + if ((0 == (3 & (SvalS)))) { + x_155X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 13; + goto push_exception_continuationB; + push_exception_continuationB_return_13: + *((long *) (SstackS)) = x_155X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 14; + goto push_exception_continuationB; + push_exception_continuationB_return_14: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 52 : { + SstackS = ((SstackS) + 4); + arg2_156X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_156X | (SvalS))))) { + x_157X = SvalS; + z_158X = (((arg2_156X)>>2)) + (((x_157X)>>2)); + if ((536870911 < z_158X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 15; + goto push_exception_continuationB; + push_exception_continuationB_return_15: + *((long *) (SstackS)) = arg2_156X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_157X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + if ((z_158X < -536870912)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 16; + goto push_exception_continuationB; + push_exception_continuationB_return_16: + *((long *) (SstackS)) = arg2_156X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_157X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + SvalS = (((z_158X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 17; + goto push_exception_continuationB; + push_exception_continuationB_return_17: + *((long *) (SstackS)) = arg2_156X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 53 : { + SstackS = ((SstackS) + 4); + arg2_159X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_159X | (SvalS))))) { + y_160X = SvalS; + a_161X = ((arg2_159X)>>2); + b_162X = ((y_160X)>>2); + if ((a_161X < 0)) { + arg0K0 = (0 - a_161X); + goto L7132;} + else { + arg0K0 = a_161X; + goto L7132;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 18; + goto push_exception_continuationB; + push_exception_continuationB_return_18: + *((long *) (SstackS)) = arg2_159X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 54 : { + SstackS = ((SstackS) + 4); + arg2_163X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_163X | (SvalS))))) { + x_164X = SvalS; + z_165X = (((arg2_163X)>>2)) - (((x_164X)>>2)); + if ((536870911 < z_165X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 19; + goto push_exception_continuationB; + push_exception_continuationB_return_19: + *((long *) (SstackS)) = arg2_163X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_164X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + if ((z_165X < -536870912)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 20; + goto push_exception_continuationB; + push_exception_continuationB_return_20: + *((long *) (SstackS)) = arg2_163X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_164X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + SvalS = (((z_165X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 21; + goto push_exception_continuationB; + push_exception_continuationB_return_21: + *((long *) (SstackS)) = arg2_163X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 55 : { + SstackS = ((SstackS) + 4); + arg2_166X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_166X | (SvalS))))) { + y_167X = SvalS; + if ((0 == y_167X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 22; + goto push_exception_continuationB; + push_exception_continuationB_return_22: + *((long *) (SstackS)) = arg2_166X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_167X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + a_168X = ((arg2_166X)>>2); + b_169X = ((y_167X)>>2); + if ((a_168X < 0)) { + arg0K0 = (0 - a_168X); + goto L8910;} + else { + arg0K0 = a_168X; + goto L8910;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 23; + goto push_exception_continuationB; + push_exception_continuationB_return_23: + *((long *) (SstackS)) = arg2_166X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 56 : { + SstackS = ((SstackS) + 4); + arg2_170X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_170X | (SvalS))))) { + x_171X = SvalS; + if ((arg2_170X == x_171X)) { + arg0K0 = 5; + goto L30435;} + else { + arg0K0 = 1; + goto L30435;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 24; + goto push_exception_continuationB; + push_exception_continuationB_return_24: + *((long *) (SstackS)) = arg2_170X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 57 : { + SstackS = ((SstackS) + 4); + arg2_172X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_172X | (SvalS))))) { + x_173X = SvalS; + if ((arg2_172X < x_173X)) { + arg0K0 = 5; + goto L30345;} + else { + arg0K0 = 1; + goto L30345;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 25; + goto push_exception_continuationB; + push_exception_continuationB_return_25: + *((long *) (SstackS)) = arg2_172X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 58 : { + SstackS = ((SstackS) + 4); + arg2_174X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_174X | (SvalS))))) { + x_175X = SvalS; + if ((x_175X < arg2_174X)) { + arg0K0 = 5; + goto L30255;} + else { + arg0K0 = 1; + goto L30255;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 26; + goto push_exception_continuationB; + push_exception_continuationB_return_26: + *((long *) (SstackS)) = arg2_174X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 59 : { + SstackS = ((SstackS) + 4); + arg2_176X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_176X | (SvalS))))) { + x_177X = SvalS; + if ((x_177X < arg2_176X)) { + arg0K0 = 1; + goto L30150;} + else { + arg0K0 = 5; + goto L30150;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 27; + goto push_exception_continuationB; + push_exception_continuationB_return_27: + *((long *) (SstackS)) = arg2_176X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 60 : { + SstackS = ((SstackS) + 4); + arg2_178X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_178X | (SvalS))))) { + x_179X = SvalS; + if ((arg2_178X < x_179X)) { + arg0K0 = 1; + goto L30043;} + else { + arg0K0 = 5; + goto L30043;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 28; + goto push_exception_continuationB; + push_exception_continuationB_return_28: + *((long *) (SstackS)) = arg2_178X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 61 : { + SstackS = ((SstackS) + 4); + arg2_180X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_180X | (SvalS))))) { + x_181X = SvalS; + if ((0 == x_181X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 29; + goto push_exception_continuationB; + push_exception_continuationB_return_29: + *((long *) (SstackS)) = arg2_180X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_181X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + a_182X = ((arg2_180X)>>2); + b_183X = ((x_181X)>>2); + if ((a_182X < 0)) { + arg0K0 = (0 - a_182X); + goto L34164;} + else { + arg0K0 = a_182X; + goto L34164;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 30; + goto push_exception_continuationB; + push_exception_continuationB_return_30: + *((long *) (SstackS)) = arg2_180X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 62 : { + SstackS = ((SstackS) + 4); + arg2_184X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_184X | (SvalS))))) { + x_185X = SvalS; + if ((0 == x_185X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 31; + goto push_exception_continuationB; + push_exception_continuationB_return_31: + *((long *) (SstackS)) = arg2_184X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_185X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + a_186X = ((arg2_184X)>>2); + if ((a_186X < 0)) { + arg0K0 = (0 - a_186X); + goto L34032;} + else { + arg0K0 = a_186X; + goto L34032;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 32; + goto push_exception_continuationB; + push_exception_continuationB_return_32: + *((long *) (SstackS)) = arg2_184X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 63 : { + if ((0 == (3 & (SvalS)))) { + SvalS = (SvalS); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 33; + goto push_exception_continuationB; + push_exception_continuationB_return_33: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 64 : { + if ((0 == (3 & (SvalS)))) { + SvalS = (SvalS); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 34; + goto push_exception_continuationB; + push_exception_continuationB_return_34: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 65 : { + if ((0 == (3 & (SvalS)))) { + SvalS = 4; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 35; + goto push_exception_continuationB; + push_exception_continuationB_return_35: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 66 : { + if ((0 == (3 & (SvalS)))) { + SvalS = (SvalS); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 36; + goto push_exception_continuationB; + push_exception_continuationB_return_36: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 67 : { + if ((0 == (3 & (SvalS)))) { + SvalS = 0; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 37; + goto push_exception_continuationB; + push_exception_continuationB_return_37: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 68 : { + if ((0 == (3 & (SvalS)))) { + x_187X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 38; + goto push_exception_continuationB; + push_exception_continuationB_return_38: + *((long *) (SstackS)) = x_187X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 39; + goto push_exception_continuationB; + push_exception_continuationB_return_39: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 69 : { + if ((0 == (3 & (SvalS)))) { + x_188X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 40; + goto push_exception_continuationB; + push_exception_continuationB_return_40: + *((long *) (SstackS)) = x_188X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 41; + goto push_exception_continuationB; + push_exception_continuationB_return_41: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 70 : { + if ((0 == (3 & (SvalS)))) { + x_189X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 42; + goto push_exception_continuationB; + push_exception_continuationB_return_42: + *((long *) (SstackS)) = x_189X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 43; + goto push_exception_continuationB; + push_exception_continuationB_return_43: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 71 : { + if ((0 == (3 & (SvalS)))) { + x_190X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 44; + goto push_exception_continuationB; + push_exception_continuationB_return_44: + *((long *) (SstackS)) = x_190X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 45; + goto push_exception_continuationB; + push_exception_continuationB_return_45: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 72 : { + if ((0 == (3 & (SvalS)))) { + x_191X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 46; + goto push_exception_continuationB; + push_exception_continuationB_return_46: + *((long *) (SstackS)) = x_191X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 47; + goto push_exception_continuationB; + push_exception_continuationB_return_47: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 73 : { + if ((0 == (3 & (SvalS)))) { + x_192X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 48; + goto push_exception_continuationB; + push_exception_continuationB_return_48: + *((long *) (SstackS)) = x_192X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 49; + goto push_exception_continuationB; + push_exception_continuationB_return_49: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 74 : { + if ((0 == (3 & (SvalS)))) { + x_193X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 50; + goto push_exception_continuationB; + push_exception_continuationB_return_50: + *((long *) (SstackS)) = x_193X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 51; + goto push_exception_continuationB; + push_exception_continuationB_return_51: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 75 : { + if ((0 == (3 & (SvalS)))) { + x_194X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 52; + goto push_exception_continuationB; + push_exception_continuationB_return_52: + *((long *) (SstackS)) = x_194X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 53; + goto push_exception_continuationB; + push_exception_continuationB_return_53: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 76 : { + if ((0 == (3 & (SvalS)))) { + x_195X = SvalS; + if ((x_195X < 0)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 54; + goto push_exception_continuationB; + push_exception_continuationB_return_54: + *((long *) (SstackS)) = x_195X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + SvalS = 0; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 55; + goto push_exception_continuationB; + push_exception_continuationB_return_55: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 77 : { + if ((0 == (3 & (SvalS)))) { + x_196X = SvalS; + if ((x_196X < 0)) { + arg0K0 = (0 - x_196X); + goto L28018;} + else { + arg0K0 = x_196X; + goto L28018;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 56; + goto push_exception_continuationB; + push_exception_continuationB_return_56: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 78 : { + SstackS = ((SstackS) + 4); + arg2_197X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_197X | (SvalS))))) { + x_198X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 57; + goto push_exception_continuationB; + push_exception_continuationB_return_57: + *((long *) (SstackS)) = arg2_197X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_198X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 58; + goto push_exception_continuationB; + push_exception_continuationB_return_58: + *((long *) (SstackS)) = arg2_197X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 79 : { + SstackS = ((SstackS) + 4); + arg2_199X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_199X | (SvalS))))) { + x_200X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 59; + goto push_exception_continuationB; + push_exception_continuationB_return_59: + *((long *) (SstackS)) = arg2_199X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_200X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 60; + goto push_exception_continuationB; + push_exception_continuationB_return_60: + *((long *) (SstackS)) = arg2_199X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 80 : { + SstackS = ((SstackS) + 4); + arg2_201X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_201X | (SvalS))))) { + x_202X = SvalS; + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 61; + goto push_exception_continuationB; + push_exception_continuationB_return_61: + *((long *) (SstackS)) = arg2_201X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_202X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 62; + goto push_exception_continuationB; + push_exception_continuationB_return_62: + *((long *) (SstackS)) = arg2_201X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 81 : { + if ((0 == (3 & (SvalS)))) { + SvalS = ((((~ ((((SvalS))>>2))))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 63; + goto push_exception_continuationB; + push_exception_continuationB_return_63: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 82 : { + SstackS = ((SstackS) + 4); + arg2_203X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_203X | (SvalS))))) { + SvalS = (((((((arg2_203X)>>2)) & ((((SvalS))>>2))))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 64; + goto push_exception_continuationB; + push_exception_continuationB_return_64: + *((long *) (SstackS)) = arg2_203X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 83 : { + SstackS = ((SstackS) + 4); + arg2_204X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_204X | (SvalS))))) { + SvalS = (((((((arg2_204X)>>2)) | ((((SvalS))>>2))))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 65; + goto push_exception_continuationB; + push_exception_continuationB_return_65: + *((long *) (SstackS)) = arg2_204X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 84 : { + SstackS = ((SstackS) + 4); + arg2_205X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_205X | (SvalS))))) { + SvalS = (((((((arg2_205X)>>2)) ^ ((((SvalS))>>2))))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 66; + goto push_exception_continuationB; + push_exception_continuationB_return_66: + *((long *) (SstackS)) = arg2_205X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 85 : { + SstackS = ((SstackS) + 4); + arg2_206X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_206X | (SvalS))))) { + x_207X = SvalS; + value_208X = ((arg2_206X)>>2); + count_209X = ((x_207X)>>2); + if ((count_209X < 0)) { + PS_SHIFT_RIGHT(value_208X, (0 - count_209X), x_210X) + SvalS = (((x_210X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + PS_SHIFT_LEFT(value_208X, count_209X, x_211X) + result_212X = (((((x_211X)<<2)))>>2); + PS_SHIFT_RIGHT(result_212X, count_209X, x_213X) + if ((value_208X == x_213X)) { + if ((value_208X < 0)) { + if ((result_212X < 0)) { + goto L33882;} + else { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 67; + goto push_exception_continuationB; + push_exception_continuationB_return_67: + *((long *) (SstackS)) = arg2_206X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_207X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + else { + if ((result_212X < 0)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 68; + goto push_exception_continuationB; + push_exception_continuationB_return_68: + *((long *) (SstackS)) = arg2_206X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_207X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + goto L33882;}}} + else { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 69; + goto push_exception_continuationB; + push_exception_continuationB_return_69: + *((long *) (SstackS)) = arg2_206X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_207X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 70; + goto push_exception_continuationB; + push_exception_continuationB_return_70: + *((long *) (SstackS)) = arg2_206X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 86 : { + x_214X = SvalS; + if ((9 == (255 & x_214X))) { + arg0K0 = 5; + goto L38937;} + else { + arg0K0 = 1; + goto L38937;}} + break; + case 87 : { + SstackS = ((SstackS) + 4); + arg2_215X = *((long *) (SstackS)); + if ((9 == (255 & arg2_215X))) { + if ((9 == (255 & (SvalS)))) { + x_216X = SvalS; + if ((arg2_215X == x_216X)) { + arg0K0 = 5; + goto L29915;} + else { + arg0K0 = 1; + goto L29915;}} + else { + goto L29888;}} + else { + goto L29888;}} + break; + case 88 : { + SstackS = ((SstackS) + 4); + arg2_217X = *((long *) (SstackS)); + if ((9 == (255 & arg2_217X))) { + if ((9 == (255 & (SvalS)))) { + x_218X = SvalS; + if ((arg2_217X < x_218X)) { + arg0K0 = 5; + goto L29825;} + else { + arg0K0 = 1; + goto L29825;}} + else { + goto L29798;}} + else { + goto L29798;}} + break; + case 89 : { + if ((9 == (255 & (SvalS)))) { + SvalS = (((((((((SvalS))>>8)))))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 71; + goto push_exception_continuationB; + push_exception_continuationB_return_71: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 90 : { + if ((0 == (3 & (SvalS)))) { + x_219X = (((SvalS))>>2); + if ((255 < x_219X)) { + goto L27918;} + else { + if ((x_219X < 0)) { + goto L27918;} + else { + SvalS = (9 + (((((x_219X)))<<8))); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 72; + goto push_exception_continuationB; + push_exception_continuationB_return_72: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 91 : { + x_220X = SvalS; + if ((21 == x_220X)) { + arg0K0 = 5; + goto L38966;} + else { + arg0K0 = 1; + goto L38966;}} + break; + case 92 : { + x_221X = SvalS; + type_222X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((3 == (3 & x_221X))) { + if (((31 & ((((*((long *) ((((char *) (-3 + x_221X))) + -4))))>>2))) == type_222X)) { + arg0K0 = 5; + goto L38980;} + else { + arg0K0 = 1; + goto L38980;}} + else { + arg0K0 = 1; + goto L38980;}} + break; + case 93 : { + x_223X = SvalS; + type_224X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((3 == (3 & x_223X))) { + if (((31 & ((((*((long *) ((((char *) (-3 + x_223X))) + -4))))>>2))) == type_224X)) { + SvalS = (-4 & (3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + x_223X))) + -4))))>>8)))); + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L24394;}} + else { + goto L24394;}} + break; + case 94 : { + len_225X = *((unsigned char *) ((Scode_pointerS) + 1)); + space_226X = 4 + (((len_225X)<<2)); + v_227X = AVAILABLEp(space_226X); + if (v_227X) { + goto L24200;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 5; + goto collect_saving_temp; + collect_saving_temp_return_5: + v_228X = AVAILABLEp(space_226X); + if (v_228X) { + goto L24200;} + else { + ps_error("Scheme48 heap overflow", 0); + goto L24200;}}} + break; + case 95 : { + SstackS = ((SstackS) + 4); + len_229X = (((*((long *) (SstackS))))>>2); + space_230X = 4 + (((len_229X)<<2)); + v_231X = AVAILABLEp(space_230X); + if (v_231X) { + goto L23991;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 6; + goto collect_saving_temp; + collect_saving_temp_return_6: + v_232X = AVAILABLEp(space_230X); + if (v_232X) { + goto L23991;} + else { + ps_error("Scheme48 heap overflow", 0); + goto L23991;}}} + break; + case 96 : { + x_233X = SvalS; + offset_234X = *((unsigned char *) ((Scode_pointerS) + 2)); + type_235X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((3 == (3 & x_233X))) { + if (((31 & ((((*((long *) ((((char *) (-3 + x_233X))) + -4))))>>2))) == type_235X)) { + SvalS = (*((long *) ((((char *) (-3 + x_233X))) + (((offset_234X)<<2))))); + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L23889;}} + else { + goto L23889;}} + break; + case 97 : { + SstackS = ((SstackS) + 4); + arg2_236X = *((long *) (SstackS)); + x_237X = SvalS; + offset_238X = *((unsigned char *) ((Scode_pointerS) + 2)); + type_239X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((3 == (3 & arg2_236X))) { + if (((31 & ((((*((long *) ((((char *) (-3 + arg2_236X))) + -4))))>>2))) == type_239X)) { + if ((3 == (3 & arg2_236X))) { + if ((0 == (128 & (*((long *) ((((char *) (-3 + arg2_236X))) + -4)))))) { + addr_240X = (((char *) (-3 + arg2_236X))) + (((offset_238X)<<2)); + WRITE_BARRIER(addr_240X, x_237X); + *((long *) addr_240X) = x_237X; + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L23677;}} + else { + goto L23677;}} + else { + goto L23677;}} + else { + goto L23677;}} + break; + case 98 : { + SstackS = ((SstackS) + 4); + arg2_241X = *((long *) (SstackS)); + x_242X = SvalS; + type_243X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((0 == (3 & arg2_241X))) { + len_244X = ((arg2_241X)>>2); + size_245X = 1 + len_244X; + if ((len_244X < 0)) { + goto L23349;} + else { + if ((4194305 < size_245X)) { + goto L23349;} + else { + v_246X = AVAILABLEp(size_245X); + if (v_246X) { + arg2K0 = 1; + arg0K1 = x_242X; + goto L23367;} + else { + merged_arg0K0 = x_242X; + collect_saving_temp_return_tag = 7; + goto collect_saving_temp; + collect_saving_temp_return_7: + temp_247X = collect_saving_temp0_return_value; + v_248X = AVAILABLEp(size_245X); + if (v_248X) { + arg2K0 = 1; + arg0K1 = temp_247X; + goto L23367;} + else { + arg2K0 = 0; + arg0K1 = temp_247X; + goto L23367;}}}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 73; + goto push_exception_continuationB; + push_exception_continuationB_return_73: + *((long *) (SstackS)) = (((type_243X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_241X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_242X; + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;}} + break; + case 99 : { + SstackS = ((SstackS) + 4); + arg2_249X = *((long *) (SstackS)); + x_250X = SvalS; + type_251X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((0 == (3 & x_250X))) { + if ((3 == (3 & arg2_249X))) { + if (((31 & ((((*((long *) ((((char *) (-3 + arg2_249X))) + -4))))>>2))) == type_251X)) { + len_252X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg2_249X))) + -4))))>>8))))>>2); + index_253X = ((x_250X)>>2); + if ((index_253X < 0)) { + goto L23086;} + else { + if ((index_253X < len_252X)) { + SvalS = (*((long *) ((((char *) (-3 + arg2_249X))) + (-4 & x_250X)))); + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L23086;}}} + else { + goto L23063;}} + else { + goto L23063;}} + else { + goto L23063;}} + break; + case 100 : { + SstackS = ((SstackS) + 4); + arg2_254X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_255X = *((long *) (SstackS)); + x_256X = SvalS; + type_257X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((0 == (3 & arg2_254X))) { + if ((3 == (3 & arg3_255X))) { + if (((31 & ((((*((long *) ((((char *) (-3 + arg3_255X))) + -4))))>>2))) == type_257X)) { + if ((3 == (3 & arg3_255X))) { + if ((0 == (128 & (*((long *) ((((char *) (-3 + arg3_255X))) + -4)))))) { + len_258X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg3_255X))) + -4))))>>8))))>>2); + index_259X = ((arg2_254X)>>2); + if ((index_259X < 0)) { + goto L22727;} + else { + if ((index_259X < len_258X)) { + addr_260X = (((char *) (-3 + arg3_255X))) + (-4 & arg2_254X); + WRITE_BARRIER(addr_260X, x_256X); + *((long *) addr_260X) = x_256X; + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L22727;}}} + else { + goto L22702;}} + else { + goto L22702;}} + else { + goto L22702;}} + else { + goto L22702;}} + else { + goto L22702;}} + break; + case 101 : { + SstackS = ((SstackS) + 4); + arg2_261X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_262X = *((long *) (SstackS)); + if ((0 == (3 & arg2_261X))) { + x_263X = SvalS; + index_264X = ((arg2_261X)>>2); + if ((3 == (3 & arg3_262X))) { + if (((31 & ((((*((long *) ((((char *) (-3 + arg3_262X))) + -4))))>>2))) < 19)) { + len_265X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg3_262X))) + -4))))>>8))))>>2); + if ((index_264X < 0)) { + goto L27679;} + else { + if ((index_264X < len_265X)) { + addr_266X = (((char *) (-3 + arg3_262X))) + (((index_264X)<<2)); + WRITE_BARRIER(addr_266X, x_263X); + *((long *) addr_266X) = x_263X; + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L27679;}}} + else { + goto L27660;}} + else { + goto L27660;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 74; + goto push_exception_continuationB; + push_exception_continuationB_return_74: + *((long *) (SstackS)) = arg3_262X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_261X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;}} + break; + case 102 : { + SstackS = ((SstackS) + 4); + arg2_267X = *((long *) (SstackS)); + if ((0 == (3 & (arg2_267X | (SvalS))))) { + len_268X = ((arg2_267X)>>2); + init_269X = (((SvalS))>>2); + size_270X = 1 + ((((3 + len_268X))>>2)); + if ((len_268X < 0)) { + goto L27392;} + else { + if ((4194305 < size_270X)) { + goto L27392;} + else { + v_271X = AVAILABLEp(size_270X); + if (v_271X) { + goto L27491;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 8; + goto collect_saving_temp; + collect_saving_temp_return_8: + v_272X = AVAILABLEp(size_270X); + if (v_272X) { + goto L27491;} + else { + merged_arg0K0 = 8; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 75; + goto push_exception_continuationB; + push_exception_continuationB_return_75: + *((long *) (SstackS)) = (((len_268X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((init_269X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 76; + goto push_exception_continuationB; + push_exception_continuationB_return_76: + *((long *) (SstackS)) = arg2_267X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 103 : { + obj_273X = SvalS; + if ((3 == (3 & obj_273X))) { + if ((20 == (31 & ((((*((long *) ((((char *) (-3 + obj_273X))) + -4))))>>2))))) { + SvalS = (((((long)(((unsigned long)(*((long *) ((((char *) (-3 + (SvalS)))) + -4))))>>8)))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L36172;}} + else { + goto L36172;}} + break; + case 104 : { + SstackS = ((SstackS) + 4); + arg2_274X = *((long *) (SstackS)); + if ((3 == (3 & arg2_274X))) { + if ((20 == (31 & ((((*((long *) ((((char *) (-3 + arg2_274X))) + -4))))>>2))))) { + if ((0 == (3 & (SvalS)))) { + index_275X = (((SvalS))>>2); + len_276X = (long)(((unsigned long)(*((long *) ((((char *) (-3 + arg2_274X))) + -4))))>>8); + if ((index_275X < 0)) { + goto L34988;} + else { + if ((index_275X < len_276X)) { + SvalS = ((((*((unsigned char *) ((((char *) (-3 + arg2_274X))) + index_275X))))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L34988;}}} + else { + goto L36731;}} + else { + goto L36731;}} + else { + goto L36731;}} + break; + case 105 : { + SstackS = ((SstackS) + 4); + arg2_277X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_278X = *((long *) (SstackS)); + if ((3 == (3 & arg3_278X))) { + if ((20 == (31 & ((((*((long *) ((((char *) (-3 + arg3_278X))) + -4))))>>2))))) { + if ((0 == (3 & (arg2_277X | (SvalS))))) { + index_279X = ((arg2_277X)>>2); + Kchar_280X = (((SvalS))>>2); + if ((3 == (3 & arg3_278X))) { + if ((0 == (128 & (*((long *) ((((char *) (-3 + arg3_278X))) + -4)))))) { + len_281X = (long)(((unsigned long)(*((long *) ((((char *) (-3 + arg3_278X))) + -4))))>>8); + if ((index_279X < 0)) { + goto L33694;} + else { + if ((index_279X < len_281X)) { + *((unsigned char *) ((((char *) (-3 + arg3_278X))) + index_279X)) = Kchar_280X; + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L33694;}}} + else { + goto L33673;}} + else { + goto L33673;}} + else { + goto L35539;}} + else { + goto L35539;}} + else { + goto L35539;}} + break; + case 106 : { + SstackS = ((SstackS) + 4); + arg2_282X = *((long *) (SstackS)); + if ((0 == (3 & arg2_282X))) { + if ((9 == (255 & (SvalS)))) { + len_283X = ((arg2_282X)>>2); + init_284X = ((((SvalS))>>8)); + size_285X = 1 + ((((4 + len_283X))>>2)); + if ((len_283X < 0)) { + goto L27153;} + else { + if ((4194305 < size_285X)) { + goto L27153;} + else { + v_286X = AVAILABLEp(size_285X); + if (v_286X) { + goto L27252;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 9; + goto collect_saving_temp; + collect_saving_temp_return_9: + v_287X = AVAILABLEp(size_285X); + if (v_287X) { + goto L27252;} + else { + merged_arg0K0 = 8; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 77; + goto push_exception_continuationB; + push_exception_continuationB_return_77: + *((long *) (SstackS)) = (((len_283X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (9 + ((((init_284X))<<8))); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}}}} + else { + goto L34765;}} + else { + goto L34765;}} + break; + case 107 : { + obj_288X = SvalS; + if ((3 == (3 & obj_288X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + obj_288X))) + -4))))>>2))))) { + SvalS = (-4 + (((((long)(((unsigned long)(*((long *) ((((char *) (-3 + (SvalS)))) + -4))))>>8)))<<2))); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L36115;}} + else { + goto L36115;}} + break; + case 108 : { + SstackS = ((SstackS) + 4); + arg2_289X = *((long *) (SstackS)); + if ((3 == (3 & arg2_289X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg2_289X))) + -4))))>>2))))) { + if ((0 == (3 & (SvalS)))) { + index_290X = (((SvalS))>>2); + len_291X = -1 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg2_289X))) + -4))))>>8)); + if ((index_290X < 0)) { + goto L35059;} + else { + if ((index_290X < len_291X)) { + SvalS = (9 + ((((((*((unsigned char *) ((((char *) (-3 + arg2_289X))) + index_290X))))))<<8))); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L35059;}}} + else { + goto L36824;}} + else { + goto L36824;}} + else { + goto L36824;}} + break; + case 109 : { + SstackS = ((SstackS) + 4); + arg2_292X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_293X = *((long *) (SstackS)); + if ((3 == (3 & arg3_293X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg3_293X))) + -4))))>>2))))) { + if ((0 == (3 & arg2_292X))) { + if ((9 == (255 & (SvalS)))) { + index_294X = ((arg2_292X)>>2); + Kchar_295X = ((((SvalS))>>8)); + if ((3 == (3 & arg3_293X))) { + if ((0 == (128 & (*((long *) ((((char *) (-3 + arg3_293X))) + -4)))))) { + len_296X = -1 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg3_293X))) + -4))))>>8)); + if ((index_294X < 0)) { + goto L33539;} + else { + if ((index_294X < len_296X)) { + *((unsigned char *) ((((char *) (-3 + arg3_293X))) + index_294X)) = (Kchar_295X); + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L33539;}}} + else { + goto L33518;}} + else { + goto L33518;}} + else { + goto L35413;}} + else { + goto L35413;}} + else { + goto L35413;}} + else { + goto L35413;}} + break; + case 110 : { + obj_297X = SvalS; + if ((3 == (3 & obj_297X))) { + if ((4 == (31 & ((((*((long *) ((((char *) (-3 + obj_297X))) + -4))))>>2))))) { + x_298X = SvalS; + descriptor_299X = *((long *) ((((char *) (-3 + x_298X))) + 8)); + if ((17 == (255 & descriptor_299X))) { + if ((529 == (*((long *) ((((char *) (-3 + x_298X))) + 8))))) { + arg0K0 = 5; + goto L29669;} + else { + arg0K0 = 1; + goto L29669;}} + else { + arg0K0 = 5; + goto L29669;}} + else { + goto L29641;}} + else { + goto L29641;}} + break; + case 111 : { + SstackS = ((SstackS) + 4); + arg2_300X = *((long *) (SstackS)); + if ((3 == (3 & arg2_300X))) { + if ((4 == (31 & ((((*((long *) ((((char *) (-3 + arg2_300X))) + -4))))>>2))))) { + x_301X = SvalS; + if ((1 == x_301X)) { + goto L31134;} + else { + if ((5 == x_301X)) { + goto L31134;} + else { + goto L31160;}}} + else { + goto L31160;}} + else { + goto L31160;}} + break; + case 112 : { + x_302X = SvalS; + if ((3 == (3 & x_302X))) { + if ((0 == (128 & (*((long *) ((((char *) (-3 + x_302X))) + -4)))))) { + arg0K0 = 1; + goto L39045;} + else { + arg0K0 = 5; + goto L39045;}} + else { + arg0K0 = 5; + goto L39045;}} + break; + case 113 : { + x_303X = SvalS; + if ((3 == (3 & x_303X))) { + if ((0 == (128 & (*((long *) ((((char *) (-3 + x_303X))) + -4)))))) { + *((long *) ((((char *) (-3 + x_303X))) + -4)) = (128 | (*((long *) ((((char *) (-3 + x_303X))) + -4)))); + goto L27102;} + else { + goto L27102;}} + else { + goto L27102;}} + break; + case 114 : { + v_304X = AVAILABLEp(72); + if (v_304X) { + arg2K0 = 1; + arg0K1 = 0; + goto L26701;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 10; + goto collect_saving_temp; + collect_saving_temp_return_10: + v_305X = AVAILABLEp(72); + if (v_305X) { + arg2K0 = 1; + arg0K1 = 0; + goto L26701;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L26701;}}} + break; + case 115 : { + v_306X = AVAILABLEp(66); + if (v_306X) { + arg2K0 = 1; + arg0K1 = 0; + goto L33400;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 11; + goto collect_saving_temp; + collect_saving_temp_return_11: + v_307X = AVAILABLEp(66); + if (v_307X) { + arg2K0 = 1; + arg0K1 = 0; + goto L33400;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L33400;}}} + break; + case 116 : { + v_308X = AVAILABLEp(66); + if (v_308X) { + arg2K0 = 1; + arg0K1 = 0; + goto L37957;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 12; + goto collect_saving_temp; + collect_saving_temp_return_12: + v_309X = AVAILABLEp(66); + if (v_309X) { + arg2K0 = 1; + arg0K1 = 0; + goto L37957;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L37957;}}} + break; + case 117 : { + v_310X = AVAILABLEp(66); + if (v_310X) { + arg2K0 = 1; + arg0K1 = 0; + goto L38172;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 13; + goto collect_saving_temp; + collect_saving_temp_return_13: + v_311X = AVAILABLEp(66); + if (v_311X) { + arg2K0 = 1; + arg0K1 = 0; + goto L38172;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L38172;}}} + break; + case 118 : { + obj_312X = SvalS; + if ((3 == (3 & obj_312X))) { + if ((5 == (31 & ((((*((long *) ((((char *) (-3 + obj_312X))) + -4))))>>2))))) { + channel_313X = SvalS; + head_314X = Spending_channels_headS; + if ((1 == head_314X)) { + n_315X = ps_abort_fd_op(((((*((long *) ((((char *) (-3 + channel_313X))) + 8))))>>2))); + arg0K0 = (((n_315X)<<2)); + goto L26502;} + else { + if ((channel_313X == head_314X)) { + channel_316X = Spending_channels_headS; + next_317X = *((long *) ((((char *) (-3 + channel_316X))) + 12)); + Spending_channels_headS = next_317X; + addr_318X = (((char *) (-3 + channel_316X))) + 12; + WRITE_BARRIER(addr_318X, 1); + *((long *) addr_318X) = 1; + if ((1 == next_317X)) { + Spending_channels_tailS = 1; + goto L8211;} + else { + goto L8211;}} + else { + arg0K0 = (*((long *) ((((char *) (-3 + head_314X))) + 12))); + arg0K1 = head_314X; + goto L8217;}}} + else { + goto L26503;}} + else { + goto L26503;}} + break; + case 119 : { + obj_319X = SvalS; + if ((3 == (3 & obj_319X))) { + if ((15 == (31 & ((((*((long *) ((((char *) (-3 + obj_319X))) + -4))))>>2))))) { + x_320X = *((long *) ((((char *) (-3 + (SvalS)))) + 8)); + if ((529 == x_320X)) { + arg0K0 = 1; + goto L29507;} + else { + arg0K0 = 5; + goto L29507;}} + else { + goto L29478;}} + else { + goto L29478;}} + break; + case 120 : { + obj_321X = SvalS; + if ((3 == (3 & obj_321X))) { + if ((15 == (31 & ((((*((long *) ((((char *) (-3 + obj_321X))) + -4))))>>2))))) { + x_322X = SvalS; + value_323X = *((long *) ((((char *) (-3 + x_322X))) + 8)); + if ((529 == value_323X)) { + merged_arg0K0 = 23; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 78; + goto push_exception_continuationB; + push_exception_continuationB_return_78: + *((long *) (SstackS)) = x_322X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + SvalS = value_323X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + else { + goto L26436;}} + else { + goto L26436;}} + break; + case 121 : { + SvalS = 529; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 122 : { + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 123 : { + x_324X = SvalS; + merged_arg0K0 = 16; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 79; + goto push_exception_continuationB; + push_exception_continuationB_return_79: + *((long *) (SstackS)) = x_324X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + break; + case 124 : { + SvalS = 1; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 125 : { + SvalS = 21; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 126 : { + v_325X = AVAILABLEp(66); + if (v_325X) { + arg2K0 = 1; + arg0K1 = 0; + goto L33042;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 14; + goto collect_saving_temp; + collect_saving_temp_return_14: + v_326X = AVAILABLEp(66); + if (v_326X) { + arg2K0 = 1; + arg0K1 = 0; + goto L33042;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L33042;}}} + break; + case 127 : { + SvalS = 13; + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 15; + goto collect_saving_temp; + collect_saving_temp_return_15: + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 128 : { + v_327X = AVAILABLEp(6); + if (v_327X) { + goto L32660;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 16; + goto collect_saving_temp; + collect_saving_temp_return_16: + v_328X = AVAILABLEp(6); + if (v_328X) { + goto L32660;} + else { + ps_error("Scheme48 heap overflow", 0); + goto L32660;}}} + break; + case 129 : { + SstackS = ((SstackS) + 4); + arg2_329X = *((long *) (SstackS)); + if ((0 == (3 & arg2_329X))) { + x_330X = SvalS; + key_331X = ((arg2_329X)>>2); + if ((5 == key_331X)) { + SvalS = (-4 & x_330X); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if ((0 == key_331X)) { + x_332X = available(); + SvalS = (((x_332X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if ((1 == key_331X)) { + bytes_333X = heap_size(); + SvalS = (-4 & (3 + bytes_333X)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if ((2 == key_331X)) { + SvalS = (((((Sstack_endS) - (Sstack_beginS)))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if ((3 == key_331X)) { + x_334X = gc_count(); + SvalS = (((x_334X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if ((4 == key_331X)) { + merged_arg0K0 = 15; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 80; + goto push_exception_continuationB; + push_exception_continuationB_return_80: + *((long *) (SstackS)) = (((key_331X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_330X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + if ((6 == key_331X)) { + v_335X = AVAILABLEp(5); + if (v_335X) { + goto L35946;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 17; + goto collect_saving_temp; + collect_saving_temp_return_17: + v_336X = AVAILABLEp(5); + if (v_336X) { + goto L35946;} + else { + ps_error("Scheme48 heap overflow", 0); + goto L35946;}}} + else { + merged_arg0K0 = 18; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 81; + goto push_exception_continuationB; + push_exception_continuationB_return_81: + *((long *) (SstackS)) = (((key_331X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_330X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}}}}}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 82; + goto push_exception_continuationB; + push_exception_continuationB_return_82: + *((long *) (SstackS)) = arg2_329X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 130 : { + if ((0 == (3 & (SvalS)))) { + type_337X = (((SvalS))>>2); + arg2K0 = 1; + goto L26300;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 83; + goto push_exception_continuationB; + push_exception_continuationB_return_83: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 131 : { + obj_338X = SvalS; + if ((3 == (3 & obj_338X))) { + if ((2 == (31 & ((((*((long *) ((((char *) (-3 + obj_338X))) + -4))))>>2))))) { + x_339X = SvalS; + arg0K0 = x_339X; + arg2K1 = 1; + goto L35273;} + else { + goto L35295;}} + else { + goto L35295;}} + break; + case 132 : { + x_340X = SvalS; + arg2K0 = 1; + arg0K1 = x_340X; + goto L39120;} + break; + case 133 : { + SvalS = (Scurrent_threadS); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 134 : { + Scurrent_threadS = (SvalS); + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 135 : { + SvalS = (Ssession_dataS); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 136 : { + Ssession_dataS = (SvalS); + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 137 : { + obj_341X = SvalS; + if ((3 == (3 & obj_341X))) { + if ((2 == (31 & ((((*((long *) ((((char *) (-3 + obj_341X))) + -4))))>>2))))) { + if ((((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + (SvalS)))) + -4))))>>8))))>>2)) < 163)) { + goto L21340;} + else { + temp_342X = Sexception_handlersS; + Sexception_handlersS = (SvalS); + SvalS = temp_342X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + else { + goto L21340;}} + else { + goto L21340;}} + break; + case 138 : { + SstackS = ((SstackS) + 4); + p_343X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + template_344X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + SstackS = ((SstackS) + 4); + p_345X = *((long *) (SstackS)); + StemplateS = template_344X; + Scode_pointerS = ((((char *) (-3 + (*((long *) (((char *) (-3 + template_344X)))))))) + ((((((((((p_343X)>>2)) + (((p_345X)>>2))))<<2)))>>2))); + arg1K0 = (Scode_pointerS); + goto L19170;} + break; + case 139 : { + obj_346X = SvalS; + if ((3 == (3 & obj_346X))) { + if ((2 == (31 & ((((*((long *) ((((char *) (-3 + obj_346X))) + -4))))>>2))))) { + if ((((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + (SvalS)))) + -4))))>>8))))>>2)) < 4)) { + goto L20181;} + else { + temp_347X = Sinterrupt_handlersS; + Sinterrupt_handlersS = (SvalS); + SvalS = temp_347X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + else { + goto L20181;}} + else { + goto L20181;}} + break; + case 140 : { + old_348X = Senabled_interruptsS; + p_349X = SvalS; + Senabled_interruptsS = (((p_349X)>>2)); + if ((0 == ((Spending_interruptsS) & (Senabled_interruptsS)))) { + Spending_interruptPS = 0; + if ((Spending_eventsPS)) { + Spending_interruptPS = 1; + goto L39161;} + else { + goto L39161;}} + else { + Spending_interruptPS = 1; + goto L39161;}} + break; + case 141 : { + SstackS = ((SstackS) + 4); + p_350X = *((long *) (SstackS)); + Senabled_interruptsS = (((p_350X)>>2)); + if ((0 == ((Spending_interruptsS) & (Senabled_interruptsS)))) { + Spending_interruptPS = 0; + if ((Spending_eventsPS)) { + Spending_interruptPS = 1; + goto L19184;} + else { + goto L19184;}} + else { + Spending_interruptPS = 1; + goto L19184;}} + break; + case 142 : { + if ((0 == (3 & (SvalS)))) { + p_351X = SvalS; + Spending_interruptsS = (-2 & (Spending_interruptsS)); + if ((0 == ((Spending_interruptsS) & (Senabled_interruptsS)))) { + Spending_interruptPS = 0; + if ((Spending_eventsPS)) { + Spending_interruptPS = 1; + goto L35843;} + else { + goto L35843;}} + else { + Spending_interruptPS = 1; + goto L35843;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 84; + goto push_exception_continuationB; + push_exception_continuationB_return_84: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + break; + case 143 : { + SstackS = ((SstackS) + 4); + arg2_352X = *((long *) (SstackS)); + if ((0 == (3 & arg2_352X))) { + x_353X = SvalS; + if ((1 == x_353X)) { + goto L30902;} + else { + if ((5 == x_353X)) { + goto L30902;} + else { + goto L30922;}}} + else { + goto L30922;}} + break; + case 144 : { + obj_354X = SvalS; + if ((3 == (3 & obj_354X))) { + if ((13 == (31 & ((((*((long *) ((((char *) (-3 + obj_354X))) + -4))))>>2))))) { + x_355X = SvalS; + value_356X = *((long *) ((((char *) (-3 + x_355X))) + 4)); + name_357X = *((long *) (((char *) (-3 + x_355X)))); + if ((3 == (3 & name_357X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + name_357X))) + -4))))>>2))))) { + if ((3 == (3 & value_356X))) { + if ((20 == (31 & ((((*((long *) ((((char *) (-3 + value_356X))) + -4))))>>2))))) { + v_358X = lookup_external_name((((char *) (-3 + name_357X))), (((char *) (-3 + value_356X)))); + if (v_358X) { + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L32516;}} + else { + goto L32516;}} + else { + goto L32516;}} + else { + goto L32516;}} + else { + goto L32516;}} + else { + goto L32521;}} + else { + goto L32521;}} + break; + case 145 : { + SstackS = ((SstackS) + 4); + nargs_359X = (((*((long *) (SstackS))))>>2); + SstackS = ((SstackS) + 4); + SstackS = ((SstackS) + 4); + rest_list_360X = *((long *) (SstackS)); + arg0K0 = rest_list_360X; + goto L17750;} + break; + case 146 : { + SstackS = ((SstackS) + 4); + arg2_361X = *((long *) (SstackS)); + if ((0 == (3 & arg2_361X))) { + x_362X = SvalS; + option_363X = ((arg2_361X)>>2); + if ((2 == option_363X)) { + x_364X = CHEAP_TIME(); + SvalS = (((x_364X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if ((0 == option_363X)) { + seconds_365X = run_time(&mseconds_366X); + arg0K0 = option_363X; + arg0K1 = seconds_365X; + arg0K2 = mseconds_366X; + goto L35710;} + else { + if ((1 == option_363X)) { + seconds_367X = real_time(&mseconds_368X); + arg0K0 = option_363X; + arg0K1 = seconds_367X; + arg0K2 = mseconds_368X; + goto L35710;} + else { + merged_arg0K0 = 18; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 85; + goto push_exception_continuationB; + push_exception_continuationB_return_85: + *((long *) (SstackS)) = (((option_363X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_362X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 86; + goto push_exception_continuationB; + push_exception_continuationB_return_86: + *((long *) (SstackS)) = arg2_361X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 147 : { + SstackS = ((SstackS) + 4); + arg2_369X = *((long *) (SstackS)); + if ((0 == (3 & arg2_369X))) { + x_370X = SvalS; + key_371X = ((arg2_369X)>>2); + status_372X = extended_vm(key_371X, x_370X); + if ((0 == status_372X)) { + SvalS = (Sextension_valueS); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if ((1 == status_372X)) { + merged_arg0K0 = 20; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 87; + goto push_exception_continuationB; + push_exception_continuationB_return_87: + *((long *) (SstackS)) = (((key_371X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_370X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + merged_arg0K0 = 21; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 88; + goto push_exception_continuationB; + push_exception_continuationB_return_88: + *((long *) (SstackS)) = (((key_371X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_370X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 89; + goto push_exception_continuationB; + push_exception_continuationB_return_89: + *((long *) (SstackS)) = arg2_369X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 148 : { + SstackS = ((SstackS) + 4); + arg2_373X = *((long *) (SstackS)); + if ((0 == (3 & arg2_373X))) { + SvalS = (SvalS); + arg0K0 = 0; + goto L20076;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 90; + goto push_exception_continuationB; + push_exception_continuationB_return_90: + *((long *) (SstackS)) = arg2_373X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + break; + case 149 : { + v_374X = AVAILABLEp(3); + if (v_374X) { + goto L25832;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 18; + goto collect_saving_temp; + collect_saving_temp_return_18: + v_375X = AVAILABLEp(3); + if (v_375X) { + goto L25832;} + else { + ps_error("Scheme48 heap overflow", 0); + goto L25832;}}} + break; + case 150 : { + space_376X = 4 + (-4 & (3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + (SvalS)))) + -4))))>>8)))); + v_377X = AVAILABLEp(space_376X); + if (v_377X) { + goto L25563;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 19; + goto collect_saving_temp; + collect_saving_temp_return_19: + v_378X = AVAILABLEp(space_376X); + if (v_378X) { + goto L25563;} + else { + ps_error("Scheme48 heap overflow", 0); + goto L25563;}}} + break; + case 151 : { + SstackS = ((SstackS) + 4); + arg2_379X = *((long *) (SstackS)); + if ((3 == (3 & arg2_379X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg2_379X))) + -4))))>>2))))) { + obj_380X = SvalS; + if ((3 == (3 & obj_380X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + obj_380X))) + -4))))>>2))))) { + x_381X = SvalS; + len_382X = (long)(((unsigned long)(*((long *) ((((char *) (-3 + arg2_379X))) + -4))))>>8); + if ((len_382X == ((long)(((unsigned long)(*((long *) ((((char *) (-3 + x_381X))) + -4))))>>8)))) { + if (((!memcmp((void *)(((char *) (-3 + x_381X))), (void *)(((char *) (-3 + arg2_379X))),len_382X)))) { + arg0K0 = 5; + goto L29376;} + else { + arg0K0 = 1; + goto L29376;}} + else { + arg0K0 = 1; + goto L29376;}} + else { + goto L29343;}} + else { + goto L29343;}} + else { + goto L29343;}} + else { + goto L29343;}} + break; + case 152 : { + obj_383X = SvalS; + if ((3 == (3 & obj_383X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + obj_383X))) + -4))))>>2))))) { + x_384X = SvalS; + n_385X = -1 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + x_384X))) + -4))))>>8)); + arg0K0 = 0; + arg0K1 = 0; + goto L35799;} + else { + goto L35776;}} + else { + goto L35776;}} + break; + case 153 : { + space_386X = 1 + ((((4 + ((((SvalS))>>2))))>>2)); + v_387X = AVAILABLEp(space_386X); + if (v_387X) { + goto L25269;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 20; + goto collect_saving_temp; + collect_saving_temp_return_20: + v_388X = AVAILABLEp(space_386X); + if (v_388X) { + goto L25269;} + else { + ps_error("Scheme48 heap overflow", 0); + goto L25269;}}} + break; + case 154 : { + v_389X = AVAILABLEp(6); + if (v_389X) { + goto L25127;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 21; + goto collect_saving_temp; + collect_saving_temp_return_21: + v_390X = AVAILABLEp(6); + if (v_390X) { + goto L25127;} + else { + ps_error("Scheme48 heap overflow", 0); + goto L25127;}}} + break; + case 155 : { + SstackS = ((SstackS) + 4); + arg2_391X = *((long *) (SstackS)); + x_392X = SvalS; + arg0K0 = x_392X; + arg0K1 = x_392X; + arg2K2 = 1; + goto L29068;} + break; + case 156 : { + SstackS = ((SstackS) + 4); + arg2_393X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_394X = *((long *) (SstackS)); + if ((0 == (3 & (SvalS)))) { + index_395X = (((SvalS))>>2); + if ((3 == (3 & arg3_394X))) { + if ((8 == (31 & ((((*((long *) ((((char *) (-3 + arg3_394X))) + -4))))>>2))))) { + if ((arg2_393X == (*((long *) (((char *) (-3 + arg3_394X))))))) { + len_396X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg3_394X))) + -4))))>>8))))>>2); + if ((index_395X < 0)) { + goto L24913;} + else { + if ((index_395X < len_396X)) { + SvalS = (*((long *) ((((char *) (-3 + arg3_394X))) + (((index_395X)<<2))))); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L24913;}}} + else { + goto L24960;}} + else { + goto L24960;}} + else { + goto L24960;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 91; + goto push_exception_continuationB; + push_exception_continuationB_return_91: + *((long *) (SstackS)) = arg3_394X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_393X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;}} + break; + case 157 : { + SstackS = ((SstackS) + 4); + arg2_397X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_398X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg4_399X = *((long *) (SstackS)); + if ((0 == (3 & arg2_397X))) { + x_400X = SvalS; + index_401X = ((arg2_397X)>>2); + if ((3 == (3 & arg4_399X))) { + if ((8 == (31 & ((((*((long *) ((((char *) (-3 + arg4_399X))) + -4))))>>2))))) { + if ((arg3_398X == (*((long *) (((char *) (-3 + arg4_399X))))))) { + if ((3 == (3 & arg4_399X))) { + if ((0 == (128 & (*((long *) ((((char *) (-3 + arg4_399X))) + -4)))))) { + len_402X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg4_399X))) + -4))))>>8))))>>2); + if ((index_401X < 0)) { + goto L32167;} + else { + if ((index_401X < len_402X)) { + addr_403X = (((char *) (-3 + arg4_399X))) + (((index_401X)<<2)); + WRITE_BARRIER(addr_403X, x_400X); + *((long *) addr_403X) = x_400X; + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L32167;}}} + else { + goto L32224;}} + else { + goto L32224;}} + else { + goto L32224;}} + else { + goto L32224;}} + else { + goto L32224;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 92; + goto push_exception_continuationB; + push_exception_continuationB_return_92: + *((long *) (SstackS)) = arg4_399X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg3_398X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_397X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 4; + goto L17068;}} + break; + case 158 : { + SstackS = ((SstackS) + 4); + arg2_404X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_405X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg4_406X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg5_407X = *((long *) (SstackS)); + if ((0 == (3 & ((arg4_406X | arg2_404X) | (SvalS))))) { + from_index_408X = ((arg4_406X)>>2); + to_index_409X = ((arg2_404X)>>2); + count_410X = (((SvalS))>>2); + if ((3 == (3 & arg5_407X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg5_407X))) + -4))))>>2))))) { + goto L31531;} + else { + goto L31526;}} + else { + goto L31526;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 93; + goto push_exception_continuationB; + push_exception_continuationB_return_93: + *((long *) (SstackS)) = arg5_407X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg4_406X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg3_405X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_404X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 5; + goto L17068;}} + break; + case 159 : { + v_411X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((0 == v_411X)) { + arg0K0 = (SvalS); + goto L22434;} + else { + merged_arg0K0 = 0; + get_current_port_return_tag = 0; + goto get_current_port; + get_current_port_return_0: + v_412X = get_current_port0_return_value; + arg0K0 = v_412X; + goto L22434;}} + break; + case 160 : { + v_413X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((0 == v_413X)) { + arg0K0 = (SvalS); + goto L22231;} + else { + merged_arg0K0 = 0; + get_current_port_return_tag = 1; + goto get_current_port; + get_current_port_return_1: + v_414X = get_current_port0_return_value; + arg0K0 = v_414X; + goto L22231;}} + break; + case 161 : { + v_415X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((0 == v_415X)) { + SstackS = ((SstackS) + 4); + arg0K0 = (*((long *) (SstackS))); + arg0K1 = (SvalS); + goto L21978;} + else { + merged_arg0K0 = 4; + get_current_port_return_tag = 2; + goto get_current_port; + get_current_port_return_2: + v_416X = get_current_port0_return_value; + arg0K0 = (SvalS); + arg0K1 = v_416X; + goto L21978;}} + break; + case 162 : { + x_417X = SvalS; + out_418X = stderr; + arg0K0 = x_417X; + goto L30811;} + break; + }} + L17068: { + nargs_419X = arg0K0; + opcode_420X = (((*((long *) ((SstackS) + (8 + (((nargs_419X)<<2)))))))>>2); + obj_421X = Sexception_handlersS; + if ((3 == (3 & obj_421X))) { + if ((2 == (31 & ((((*((long *) ((((char *) (-3 + obj_421X))) + -4))))>>2))))) { + goto L17127;} + else { + goto L17200;}} + else { + goto L17200;}} + L24647: { + env_422X = arg0K0; + i_423X = arg0K1; + if ((0 == i_423X)) { + SvalS = (*((long *) ((((char *) (-3 + env_422X))) + ((((*((unsigned char *) ((Scode_pointerS) + 2))))<<2))))); + if ((529 == (SvalS))) { + merged_arg0K0 = 0; + merged_arg0K1 = 3; + push_exception_continuationB_return_tag = 94; + goto push_exception_continuationB; + push_exception_continuationB_return_94: + arg0K0 = 0; + goto L17068;} + else { + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;}} + else { + arg0K0 = (*((long *) (((char *) (-3 + env_422X))))); + arg0K1 = (-1 + i_423X); + goto L24647;}} + L20936: { + env_424X = arg0K0; + i_425X = arg0K1; + if ((0 == i_425X)) { + SvalS = (*((long *) ((((char *) (-3 + env_424X))) + ((((((((*((unsigned char *) ((Scode_pointerS) + 2))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 3)))))<<2))))); + if ((529 == (SvalS))) { + merged_arg0K0 = 0; + merged_arg0K1 = 4; + push_exception_continuationB_return_tag = 95; + goto push_exception_continuationB; + push_exception_continuationB_return_95: + arg0K0 = 0; + goto L17068;} + else { + Scode_pointerS = ((Scode_pointerS) + 4); + arg1K0 = (Scode_pointerS); + goto L19170;}} + else { + arg0K0 = (*((long *) (((char *) (-3 + env_424X))))); + arg0K1 = (-1 + i_425X); + goto L20936;}} + L20874: { + env_426X = arg0K0; + i_427X = arg0K1; + if ((0 == i_427X)) { + index_428X = ((((*((unsigned char *) ((Scode_pointerS) + 2))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 3))); + value_429X = SvalS; + addr_430X = (((char *) (-3 + env_426X))) + (((index_428X)<<2)); + WRITE_BARRIER(addr_430X, value_429X); + *((long *) addr_430X) = value_429X; + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 4); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + arg0K0 = (*((long *) (((char *) (-3 + env_426X))))); + arg0K1 = (-1 + i_427X); + goto L20874;}} + L21732: { + space_431X = arg0K0; + v_432X = AVAILABLEp(space_431X); + if (v_432X) { + arg2K0 = 1; + arg0K1 = 0; + goto L21830;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 22; + goto collect_saving_temp; + collect_saving_temp_return_22: + v_433X = AVAILABLEp(space_431X); + if (v_433X) { + arg2K0 = 1; + arg0K1 = 0; + goto L21830;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L21830;}}} + L21739: { + env_434X = arg0K0; + v_435X = AVAILABLEp(3); + if (v_435X) { + arg2K0 = 1; + arg0K1 = env_434X; + goto L21764;} + else { + merged_arg0K0 = env_434X; + collect_saving_temp_return_tag = 23; + goto collect_saving_temp; + collect_saving_temp_return_23: + temp_436X = collect_saving_temp0_return_value; + v_437X = AVAILABLEp(3); + if (v_437X) { + arg2K0 = 1; + arg0K1 = temp_436X; + goto L21764;} + else { + arg2K0 = 0; + arg0K1 = temp_436X; + goto L21764;}}} + L21535: { + len_438X = ((total_count_91X)<<2); + addr_439X = ALLOCATE_SPACE(2, (4 + len_438X)); + *((long *) addr_439X) = (10 + (((len_438X)<<8))); + new_env_440X = 3 + (((long) (addr_439X + 4))); + v_441X = *((unsigned char *) ((Scode_pointerS) + 1)); + if ((0 == v_441X)) { + arg0K0 = 0; + goto L21549;} + else { + value_442X = SvalS; + addr_443X = ((char *) (-3 + new_env_440X)); + WRITE_BARRIER(addr_443X, value_442X); + *((long *) addr_443X) = value_442X; + arg0K0 = 1; + goto L21549;}} + L21462: { + okayP_444X = arg2K0; + key_445X = arg0K1; + if (okayP_444X) { + arg0K0 = key_445X; + goto L21450;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_445X; + goto L21450;}} + L20534: { + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L20571: { + SstackS = ((((char *) (-3 + (Sbottom_of_stackS)))) + -8); + *((long *) (((char *) (-3 + (Sbottom_of_stackS))))) = cont_98X; + ScontS = (Sbottom_of_stackS); + goto L20534;} + L20535: { + if ((1 == cont_98X)) { + if ((0 == (3 & (SvalS)))) { + SvalS = ((((SvalS))>>2)); + arg0K0 = 0; + goto L20076;} + else { + goto L20552;}} + else { + goto L20552;}} + L19938: { + okayP_446X = arg2K0; + key_447X = arg0K1; + if (okayP_446X) { + arg0K0 = key_447X; + goto L19893;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_447X; + goto L19893;}} + L19850: { + if ((Spending_interruptPS)) { + if ((Spending_eventsPS)) { + Spending_eventsPS = 0; + check_events_return_tag = 0; + goto check_events; + check_events_return_0: + v_448X = check_events0_return_value; + if (v_448X) { + arg0K0 = stack_arg_count_99X; + goto L17297;} + else { + goto L19854;}} + else { + arg0K0 = stack_arg_count_99X; + goto L17297;}} + else { + goto L19854;}} + L16469: { + stack_arg_count_449X = arg0K0; + code_450X = *((long *) (((char *) (-3 + (*((long *) (((char *) (-3 + (SvalS)))))))))); + arg0K0 = (*((unsigned char *) ((((char *) (-3 + code_450X))) + 1))); + arg0K1 = 64; + goto L16483;} + L17564: { + exception_451X = arg0K0; + stack_arg_count_452X = arg0K1; + list_args_453X = arg0K2; + list_arg_count_454X = arg0K3; + if (((StemplateS) == (SvalS))) { + if ((0 < (Slosing_opcodeS))) { + ps_error("wrong number of arguments to exception handler", 1, (Slosing_opcodeS)); + arg0K0 = v_455X; + goto L20076;} + else { + ps_error("wrong number of arguments to interrupt handler", 1, (0 - (Slosing_opcodeS))); + arg0K0 = v_456X; + goto L20076;}} + else { + merged_arg0K0 = list_args_453X; + merged_arg0K1 = list_arg_count_454X; + copy_listS_return_tag = 0; + goto copy_listS; + copy_listS_return_0: + v_457X = copy_listS0_return_value; + merged_arg0K0 = v_457X; + merged_arg0K1 = stack_arg_count_452X; + pop_args_GlistS_return_tag = 1; + goto pop_args_GlistS; + pop_args_GlistS_return_1: + args_458X = pop_args_GlistS0_return_value; + merged_arg0K0 = exception_451X; + merged_arg0K1 = 0; + push_exception_continuationB_return_tag = 96; + goto push_exception_continuationB; + push_exception_continuationB_return_96: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = args_458X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + L18934: { + loc_459X = arg1K0; + arg_460X = arg1K1; + if ((top_of_args_109X < arg_460X)) { + *((long *) loc_459X) = (*((long *) arg_460X)); + arg1K0 = (loc_459X + -4); + arg1K1 = (arg_460X + -4); + goto L18934;} + else { + SstackS = loc_459X; + obj_461X = SvalS; + if ((3 == (3 & obj_461X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + obj_461X))) + -4))))>>2))))) { + arg0K0 = nargs_108X; + goto L16469;} + else { + arg0K0 = 3; + arg0K1 = nargs_108X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + else { + arg0K0 = 3; + arg0K1 = nargs_108X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}}} + L18972: { + stack_arg_count_462X = arg0K0; + list_args_463X = arg0K1; + list_arg_count_464X = arg0K2; + if ((0 == list_arg_count_464X)) { + obj_465X = SvalS; + if ((3 == (3 & obj_465X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + obj_465X))) + -4))))>>2))))) { + arg0K0 = stack_arg_count_462X; + goto L16469;} + else { + arg0K0 = 3; + arg0K1 = stack_arg_count_462X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + else { + arg0K0 = 3; + arg0K1 = stack_arg_count_462X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + else { + obj_466X = SvalS; + if ((3 == (3 & obj_466X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + obj_466X))) + -4))))>>2))))) { + code_467X = *((long *) (((char *) (-3 + (*((long *) (((char *) (-3 + (SvalS)))))))))); + total_arg_count_468X = stack_arg_count_462X + list_arg_count_464X; + arg0K0 = (*((unsigned char *) ((((char *) (-3 + code_467X))) + 1))); + arg0K1 = 64; + goto L16760;} + else { + arg0K0 = 3; + arg0K1 = stack_arg_count_462X; + arg0K2 = list_args_463X; + arg0K3 = list_arg_count_464X; + goto L17564;}} + else { + arg0K0 = 3; + arg0K1 = stack_arg_count_462X; + arg0K2 = list_args_463X; + arg0K3 = list_arg_count_464X; + goto L17564;}}} + L11608: { + list_args_469X = arg0K0; + stack_nargs_470X = arg0K1; + merged_arg0K0 = list_args_469X; + okay_argument_list_return_tag = 1; + goto okay_argument_list; + okay_argument_list_return_1: + okayP_471X = okay_argument_list0_return_value; + list_arg_count_472X = okay_argument_list1_return_value; + if (okayP_471X) { + SvalS = proc_116X; + arg0K0 = stack_nargs_470X; + arg0K1 = list_args_469X; + arg0K2 = list_arg_count_472X; + goto L18972;} + else { + *((long *) (SstackS)) = list_args_469X; + SstackS = ((SstackS) + -4); + merged_arg0K0 = 25; + merged_arg0K1 = (1 + stack_nargs_470X); + pop_args_GlistS_return_tag = 2; + goto pop_args_GlistS; + pop_args_GlistS_return_2: + args_473X = pop_args_GlistS0_return_value; + SstackS = ((SstackS) + 4); + merged_arg0K0 = 5; + merged_arg0K1 = 0; + push_exception_continuationB_return_tag = 97; + goto push_exception_continuationB; + push_exception_continuationB_return_97: + *((long *) (SstackS)) = proc_116X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = args_473X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + L11649: { + list_474X = arg0K0; + follower_475X = arg0K1; + if ((25 == list_474X)) { + list_args_476X = *((long *) (((char *) (-3 + (*((long *) ((((char *) (-3 + follower_475X))) + 4))))))); + addr_477X = (((char *) (-3 + follower_475X))) + 4; + WRITE_BARRIER(addr_477X, list_args_476X); + *((long *) addr_477X) = list_args_476X; + arg0K0 = rest_list_117X; + arg0K1 = (-1 + stack_nargs_115X); + goto L11608;} + else { + arg0K0 = (*((long *) ((((char *) (-3 + list_474X))) + 4))); + arg0K1 = (*((long *) ((((char *) (-3 + follower_475X))) + 4))); + goto L11649;}} + L18877: { + obj_478X = SvalS; + if ((3 == (3 & obj_478X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + obj_478X))) + -4))))>>2))))) { + arg0K0 = 0; + goto L16469;} + else { + arg0K0 = 3; + arg0K1 = 0; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + else { + arg0K0 = 3; + arg0K1 = 0; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + L18884: { + SstackS = ((((char *) (-3 + (Sbottom_of_stackS)))) + -8); + *((long *) (((char *) (-3 + (Sbottom_of_stackS))))) = cont_118X; + ScontS = (Sbottom_of_stackS); + goto L18877;} + L21104: { + stack_nargs_479X = arg0K0; + list_args_480X = arg0K1; + list_arg_count_481X = arg0K2; + if ((1 == stack_nargs_479X)) { + SstackS = ((SstackS) + 4); + SvalS = (*((long *) (SstackS))); + pop_continuationB_return_tag = 1; + goto pop_continuationB; + pop_continuationB_return_1: + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if (((ScontS) == (Sbottom_of_stackS))) { + arg0K0 = (*((long *) (((char *) (-3 + (Sbottom_of_stackS)))))); + goto L21115;} + else { + arg0K0 = (ScontS); + goto L21115;}}} + L19676: { + okayP_482X = arg2K0; + key_483X = arg0K1; + if (okayP_482X) { + arg0K0 = key_483X; + goto L19664;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_483X; + goto L19664;}} + L19549: { + tem_484X = *((long *) ((((char *) (-3 + (StemplateS)))) + ((((((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))))<<2)))); + StemplateS = tem_484X; + Scode_pointerS = ((((char *) (-3 + (*((long *) (((char *) (-3 + tem_484X)))))))) + 2); + if ((Spending_interruptPS)) { + if ((Spending_eventsPS)) { + Spending_eventsPS = 0; + check_events_return_tag = 1; + goto check_events; + check_events_return_1: + v_485X = check_events0_return_value; + if (v_485X) { + goto L19558;} + else { + goto L19561;}} + else { + goto L19558;}} + else { + goto L19561;}} + L19731: { + okayP_486X = arg2K0; + key_487X = arg0K1; + if (okayP_486X) { + arg0K0 = key_487X; + goto L19718;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_487X; + goto L19718;}} + L19594: { + merged_arg0K0 = 5; + merged_arg0K1 = 4; + push_exception_continuationB_return_tag = 98; + goto push_exception_continuationB; + push_exception_continuationB_return_98: + *((long *) (SstackS)) = (*((long *) ((((char *) (-3 + (StemplateS)))) + ((((((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))))<<2))))); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L19450: { + arg0K0 = (2 + (((max_135X)<<1))); + goto L19452;} + L19452: { + offset_488X = arg0K0; + Scode_pointerS = ((Scode_pointerS) + offset_488X); + arg1K0 = (Scode_pointerS); + goto L19170;} + L20437: { + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L19348: { + delta_489X = arg0K0; + Scode_pointerS = ((Scode_pointerS) + delta_489X); + arg1K0 = (Scode_pointerS); + goto L19170;} + L20328: { + delta_490X = arg0K0; + Scode_pointerS = ((Scode_pointerS) + delta_490X); + arg1K0 = (Scode_pointerS); + goto L19170;} + L38594: { + val_491X = arg0K0; + SvalS = val_491X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L30584: { + val_492X = arg0K0; + SvalS = val_492X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L30539: { + if ((3 == (3 & x_149X))) { + if ((7 == (31 & ((((*((long *) ((((char *) (-3 + x_149X))) + -4))))>>2))))) { + arg0K0 = 5; + goto L30584;} + else { + goto L30547;}} + else { + goto L30547;}} + L28870: { + SvalS = 5; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L28873: { + if ((3 == (3 & x_150X))) { + if ((10 == (31 & ((((*((long *) ((((char *) (-3 + x_150X))) + -4))))>>2))))) { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 99; + goto push_exception_continuationB; + push_exception_continuationB_return_99: + *((long *) (SstackS)) = x_150X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + goto L28881;}} + else { + goto L28881;}} + L28679: { + SvalS = 5; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L28662: { + if ((3 == (3 & x_151X))) { + if ((7 == (31 & ((((*((long *) ((((char *) (-3 + x_151X))) + -4))))>>2))))) { + goto L28679;} + else { + goto L28670;}} + else { + goto L28670;}} + L28468: { + SvalS = 5; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L28451: { + if ((3 == (3 & x_152X))) { + if ((7 == (31 & ((((*((long *) ((((char *) (-3 + x_152X))) + -4))))>>2))))) { + goto L28468;} + else { + goto L28459;}} + else { + goto L28459;}} + L28257: { + SvalS = 5; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L28240: { + if ((3 == (3 & x_153X))) { + if ((7 == (31 & ((((*((long *) ((((char *) (-3 + x_153X))) + -4))))>>2))))) { + goto L28257;} + else { + goto L28248;}} + else { + goto L28248;}} + L7132: { + a_493X = arg0K0; + if ((b_162X < 0)) { + arg0K0 = (0 - b_162X); + goto L7136;} + else { + arg0K0 = b_162X; + goto L7136;}} + L8910: { + a_494X = arg0K0; + if ((b_169X < 0)) { + arg0K0 = (0 - b_169X); + goto L8912;} + else { + arg0K0 = b_169X; + goto L8912;}} + L30435: { + val_495X = arg0K0; + SvalS = val_495X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L30345: { + val_496X = arg0K0; + SvalS = val_496X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L30255: { + val_497X = arg0K0; + SvalS = val_497X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L30150: { + val_498X = arg0K0; + SvalS = val_498X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L30043: { + val_499X = arg0K0; + SvalS = val_499X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L34164: { + a_500X = arg0K0; + if ((b_183X < 0)) { + arg0K0 = (0 - b_183X); + goto L34166;} + else { + arg0K0 = b_183X; + goto L34166;}} + L34032: { + a_501X = arg0K0; + n_502X = ((x_185X)>>2); + if ((n_502X < 0)) { + arg0K0 = (0 - n_502X); + goto L34034;} + else { + arg0K0 = n_502X; + goto L34034;}} + L28018: { + r_503X = arg0K0; + if ((536870911 < r_503X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 100; + goto push_exception_continuationB; + push_exception_continuationB_return_100: + *((long *) (SstackS)) = x_196X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + SvalS = (((r_503X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L33882: { + SvalS = (((result_212X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L38937: { + val_504X = arg0K0; + SvalS = val_504X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L29915: { + val_505X = arg0K0; + SvalS = val_505X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L29888: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 101; + goto push_exception_continuationB; + push_exception_continuationB_return_101: + *((long *) (SstackS)) = arg2_215X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L29825: { + val_506X = arg0K0; + SvalS = val_506X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L29798: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 102; + goto push_exception_continuationB; + push_exception_continuationB_return_102: + *((long *) (SstackS)) = arg2_217X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L27918: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 103; + goto push_exception_continuationB; + push_exception_continuationB_return_103: + *((long *) (SstackS)) = (((x_219X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L38966: { + val_507X = arg0K0; + SvalS = val_507X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L38980: { + value_508X = arg0K0; + SvalS = value_508X; + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;} + L24394: { + merged_arg0K0 = 5; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 104; + goto push_exception_continuationB; + push_exception_continuationB_return_104: + *((long *) (SstackS)) = x_223X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((type_224X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L24200: { + type_509X = *((unsigned char *) ((Scode_pointerS) + 2)); + len_510X = ((len_225X)<<2); + addr_511X = ALLOCATE_SPACE(type_509X, (4 + len_510X)); + *((long *) addr_511X) = (2 + (((((((len_510X)<<6)) + type_509X))<<2))); + new_512X = 3 + (((long) (addr_511X + 4))); + if ((len_225X < 1)) { + goto L24235;} + else { + *((long *) ((((char *) (-3 + new_512X))) + (-4 + (((len_225X)<<2))))) = (SvalS); + arg0K0 = (-2 + len_225X); + goto L24219;}} + L23991: { + type_513X = *((unsigned char *) ((Scode_pointerS) + 1)); + len_514X = ((len_229X)<<2); + addr_515X = ALLOCATE_SPACE(type_513X, (4 + len_514X)); + *((long *) addr_515X) = (2 + (((((((len_514X)<<6)) + type_513X))<<2))); + new_516X = 3 + (((long) (addr_515X + 4))); + SstackS = ((SstackS) + 4); + stack_nargs_517X = (((*((long *) (SstackS))))>>2); + SstackS = ((SstackS) + 4); + rest_list_518X = *((long *) (SstackS)); + arg0K0 = (-1 + stack_nargs_517X); + goto L24013;} + L23889: { + merged_arg0K0 = 5; + merged_arg0K1 = 3; + push_exception_continuationB_return_tag = 105; + goto push_exception_continuationB; + push_exception_continuationB_return_105: + *((long *) (SstackS)) = x_233X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((type_235X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((offset_234X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L23677: { + merged_arg0K0 = 5; + merged_arg0K1 = 3; + push_exception_continuationB_return_tag = 106; + goto push_exception_continuationB; + push_exception_continuationB_return_106: + *((long *) (SstackS)) = arg2_236X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((type_239X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((offset_238X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_237X; + SstackS = ((SstackS) + -4); + arg0K0 = 4; + goto L17068;} + L23349: { + merged_arg0K0 = 5; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 107; + goto push_exception_continuationB; + push_exception_continuationB_return_107: + *((long *) (SstackS)) = (((type_243X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((len_244X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_242X; + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L23367: { + okayP_519X = arg2K0; + init_520X = arg0K1; + if (okayP_519X) { + len_521X = ((len_244X)<<2); + addr_522X = ALLOCATE_SPACE(type_243X, (4 + len_521X)); + *((long *) addr_522X) = (2 + (((((((len_521X)<<6)) + type_243X))<<2))); + value_523X = 3 + (((long) (addr_522X + 4))); + arg0K0 = (-1 + len_244X); + goto L23396;} + else { + merged_arg0K0 = 8; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 108; + goto push_exception_continuationB; + push_exception_continuationB_return_108: + *((long *) (SstackS)) = (((type_243X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((len_244X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = init_520X; + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;}} + L23086: { + merged_arg0K0 = 7; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 109; + goto push_exception_continuationB; + push_exception_continuationB_return_109: + *((long *) (SstackS)) = arg2_249X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((type_251X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_250X; + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L23063: { + merged_arg0K0 = 5; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 110; + goto push_exception_continuationB; + push_exception_continuationB_return_110: + *((long *) (SstackS)) = arg2_249X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((type_251X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_250X; + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L22727: { + merged_arg0K0 = 7; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 111; + goto push_exception_continuationB; + push_exception_continuationB_return_111: + *((long *) (SstackS)) = arg3_255X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((type_257X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_254X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_256X; + SstackS = ((SstackS) + -4); + arg0K0 = 4; + goto L17068;} + L22702: { + merged_arg0K0 = 5; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 112; + goto push_exception_continuationB; + push_exception_continuationB_return_112: + *((long *) (SstackS)) = arg3_255X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((type_257X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_254X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_256X; + SstackS = ((SstackS) + -4); + arg0K0 = 4; + goto L17068;} + L27679: { + merged_arg0K0 = 7; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 113; + goto push_exception_continuationB; + push_exception_continuationB_return_113: + *((long *) (SstackS)) = arg3_262X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_264X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_263X; + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L27660: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 114; + goto push_exception_continuationB; + push_exception_continuationB_return_114: + *((long *) (SstackS)) = arg3_262X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_264X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_263X; + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L27392: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 115; + goto push_exception_continuationB; + push_exception_continuationB_return_115: + *((long *) (SstackS)) = (((len_268X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((init_269X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L27491: { + addr_524X = ALLOCATE_SPACE(20, (4 + len_268X)); + *((long *) addr_524X) = (82 + (((len_268X)<<8))); + vector_525X = 3 + (((long) (addr_524X + 4))); + arg0K0 = (-1 + len_268X); + goto L27437;} + L36172: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 116; + goto push_exception_continuationB; + push_exception_continuationB_return_116: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L34988: { + merged_arg0K0 = 7; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 117; + goto push_exception_continuationB; + push_exception_continuationB_return_117: + *((long *) (SstackS)) = arg2_274X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_275X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L36731: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 118; + goto push_exception_continuationB; + push_exception_continuationB_return_118: + *((long *) (SstackS)) = arg2_274X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L33694: { + merged_arg0K0 = 7; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 119; + goto push_exception_continuationB; + push_exception_continuationB_return_119: + *((long *) (SstackS)) = arg3_278X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_279X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((Kchar_280X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L33673: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 120; + goto push_exception_continuationB; + push_exception_continuationB_return_120: + *((long *) (SstackS)) = arg3_278X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_279X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((Kchar_280X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L35539: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 121; + goto push_exception_continuationB; + push_exception_continuationB_return_121: + *((long *) (SstackS)) = arg3_278X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_277X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L27153: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 122; + goto push_exception_continuationB; + push_exception_continuationB_return_122: + *((long *) (SstackS)) = (((len_283X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (9 + ((((init_284X))<<8))); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L27252: { + len_526X = 1 + len_283X; + addr_527X = ALLOCATE_SPACE(19, (4 + len_526X)); + *((long *) addr_527X) = (78 + (((len_526X)<<8))); + string_528X = 3 + (((long) (addr_527X + 4))); + *((unsigned char *) ((((char *) (-3 + string_528X))) + len_283X)) = 0; + arg0K0 = (-1 + len_283X); + goto L27198;} + L34765: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 123; + goto push_exception_continuationB; + push_exception_continuationB_return_123: + *((long *) (SstackS)) = arg2_282X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L36115: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 124; + goto push_exception_continuationB; + push_exception_continuationB_return_124: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L35059: { + merged_arg0K0 = 7; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 125; + goto push_exception_continuationB; + push_exception_continuationB_return_125: + *((long *) (SstackS)) = arg2_289X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_290X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L36824: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 126; + goto push_exception_continuationB; + push_exception_continuationB_return_126: + *((long *) (SstackS)) = arg2_289X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L33539: { + merged_arg0K0 = 7; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 127; + goto push_exception_continuationB; + push_exception_continuationB_return_127: + *((long *) (SstackS)) = arg3_293X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_294X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (9 + ((((Kchar_295X))<<8))); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L33518: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 128; + goto push_exception_continuationB; + push_exception_continuationB_return_128: + *((long *) (SstackS)) = arg3_293X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_294X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (9 + ((((Kchar_295X))<<8))); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L35413: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 129; + goto push_exception_continuationB; + push_exception_continuationB_return_129: + *((long *) (SstackS)) = arg3_293X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_292X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L29669: { + val_529X = arg0K0; + SvalS = val_529X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L29641: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 130; + goto push_exception_continuationB; + push_exception_continuationB_return_130: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L31134: { + if ((1 == (SvalS))) { + addr_530X = (((char *) (-3 + arg2_300X))) + 8; + WRITE_BARRIER(addr_530X, 273); + *((long *) addr_530X) = 273; + goto L31159;} + else { + if ((17 == (255 & (*((long *) ((((char *) (-3 + arg2_300X))) + 8)))))) { + addr_531X = (((char *) (-3 + arg2_300X))) + 8; + WRITE_BARRIER(addr_531X, 529); + *((long *) addr_531X) = 529; + goto L31159;} + else { + goto L31159;}}} + L31160: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 131; + goto push_exception_continuationB; + push_exception_continuationB_return_131: + *((long *) (SstackS)) = arg2_300X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L39045: { + val_532X = arg0K0; + SvalS = val_532X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L27102: { + SvalS = x_303X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L26701: { + okayP_533X = arg2K0; + key_534X = arg0K1; + if (okayP_533X) { + arg0K0 = key_534X; + goto L26550;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_534X; + goto L26550;}} + L33400: { + okayP_535X = arg2K0; + key_536X = arg0K1; + if (okayP_535X) { + arg0K0 = key_536X; + goto L33355;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_536X; + goto L33355;}} + L37957: { + okayP_537X = arg2K0; + key_538X = arg0K1; + if (okayP_537X) { + arg0K0 = key_538X; + goto L37887;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_538X; + goto L37887;}} + L38172: { + okayP_539X = arg2K0; + key_540X = arg0K1; + if (okayP_539X) { + arg0K0 = key_540X; + goto L38108;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_540X; + goto L38108;}} + L26502: { + val_541X = arg0K0; + SvalS = val_541X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L8211: { + arg0K0 = (*((long *) ((((char *) (-3 + channel_313X))) + 16))); + goto L26502;} + L8217: { + ch_542X = arg0K0; + prev_543X = arg0K1; + if ((1 == ch_542X)) { + n_544X = ps_abort_fd_op(((((*((long *) ((((char *) (-3 + channel_313X))) + 8))))>>2))); + arg0K0 = (((n_544X)<<2)); + goto L26502;} + else { + if ((ch_542X == channel_313X)) { + y_545X = Spending_channels_tailS; + if ((ch_542X == y_545X)) { + Spending_channels_tailS = prev_543X; + goto L8239;} + else { + goto L8239;}} + else { + arg0K0 = (*((long *) ((((char *) (-3 + ch_542X))) + 12))); + arg0K1 = ch_542X; + goto L8217;}}} + L26503: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 132; + goto push_exception_continuationB; + push_exception_continuationB_return_132: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L29507: { + val_546X = arg0K0; + SvalS = val_546X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L29478: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 133; + goto push_exception_continuationB; + push_exception_continuationB_return_133: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L26436: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 134; + goto push_exception_continuationB; + push_exception_continuationB_return_134: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L33042: { + okayP_547X = arg2K0; + key_548X = arg0K1; + if (okayP_547X) { + arg0K0 = key_548X; + goto L32906;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_548X; + goto L32906;}} + L32660: { + SstackS = ((SstackS) + 4); + arg2_549X = *((long *) (SstackS)); + x_550X = SvalS; + if ((3 == (3 & arg2_549X))) { + if ((3 == (3 & x_550X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + x_550X))) + -4))))>>2))))) { + addr_551X = ALLOCATE_SPACE(0, 12); + *((long *) addr_551X) = 2050; + x_552X = 3 + (((long) (addr_551X + 4))); + *((long *) (((char *) (-3 + x_552X)))) = arg2_549X; + *((long *) ((((char *) (-3 + x_552X))) + 4)) = x_550X; + b_553X = Sfinalizer_alistS; + addr_554X = ALLOCATE_SPACE(0, 12); + *((long *) addr_554X) = 2050; + x_555X = 3 + (((long) (addr_554X + 4))); + *((long *) (((char *) (-3 + x_555X)))) = x_552X; + *((long *) ((((char *) (-3 + x_555X))) + 4)) = b_553X; + Sfinalizer_alistS = x_555X; + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + goto L32760;}} + else { + goto L32760;}} + else { + goto L32760;}} + L35946: { + arg0K0 = 0; + arg0K1 = 0; + goto L9391;} + L26300: { + firstP_556X = arg2K0; + vector_557X = find_all(type_337X); + if ((1 == vector_557X)) { + if (firstP_556X) { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 24; + goto collect_saving_temp; + collect_saving_temp_return_24: + arg2K0 = 0; + goto L26300;} + else { + merged_arg0K0 = 8; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 135; + goto push_exception_continuationB; + push_exception_continuationB_return_135: + *((long *) (SstackS)) = (((type_337X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + else { + SvalS = vector_557X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L35273: { + table_558X = arg0K0; + firstP_559X = arg2K1; + symbols_560X = find_all(1); + if ((1 == symbols_560X)) { + if (firstP_559X) { + merged_arg0K0 = table_558X; + collect_saving_temp_return_tag = 25; + goto collect_saving_temp; + collect_saving_temp_return_25: + v_561X = collect_saving_temp0_return_value; + arg0K0 = v_561X; + arg2K1 = 0; + goto L35273;} + else { + merged_arg0K0 = 8; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 136; + goto push_exception_continuationB; + push_exception_continuationB_return_136: + *((long *) (SstackS)) = table_558X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + else { + arg0K0 = table_558X; + arg0K1 = symbols_560X; + arg2K2 = 1; + goto L31327;}} + L35295: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 137; + goto push_exception_continuationB; + push_exception_continuationB_return_137: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L39120: { + firstP_562X = arg2K0; + type_563X = arg0K1; + vector_564X = find_all_records(type_563X); + if ((1 == vector_564X)) { + if (firstP_562X) { + merged_arg0K0 = type_563X; + collect_saving_temp_return_tag = 26; + goto collect_saving_temp; + collect_saving_temp_return_26: + v_565X = collect_saving_temp0_return_value; + arg2K0 = 0; + arg0K1 = v_565X; + goto L39120;} + else { + merged_arg0K0 = 8; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 138; + goto push_exception_continuationB; + push_exception_continuationB_return_138: + *((long *) (SstackS)) = type_563X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}} + else { + SvalS = vector_564X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L21340: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 139; + goto push_exception_continuationB; + push_exception_continuationB_return_139: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L20181: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 140; + goto push_exception_continuationB; + push_exception_continuationB_return_140: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L39161: { + SvalS = (((old_348X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L19184: { + SstackS = ((SstackS) + 4); + pc_566X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + tem_567X = *((long *) (SstackS)); + StemplateS = tem_567X; + Scode_pointerS = ((((char *) (-3 + (*((long *) (((char *) (-3 + tem_567X)))))))) + (((pc_566X)>>2))); + SstackS = ((SstackS) + 4); + SvalS = (*((long *) (SstackS))); + arg1K0 = (Scode_pointerS); + goto L19170;} + L35843: { + x_568X = schedule_alarm_interrupt((((p_351X)>>2))); + SvalS = (((x_568X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L30902: { + if ((1 == (SvalS))) { + arg2K0 = 0; + goto L30906;} + else { + arg2K0 = 1; + goto L30906;}} + L30922: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 141; + goto push_exception_continuationB; + push_exception_continuationB_return_141: + *((long *) (SstackS)) = arg2_352X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L32516: { + merged_arg0K0 = 19; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 142; + goto push_exception_continuationB; + push_exception_continuationB_return_142: + *((long *) (SstackS)) = x_355X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L32521: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 143; + goto push_exception_continuationB; + push_exception_continuationB_return_143: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L17750: { + rest_list_569X = arg0K0; + if ((25 == rest_list_569X)) { + proc_570X = *((long *) ((SstackS) + (((nargs_359X)<<2)))); + if ((3 == (3 & proc_570X))) { + if ((13 == (31 & ((((*((long *) ((((char *) (-3 + proc_570X))) + -4))))>>2))))) { + Sexternal_call_nargsS = (-1 + nargs_359X); + SvalS = proc_570X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg0K0 = 1; + goto L20076;} + else { + goto L17820;}} + else { + goto L17820;}} + else { + *((long *) (SstackS)) = (*((long *) (((char *) (-3 + rest_list_569X))))); + SstackS = ((SstackS) + -4); + arg0K0 = (*((long *) ((((char *) (-3 + rest_list_569X))) + 4))); + goto L17750;}} + L35710: { + option_571X = arg0K0; + seconds_572X = arg0K1; + mseconds_573X = arg0K2; + if ((536869 < seconds_572X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 144; + goto push_exception_continuationB; + push_exception_continuationB_return_144: + *((long *) (SstackS)) = (((option_571X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((seconds_572X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mseconds_573X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + else { + SvalS = (((((1000 * seconds_572X) + mseconds_573X))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L20076: { + option_574X = arg0K0; + if ((0 == option_574X)) { + return (SvalS);} + else { + if ((1 == option_574X)) { + v_575X = (long(*)())((*((long *) (((char *) (-3 + (*((long *) ((((char *) (-3 + (SvalS)))) + 4))))))))); + v_576X = (*v_575X)((Sexternal_call_nargsS), ((SstackS) + 4)); + SvalS = v_576X; + SstackS = ((SstackS) + (0 - ((((-1 - (Sexternal_call_nargsS)))<<2)))); + goto L20074;} + else { + ps_error("unknown VM return option", 1, option_574X); + return -1;}}} + L25832: { + SstackS = ((SstackS) + 4); + arg2_577X = *((long *) (SstackS)); + obj_578X = SvalS; + if ((3 == (3 & obj_578X))) { + if ((16 == (31 & ((((*((long *) ((((char *) (-3 + obj_578X))) + -4))))>>2))))) { + x_579X = SvalS; + addr_580X = ALLOCATE_SPACE(0, 12); + *((long *) addr_580X) = 2050; + x_581X = 3 + (((long) (addr_580X + 4))); + *((long *) (((char *) (-3 + x_581X)))) = 1; + *((long *) ((((char *) (-3 + x_581X))) + 4)) = 1; + merged_arg0K0 = arg2_577X; + merged_arg0K1 = x_579X; + merged_arg0K2 = x_581X; + encode_return_tag = 0; + goto encode; + encode_return_0: + v_582X = encode0_return_value; + if (v_582X) { + SvalS = x_581X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + *((long *) (SstackS)) = x_579X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_581X; + SstackS = ((SstackS) + -4); + merged_arg0K0 = arg2_577X; + collect_saving_temp_return_tag = 27; + goto collect_saving_temp; + collect_saving_temp_return_27: + thing_583X = collect_saving_temp0_return_value; + SstackS = ((SstackS) + 4); + pair_584X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + aspace_585X = *((long *) (SstackS)); + merged_arg0K0 = thing_583X; + merged_arg0K1 = aspace_585X; + merged_arg0K2 = pair_584X; + encode_return_tag = 1; + goto encode; + encode_return_1: + v_586X = encode0_return_value; + if (v_586X) { + SvalS = pair_584X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 8; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 145; + goto push_exception_continuationB; + push_exception_continuationB_return_145: + *((long *) (SstackS)) = thing_583X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = aspace_585X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}} + else { + goto L25892;}} + else { + goto L25892;}} + L25563: { + SstackS = ((SstackS) + 4); + arg2_587X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_588X = *((long *) (SstackS)); + if ((3 == (3 & arg3_588X))) { + if ((16 == (31 & ((((*((long *) ((((char *) (-3 + arg3_588X))) + -4))))>>2))))) { + if ((1 == arg2_587X)) { + goto L25581;} + else { + if ((5 == arg2_587X)) { + goto L25581;} + else { + goto L25620;}}} + else { + goto L25620;}} + else { + goto L25620;}} + L29376: { + val_589X = arg0K0; + SvalS = val_589X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L29343: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 146; + goto push_exception_continuationB; + push_exception_continuationB_return_146: + *((long *) (SstackS)) = arg2_379X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L35799: { + i_590X = arg0K0; + h_591X = arg0K1; + if ((i_590X < n_385X)) { + arg0K0 = (1 + i_590X); + arg0K1 = (h_591X + (((*((unsigned char *) ((((char *) (-3 + x_384X))) + i_590X)))))); + goto L35799;} + else { + SvalS = (((h_591X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L35776: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 147; + goto push_exception_continuationB; + push_exception_continuationB_return_147: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L25269: { + SstackS = ((SstackS) + 4); + arg2_592X = *((long *) (SstackS)); + if ((0 == (3 & (SvalS)))) { + n_593X = (((SvalS))>>2); + if ((3 == (3 & arg2_592X))) { + if ((0 == (31 & ((((*((long *) ((((char *) (-3 + arg2_592X))) + -4))))>>2))))) { + goto L25397;} + else { + goto L25302;}} + else { + goto L25302;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 148; + goto push_exception_continuationB; + push_exception_continuationB_return_148: + *((long *) (SstackS)) = arg2_592X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + L25127: { + SstackS = ((SstackS) + 4); + arg2_594X = *((long *) (SstackS)); + if ((3 == (3 & arg2_594X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg2_594X))) + -4))))>>2))))) { + obj_595X = SvalS; + if ((3 == (3 & obj_595X))) { + if ((2 == (31 & ((((*((long *) ((((char *) (-3 + obj_595X))) + -4))))>>2))))) { + table_596X = SvalS; + v_597X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + table_596X))) + -4))))>>8))))>>2); + n_598X = -1 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg2_594X))) + -4))))>>8)); + arg0K0 = 0; + arg0K1 = 0; + goto L12920;} + else { + goto L25151;}} + else { + goto L25151;}} + else { + goto L25151;}} + else { + goto L25151;}} + L29068: { + list_599X = arg0K0; + slow_600X = arg0K1; + move_slowP_601X = arg2K2; + if ((25 == list_599X)) { + SvalS = 1; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if ((3 == (3 & list_599X))) { + if ((0 == (31 & ((((*((long *) ((((char *) (-3 + list_599X))) + -4))))>>2))))) { + head_602X = *((long *) (((char *) (-3 + list_599X)))); + if ((3 == (3 & head_602X))) { + if ((0 == (31 & ((((*((long *) ((((char *) (-3 + head_602X))) + -4))))>>2))))) { + if (((*((long *) (((char *) (-3 + head_602X))))) == arg2_391X)) { + SvalS = head_602X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + list_603X = *((long *) ((((char *) (-3 + list_599X))) + 4)); + if ((list_603X == slow_600X)) { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 149; + goto push_exception_continuationB; + push_exception_continuationB_return_149: + *((long *) (SstackS)) = arg2_391X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_392X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + if (move_slowP_601X) { + arg0K0 = list_603X; + arg0K1 = (*((long *) ((((char *) (-3 + slow_600X))) + 4))); + arg2K2 = 0; + goto L29068;} + else { + arg0K0 = list_603X; + arg0K1 = slow_600X; + arg2K2 = 1; + goto L29068;}}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 150; + goto push_exception_continuationB; + push_exception_continuationB_return_150: + *((long *) (SstackS)) = arg2_391X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_392X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 151; + goto push_exception_continuationB; + push_exception_continuationB_return_151: + *((long *) (SstackS)) = arg2_391X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_392X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 152; + goto push_exception_continuationB; + push_exception_continuationB_return_152: + *((long *) (SstackS)) = arg2_391X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_392X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 153; + goto push_exception_continuationB; + push_exception_continuationB_return_153: + *((long *) (SstackS)) = arg2_391X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_392X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}} + L24913: { + merged_arg0K0 = 7; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 154; + goto push_exception_continuationB; + push_exception_continuationB_return_154: + *((long *) (SstackS)) = arg3_394X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_393X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_395X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L24960: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 155; + goto push_exception_continuationB; + push_exception_continuationB_return_155: + *((long *) (SstackS)) = arg3_394X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_393X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_395X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L32167: { + merged_arg0K0 = 7; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 156; + goto push_exception_continuationB; + push_exception_continuationB_return_156: + *((long *) (SstackS)) = arg4_399X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg3_398X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_401X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_400X; + SstackS = ((SstackS) + -4); + arg0K0 = 4; + goto L17068;} + L32224: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 157; + goto push_exception_continuationB; + push_exception_continuationB_return_157: + *((long *) (SstackS)) = arg4_399X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg3_398X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((index_401X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_400X; + SstackS = ((SstackS) + -4); + arg0K0 = 4; + goto L17068;} + L31531: { + if ((3 == (3 & arg5_407X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg5_407X))) + -4))))>>2))))) { + goto L31544;} + else { + goto L31539;}} + else { + goto L31539;}} + L31526: { + if ((3 == (3 & arg5_407X))) { + if ((20 == (31 & ((((*((long *) ((((char *) (-3 + arg5_407X))) + -4))))>>2))))) { + goto L31531;} + else { + goto L31598;}} + else { + goto L31598;}} + L22434: { + port_604X = arg0K0; + if ((3 == (3 & port_604X))) { + if ((6 == (31 & ((((*((long *) ((((char *) (-3 + port_604X))) + -4))))>>2))))) { + if ((0 == (4 & ((((*((long *) ((((char *) (-3 + port_604X))) + 4))))>>2))))) { + goto L22494;} + else { + p_605X = *((long *) ((((char *) (-3 + port_604X))) + 24)); + p_606X = *((long *) ((((char *) (-3 + port_604X))) + 28)); + b_607X = *((long *) ((((char *) (-3 + port_604X))) + 20)); + i_608X = ((p_605X)>>2); + x_609X = *((long *) ((((char *) (-3 + port_604X))) + 12)); + if ((5 == x_609X)) { + goto L22474;} + else { + if ((i_608X == (((p_606X)>>2)))) { + goto L22474;} + else { + val_610X = 4 + (((i_608X)<<2)); + addr_611X = (((char *) (-3 + port_604X))) + 24; + WRITE_BARRIER(addr_611X, val_610X); + *((long *) addr_611X) = val_610X; + SvalS = (9 + ((((((*((unsigned char *) ((((char *) (-3 + b_607X))) + i_608X))))))<<8))); + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;}}}} + else { + goto L22494;}} + else { + goto L22494;}} + L22231: { + port_612X = arg0K0; + if ((3 == (3 & port_612X))) { + if ((6 == (31 & ((((*((long *) ((((char *) (-3 + port_612X))) + -4))))>>2))))) { + if ((0 == (4 & ((((*((long *) ((((char *) (-3 + port_612X))) + 4))))>>2))))) { + goto L22291;} + else { + p_613X = *((long *) ((((char *) (-3 + port_612X))) + 24)); + p_614X = *((long *) ((((char *) (-3 + port_612X))) + 28)); + b_615X = *((long *) ((((char *) (-3 + port_612X))) + 20)); + i_616X = ((p_613X)>>2); + x_617X = *((long *) ((((char *) (-3 + port_612X))) + 12)); + if ((5 == x_617X)) { + goto L22271;} + else { + if ((i_616X == (((p_614X)>>2)))) { + goto L22271;} + else { + SvalS = (9 + ((((((*((unsigned char *) ((((char *) (-3 + b_615X))) + i_616X))))))<<8))); + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;}}}} + else { + goto L22291;}} + else { + goto L22291;}} + L21978: { + Kchar_618X = arg0K0; + port_619X = arg0K1; + if ((9 == (255 & Kchar_618X))) { + if ((3 == (3 & port_619X))) { + if ((6 == (31 & ((((*((long *) ((((char *) (-3 + port_619X))) + -4))))>>2))))) { + if ((0 == (8 & ((((*((long *) ((((char *) (-3 + port_619X))) + 4))))>>2))))) { + goto L22039;} + else { + p_620X = *((long *) ((((char *) (-3 + port_619X))) + 24)); + b_621X = *((long *) ((((char *) (-3 + port_619X))) + 20)); + i_622X = ((p_620X)>>2); + x_623X = *((long *) ((((char *) (-3 + port_619X))) + 12)); + if ((5 == x_623X)) { + goto L22021;} + else { + if ((i_622X == ((long)(((unsigned long)(*((long *) ((((char *) (-3 + b_621X))) + -4))))>>8)))) { + goto L22021;} + else { + val_624X = 4 + (((i_622X)<<2)); + addr_625X = (((char *) (-3 + port_619X))) + 24; + WRITE_BARRIER(addr_625X, val_624X); + *((long *) addr_625X) = val_624X; + *((unsigned char *) ((((char *) (-3 + (*((long *) ((((char *) (-3 + port_619X))) + 20)))))) + i_622X)) = (((((Kchar_618X)>>8)))); + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;}}}} + else { + goto L22039;}} + else { + goto L22039;}} + else { + goto L22039;}} + L30811: { + stuff_626X = arg0K0; + if ((3 == (3 & stuff_626X))) { + if ((0 == (31 & ((((*((long *) ((((char *) (-3 + stuff_626X))) + -4))))>>2))))) { + thing_627X = *((long *) (((char *) (-3 + stuff_626X)))); + if ((0 == (3 & thing_627X))) { + ps_write_integer((((thing_627X)>>2)), out_418X); + goto L30818;} + else { + if ((9 == (255 & thing_627X))) { + ps_write_string("#\\", out_418X); + { long ignoreXX; + PS_WRITE_CHAR(((((thing_627X)>>8))), out_418X, ignoreXX) } + goto L30818;} + else { + if ((3 == (3 & thing_627X))) { + if ((8 == (31 & ((((*((long *) ((((char *) (-3 + thing_627X))) + -4))))>>2))))) { + if ((0 < ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + thing_627X))) + -4))))>>8))))>>2)))) { + type_628X = *((long *) (((char *) (-3 + thing_627X)))); + if ((3 == (3 & type_628X))) { + if ((8 == (31 & ((((*((long *) ((((char *) (-3 + type_628X))) + -4))))>>2))))) { + if ((2 < ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + type_628X))) + -4))))>>8))))>>2)))) { + obj_629X = *((long *) ((((char *) (-3 + type_628X))) + 8)); + if ((3 == (3 & obj_629X))) { + if ((1 == (31 & ((((*((long *) ((((char *) (-3 + obj_629X))) + -4))))>>2))))) { + ps_write_string("#{", out_418X); + ps_write_string((((char *)(((char *) (-3 + (*((long *) ((((char *) (-3 + (*((long *) ((((char *) (-3 + (*((long *) (((char *) (-3 + thing_627X)))))))) + 8)))))) + 4)))))))), out_418X); + { long ignoreXX; + PS_WRITE_CHAR(125, out_418X, ignoreXX) } + goto L30818;} + else { + goto L11984;}} + else { + goto L11984;}} + else { + goto L11984;}} + else { + goto L11984;}} + else { + goto L11984;}} + else { + goto L11984;}} + else { + goto L11984;}} + else { + goto L11984;}}}} + else { + goto L30826;}} + else { + goto L30826;}} + L17127: { + SvalS = (*((long *) ((((char *) (-3 + (Sexception_handlersS)))) + (((opcode_420X)<<2))))); + obj_630X = SvalS; + if ((3 == (3 & obj_630X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + obj_630X))) + -4))))>>2))))) { + goto L17144;} + else { + goto L17214;}} + else { + goto L17214;}} + L17200: { + merged_arg3K0 = "exception-handlers is not a vector"; + loseD0_return_tag = 0; + goto loseD0; + loseD0_return_0: + goto L17127;} + L21830: { + okayP_631X = arg2K0; + key_632X = arg0K1; + if (okayP_631X) { + arg0K0 = key_632X; + goto L21734;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_632X; + goto L21734;}} + L21764: { + okayP_633X = arg2K0; + temp_634X = arg0K1; + if (okayP_633X) { + arg0K0 = temp_634X; + goto L21745;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = temp_634X; + goto L21745;}} + L21549: { + start_i_635X = arg0K0; + arg0K0 = start_i_635X; + arg0K1 = 2; + arg0K2 = (SenvS); + goto L21557;} + L21450: { + key_636X = arg0K0; + if ((1 == (ScontS))) { + arg0K0 = 1; + goto L21454;} + else { + merged_arg0K0 = key_636X; + merged_arg0K1 = 2; + really_preserve_continuation_return_tag = 0; + goto really_preserve_continuation; + really_preserve_continuation_return_0: + v_637X = really_preserve_continuation0_return_value; + arg0K0 = v_637X; + goto L21454;}} + L20552: { + SstackS = ((((char *) (-3 + (Sbottom_of_stackS)))) + -8); + *((long *) (((char *) (-3 + (Sbottom_of_stackS))))) = 1; + ScontS = (Sbottom_of_stackS); + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 158; + goto push_exception_continuationB; + push_exception_continuationB_return_158: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = cont_98X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L19893: { + v_638X = arg0K0; + merged_arg0K0 = v_638X; + copy_stack_into_heap_return_tag = 0; + goto copy_stack_into_heap; + copy_stack_into_heap_return_0: + if (((SstackS) < (Sstack_limitS))) { + ps_error("Couldn't get default procedure space (how can this happen?)", 0); + goto L19850;} + else { + goto L19850;}} + L17297: { + stack_arg_count_639X = arg0K0; + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (StemplateS); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((((Scode_pointerS) - (((char *) (-3 + (*((long *) (((char *) (-3 + (StemplateS)))))))))))<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = ((((Senabled_interruptsS))<<2)); + SstackS = ((SstackS) + -4); + tem_640X = Sinterrupt_templateS; + StemplateS = tem_640X; + Scode_pointerS = (((char *) (-3 + (*((long *) (((char *) (-3 + tem_640X)))))))); + merged_arg1K0 = (Scode_pointerS); + merged_arg0K1 = (4 + stack_arg_count_639X); + push_continuationB_return_tag = 2; + goto push_continuationB; + push_continuationB_return_2: + n_641X = (Spending_interruptsS) & (Senabled_interruptsS); + arg0K0 = 0; + arg0K1 = 1; + goto L17402;} + L19854: { + arg1K0 = (Scode_pointerS); + goto L19170;} + L16483: { + protocol_642X = arg0K0; + stack_space_643X = arg0K1; + if ((68 == protocol_642X)) { + if ((stack_arg_count_449X < 3)) { + skip_644X = *((unsigned char *) ((((char *) (-3 + code_450X))) + (2 + stack_arg_count_449X))); + if ((0 == skip_644X)) { + arg0K0 = 4; + arg0K1 = stack_arg_count_449X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;} + else { + arg0K0 = skip_644X; + arg0K1 = stack_arg_count_449X; + goto L16487;}} + else { + skip_645X = *((unsigned char *) ((((char *) (-3 + code_450X))) + 5)); + if ((0 == skip_645X)) { + arg0K0 = 4; + arg0K1 = stack_arg_count_449X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;} + else { + arg0K0 = skip_645X; + goto L16510;}}} + else { + if ((67 == protocol_642X)) { + if ((stack_arg_count_449X < (*((unsigned char *) ((((char *) (-3 + code_450X))) + 2))))) { + arg0K0 = 4; + arg0K1 = stack_arg_count_449X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;} + else { + arg0K0 = 3; + goto L16510;}} + else { + if ((65 == protocol_642X)) { + wants_stack_args_646X = ((((*((unsigned char *) ((((char *) (-3 + code_450X))) + 2))))<<8)) + (*((unsigned char *) ((((char *) (-3 + code_450X))) + 3))); + if ((stack_arg_count_449X < wants_stack_args_646X)) { + arg0K0 = 4; + arg0K1 = stack_arg_count_449X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;} + else { + merged_arg0K0 = wants_stack_args_646X; + merged_arg0K1 = stack_arg_count_449X; + merged_arg0K2 = 25; + merged_arg0K3 = 0; + rest_list_setup_return_tag = 0; + goto rest_list_setup; + rest_list_setup_return_0: + arg0K0 = 4; + arg0K1 = (1 + wants_stack_args_646X); + goto L16487;}} + else { + if ((63 < protocol_642X)) { + if ((64 == protocol_642X)) { + if (((((((*((unsigned char *) ((((char *) (-3 + code_450X))) + 2))))<<8)) + (*((unsigned char *) ((((char *) (-3 + code_450X))) + 3)))) == stack_arg_count_449X)) { + arg0K0 = 4; + arg0K1 = stack_arg_count_449X; + goto L16487;} + else { + arg0K0 = 4; + arg0K1 = stack_arg_count_449X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}} + else { + if ((66 == protocol_642X)) { + length_647X = (long)(((unsigned long)(*((long *) ((((char *) (-3 + code_450X))) + -4))))>>8); + index_648X = -2 + length_647X; + arg0K0 = (*((unsigned char *) ((((char *) (-3 + code_450X))) + (-3 + length_647X)))); + arg0K1 = (((((*((unsigned char *) ((((char *) (-3 + code_450X))) + index_648X))))<<8)) + (*((unsigned char *) ((((char *) (-3 + code_450X))) + (1 + index_648X))))); + goto L16483;} + else { + ps_error("unknown protocol", 1, protocol_642X); + arg0K0 = 4; + arg0K1 = stack_arg_count_449X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}}} + else { + if ((protocol_642X == stack_arg_count_449X)) { + arg0K0 = 2; + arg0K1 = stack_arg_count_449X; + goto L16487;} + else { + arg0K0 = 4; + arg0K1 = stack_arg_count_449X; + arg0K2 = 25; + arg0K3 = 0; + goto L17564;}}}}}} + L16760: { + protocol_649X = arg0K0; + stack_space_650X = arg0K1; + if ((68 == protocol_649X)) { + if ((total_arg_count_468X < 3)) { + skip_651X = *((unsigned char *) ((((char *) (-3 + code_467X))) + (2 + total_arg_count_468X))); + if ((0 == skip_651X)) { + arg0K0 = 4; + arg0K1 = stack_arg_count_462X; + arg0K2 = list_args_463X; + arg0K3 = list_arg_count_464X; + goto L17564;} + else { + merged_arg0K0 = list_args_463X; + merged_arg0K1 = list_arg_count_464X; + push_list_return_tag = 0; + goto push_list; + push_list_return_0: + arg0K0 = skip_651X; + arg0K1 = total_arg_count_468X; + goto L16764;}} + else { + skip_652X = *((unsigned char *) ((((char *) (-3 + code_467X))) + 5)); + if ((0 == skip_652X)) { + arg0K0 = 4; + arg0K1 = stack_arg_count_462X; + arg0K2 = list_args_463X; + arg0K3 = list_arg_count_464X; + goto L17564;} + else { + arg0K0 = skip_652X; + goto L16789;}}} + else { + if ((67 == protocol_649X)) { + if ((total_arg_count_468X < (*((unsigned char *) ((((char *) (-3 + code_467X))) + 2))))) { + arg0K0 = 4; + arg0K1 = stack_arg_count_462X; + arg0K2 = list_args_463X; + arg0K3 = list_arg_count_464X; + goto L17564;} + else { + arg0K0 = 3; + goto L16789;}} + else { + if ((63 < protocol_649X)) { + if ((65 == protocol_649X)) { + wants_stack_args_653X = ((((*((unsigned char *) ((((char *) (-3 + code_467X))) + 2))))<<8)) + (*((unsigned char *) ((((char *) (-3 + code_467X))) + 3))); + if ((total_arg_count_468X < wants_stack_args_653X)) { + arg0K0 = 4; + arg0K1 = stack_arg_count_462X; + arg0K2 = list_args_463X; + arg0K3 = list_arg_count_464X; + goto L17564;} + else { + merged_arg0K0 = wants_stack_args_653X; + merged_arg0K1 = stack_arg_count_462X; + merged_arg0K2 = list_args_463X; + merged_arg0K3 = list_arg_count_464X; + rest_list_setup_return_tag = 1; + goto rest_list_setup; + rest_list_setup_return_1: + arg0K0 = 4; + arg0K1 = (1 + wants_stack_args_653X); + goto L16764;}} + else { + if ((64 == protocol_649X)) { + if (((((((*((unsigned char *) ((((char *) (-3 + code_467X))) + 2))))<<8)) + (*((unsigned char *) ((((char *) (-3 + code_467X))) + 3)))) == total_arg_count_468X)) { + merged_arg0K0 = list_args_463X; + merged_arg0K1 = list_arg_count_464X; + push_list_return_tag = 1; + goto push_list; + push_list_return_1: + arg0K0 = 4; + arg0K1 = total_arg_count_468X; + goto L16764;} + else { + arg0K0 = 4; + arg0K1 = stack_arg_count_462X; + arg0K2 = list_args_463X; + arg0K3 = list_arg_count_464X; + goto L17564;}} + else { + if ((66 == protocol_649X)) { + length_654X = (long)(((unsigned long)(*((long *) ((((char *) (-3 + code_467X))) + -4))))>>8); + index_655X = -2 + length_654X; + arg0K0 = (*((unsigned char *) ((((char *) (-3 + code_467X))) + (-3 + length_654X)))); + arg0K1 = (((((*((unsigned char *) ((((char *) (-3 + code_467X))) + index_655X))))<<8)) + (*((unsigned char *) ((((char *) (-3 + code_467X))) + (1 + index_655X))))); + goto L16760;} + else { + ps_error("unknown protocol", 1, protocol_649X); + arg0K0 = 4; + arg0K1 = stack_arg_count_462X; + arg0K2 = list_args_463X; + arg0K3 = list_arg_count_464X; + goto L17564;}}}} + else { + if ((protocol_649X == total_arg_count_468X)) { + merged_arg0K0 = list_args_463X; + merged_arg0K1 = list_arg_count_464X; + push_list_return_tag = 2; + goto push_list; + push_list_return_2: + arg0K0 = 2; + arg0K1 = total_arg_count_468X; + goto L16764;} + else { + arg0K0 = 4; + arg0K1 = stack_arg_count_462X; + arg0K2 = list_args_463X; + arg0K3 = list_arg_count_464X; + goto L17564;}}}}} + L21115: { + cont_656X = arg0K0; + if ((3 == (3 & cont_656X))) { + if ((9 == (31 & ((((*((long *) ((((char *) (-3 + cont_656X))) + -4))))>>2))))) { + next_op_657X = *((unsigned char *) ((((char *) (-3 + (*((long *) (((char *) (-3 + (*((long *) ((((char *) (-3 + cont_656X))) + 8))))))))))) + ((((*((long *) ((((char *) (-3 + cont_656X))) + 4))))>>2)))); + if ((34 == next_op_657X)) { + pop_continuationB_return_tag = 2; + goto pop_continuationB; + pop_continuationB_return_2: + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if ((30 == next_op_657X)) { + next_658X = *((long *) (((char *) (-3 + (ScontS))))); + if (((ScontS) == (Sbottom_of_stackS))) { + *((long *) (((char *) (-3 + (ScontS))))) = (*((long *) (((char *) (-3 + next_658X))))); + goto L20011;} + else { + ScontS = next_658X; + goto L20011;}} + else { + merged_arg0K0 = list_args_480X; + merged_arg0K1 = stack_nargs_479X; + pop_args_GlistS_return_tag = 3; + goto pop_args_GlistS; + pop_args_GlistS_return_3: + args_659X = pop_args_GlistS0_return_value; + merged_arg0K0 = 4; + merged_arg0K1 = 0; + push_exception_continuationB_return_tag = 159; + goto push_exception_continuationB; + push_exception_continuationB_return_159: + *((long *) (SstackS)) = 1; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = args_659X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}} + else { + goto L21121;}} + else { + goto L21121;}} + L19664: { + v_660X = arg0K0; + merged_arg0K0 = v_660X; + copy_stack_into_heap_return_tag = 1; + goto copy_stack_into_heap; + copy_stack_into_heap_return_1: + if (((SstackS) < (Sstack_limitS))) { + ps_error("Couldn't get default procedure space (how can this happen?)", 0); + goto L19549;} + else { + goto L19549;}} + L19558: { + arg0K0 = (*((unsigned char *) ((Scode_pointerS) + 3))); + goto L17297;} + L19561: { + arg1K0 = (Scode_pointerS); + goto L19170;} + L19718: { + v_661X = arg0K0; + merged_arg0K0 = v_661X; + copy_stack_into_heap_return_tag = 2; + goto copy_stack_into_heap; + copy_stack_into_heap_return_2: + if ((space_130X < (64 + (((((SstackS) - (Sstack_limitS)))>>2))))) { + goto L19549;} + else { + ps_error("VM's stack is too small (how can this happen?)", 0); + goto L19549;}} + L30547: { + if ((3 == (3 & x_149X))) { + if ((21 == (31 & ((((*((long *) ((((char *) (-3 + x_149X))) + -4))))>>2))))) { + arg0K0 = 5; + goto L30584;} + else { + goto L30555;}} + else { + goto L30555;}} + L28881: { + SvalS = 1; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L28670: { + if ((3 == (3 & x_151X))) { + if ((21 == (31 & ((((*((long *) ((((char *) (-3 + x_151X))) + -4))))>>2))))) { + goto L28679;} + else { + goto L28682;}} + else { + goto L28682;}} + L28459: { + if ((3 == (3 & x_152X))) { + if ((21 == (31 & ((((*((long *) ((((char *) (-3 + x_152X))) + -4))))>>2))))) { + goto L28468;} + else { + goto L28471;}} + else { + goto L28471;}} + L28248: { + if ((3 == (3 & x_153X))) { + if ((21 == (31 & ((((*((long *) ((((char *) (-3 + x_153X))) + -4))))>>2))))) { + goto L28257;} + else { + goto L28260;}} + else { + goto L28260;}} + L7136: { + b_662X = arg0K0; + lo_a_663X = 65535 & a_493X; + lo_b_664X = 65535 & b_662X; + hi_a_665X = 65535 & (((a_493X)>>16)); + hi_b_666X = 65535 & (((b_662X)>>16)); + lo_c_667X = SMALL_MULTIPLY(lo_a_663X, lo_b_664X); + v_668X = SMALL_MULTIPLY(lo_b_664X, hi_a_665X); + v_669X = SMALL_MULTIPLY(lo_a_663X, hi_b_666X); + mid_c_670X = v_669X + v_668X; + c_671X = lo_c_667X + (((mid_c_670X)<<16)); + if ((0 < hi_a_665X)) { + if ((0 < hi_b_666X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 160; + goto push_exception_continuationB; + push_exception_continuationB_return_160: + *((long *) (SstackS)) = arg2_159X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_160X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + goto L7178;}} + else { + goto L7178;}} + L8912: { + b_672X = arg0K0; + c_673X = a_494X / b_672X; + if ((a_168X < 0)) { + if ((b_169X < 0)) { + goto L8916;} + else { + goto L8915;}} + else { + if ((b_169X < 0)) { + goto L8915;} + else { + goto L8916;}}} + L34166: { + b_674X = arg0K0; + c_675X = a_500X / b_674X; + if ((a_182X < 0)) { + if ((b_183X < 0)) { + goto L34170;} + else { + goto L34169;}} + else { + if ((b_183X < 0)) { + goto L34169;} + else { + goto L34170;}}} + L34034: { + b_676X = arg0K0; + c_677X = a_501X % b_676X; + if ((a_186X < 0)) { + arg0K0 = (0 - c_677X); + goto L34038;} + else { + arg0K0 = c_677X; + goto L34038;}} + L24235: { + SvalS = new_512X; + Scode_pointerS = ((Scode_pointerS) + 3); + arg1K0 = (Scode_pointerS); + goto L19170;} + L24219: { + i_678X = arg0K0; + if ((i_678X < 0)) { + goto L24235;} + else { + SstackS = ((SstackS) + 4); + *((long *) ((((char *) (-3 + new_512X))) + (((i_678X)<<2)))) = (*((long *) (SstackS))); + arg0K0 = (-1 + i_678X); + goto L24219;}} + L24013: { + i_679X = arg0K0; + if ((i_679X < 0)) { + arg0K0 = stack_nargs_517X; + arg0K1 = rest_list_518X; + goto L24031;} + else { + SstackS = ((SstackS) + 4); + *((long *) ((((char *) (-3 + new_516X))) + (((i_679X)<<2)))) = (*((long *) (SstackS))); + arg0K0 = (-1 + i_679X); + goto L24013;}} + L23396: { + i_680X = arg0K0; + if ((i_680X < 0)) { + SvalS = value_523X; + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + addr_681X = (((char *) (-3 + value_523X))) + (((i_680X)<<2)); + WRITE_BARRIER(addr_681X, init_520X); + *((long *) addr_681X) = init_520X; + arg0K0 = (-1 + i_680X); + goto L23396;}} + L27437: { + i_682X = arg0K0; + if ((i_682X < 0)) { + SvalS = vector_525X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + *((unsigned char *) ((((char *) (-3 + vector_525X))) + i_682X)) = init_269X; + arg0K0 = (-1 + i_682X); + goto L27437;}} + L27198: { + i_683X = arg0K0; + if ((i_683X < 0)) { + SvalS = string_528X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + *((unsigned char *) ((((char *) (-3 + string_528X))) + i_683X)) = (init_284X); + arg0K0 = (-1 + i_683X); + goto L27198;}} + L31159: { + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L26550: { + key_684X = arg0K0; + SstackS = ((SstackS) + 4); + arg2_685X = *((long *) (SstackS)); + if ((0 == (3 & (SvalS)))) { + mode_686X = (((SvalS))>>2); + if ((1 == mode_686X)) { + goto L26829;} + else { + if ((2 == mode_686X)) { + goto L26829;} + else { + if ((3 == mode_686X)) { + goto L26829;} + else { + if ((4 == mode_686X)) { + goto L26829;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 161; + goto push_exception_continuationB; + push_exception_continuationB_return_161: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 162; + goto push_exception_continuationB; + push_exception_continuationB_return_162: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + L33355: { + key_687X = arg0K0; + obj_688X = SvalS; + if ((3 == (3 & obj_688X))) { + if ((5 == (31 & ((((*((long *) ((((char *) (-3 + obj_688X))) + -4))))>>2))))) { + x_689X = SvalS; + if ((0 == (*((long *) (((char *) (-3 + x_689X))))))) { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 163; + goto push_exception_continuationB; + push_exception_continuationB_return_163: + *((long *) (SstackS)) = x_689X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + merged_arg0K0 = x_689X; + close_channelB_return_tag = 0; + goto close_channelB; + close_channelB_return_0: + status_690X = close_channelB0_return_value; + if ((status_690X == NO_ERRORS)) { + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 22; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 164; + goto push_exception_continuationB; + push_exception_continuationB_return_164: + *((long *) (SstackS)) = x_689X; + SstackS = ((SstackS) + -4); + merged_arg0K0 = status_690X; + merged_arg0K1 = key_687X; + get_error_string_return_tag = 0; + goto get_error_string; + get_error_string_return_0: + x_691X = get_error_string0_return_value; + *((long *) (SstackS)) = x_691X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}} + else { + goto L33390;}} + else { + goto L33390;}} + L37887: { + key_692X = arg0K0; + SstackS = ((SstackS) + 4); + arg2_693X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_694X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg4_695X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg5_696X = *((long *) (SstackS)); + if ((0 == (3 & (arg4_695X | arg3_694X)))) { + if ((1 == arg2_693X)) { + goto L37919;} + else { + if ((5 == arg2_693X)) { + goto L37919;} + else { + goto L37939;}}} + else { + goto L37939;}} + L38108: { + key_697X = arg0K0; + SstackS = ((SstackS) + 4); + arg2_698X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_699X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg4_700X = *((long *) (SstackS)); + if ((0 == (3 & (arg3_699X | arg2_698X)))) { + obj_701X = SvalS; + if ((3 == (3 & obj_701X))) { + if ((5 == (31 & ((((*((long *) ((((char *) (-3 + obj_701X))) + -4))))>>2))))) { + start_702X = ((arg3_699X)>>2); + count_703X = ((arg2_698X)>>2); + channel_704X = SvalS; + v_705X = 8 == (*((long *) (((char *) (-3 + channel_704X))))); + if (v_705X) { + if ((3 == (3 & arg4_700X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg4_700X))) + -4))))>>2))))) { + goto L37665;} + else { + goto L37657;}} + else { + goto L37657;}} + else { + arg0K0 = 5; + goto L37548;}} + else { + goto L38156;}} + else { + goto L38156;}} + else { + goto L38156;}} + L8239: { + val_706X = *((long *) ((((char *) (-3 + ch_542X))) + 12)); + addr_707X = (((char *) (-3 + prev_543X))) + 12; + WRITE_BARRIER(addr_707X, val_706X); + *((long *) addr_707X) = val_706X; + addr_708X = (((char *) (-3 + ch_542X))) + 12; + WRITE_BARRIER(addr_708X, 1); + *((long *) addr_708X) = 1; + arg0K0 = (*((long *) ((((char *) (-3 + ch_542X))) + 16))); + goto L26502;} + L32906: { + key_709X = arg0K0; + SstackS = ((SstackS) + 4); + arg2_710X = *((long *) (SstackS)); + SstackS = ((SstackS) + 4); + arg3_711X = *((long *) (SstackS)); + if ((3 == (3 & arg3_711X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg3_711X))) + -4))))>>2))))) { + obj_712X = SvalS; + if ((3 == (3 & obj_712X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + obj_712X))) + -4))))>>2))))) { + x_713X = SvalS; + x_714X = image_writing_okayP(); + if (x_714X) { + port_715X = ps_open_output_file((((char *)(((char *) (-3 + arg3_711X))))), &status_716X); + if ((status_716X == NO_ERRORS)) { + status_717X = ps_write_string((((char *)(((char *) (-3 + x_713X))))), port_715X); + if ((status_717X == NO_ERRORS)) { + status_718X = write_image(arg2_710X, port_715X, mark_traced_channels_closedB); + if ((status_718X == NO_ERRORS)) { + status_719X = ps_close(port_715X); + if ((status_719X == NO_ERRORS)) { + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + arg0K0 = 22; + arg0K1 = status_719X; + goto L32946;}} + else { + status_720X = ps_close(port_715X); + if ((status_720X == NO_ERRORS)) { + arg0K0 = 22; + arg0K1 = status_718X; + goto L32946;} + else { + ps_write_string("Unable to close image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + arg0K0 = 22; + arg0K1 = status_718X; + goto L32946;}}} + else { + status_721X = ps_close(port_715X); + if ((status_721X == NO_ERRORS)) { + arg0K0 = 22; + arg0K1 = status_717X; + goto L32946;} + else { + ps_write_string("Unable to close image file", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + arg0K0 = 22; + arg0K1 = status_717X; + goto L32946;}}} + else { + arg0K0 = 10; + arg0K1 = status_716X; + goto L32946;}} + else { + merged_arg0K0 = 15; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 165; + goto push_exception_continuationB; + push_exception_continuationB_return_165: + *((long *) (SstackS)) = arg3_711X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_710X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_713X; + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;}} + else { + goto L33028;}} + else { + goto L33028;}} + else { + goto L33028;}} + else { + goto L33028;}} + L32760: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 166; + goto push_exception_continuationB; + push_exception_continuationB_return_166: + *((long *) (SstackS)) = arg2_549X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_550X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L9391: { + i_722X = arg0K0; + map_723X = arg0K1; + if ((4 == i_722X)) { + addr_724X = ALLOCATE_SPACE(2, 20); + *((long *) addr_724X) = 4106; + vector_725X = 3 + (((long) (addr_724X + 4))); + addr_726X = ((char *) (-3 + vector_725X)); + WRITE_BARRIER(addr_726X, map_723X); + *((long *) addr_726X) = map_723X; + addr_727X = ((char *) (-3 + vector_725X)); + arg0K0 = 1; + goto L9411;} + else { + PS_SHIFT_LEFT(i_722X, (((i_722X)<<3)), x_728X) + arg0K0 = (1 + i_722X); + arg0K1 = (map_723X | x_728X); + goto L9391;}} + L31327: { + table_729X = arg0K0; + symbols_730X = arg0K1; + firstP_731X = arg2K2; + arg0K0 = 0; + goto L31331;} + L30906: { + minutesP_732X = arg2K0; + if ((Spending_interruptPS)) { + if ((Spending_eventsPS)) { + Spending_eventsPS = 0; + check_events_return_tag = 2; + goto check_events; + check_events_return_2: + temp_733X = check_events0_return_value; + if (temp_733X) { + goto L30921;} + else { + goto L30945;}} + else { + goto L30921;}} + else { + goto L30945;}} + L17820: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 167; + goto push_exception_continuationB; + push_exception_continuationB_return_167: + *((long *) (SstackS)) = proc_570X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L25892: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 168; + goto push_exception_continuationB; + push_exception_continuationB_return_168: + *((long *) (SstackS)) = arg2_577X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L25581: { + obj_734X = SvalS; + if ((3 == (3 & obj_734X))) { + if ((20 == (31 & ((((*((long *) ((((char *) (-3 + obj_734X))) + -4))))>>2))))) { + x_735X = SvalS; + limit_736X = (((char *) (-3 + x_735X))) + (-4 & (3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + x_735X))) + -4))))>>8)))); + start_737X = (((char *) (-3 + x_735X))) + -4; + if ((1 == arg2_587X)) { + goto L15346;} + else { + arg1K0 = (start_737X + 4); + goto L6529;}} + else { + goto L25620;}} + else { + goto L25620;}} + L25620: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 169; + goto push_exception_continuationB; + push_exception_continuationB_return_169: + *((long *) (SstackS)) = arg3_588X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_587X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L25397: { + len_738X = 1 + n_593X; + addr_739X = ALLOCATE_SPACE(19, (4 + len_738X)); + *((long *) addr_739X) = (78 + (((len_738X)<<8))); + string_740X = 3 + (((long) (addr_739X + 4))); + *((unsigned char *) ((((char *) (-3 + string_740X))) + n_593X)) = 0; + arg0K0 = arg2_592X; + arg0K1 = (-1 + n_593X); + goto L25327;} + L25302: { + if ((25 == arg2_592X)) { + goto L25397;} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 170; + goto push_exception_continuationB; + push_exception_continuationB_return_170: + *((long *) (SstackS)) = arg2_592X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((n_593X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + L12920: { + i_741X = arg0K0; + h_742X = arg0K1; + if ((i_741X < n_598X)) { + arg0K0 = (1 + i_741X); + arg0K1 = (h_742X + (((*((unsigned char *) ((((char *) (-3 + arg2_594X))) + i_741X)))))); + goto L12920;} + else { + index_743X = h_742X & (-1 + v_597X); + bucket_744X = *((long *) ((((char *) (-3 + table_596X))) + (((index_743X)<<2)))); + arg0K0 = bucket_744X; + goto L12883;}} + L25151: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 171; + goto push_exception_continuationB; + push_exception_continuationB_return_171: + *((long *) (SstackS)) = arg2_594X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L31544: { + if ((from_index_408X < 0)) { + goto L31598;} + else { + if ((to_index_409X < 0)) { + goto L31598;} + else { + if ((count_410X < 0)) { + goto L31598;} + else { + if ((3 == (3 & arg5_407X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg5_407X))) + -4))))>>2))))) { + arg0K0 = (-1 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg5_407X))) + -4))))>>8))); + goto L31565;} + else { + goto L31561;}} + else { + goto L31561;}}}}} + L31539: { + if ((3 == (3 & arg5_407X))) { + if ((20 == (31 & ((((*((long *) ((((char *) (-3 + arg5_407X))) + -4))))>>2))))) { + goto L31544;} + else { + goto L31598;}} + else { + goto L31598;}} + L31598: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 172; + goto push_exception_continuationB; + push_exception_continuationB_return_172: + *((long *) (SstackS)) = arg5_407X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((from_index_408X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg3_405X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((to_index_409X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((count_410X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 5; + goto L17068;} + L22494: { + merged_arg0K0 = 5; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 173; + goto push_exception_continuationB; + push_exception_continuationB_return_173: + *((long *) (SstackS)) = port_604X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L22474: { + merged_arg0K0 = 14; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 174; + goto push_exception_continuationB; + push_exception_continuationB_return_174: + *((long *) (SstackS)) = port_604X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L22291: { + merged_arg0K0 = 5; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 175; + goto push_exception_continuationB; + push_exception_continuationB_return_175: + *((long *) (SstackS)) = port_612X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L22271: { + merged_arg0K0 = 14; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 176; + goto push_exception_continuationB; + push_exception_continuationB_return_176: + *((long *) (SstackS)) = port_612X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L22039: { + merged_arg0K0 = 5; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 177; + goto push_exception_continuationB; + push_exception_continuationB_return_177: + *((long *) (SstackS)) = Kchar_618X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = port_619X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L22021: { + merged_arg0K0 = 14; + merged_arg0K1 = 2; + push_exception_continuationB_return_tag = 178; + goto push_exception_continuationB; + push_exception_continuationB_return_178: + *((long *) (SstackS)) = Kchar_618X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = port_619X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L30818: { + arg0K0 = (*((long *) ((((char *) (-3 + stuff_626X))) + 4))); + goto L30811;} + L11984: { + if ((3 == (3 & thing_627X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + thing_627X))) + -4))))>>2))))) { + arg3K0 = (((char *)(((char *) (-3 + thing_627X))))); + goto L12026;} + else { + goto L11992;}} + else { + goto L11992;}} + L30826: { + { long ignoreXX; + PS_WRITE_CHAR(10, out_418X, ignoreXX) } + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L17144: { + StemplateS = (SvalS); + Slosing_opcodeS = opcode_420X; + arg0K0 = (2 + nargs_419X); + goto L16469;} + L17214: { + merged_arg3K0 = "exception handler is not a closure"; + loseD0_return_tag = 1; + goto loseD0; + loseD0_return_1: + goto L17144;} + L21734: { + key_745X = arg0K0; + p_746X = SenvS; + if ((3 == (3 & p_746X))) { + if ((p_746X < (((long) (Sstack_beginS))))) { + goto L21852;} + else { + if (((((long) (Sstack_endS))) < p_746X)) { + goto L21852;} + else { + merged_arg0K0 = (SenvS); + merged_arg0K1 = (ScontS); + merged_arg0K2 = key_745X; + merged_arg0K3 = 0; + save_env_in_heap_return_tag = 0; + goto save_env_in_heap; + save_env_in_heap_return_0: + v_747X = save_env_in_heap0_return_value; + SenvS = v_747X; + goto L21852;}}} + else { + goto L21852;}} + L21745: { + env_748X = arg0K0; + a_749X = *((long *) ((((char *) (-3 + (StemplateS)))) + ((((((((*((unsigned char *) ((Scode_pointerS) + 1))))<<8)) + (*((unsigned char *) ((Scode_pointerS) + 2)))))<<2)))); + addr_750X = ALLOCATE_SPACE(3, 12); + *((long *) addr_750X) = 2062; + x_751X = 3 + (((long) (addr_750X + 4))); + *((long *) (((char *) (-3 + x_751X)))) = a_749X; + *((long *) ((((char *) (-3 + x_751X))) + 4)) = env_748X; + SvalS = x_751X; + Scode_pointerS = ((Scode_pointerS) + 4); + arg1K0 = (Scode_pointerS); + goto L19170;} + L21557: { + i_752X = arg0K0; + offset_753X = arg0K1; + env_754X = arg0K2; + if ((i_752X == total_count_91X)) { + SvalS = new_env_440X; + Scode_pointerS = ((Scode_pointerS) + (1 + offset_753X)); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + back_755X = *((unsigned char *) ((Scode_pointerS) + (1 + offset_753X))); + arg0K0 = env_754X; + arg0K1 = back_755X; + goto L21652;}} + L21454: { + value_756X = arg0K0; + SvalS = value_756X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L17402: { + i_757X = arg0K0; + m_758X = arg0K1; + if ((0 == (n_641X & m_758X))) { + arg0K0 = (1 + i_757X); + arg0K1 = (((m_758X)<<1)); + goto L17402;} + else { + Spending_interruptsS = ((Spending_interruptsS) & (~ m_758X)); + if ((i_757X == 0)) { + *((long *) (SstackS)) = (Sinterrupted_templateS); + SstackS = ((SstackS) + -4); + Sinterrupted_templateS = 1; + *((long *) (SstackS)) = ((((Senabled_interruptsS))<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17321;} + else { + if ((i_757X == 2)) { + *((long *) (SstackS)) = (Sfinalize_theseS); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = ((((Senabled_interruptsS))<<2)); + SstackS = ((SstackS) + -4); + Sfinalize_theseS = 25; + arg0K0 = 2; + goto L17321;} + else { + if ((i_757X == 3)) { + channel_759X = Spending_channels_headS; + next_760X = *((long *) ((((char *) (-3 + channel_759X))) + 12)); + Spending_channels_headS = next_760X; + addr_761X = (((char *) (-3 + channel_759X))) + 12; + WRITE_BARRIER(addr_761X, 1); + *((long *) addr_761X) = 1; + if ((1 == next_760X)) { + Spending_channels_tailS = 1; + arg0K0 = channel_759X; + goto L8380;} + else { + arg0K0 = channel_759X; + goto L8380;}} + else { + *((long *) (SstackS)) = ((((Senabled_interruptsS))<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17321;}}}}} + L16487: { + skip_762X = arg0K0; + stack_arg_count_763X = arg0K1; + template_764X = *((long *) (((char *) (-3 + (SvalS))))); + StemplateS = template_764X; + Scode_pointerS = ((((char *) (-3 + (*((long *) (((char *) (-3 + template_764X)))))))) + skip_762X); + SenvS = (*((long *) ((((char *) (-3 + (SvalS)))) + 4))); + arg0K0 = stack_space_643X; + arg0K1 = stack_arg_count_763X; + goto L16378;} + L16510: { + skip_765X = arg0K0; + *((long *) (SstackS)) = 25; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((stack_arg_count_449X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((stack_arg_count_449X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = skip_765X; + arg0K1 = (3 + stack_arg_count_449X); + goto L16487;} + L16764: { + skip_766X = arg0K0; + stack_arg_count_767X = arg0K1; + template_768X = *((long *) (((char *) (-3 + (SvalS))))); + StemplateS = template_768X; + Scode_pointerS = ((((char *) (-3 + (*((long *) (((char *) (-3 + template_768X)))))))) + skip_766X); + SenvS = (*((long *) ((((char *) (-3 + (SvalS)))) + 4))); + arg0K0 = stack_space_650X; + arg0K1 = stack_arg_count_767X; + goto L16378;} + L16789: { + skip_769X = arg0K0; + if ((total_arg_count_468X < 3)) { + arg0K0 = total_arg_count_468X; + goto L16797;} + else { + if ((2 < stack_arg_count_462X)) { + arg0K0 = stack_arg_count_462X; + goto L16797;} + else { + arg0K0 = 2; + goto L16797;}}} + L20011: { + SvalS = (*((long *) ((((char *) (-3 + cont_656X))) + 16))); + arg0K0 = stack_nargs_479X; + arg0K1 = list_args_480X; + arg0K2 = list_arg_count_481X; + goto L18972;} + L21121: { + merged_arg0K0 = list_args_480X; + merged_arg0K1 = stack_nargs_479X; + pop_args_GlistS_return_tag = 4; + goto pop_args_GlistS; + pop_args_GlistS_return_4: + args_770X = pop_args_GlistS0_return_value; + merged_arg0K0 = 4; + merged_arg0K1 = 0; + push_exception_continuationB_return_tag = 179; + goto push_exception_continuationB; + push_exception_continuationB_return_179: + *((long *) (SstackS)) = 1; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = args_770X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + L30555: { + if ((3 == (3 & x_149X))) { + if ((10 == (31 & ((((*((long *) ((((char *) (-3 + x_149X))) + -4))))>>2))))) { + arg0K0 = 5; + goto L30584;} + else { + arg0K0 = 1; + goto L30584;}} + else { + arg0K0 = 1; + goto L30584;}} + L28682: { + if ((3 == (3 & x_151X))) { + if ((10 == (31 & ((((*((long *) ((((char *) (-3 + x_151X))) + -4))))>>2))))) { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 180; + goto push_exception_continuationB; + push_exception_continuationB_return_180: + *((long *) (SstackS)) = x_151X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + goto L28690;}} + else { + goto L28690;}} + L28471: { + if ((3 == (3 & x_152X))) { + if ((10 == (31 & ((((*((long *) ((((char *) (-3 + x_152X))) + -4))))>>2))))) { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 181; + goto push_exception_continuationB; + push_exception_continuationB_return_181: + *((long *) (SstackS)) = x_152X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + goto L28479;}} + else { + goto L28479;}} + L28260: { + if ((3 == (3 & x_153X))) { + if ((10 == (31 & ((((*((long *) ((((char *) (-3 + x_153X))) + -4))))>>2))))) { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 182; + goto push_exception_continuationB; + push_exception_continuationB_return_182: + *((long *) (SstackS)) = x_153X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + else { + goto L28268;}} + else { + goto L28268;}} + L7178: { + if ((536870911 < lo_c_667X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 183; + goto push_exception_continuationB; + push_exception_continuationB_return_183: + *((long *) (SstackS)) = arg2_159X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_160X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + if ((lo_c_667X < 0)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 184; + goto push_exception_continuationB; + push_exception_continuationB_return_184: + *((long *) (SstackS)) = arg2_159X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_160X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + if ((8192 < mid_c_670X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 185; + goto push_exception_continuationB; + push_exception_continuationB_return_185: + *((long *) (SstackS)) = arg2_159X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_160X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + if ((a_161X < 0)) { + if ((b_162X < 0)) { + goto L7205;} + else { + goto L7212;}} + else { + if ((b_162X < 0)) { + goto L7212;} + else { + goto L7205;}}}}}} + L8916: { + if ((536870911 < c_673X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 186; + goto push_exception_continuationB; + push_exception_continuationB_return_186: + *((long *) (SstackS)) = arg2_166X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_167X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + arg0K0 = (((c_673X)<<2)); + goto L8890;}} + L8915: { + arg0K0 = ((((0 - c_673X))<<2)); + goto L8890;} + L34170: { + if ((536870911 < c_675X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 187; + goto push_exception_continuationB; + push_exception_continuationB_return_187: + *((long *) (SstackS)) = arg2_180X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_181X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + SvalS = (((c_675X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L34169: { + SvalS = ((((0 - c_675X))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L34038: { + n_771X = arg0K0; + SvalS = (((n_771X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L24031: { + i_772X = arg0K0; + rest_list_773X = arg0K1; + if ((25 == rest_list_773X)) { + SvalS = new_516X; + Scode_pointerS = ((Scode_pointerS) + 2); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + *((long *) ((((char *) (-3 + new_516X))) + (((i_772X)<<2)))) = (*((long *) (((char *) (-3 + rest_list_773X))))); + arg0K0 = (1 + i_772X); + arg0K1 = (*((long *) ((((char *) (-3 + rest_list_773X))) + 4))); + goto L24031;}} + L26829: { + if ((0 == (3 & arg2_685X))) { + if (((((arg2_685X)>>2)) < 0)) { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 188; + goto push_exception_continuationB; + push_exception_continuationB_return_188: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + arg0K0 = (((arg2_685X)>>2)); + goto L26608;}} + else { + if ((3 == (3 & arg2_685X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg2_685X))) + -4))))>>2))))) { + if ((1 == mode_686X)) { + goto L26666;} + else { + if ((3 == mode_686X)) { + goto L26666;} + else { + v_774X = ps_open_fd((((char *)(((char *) (-3 + arg2_685X))))), 0, &v_775X); + arg0K0 = v_774X; + arg0K1 = v_775X; + goto L26679;}}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 189; + goto push_exception_continuationB; + push_exception_continuationB_return_189: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + else { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 190; + goto push_exception_continuationB; + push_exception_continuationB_return_190: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}}} + L33390: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 191; + goto push_exception_continuationB; + push_exception_continuationB_return_191: + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;} + L37919: { + obj_776X = SvalS; + if ((3 == (3 & obj_776X))) { + if ((5 == (31 & ((((*((long *) ((((char *) (-3 + obj_776X))) + -4))))>>2))))) { + x_777X = SvalS; + if ((1 == arg2_693X)) { + arg2K0 = 0; + goto L37936;} + else { + arg2K0 = 1; + goto L37936;}} + else { + goto L37939;}} + else { + goto L37939;}} + L37939: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 192; + goto push_exception_continuationB; + push_exception_continuationB_return_192: + *((long *) (SstackS)) = arg5_696X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg4_695X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg3_694X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_693X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 5; + goto L17068;} + L37665: { + if ((3 == (3 & arg4_700X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg4_700X))) + -4))))>>2))))) { + arg0K0 = (-1 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg4_700X))) + -4))))>>8))); + goto L37677;} + else { + goto L37673;}} + else { + goto L37673;}} + L37657: { + if ((3 == (3 & arg4_700X))) { + if ((20 == (31 & ((((*((long *) ((((char *) (-3 + arg4_700X))) + -4))))>>2))))) { + goto L37665;} + else { + arg0K0 = 5; + goto L37548;}} + else { + arg0K0 = 5; + goto L37548;}} + L37548: { + reason_778X = arg0K0; + merged_arg0K0 = reason_778X; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 193; + goto push_exception_continuationB; + push_exception_continuationB_return_193: + *((long *) (SstackS)) = arg4_700X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((start_702X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((count_703X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = channel_704X; + SstackS = ((SstackS) + -4); + arg0K0 = 4; + goto L17068;} + L38156: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 194; + goto push_exception_continuationB; + push_exception_continuationB_return_194: + *((long *) (SstackS)) = arg4_700X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg3_699X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_698X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 4; + goto L17068;} + L32946: { + reason_779X = arg0K0; + status_780X = arg0K1; + merged_arg0K0 = reason_779X; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 195; + goto push_exception_continuationB; + push_exception_continuationB_return_195: + *((long *) (SstackS)) = arg3_711X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_710X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_713X; + SstackS = ((SstackS) + -4); + merged_arg0K0 = status_780X; + merged_arg0K1 = key_709X; + get_error_string_return_tag = 1; + goto get_error_string; + get_error_string_return_1: + x_781X = get_error_string0_return_value; + *((long *) (SstackS)) = x_781X; + SstackS = ((SstackS) + -4); + arg0K0 = 4; + goto L17068;} + L33028: { + merged_arg0K0 = 5; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 196; + goto push_exception_continuationB; + push_exception_continuationB_return_196: + *((long *) (SstackS)) = arg3_711X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = arg2_710X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (SvalS); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;} + L9411: { + i_782X = arg0K0; + if ((4 == i_782X)) { + value_783X = (((*((unsigned char *) addr_727X)))<<2); + addr_784X = ((char *) (-3 + vector_725X)); + WRITE_BARRIER(addr_784X, value_783X); + *((long *) addr_784X) = value_783X; + if ((3 == (3 & vector_725X))) { + if ((0 == (128 & (*((long *) ((((char *) (-3 + vector_725X))) + -4)))))) { + *((long *) ((((char *) (-3 + vector_725X))) + -4)) = (128 | (*((long *) ((((char *) (-3 + vector_725X))) + -4)))); + arg0K0 = vector_725X; + goto L35950;} + else { + arg0K0 = vector_725X; + goto L35950;}} + else { + arg0K0 = vector_725X; + goto L35950;}} + else { + value_785X = (((*((unsigned char *) (addr_727X + i_782X))))<<2); + addr_786X = (((char *) (-3 + vector_725X))) + (((i_782X)<<2)); + WRITE_BARRIER(addr_786X, value_785X); + *((long *) addr_786X) = value_785X; + arg0K0 = (1 + i_782X); + goto L9411;}} + L31331: { + i_787X = arg0K0; + if ((i_787X == ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + symbols_730X))) + -4))))>>8))))>>2)))) { + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + v_788X = AVAILABLEp(3); + if (v_788X) { + obj_789X = *((long *) ((((char *) (-3 + symbols_730X))) + (((i_787X)<<2)))); + v_790X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + table_729X))) + -4))))>>8))))>>2); + s_791X = *((long *) ((((char *) (-3 + obj_789X))) + 4)); + n_792X = -1 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + s_791X))) + -4))))>>8)); + arg0K0 = 0; + arg0K1 = 0; + goto L14764;} + else { + if (firstP_731X) { + arg0K0 = 1; + goto L31352;} + else { + merged_arg0K0 = 8; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 197; + goto push_exception_continuationB; + push_exception_continuationB_return_197: + *((long *) (SstackS)) = table_729X; + SstackS = ((SstackS) + -4); + arg0K0 = 1; + goto L17068;}}}} + L30921: { + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L30945: { + if ((0 == (Spending_interruptsS))) { + wait_for_event((((arg2_352X)>>2)), minutesP_732X); + goto L30921;} + else { + goto L30921;}} + L15346: { + SstartS = start_737X; + Snew_uidsS = 25; + Sbad_count_proxiesS = 25; + arg1K0 = (start_737X + 8); + goto L15074;} + L6529: { + ptr_793X = arg1K0; + if ((ptr_793X < limit_736X)) { + x_794X = *((unsigned char *) ptr_793X); + *((unsigned char *) ptr_793X) = (*((unsigned char *) (ptr_793X + 3))); + *((unsigned char *) (ptr_793X + 3)) = x_794X; + x_795X = *((unsigned char *) (ptr_793X + 1)); + *((unsigned char *) (ptr_793X + 1)) = (*((unsigned char *) (ptr_793X + 2))); + *((unsigned char *) (ptr_793X + 2)) = x_795X; + value_796X = *((long *) ptr_793X); + next_797X = ptr_793X + 4; + if ((2 == (3 & value_796X))) { + if (((31 & (((value_796X)>>2))) < 19)) { + arg1K0 = next_797X; + goto L6529;} + else { + arg1K0 = (next_797X + (-4 & (3 + ((long)(((unsigned long)value_796X)>>8))))); + goto L6529;}} + else { + arg1K0 = next_797X; + goto L6529;}} + else { + goto L15346;}} + L25327: { + l_798X = arg0K0; + i_799X = arg0K1; + if ((i_799X < 0)) { + SvalS = string_740X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + *((unsigned char *) ((((char *) (-3 + string_740X))) + i_799X)) = ((((((*((long *) (((char *) (-3 + l_798X))))))>>8)))); + arg0K0 = (*((long *) ((((char *) (-3 + l_798X))) + 4))); + arg0K1 = (-1 + i_799X); + goto L25327;}} + L12883: { + b_800X = arg0K0; + if ((25 == b_800X)) { + addr_801X = ALLOCATE_SPACE(1, 12); + *((long *) addr_801X) = 2054; + x_802X = 3 + (((long) (addr_801X + 4))); + *((long *) (((char *) (-3 + x_802X)))) = 1; + *((long *) ((((char *) (-3 + x_802X))) + 4)) = arg2_594X; + addr_803X = ALLOCATE_SPACE(0, 12); + *((long *) addr_803X) = 2050; + x_804X = 3 + (((long) (addr_803X + 4))); + *((long *) (((char *) (-3 + x_804X)))) = x_802X; + *((long *) ((((char *) (-3 + x_804X))) + 4)) = bucket_744X; + addr_805X = (((char *) (-3 + table_596X))) + (((index_743X)<<2)); + WRITE_BARRIER(addr_805X, x_804X); + *((long *) addr_805X) = x_804X; + arg0K0 = x_802X; + goto L25150;} + else { + s2_806X = *((long *) ((((char *) (-3 + (*((long *) (((char *) (-3 + b_800X)))))))) + 4)); + len_807X = (long)(((unsigned long)(*((long *) ((((char *) (-3 + arg2_594X))) + -4))))>>8); + if ((len_807X == ((long)(((unsigned long)(*((long *) ((((char *) (-3 + s2_806X))) + -4))))>>8)))) { + if (((!memcmp((void *)(((char *) (-3 + s2_806X))), (void *)(((char *) (-3 + arg2_594X))),len_807X)))) { + arg0K0 = (*((long *) (((char *) (-3 + b_800X))))); + goto L25150;} + else { + goto L12901;}} + else { + goto L12901;}}} + L31565: { + y_808X = arg0K0; + if ((y_808X < (from_index_408X + count_410X))) { + goto L31598;} + else { + if ((3 == (3 & arg3_405X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg3_405X))) + -4))))>>2))))) { + arg0K0 = (-1 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg3_405X))) + -4))))>>8))); + goto L31580;} + else { + goto L31576;}} + else { + goto L31576;}}} + L31561: { + arg0K0 = ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg5_407X))) + -4))))>>8)); + goto L31565;} + L12026: { + v_809X = arg3K0; + ps_write_string(v_809X, out_418X); + goto L30818;} + L11992: { + if ((3 == (3 & thing_627X))) { + if ((1 == (31 & ((((*((long *) ((((char *) (-3 + thing_627X))) + -4))))>>2))))) { + arg3K0 = (((char *)(((char *) (-3 + (*((long *) ((((char *) (-3 + thing_627X))) + 4)))))))); + goto L12026;} + else { + goto L12000;}} + else { + goto L12000;}} + L21852: { + arg0K0 = (SenvS); + goto L21739;} + L21652: { + env_810X = arg0K0; + i_811X = arg0K1; + if ((0 == i_811X)) { + count_812X = *((unsigned char *) ((Scode_pointerS) + (2 + offset_753X))); + arg0K0 = count_812X; + arg0K1 = i_752X; + arg0K2 = (2 + offset_753X); + goto L21574;} + else { + arg0K0 = (*((long *) (((char *) (-3 + env_810X))))); + arg0K1 = (-1 + i_811X); + goto L21652;}} + L17321: { + arg_count_813X = arg0K0; + obj_814X = Sinterrupt_handlersS; + if ((3 == (3 & obj_814X))) { + if ((2 == (31 & ((((*((long *) ((((char *) (-3 + obj_814X))) + -4))))>>2))))) { + goto L17335;} + else { + goto L17415;}} + else { + goto L17415;}} + L8380: { + channel_815X = arg0K0; + x_816X = 1 == (Spending_channels_headS); + if (x_816X) { + goto L8394;} + else { + Spending_interruptsS = (8 | (Spending_interruptsS)); + if ((0 == ((Spending_interruptsS) & (Senabled_interruptsS)))) { + Spending_interruptPS = 0; + if ((Spending_eventsPS)) { + Spending_interruptPS = 1; + goto L8394;} + else { + goto L8394;}} + else { + Spending_interruptPS = 1; + goto L8394;}}} + L16378: { + stack_slots_817X = arg0K0; + stack_arg_count_818X = arg0K1; + if ((stack_slots_817X < (64 + (((((SstackS) - (Sstack_limitS)))>>2))))) { + goto L16380;} + else { + space_819X = 1 + (((((Sstack_endS) - (SstackS)))>>2)); + v_820X = AVAILABLEp(space_819X); + if (v_820X) { + arg2K0 = 1; + arg0K1 = 0; + goto L16437;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 28; + goto collect_saving_temp; + collect_saving_temp_return_28: + v_821X = AVAILABLEp(space_819X); + if (v_821X) { + arg2K0 = 1; + arg0K1 = 0; + goto L16437;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L16437;}}}} + L16797: { + final_stack_arg_count_822X = arg0K0; + if ((stack_arg_count_462X < final_stack_arg_count_822X)) { + arg0K0 = final_stack_arg_count_822X; + goto L16801;} + else { + arg0K0 = stack_arg_count_462X; + goto L16801;}} + L28690: { + SvalS = 1; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L28479: { + SvalS = 1; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L28268: { + SvalS = 1; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L7205: { + if ((536870911 < c_671X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 198; + goto push_exception_continuationB; + push_exception_continuationB_return_198: + *((long *) (SstackS)) = arg2_159X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_160X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + SvalS = (((c_671X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L7212: { + if ((536870912 < c_671X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 199; + goto push_exception_continuationB; + push_exception_continuationB_return_199: + *((long *) (SstackS)) = arg2_159X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_160X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + SvalS = ((((0 - c_671X))<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L8890: { + q_823X = arg0K0; + if ((0 == y_167X)) { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 200; + goto push_exception_continuationB; + push_exception_continuationB_return_200: + *((long *) (SstackS)) = arg2_166X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_167X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + a_824X = ((arg2_166X)>>2); + if ((a_824X < 0)) { + arg0K0 = (0 - a_824X); + goto L8947;} + else { + arg0K0 = a_824X; + goto L8947;}}} + L26608: { + index_825X = arg0K0; + temp_826X = index_825X < (Snumber_of_channelsS); + if (temp_826X) { + goto L10939;} + else { + x_827X = 1 + index_825X; + y_828X = 8 + (Snumber_of_channelsS); + if ((x_827X < y_828X)) { + arg0K0 = y_828X; + goto L2160;} + else { + arg0K0 = x_827X; + goto L2160;}}} + L26666: { + v_829X = ps_open_fd((((char *)(((char *) (-3 + arg2_685X))))), 1, &v_830X); + arg0K0 = v_829X; + arg0K1 = v_830X; + goto L26679;} + L26679: { + channel_831X = arg0K0; + status_832X = arg0K1; + if ((status_832X == NO_ERRORS)) { + arg0K0 = channel_831X; + goto L26608;} + else { + if ((status_832X == ENOENT)) { + merged_arg0K0 = 10; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 201; + goto push_exception_continuationB; + push_exception_continuationB_return_201: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + merged_arg0K0 = 22; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 202; + goto push_exception_continuationB; + push_exception_continuationB_return_202: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + merged_arg0K0 = status_832X; + merged_arg0K1 = key_684X; + get_error_string_return_tag = 2; + goto get_error_string; + get_error_string_return_2: + x_833X = get_error_string0_return_value; + *((long *) (SstackS)) = x_833X; + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17068;}}} + L37936: { + waitP_834X = arg2K0; + start_835X = ((arg4_695X)>>2); + count_836X = ((arg3_694X)>>2); + if ((4 == (*((long *) (((char *) (-3 + x_777X))))))) { + if ((3 == (3 & arg5_696X))) { + if ((0 == (128 & (*((long *) ((((char *) (-3 + arg5_696X))) + -4)))))) { + if ((3 == (3 & arg5_696X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg5_696X))) + -4))))>>2))))) { + goto L37238;} + else { + goto L37230;}} + else { + goto L37230;}} + else { + arg0K0 = 5; + goto L37121;}} + else { + arg0K0 = 5; + goto L37121;}} + else { + arg0K0 = 5; + goto L37121;}} + L37677: { + length_837X = arg0K0; + if ((length_837X < (start_702X + count_703X))) { + arg0K0 = 7; + goto L37548;} + else { + got_838X = ps_write_fd(((((*((long *) ((((char *) (-3 + channel_704X))) + 8))))>>2)), ((((char *) (-3 + arg4_700X))) + start_702X), count_703X, &pendingP_839X, &status_840X); + if ((status_840X == NO_ERRORS)) { + if (pendingP_839X) { + Spending_interruptPS = 0; + Senabled_interruptsS = 0; + arg0K0 = 13; + goto L37548;} + else { + SvalS = (((got_838X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + else { + merged_arg0K0 = 22; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 203; + goto push_exception_continuationB; + push_exception_continuationB_return_203: + *((long *) (SstackS)) = arg4_700X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((start_702X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((count_703X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = channel_704X; + SstackS = ((SstackS) + -4); + merged_arg0K0 = status_840X; + merged_arg0K1 = key_697X; + get_error_string_return_tag = 3; + goto get_error_string; + get_error_string_return_3: + x_841X = get_error_string0_return_value; + *((long *) (SstackS)) = x_841X; + SstackS = ((SstackS) + -4); + arg0K0 = 5; + goto L17068;}}} + L37673: { + arg0K0 = ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg4_700X))) + -4))))>>8)); + goto L37677;} + L35950: { + val_842X = arg0K0; + SvalS = val_842X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L14764: { + i_843X = arg0K0; + h_844X = arg0K1; + if ((i_843X < n_792X)) { + arg0K0 = (1 + i_843X); + arg0K1 = (h_844X + (((*((unsigned char *) ((((char *) (-3 + s_791X))) + i_843X)))))); + goto L14764;} + else { + index_845X = h_844X & (-1 + v_790X); + bucket_846X = *((long *) ((((char *) (-3 + table_729X))) + (((index_845X)<<2)))); + arg0K0 = bucket_846X; + goto L14725;}} + L31352: { + i_847X = arg0K0; + if ((i_847X == ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + table_729X))) + -4))))>>8))))>>2)))) { + addr_848X = ((char *) (-3 + table_729X)); + WRITE_BARRIER(addr_848X, symbols_730X); + *((long *) addr_848X) = symbols_730X; + merged_arg0K0 = table_729X; + collect_saving_temp_return_tag = 29; + goto collect_saving_temp; + collect_saving_temp_return_29: + table_849X = collect_saving_temp0_return_value; + symbols_850X = *((long *) (((char *) (-3 + table_849X)))); + addr_851X = ((char *) (-3 + table_849X)); + WRITE_BARRIER(addr_851X, 25); + *((long *) addr_851X) = 25; + arg0K0 = table_849X; + arg0K1 = symbols_850X; + arg2K2 = 0; + goto L31327;} + else { + addr_852X = (((char *) (-3 + table_729X))) + (((i_847X)<<2)); + WRITE_BARRIER(addr_852X, 25); + *((long *) addr_852X) = 25; + arg0K0 = (1 + i_847X); + goto L31352;}} + L15074: { + addr_853X = arg1K0; + if ((addr_853X < limit_736X)) { + thing_854X = *((long *) addr_853X); + next_855X = addr_853X + 4; + if (((31 & (((thing_854X)>>2))) < 19)) { + arg1K0 = next_855X; + goto L15126;} + else { + goto L15094;}} + else { + *((long *) ((((char *) (-3 + x_735X))) + -4)) = 1106; + thing_856X = 3 + (((long) ((SstartS) + ((((*((long *) (start_737X + 4))))>>8))))); + missing_uids_857X = Snew_uidsS; + low_count_proxies_858X = Sbad_count_proxiesS; + addr_859X = ALLOCATE_SPACE(2, 20); + *((long *) addr_859X) = 4106; + result_860X = 3 + (((long) (addr_859X + 4))); + addr_861X = ((char *) (-3 + result_860X)); + WRITE_BARRIER(addr_861X, thing_856X); + *((long *) addr_861X) = thing_856X; + addr_862X = (((char *) (-3 + result_860X))) + 4; + WRITE_BARRIER(addr_862X, missing_uids_857X); + *((long *) addr_862X) = missing_uids_857X; + addr_863X = (((char *) (-3 + result_860X))) + 8; + WRITE_BARRIER(addr_863X, low_count_proxies_858X); + *((long *) addr_863X) = low_count_proxies_858X; + SvalS = result_860X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L25150: { + val_864X = arg0K0; + SvalS = val_864X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + L12901: { + arg0K0 = (*((long *) ((((char *) (-3 + b_800X))) + 4))); + goto L12883;} + L31580: { + y_865X = arg0K0; + if ((y_865X < (to_index_409X + count_410X))) { + goto L31598;} + else { + memcpy((void *)((((char *) (-3 + arg3_405X))) + to_index_409X), (void *)((((char *) (-3 + arg5_407X))) + from_index_408X),count_410X); + SvalS = 13; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L31576: { + arg0K0 = ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg3_405X))) + -4))))>>8)); + goto L31580;} + L12000: { + if ((1 == thing_627X)) { + goto L12003;} + else { + if ((5 == thing_627X)) { + goto L12003;} + else { + if ((25 == thing_627X)) { + arg3K0 = "()"; + goto L12026;} + else { + if ((3 == (3 & thing_627X))) { + if ((0 == (31 & ((((*((long *) ((((char *) (-3 + thing_627X))) + -4))))>>2))))) { + arg3K0 = "(...)"; + goto L12026;} + else { + goto L12016;}} + else { + goto L12016;}}}}} + L21574: { + count_866X = arg0K0; + i_867X = arg0K1; + offset_868X = arg0K2; + if ((0 == count_866X)) { + arg0K0 = i_867X; + arg0K1 = offset_868X; + arg0K2 = env_810X; + goto L21557;} + else { + value_869X = *((long *) ((((char *) (-3 + env_810X))) + ((((*((unsigned char *) ((Scode_pointerS) + (1 + offset_868X)))))<<2)))); + addr_870X = (((char *) (-3 + new_env_440X))) + (((i_867X)<<2)); + WRITE_BARRIER(addr_870X, value_869X); + *((long *) addr_870X) = value_869X; + arg0K0 = (-1 + count_866X); + arg0K1 = (1 + i_867X); + arg0K2 = (1 + offset_868X); + goto L21574;}} + L17335: { + Senabled_interruptsS = 0; + if ((0 == ((Spending_interruptsS) & (Senabled_interruptsS)))) { + Spending_interruptPS = 0; + if ((Spending_eventsPS)) { + Spending_interruptPS = 1; + goto L17337;} + else { + goto L17337;}} + else { + Spending_interruptPS = 1; + goto L17337;}} + L17415: { + ps_error("interrupt handler is not a vector", 0); + goto L17335;} + L8394: { + *((long *) (SstackS)) = channel_815X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (*((long *) ((((char *) (-3 + channel_815X))) + 16))); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = ((((Senabled_interruptsS))<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 3; + goto L17321;} + L16380: { + if ((Spending_interruptPS)) { + if ((Spending_eventsPS)) { + Spending_eventsPS = 0; + check_events_return_tag = 3; + goto check_events; + check_events_return_3: + v_871X = check_events0_return_value; + if (v_871X) { + arg0K0 = stack_arg_count_818X; + goto L17297;} + else { + goto L16384;}} + else { + arg0K0 = stack_arg_count_818X; + goto L17297;}} + else { + goto L16384;}} + L16437: { + okayP_872X = arg2K0; + key_873X = arg0K1; + if (okayP_872X) { + arg0K0 = key_873X; + goto L16391;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_873X; + goto L16391;}} + L16801: { + v_874X = arg0K0; + merged_arg0K0 = v_874X; + merged_arg0K1 = stack_arg_count_462X; + merged_arg0K2 = list_args_463X; + merged_arg0K3 = list_arg_count_464X; + rest_list_setup_return_tag = 2; + goto rest_list_setup; + rest_list_setup_return_2: + *((long *) (SstackS)) = (((final_stack_arg_count_822X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((total_arg_count_468X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = skip_769X; + arg0K1 = (3 + final_stack_arg_count_822X); + goto L16764;} + L8947: { + a_875X = arg0K0; + n_876X = ((y_167X)>>2); + if ((n_876X < 0)) { + arg0K0 = (0 - n_876X); + goto L8949;} + else { + arg0K0 = n_876X; + goto L8949;}} + L10939: { + if ((1 == (*((Svm_channelsS) + index_825X)))) { + addr_877X = ALLOCATE_SPACE(5, 24); + *((long *) addr_877X) = 5142; + x_878X = 3 + (((long) (addr_877X + 4))); + *((long *) (((char *) (-3 + x_878X)))) = (((mode_686X)<<2)); + *((long *) ((((char *) (-3 + x_878X))) + 4)) = arg2_685X; + *((long *) ((((char *) (-3 + x_878X))) + 8)) = (((index_825X)<<2)); + *((long *) ((((char *) (-3 + x_878X))) + 12)) = 1; + *((long *) ((((char *) (-3 + x_878X))) + 16)) = 1; + *((Svm_channelsS) + index_825X) = x_878X; + arg0K0 = x_878X; + arg0K1 = 9; + goto L26612;} + else { + arg0K0 = 1; + arg0K1 = 11; + goto L26612;}} + L2160: { + new_count_879X = arg0K0; + new_vm_channels_880X = (long*)malloc(sizeof(long) * new_count_879X); + if ((NULL == new_vm_channels_880X)) { + arg0K0 = 1; + arg0K1 = 9; + goto L26612;} + else { + arg0K0 = 0; + goto L2172;}} + L37238: { + if ((3 == (3 & arg5_696X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg5_696X))) + -4))))>>2))))) { + arg0K0 = (-1 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg5_696X))) + -4))))>>8))); + goto L37250;} + else { + goto L37246;}} + else { + goto L37246;}} + L37230: { + if ((3 == (3 & arg5_696X))) { + if ((20 == (31 & ((((*((long *) ((((char *) (-3 + arg5_696X))) + -4))))>>2))))) { + goto L37238;} + else { + arg0K0 = 5; + goto L37121;}} + else { + arg0K0 = 5; + goto L37121;}} + L37121: { + reason_881X = arg0K0; + merged_arg0K0 = reason_881X; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 204; + goto push_exception_continuationB; + push_exception_continuationB_return_204: + *((long *) (SstackS)) = arg5_696X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((start_835X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((count_836X)<<2)); + SstackS = ((SstackS) + -4); + if (waitP_834X) { + arg0K0 = 5; + goto L37136;} + else { + arg0K0 = 1; + goto L37136;}} + L14725: { + b_882X = arg0K0; + if ((25 == b_882X)) { + addr_883X = ALLOCATE_SPACE(0, 12); + *((long *) addr_883X) = 2050; + x_884X = 3 + (((long) (addr_883X + 4))); + *((long *) (((char *) (-3 + x_884X)))) = obj_789X; + *((long *) ((((char *) (-3 + x_884X))) + 4)) = bucket_846X; + addr_885X = (((char *) (-3 + table_729X))) + (((index_845X)<<2)); + WRITE_BARRIER(addr_885X, x_884X); + *((long *) addr_885X) = x_884X; + goto L31346;} + else { + if ((obj_789X == (*((long *) (((char *) (-3 + b_882X))))))) { + goto L31346;} + else { + arg0K0 = (*((long *) ((((char *) (-3 + b_882X))) + 4))); + goto L14725;}}} + L15126: { + addr_886X = arg1K0; + if ((addr_886X == (next_855X + (-4 & (3 + ((long)(((unsigned long)thing_854X)>>8))))))) { + goto L15094;} + else { + thing_887X = *((long *) addr_886X); + if ((3 == (3 & thing_887X))) { + data_888X = ((thing_887X)>>8); + temp_889X = 63 & (((thing_887X)>>2)); + if ((0 == temp_889X)) { + arg0K0 = (3 + (((long) ((SstartS) + data_888X)))); + goto L15138;} + else { + if ((1 == temp_889X)) { + decode_vector_890X = *((long *) ((((char *) (-3 + arg3_588X))) + 4)); + if ((data_888X < ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + decode_vector_890X))) + -4))))>>8))))>>2)))) { + arg0K0 = (*((long *) ((((char *) (-3 + decode_vector_890X))) + (((data_888X)<<2))))); + goto L14309;} + else { + arg0K0 = 1; + goto L14309;}} + else { + if ((2 == temp_889X)) { + data_addr_891X = (SstartS) + (-4 + data_888X); + p_892X = *((long *) data_addr_891X); + p_893X = *((long *) (data_addr_891X + 4)); + *((long *) data_addr_891X) = 1106; + aspace_uid_894X = ((p_892X)>>2); + uid_895X = ((p_893X)>>2); + decode_vector_896X = *((long *) ((((char *) (-3 + arg3_588X))) + 4)); + if ((aspace_uid_894X < ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + decode_vector_896X))) + -4))))>>8))))>>2)))) { + arg0K0 = (*((long *) ((((char *) (-3 + decode_vector_896X))) + (((aspace_uid_894X)<<2))))); + goto L14265;} + else { + arg0K0 = 1; + goto L14265;}} + else { + data_addr_897X = (SstartS) + (-4 + data_888X); + p_898X = *((long *) (data_addr_897X + 8)); + p_899X = *((long *) (data_addr_897X + 4)); + p_900X = *((long *) data_addr_897X); + *((long *) data_addr_897X) = 2130; + aspace_uid_901X = ((p_900X)>>2); + uid_902X = ((p_899X)>>2); + count_903X = ((p_898X)>>2); + decode_vector_904X = *((long *) ((((char *) (-3 + arg3_588X))) + 4)); + if ((aspace_uid_901X < ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + decode_vector_904X))) + -4))))>>8))))>>2)))) { + arg0K0 = (*((long *) ((((char *) (-3 + decode_vector_904X))) + (((aspace_uid_901X)<<2))))); + goto L14284;} + else { + arg0K0 = 1; + goto L14284;}}}}} + else { + goto L15132;}}} + L15094: { + arg1K0 = (next_855X + (-4 & (3 + ((long)(((unsigned long)thing_854X)>>8))))); + goto L15074;} + L12003: { + if ((1 == thing_627X)) { + arg3K0 = "#f"; + goto L12026;} + else { + arg3K0 = "#t"; + goto L12026;}} + L12016: { + if ((3 == (3 & thing_627X))) { + if ((2 == (31 & ((((*((long *) ((((char *) (-3 + thing_627X))) + -4))))>>2))))) { + arg3K0 = "#(...)"; + goto L12026;} + else { + goto L12020;}} + else { + goto L12020;}} + L17337: { + SvalS = (*((long *) ((((char *) (-3 + (Sinterrupt_handlersS)))) + (((i_757X)<<2))))); + obj_905X = SvalS; + if ((3 == (3 & obj_905X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + obj_905X))) + -4))))>>2))))) { + goto L17354;} + else { + goto L17440;}} + else { + goto L17440;}} + L16384: { + arg1K0 = (Scode_pointerS); + goto L19170;} + L16391: { + v_906X = arg0K0; + merged_arg0K0 = v_906X; + copy_stack_into_heap_return_tag = 3; + goto copy_stack_into_heap; + copy_stack_into_heap_return_3: + if ((stack_slots_817X < (64 + (((((SstackS) - (Sstack_limitS)))>>2))))) { + goto L16380;} + else { + ps_error("VM's stack is too small (how can this happen?)", 0); + goto L16380;}} + L8949: { + b_907X = arg0K0; + c_908X = a_875X % b_907X; + if ((a_824X < 0)) { + arg0K0 = (0 - c_908X); + goto L8953;} + else { + arg0K0 = c_908X; + goto L8953;}} + L26612: { + channel_909X = arg0K0; + reason_910X = arg0K1; + if ((1 == channel_909X)) { + if ((3 == (3 & arg2_685X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + arg2_685X))) + -4))))>>2))))) { + if ((1 == mode_686X)) { + goto L26764;} + else { + if ((3 == mode_686X)) { + goto L26764;} + else { + v_911X = ps_close_fd(index_825X); + arg0K0 = v_911X; + goto L26759;}}} + else { + merged_arg0K0 = reason_910X; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 205; + goto push_exception_continuationB; + push_exception_continuationB_return_205: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + else { + merged_arg0K0 = reason_910X; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 206; + goto push_exception_continuationB; + push_exception_continuationB_return_206: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + else { + SvalS = channel_909X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}} + L2172: { + i_912X = arg0K0; + if ((i_912X == (Snumber_of_channelsS))) { + arg0K0 = (Snumber_of_channelsS); + goto L2187;} + else { + *(new_vm_channels_880X + i_912X) = (*((Svm_channelsS) + i_912X)); + arg0K0 = (1 + i_912X); + goto L2172;}} + L37250: { + length_913X = arg0K0; + if ((length_913X < (start_835X + count_836X))) { + arg0K0 = 7; + goto L37121;} + else { + got_914X = ps_read_fd(((((*((long *) ((((char *) (-3 + x_777X))) + 8))))>>2)), ((((char *) (-3 + arg5_696X))) + start_835X), count_836X, waitP_834X, &eofP_915X, &pendingP_916X, &status_917X); + if ((status_917X == NO_ERRORS)) { + if (eofP_915X) { + SvalS = 21; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + if (pendingP_916X) { + Spending_interruptPS = 0; + Senabled_interruptsS = 0; + arg0K0 = 13; + goto L37121;} + else { + SvalS = (((got_914X)<<2)); + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;}}} + else { + merged_arg0K0 = 22; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 207; + goto push_exception_continuationB; + push_exception_continuationB_return_207: + *((long *) (SstackS)) = arg5_696X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((start_835X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((count_836X)<<2)); + SstackS = ((SstackS) + -4); + if (waitP_834X) { + arg0K0 = 5; + goto L37173;} + else { + arg0K0 = 1; + goto L37173;}}}} + L37246: { + arg0K0 = ((long)(((unsigned long)(*((long *) ((((char *) (-3 + arg5_696X))) + -4))))>>8)); + goto L37250;} + L37136: { + x_918X = arg0K0; + *((long *) (SstackS)) = x_918X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_777X; + SstackS = ((SstackS) + -4); + arg0K0 = 5; + goto L17068;} + L31346: { + arg0K0 = (1 + i_787X); + goto L31331;} + L15138: { + x2_919X = arg0K0; + *((long *) addr_886X) = x2_919X; + goto L15132;} + L14309: { + thing_920X = arg0K0; + if ((3 == (3 & thing_920X))) { + arg0K0 = thing_920X; + goto L15138;} + else { + arg0K0 = 1; + arg0K1 = data_888X; + arg0K2 = 1; + arg1K3 = addr_886X; + arg1K4 = next_855X; + goto L10704;}} + L14265: { + aspace_921X = arg0K0; + if ((3 == (3 & aspace_921X))) { + if ((16 == (31 & ((((*((long *) ((((char *) (-3 + aspace_921X))) + -4))))>>2))))) { + decode_vector_922X = *((long *) ((((char *) (-3 + aspace_921X))) + 4)); + if ((uid_895X < ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + decode_vector_922X))) + -4))))>>8))))>>2)))) { + arg0K0 = (*((long *) ((((char *) (-3 + decode_vector_922X))) + (((uid_895X)<<2))))); + goto L14351;} + else { + arg0K0 = 1; + goto L14351;}} + else { + arg0K0 = aspace_uid_894X; + arg0K1 = uid_895X; + arg0K2 = 1; + arg1K3 = addr_886X; + arg1K4 = next_855X; + goto L10704;}} + else { + arg0K0 = aspace_uid_894X; + arg0K1 = uid_895X; + arg0K2 = 1; + arg1K3 = addr_886X; + arg1K4 = next_855X; + goto L10704;}} + L14284: { + aspace_923X = arg0K0; + if ((3 == (3 & aspace_923X))) { + if ((16 == (31 & ((((*((long *) ((((char *) (-3 + aspace_923X))) + -4))))>>2))))) { + proxy_vector_924X = *((long *) ((((char *) (-3 + aspace_923X))) + 8)); + if ((uid_902X < ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + proxy_vector_924X))) + -4))))>>8))))>>2)))) { + thing_925X = *((long *) ((((char *) (-3 + proxy_vector_924X))) + (((uid_902X)<<2)))); + if ((3 == (3 & thing_925X))) { + if ((15 == (31 & ((((*((long *) ((((char *) (-3 + thing_925X))) + -4))))>>2))))) { + proxy_926X = *((long *) (((char *) (-3 + (*((long *) ((((char *) (-3 + thing_925X))) + 16))))))); + count_927X = (((*((long *) ((((char *) (-3 + thing_925X))) + 12))))>>2); + if ((count_927X < 1)) { + addr_928X = ALLOCATE_SPACE(0, 12); + *((long *) addr_928X) = 2050; + x_929X = 3 + (((long) (addr_928X + 4))); + *((long *) (((char *) (-3 + x_929X)))) = thing_925X; + *((long *) ((((char *) (-3 + x_929X))) + 4)) = count_903X; + b_930X = Sbad_count_proxiesS; + addr_931X = ALLOCATE_SPACE(0, 12); + *((long *) addr_931X) = 2050; + x_932X = 3 + (((long) (addr_931X + 4))); + *((long *) (((char *) (-3 + x_932X)))) = x_929X; + *((long *) ((((char *) (-3 + x_932X))) + 4)) = b_930X; + Sbad_count_proxiesS = x_932X; + goto L13415;} + else { + if ((131072 < (count_927X + count_903X))) { + if ((1 == (*((long *) ((((char *) (-3 + thing_925X))) + 4))))) { + goto L10590;} + else { + b_933X = Sbad_count_proxiesS; + addr_934X = ALLOCATE_SPACE(0, 12); + *((long *) addr_934X) = 2050; + x_935X = 3 + (((long) (addr_934X + 4))); + *((long *) (((char *) (-3 + x_935X)))) = thing_925X; + *((long *) ((((char *) (-3 + x_935X))) + 4)) = b_933X; + Sbad_count_proxiesS = x_935X; + goto L10590;}} + else { + goto L10590;}}} + else { + goto L13420;}} + else { + goto L13420;}} + else { + arg0K0 = aspace_uid_901X; + arg0K1 = uid_902X; + arg0K2 = (((count_903X)<<2)); + arg1K3 = addr_886X; + arg1K4 = next_855X; + goto L10704;}} + else { + goto L14290;}} + else { + goto L14290;}} + L15132: { + arg1K0 = (addr_886X + 4); + goto L15126;} + L12020: { + if ((3 == (3 & thing_627X))) { + if ((3 == (31 & ((((*((long *) ((((char *) (-3 + thing_627X))) + -4))))>>2))))) { + arg3K0 = "#{procedure}"; + goto L12026;} + else { + arg3K0 = "???"; + goto L12026;}} + else { + arg3K0 = "???"; + goto L12026;}} + L17354: { + StemplateS = (SvalS); + Slosing_opcodeS = (0 - i_757X); + arg0K0 = arg_count_813X; + goto L16469;} + L17440: { + ps_error("interrupt handler is not a closure", 1, i_757X); + goto L17354;} + L8953: { + n_936X = arg0K0; + if ((0 == (((n_936X)<<2)))) { + SvalS = q_823X; + Scode_pointerS = ((Scode_pointerS) + 1); + arg1K0 = (Scode_pointerS); + goto L19170;} + else { + merged_arg0K0 = 6; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 208; + goto push_exception_continuationB; + push_exception_continuationB_return_208: + *((long *) (SstackS)) = arg2_166X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = y_167X; + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + L26764: { + v_937X = ps_close_fd(index_825X); + arg0K0 = v_937X; + goto L26759;} + L26759: { + status_938X = arg0K0; + if ((status_938X == NO_ERRORS)) { + merged_arg0K0 = reason_910X; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 209; + goto push_exception_continuationB; + push_exception_continuationB_return_209: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;} + else { + merged_arg0K0 = status_938X; + merged_arg0K1 = index_825X; + merged_arg0K2 = arg2_685X; + channel_close_error_return_tag = 0; + goto channel_close_error; + channel_close_error_return_0: + merged_arg0K0 = reason_910X; + merged_arg0K1 = 1; + push_exception_continuationB_return_tag = 210; + goto push_exception_continuationB; + push_exception_continuationB_return_210: + *((long *) (SstackS)) = arg2_685X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((mode_686X)<<2)); + SstackS = ((SstackS) + -4); + arg0K0 = 2; + goto L17068;}} + L2187: { + i_939X = arg0K0; + if ((i_939X == new_count_879X)) { + free((Svm_channelsS)); + Svm_channelsS = new_vm_channels_880X; + Snumber_of_channelsS = new_count_879X; + goto L10939;} + else { + *(new_vm_channels_880X + i_939X) = 1; + arg0K0 = (1 + i_939X); + goto L2187;}} + L37173: { + x_940X = arg0K0; + *((long *) (SstackS)) = x_940X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_777X; + SstackS = ((SstackS) + -4); + merged_arg0K0 = status_917X; + merged_arg0K1 = key_692X; + get_error_string_return_tag = 4; + goto get_error_string; + get_error_string_return_4: + x_941X = get_error_string0_return_value; + *((long *) (SstackS)) = x_941X; + SstackS = ((SstackS) + -4); + arg0K0 = 6; + goto L17068;} + L10704: { + aspace_uid_942X = arg0K0; + uid_943X = arg0K1; + count_944X = arg0K2; + addr_945X = arg1K3; + stob_start_946X = arg1K4; + addr_947X = ALLOCATE_SPACE(2, 24); + *((long *) addr_947X) = 5130; + vector_948X = 3 + (((long) (addr_947X + 4))); + value_949X = ((aspace_uid_942X)<<2); + addr_950X = ((char *) (-3 + vector_948X)); + WRITE_BARRIER(addr_950X, value_949X); + *((long *) addr_950X) = value_949X; + value_951X = ((uid_943X)<<2); + addr_952X = (((char *) (-3 + vector_948X))) + 4; + WRITE_BARRIER(addr_952X, value_951X); + *((long *) addr_952X) = value_951X; + addr_953X = (((char *) (-3 + vector_948X))) + 8; + WRITE_BARRIER(addr_953X, count_944X); + *((long *) addr_953X) = count_944X; + value_954X = 3 + (((long) stob_start_946X)); + addr_955X = (((char *) (-3 + vector_948X))) + 12; + WRITE_BARRIER(addr_955X, value_954X); + *((long *) addr_955X) = value_954X; + value_956X = -4 & (addr_945X - stob_start_946X); + addr_957X = (((char *) (-3 + vector_948X))) + 16; + WRITE_BARRIER(addr_957X, value_956X); + *((long *) addr_957X) = value_956X; + b_958X = Snew_uidsS; + addr_959X = ALLOCATE_SPACE(0, 12); + *((long *) addr_959X) = 2050; + x_960X = 3 + (((long) (addr_959X + 4))); + *((long *) (((char *) (-3 + x_960X)))) = vector_948X; + *((long *) ((((char *) (-3 + x_960X))) + 4)) = b_958X; + Snew_uidsS = x_960X; + arg0K0 = 1; + goto L15138;} + L14351: { + thing_961X = arg0K0; + if ((3 == (3 & thing_961X))) { + arg0K0 = thing_961X; + goto L15138;} + else { + arg0K0 = aspace_uid_894X; + arg0K1 = uid_895X; + arg0K2 = 1; + arg1K3 = addr_886X; + arg1K4 = next_855X; + goto L10704;}} + L13415: { + if ((3 == (3 & proxy_926X))) { + if ((14 == (31 & ((((*((long *) ((((char *) (-3 + proxy_926X))) + -4))))>>2))))) { + arg0K0 = proxy_926X; + goto L15138;} + else { + goto L13419;}} + else { + goto L13419;}} + L10590: { + val_962X = (((count_927X + count_903X))<<2); + addr_963X = (((char *) (-3 + thing_925X))) + 12; + WRITE_BARRIER(addr_963X, val_962X); + *((long *) addr_963X) = val_962X; + goto L13415;} + L13420: { + addr_964X = ALLOCATE_SPACE(15, 28); + *((long *) addr_964X) = 6206; + x_965X = 3 + (((long) (addr_964X + 4))); + *((long *) (((char *) (-3 + x_965X)))) = (((uid_902X)<<2)); + *((long *) ((((char *) (-3 + x_965X))) + 4)) = aspace_923X; + *((long *) ((((char *) (-3 + x_965X))) + 8)) = 529; + *((long *) ((((char *) (-3 + x_965X))) + 12)) = (((count_903X)<<2)); + *((long *) ((((char *) (-3 + x_965X))) + 16)) = 1; + *((long *) ((((char *) (-3 + x_965X))) + 20)) = 25; + addr_966X = (((char *) (-3 + proxy_vector_924X))) + (((uid_902X)<<2)); + WRITE_BARRIER(addr_966X, x_965X); + *((long *) addr_966X) = x_965X; + addr_967X = ALLOCATE_SPACE(14, 8); + *((long *) addr_967X) = 1082; + x_968X = 3 + (((long) (addr_967X + 4))); + *((long *) (((char *) (-3 + x_968X)))) = x_965X; + addr_969X = ALLOCATE_SPACE(12, 8); + *((long *) addr_969X) = 1074; + x_970X = 3 + (((long) (addr_969X + 4))); + *((long *) (((char *) (-3 + x_970X)))) = x_968X; + addr_971X = (((char *) (-3 + x_965X))) + 16; + WRITE_BARRIER(addr_971X, x_970X); + *((long *) addr_971X) = x_970X; + arg0K0 = x_968X; + goto L15138;} + L14290: { + arg0K0 = aspace_uid_901X; + arg0K1 = uid_902X; + arg0K2 = (((count_903X)<<2)); + arg1K3 = addr_886X; + arg1K4 = next_855X; + goto L10704;} + L13419: { + addr_972X = ALLOCATE_SPACE(14, 8); + *((long *) addr_972X) = 1082; + x_973X = 3 + (((long) (addr_972X + 4))); + *((long *) (((char *) (-3 + x_973X)))) = thing_925X; + addr_974X = ALLOCATE_SPACE(12, 8); + *((long *) addr_974X) = 1074; + x_975X = 3 + (((long) (addr_974X + 4))); + *((long *) (((char *) (-3 + x_975X)))) = x_973X; + addr_976X = (((char *) (-3 + thing_925X))) + 16; + WRITE_BARRIER(addr_976X, x_975X); + *((long *) addr_976X) = x_975X; + arg0K0 = x_973X; + goto L15138;} + loseD0: { + message_76X = merged_arg3K0;{ + why_977X = (((*((long *) ((SstackS) + (4 + (((nargs_419X)<<2)))))))>>2); + ps_write_string("Template UIDs: ", (stderr)); + current_template_978X = StemplateS; + out_979X = stderr; + if ((0 == (3 & (*((long *) ((((char *) (-3 + current_template_978X))) + 4)))))) { + if ((current_template_978X == (*((long *) ((((char *) (-3 + (Sbottom_of_stackS)))) + 8))))) { + arg2K0 = 0; + goto L10384;} + else { + ps_write_integer(((((*((long *) ((((char *) (-3 + current_template_978X))) + 4))))>>2)), out_979X); + arg2K0 = 1; + goto L10384;}} + else { + arg2K0 = 0; + goto L10384;}} + L10384: { + not_firstP_980X = arg2K0; + arg0K0 = (ScontS); + arg2K1 = not_firstP_980X; + goto L10391;} + L10391: { + cont_981X = arg0K0; + not_firstP_982X = arg2K1; + if ((3 == (3 & cont_981X))) { + if ((9 == (31 & ((((*((long *) ((((char *) (-3 + cont_981X))) + -4))))>>2))))) { + template_983X = *((long *) ((((char *) (-3 + cont_981X))) + 8)); + if ((0 == (3 & (*((long *) ((((char *) (-3 + template_983X))) + 4)))))) { + if ((template_983X == (*((long *) ((((char *) (-3 + (Sbottom_of_stackS)))) + 8))))) { + arg2K0 = not_firstP_982X; + goto L10400;} + else { + if (not_firstP_982X) { + ps_write_string(" <- ", out_979X); + goto L10439;} + else { + goto L10439;}}} + else { + arg2K0 = not_firstP_982X; + goto L10400;}} + else { + goto L17087;}} + else { + goto L17087;}} + L10400: { + v_984X = arg2K0; + arg0K0 = (*((long *) (((char *) (-3 + cont_981X))))); + arg2K1 = v_984X; + goto L10391;} + L10439: { + ps_write_integer(((((*((long *) ((((char *) (-3 + template_983X))) + 4))))>>2)), out_979X); + arg2K0 = 1; + goto L10400;} + L17087: { + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + if ((why_977X == 1)) { + if ((0 == (3 & (*((long *) ((((char *) (-3 + (*((long *) ((SstackS) + (((nargs_419X)<<2)))))))) + 4)))))) { + ps_error(message_76X, 3, opcode_420X, why_977X, ((((*((long *) ((((char *) (-3 + (*((long *) ((SstackS) + (((nargs_419X)<<2)))))))) + 4))))>>2))); + goto loseD0_return;} + else { + goto L17111;}} + else { + goto L17111;}} + L17111: { + ps_error(message_76X, 2, opcode_420X, why_977X); + goto loseD0_return;} + loseD0_return: + switch (loseD0_return_tag) { + case 0: goto loseD0_return_0; + default: goto loseD0_return_1; + }} + + check_events: { +{ goto L41125;} + L41125: { + type_985X = get_next_event(&channel_986X, &status_987X); + if ((type_985X == ALARM_EVENT)) { + if ((1 == (Sinterrupted_templateS))) { + Sinterrupted_templateS = (StemplateS); + arg0K0 = 1; + goto L16273;} + else { + arg0K0 = 1; + goto L16273;}} + else { + if ((type_985X == KEYBOARD_INTERRUPT_EVENT)) { + arg0K0 = 2; + goto L16273;} + else { + if ((type_985X == IO_COMPLETION_EVENT)) { + channel_988X = *((Svm_channelsS) + channel_986X); + val_989X = ((status_987X)<<2); + addr_990X = (((char *) (-3 + channel_988X))) + 16; + WRITE_BARRIER(addr_990X, val_989X); + *((long *) addr_990X) = val_989X; + if ((1 == (*((long *) ((((char *) (-3 + channel_988X))) + 12))))) { + if ((1 == (Spending_channels_headS))) { + Spending_channels_headS = channel_988X; + Spending_channels_tailS = channel_988X; + arg0K0 = 8; + goto L16273;} + else { + addr_991X = (((char *) (-3 + (Spending_channels_tailS)))) + 12; + WRITE_BARRIER(addr_991X, channel_988X); + *((long *) addr_991X) = channel_988X; + Spending_channels_tailS = channel_988X; + arg0K0 = 8; + goto L16273;}} + else { + arg0K0 = 8; + goto L16273;}} + else { + if ((type_985X == NO_EVENT)) { + arg0K0 = 0; + goto L16273;} + else { + if ((type_985X == ERROR_EVENT)) { + ps_write_string("OS error while getting event", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + ps_write_string((ps_error_string(status_987X)), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + arg0K0 = 0; + goto L16273;} + else { + ps_write_string("unknown type of event", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + arg0K0 = 0; + goto L16273;}}}}}} + L16273: { + v_992X = arg0K0; + Spending_interruptsS = (v_992X | (Spending_interruptsS)); + if ((type_985X == NO_EVENT)) { + if ((0 == ((Spending_interruptsS) & (Senabled_interruptsS)))) { + Spending_interruptPS = 0; + if ((Spending_eventsPS)) { + Spending_interruptPS = 1; + goto L16300;} + else { + goto L16300;}} + else { + Spending_interruptPS = 1; + goto L16300;}} + else { + goto L41125;}} + L16300: { + if ((Spending_interruptPS)) { + if ((Spending_eventsPS)) { + Spending_eventsPS = 0; + goto L41125;} + else { + check_events0_return_value = 1; + goto check_events_return;}} + else { + check_events0_return_value = 0; + goto check_events_return;}} + check_events_return: + switch (check_events_return_tag) { + case 0: goto check_events_return_0; + case 1: goto check_events_return_1; + case 2: goto check_events_return_2; + default: goto check_events_return_3; + }} + + rest_list_setup: { + wants_stack_args_72X = merged_arg0K0; + stack_arg_count_73X = merged_arg0K1; + list_args_74X = merged_arg0K2; + list_arg_count_75X = merged_arg0K3;{ + if ((stack_arg_count_73X == wants_stack_args_72X)) { + merged_arg0K0 = list_args_74X; + merged_arg0K1 = list_arg_count_75X; + copy_listS_return_tag = 1; + goto copy_listS; + copy_listS_return_1: + x_993X = copy_listS0_return_value; + *((long *) (SstackS)) = x_993X; + SstackS = ((SstackS) + -4); + goto rest_list_setup_return;} + else { + if ((stack_arg_count_73X < wants_stack_args_72X)) { + count_994X = wants_stack_args_72X - stack_arg_count_73X; + merged_arg0K0 = list_args_74X; + merged_arg0K1 = count_994X; + push_list_return_tag = 3; + goto push_list; + push_list_return_3: + v_995X = push_list0_return_value; + merged_arg0K0 = v_995X; + merged_arg0K1 = (list_arg_count_75X - count_994X); + copy_listS_return_tag = 2; + goto copy_listS; + copy_listS_return_2: + x_996X = copy_listS0_return_value; + *((long *) (SstackS)) = x_996X; + SstackS = ((SstackS) + -4); + goto rest_list_setup_return;} + else { + merged_arg0K0 = list_args_74X; + merged_arg0K1 = list_arg_count_75X; + copy_listS_return_tag = 3; + goto copy_listS; + copy_listS_return_3: + v_997X = copy_listS0_return_value; + merged_arg0K0 = v_997X; + merged_arg0K1 = (stack_arg_count_73X - wants_stack_args_72X); + pop_args_GlistS_return_tag = 5; + goto pop_args_GlistS; + pop_args_GlistS_return_5: + x_998X = pop_args_GlistS0_return_value; + *((long *) (SstackS)) = x_998X; + SstackS = ((SstackS) + -4); + goto rest_list_setup_return;}}} + rest_list_setup_return: + switch (rest_list_setup_return_tag) { + case 0: goto rest_list_setup_return_0; + case 1: goto rest_list_setup_return_1; + default: goto rest_list_setup_return_2; + }} + + push_list: { + list_70X = merged_arg0K0; + count_71X = merged_arg0K1;{ + *((long *) (SstackS)) = list_70X; + SstackS = ((SstackS) + -4); + if ((count_71X < (64 + (((((SstackS) - (Sstack_limitS)))>>2))))) { + goto L16106;} + else { + space_999X = 1 + (((((Sstack_endS) - (SstackS)))>>2)); + v_1000X = AVAILABLEp(space_999X); + if (v_1000X) { + arg2K0 = 1; + arg0K1 = 0; + goto L16190;} + else { + merged_arg0K0 = 0; + collect_saving_temp_return_tag = 30; + goto collect_saving_temp; + collect_saving_temp_return_30: + v_1001X = AVAILABLEp(space_999X); + if (v_1001X) { + arg2K0 = 1; + arg0K1 = 0; + goto L16190;} + else { + arg2K0 = 0; + arg0K1 = 0; + goto L16190;}}}} + L16106: { + SstackS = ((SstackS) + 4); + list_1002X = *((long *) (SstackS)); + arg0K0 = count_71X; + arg0K1 = list_1002X; + goto L16115;} + L16190: { + okayP_1003X = arg2K0; + key_1004X = arg0K1; + if (okayP_1003X) { + arg0K0 = key_1004X; + goto L16141;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = key_1004X; + goto L16141;}} + L16115: { + i_1005X = arg0K0; + l_1006X = arg0K1; + if ((0 < i_1005X)) { + *((long *) (SstackS)) = (*((long *) (((char *) (-3 + l_1006X))))); + SstackS = ((SstackS) + -4); + arg0K0 = (-1 + i_1005X); + arg0K1 = (*((long *) ((((char *) (-3 + l_1006X))) + 4))); + goto L16115;} + else { + push_list0_return_value = l_1006X; + goto push_list_return;}} + L16141: { + v_1007X = arg0K0; + merged_arg0K0 = v_1007X; + copy_stack_into_heap_return_tag = 4; + goto copy_stack_into_heap; + copy_stack_into_heap_return_4: + if ((count_71X < (64 + (((((SstackS) - (Sstack_limitS)))>>2))))) { + goto L16106;} + else { + ps_error("VM's stack is too small (how can this happen?)", 0); + goto L16106;}} + push_list_return: + switch (push_list_return_tag) { + case 0: goto push_list_return_0; + case 1: goto push_list_return_1; + case 2: goto push_list_return_2; + default: goto push_list_return_3; + }} + + copy_stack_into_heap: { + key_69X = merged_arg0K0;{ + arg1K0 = ((SstackS) + 4); + arg0K1 = 0; + goto L15168;} + L15168: { + p_1008X = arg1K0; + i_1009X = arg0K1; + if ((2 == (3 & (*((long *) p_1008X))))) { + if ((54 == (*((long *) p_1008X)))) { + arg0K0 = (-1 + i_1009X); + goto L15155;} + else { + arg0K0 = i_1009X; + goto L15155;}} + else { + arg1K0 = (p_1008X + 4); + arg0K1 = (1 + i_1009X); + goto L15168;}} + L15155: { + arg_count_1010X = arg0K0; + top_1011X = SstackS; + if ((1 == (ScontS))) { + goto L15160;} + else { + merged_arg0K0 = key_69X; + merged_arg0K1 = 1; + really_preserve_continuation_return_tag = 1; + goto really_preserve_continuation; + really_preserve_continuation_return_1: + goto L15160;}} + L15160: { + stob_1012X = ScontS; + arg1K0 = ((((char *) (-3 + stob_1012X))) + -8); + arg1K1 = (top_1011X + (((arg_count_1010X)<<2))); + goto L15193;} + L15193: { + loc_1013X = arg1K0; + arg_1014X = arg1K1; + if ((top_1011X < arg_1014X)) { + *((long *) loc_1013X) = (*((long *) arg_1014X)); + arg1K0 = (loc_1013X + -4); + arg1K1 = (arg_1014X + -4); + goto L15193;} + else { + SstackS = loc_1013X; + goto copy_stack_into_heap_return;}} + copy_stack_into_heap_return: + switch (copy_stack_into_heap_return_tag) { + case 0: goto copy_stack_into_heap_return_0; + case 1: goto copy_stack_into_heap_return_1; + case 2: goto copy_stack_into_heap_return_2; + case 3: goto copy_stack_into_heap_return_3; + default: goto copy_stack_into_heap_return_4; + }} + + really_preserve_continuation: { + key_67X = merged_arg0K0; + reason_68X = merged_arg0K1;{ + p_1015X = SenvS; + if ((3 == (3 & p_1015X))) { + if ((p_1015X < (((long) (Sstack_beginS))))) { + goto L14498;} + else { + if (((((long) (Sstack_endS))) < p_1015X)) { + goto L14498;} + else { + merged_arg0K0 = (SenvS); + merged_arg0K1 = (ScontS); + merged_arg0K2 = key_67X; + merged_arg0K3 = reason_68X; + save_env_in_heap_return_tag = 1; + goto save_env_in_heap; + save_env_in_heap_return_1: + v_1016X = save_env_in_heap0_return_value; + SenvS = v_1016X; + goto L14498;}}} + else { + goto L14498;}} + L14498: { + end_1017X = *((long *) (((char *) (-3 + (Sbottom_of_stackS))))); + arg0K0 = (ScontS); + arg0K1 = (Sbottom_of_stackS); + goto L14451;} + L14451: { + cont_1018X = arg0K0; + previous_1019X = arg0K1; + if ((cont_1018X == (Sbottom_of_stackS))) { + *((long *) (((char *) (-3 + previous_1019X)))) = end_1017X; + ScontS = (Sbottom_of_stackS); + really_preserve_continuation0_return_value = (*((long *) (((char *) (-3 + (Sbottom_of_stackS)))))); + goto really_preserve_continuation_return;} + else { + p_1020X = *((long *) ((((char *) (-3 + cont_1018X))) + 12)); + if ((3 == (3 & p_1020X))) { + if ((p_1020X < (((long) (Sstack_beginS))))) { + goto L14469;} + else { + if (((((long) (Sstack_endS))) < p_1020X)) { + goto L14469;} + else { + merged_arg0K0 = (*((long *) ((((char *) (-3 + cont_1018X))) + 12))); + merged_arg0K1 = cont_1018X; + merged_arg0K2 = key_67X; + merged_arg0K3 = reason_68X; + save_env_in_heap_return_tag = 2; + goto save_env_in_heap; + save_env_in_heap_return_2: + goto L14469;}}} + else { + goto L14469;}}} + L14469: { + header_1021X = *((long *) ((((char *) (-3 + cont_1018X))) + -4)); + addr_1022X = ALLOCATE_SPACE((31 & (((header_1021X)>>2))), (4 + ((long)(((unsigned long)header_1021X)>>8)))); + data_addr_1023X = addr_1022X + 4; + *((long *) addr_1022X) = header_1021X; + memcpy((void *)data_addr_1023X, (void *)(((char *) (-3 + cont_1018X))),((long)(((unsigned long)header_1021X)>>8))); + new_1024X = 3 + (((long) data_addr_1023X)); + *((long *) (((char *) (-3 + previous_1019X)))) = new_1024X; + arg0K0 = (*((long *) (((char *) (-3 + new_1024X))))); + arg0K1 = new_1024X; + goto L14451;} + really_preserve_continuation_return: + switch (really_preserve_continuation_return_tag) { + case 0: goto really_preserve_continuation_return_0; + default: goto really_preserve_continuation_return_1; + }} + + copy_env: { + env_66X = merged_arg0K0;{ + header_1025X = *((long *) ((((char *) (-3 + env_66X))) + -4)); + addr_1026X = ALLOCATE_SPACE((31 & (((header_1025X)>>2))), (4 + ((long)(((unsigned long)header_1025X)>>8)))); + data_addr_1027X = addr_1026X + 4; + *((long *) addr_1026X) = header_1025X; + memcpy((void *)data_addr_1027X, (void *)(((char *) (-3 + env_66X))),((long)(((unsigned long)header_1025X)>>8))); + new_1028X = 3 + (((long) data_addr_1027X)); + addr_1029X = ((char *) (-3 + env_66X)); + WRITE_BARRIER(addr_1029X, 54); + *((long *) addr_1029X) = 54; + *((long *) ((((char *) (-3 + env_66X))) + -4)) = new_1028X; + copy_env0_return_value = new_1028X; + goto copy_env_return;} + copy_env_return: + switch (copy_env_return_tag) { + case 0: goto copy_env_return_0; + default: goto copy_env_return_1; + }} + + save_env_in_heap: { + env_62X = merged_arg0K0; + cont_63X = merged_arg0K1; + key_64X = merged_arg0K2; + reason_65X = merged_arg0K3;{ + merged_arg0K0 = env_62X; + merged_arg0K1 = key_64X; + merged_arg0K2 = reason_65X; + copy_env_return_tag = 0; + goto copy_env; + copy_env_return_0: + top_1030X = copy_env0_return_value; + arg0K0 = top_1030X; + goto L12585;} + L12585: { + env_1031X = arg0K0; + p_1032X = *((long *) (((char *) (-3 + env_1031X)))); + if ((3 == (3 & p_1032X))) { + if ((p_1032X < (((long) (Sstack_beginS))))) { + goto L12604;} + else { + if (((((long) (Sstack_endS))) < p_1032X)) { + goto L12604;} + else { + merged_arg0K0 = (*((long *) (((char *) (-3 + env_1031X))))); + merged_arg0K1 = key_64X; + merged_arg0K2 = reason_65X; + copy_env_return_tag = 1; + goto copy_env; + copy_env_return_1: + new_1033X = copy_env0_return_value; + addr_1034X = ((char *) (-3 + env_1031X)); + WRITE_BARRIER(addr_1034X, new_1033X); + *((long *) addr_1034X) = new_1033X; + arg0K0 = new_1033X; + goto L12585;}}} + else { + goto L12604;}} + L12604: { + arg0K0 = cont_63X; + goto L12608;} + L12608: { + cont_1035X = arg0K0; + env_1036X = *((long *) ((((char *) (-3 + cont_1035X))) + 12)); + if ((3 == (3 & env_1036X))) { + if ((3 == (3 & (*((long *) ((((char *) (-3 + env_1036X))) + -4)))))) { + *((long *) ((((char *) (-3 + cont_1035X))) + 12)) = (*((long *) ((((char *) (-3 + env_1036X))) + -4))); + arg0K0 = (*((long *) (((char *) (-3 + cont_1035X))))); + goto L12608;} + else { + save_env_in_heap0_return_value = top_1030X; + goto save_env_in_heap_return;}} + else { + save_env_in_heap0_return_value = top_1030X; + goto save_env_in_heap_return;}} + save_env_in_heap_return: + switch (save_env_in_heap_return_tag) { + case 0: goto save_env_in_heap_return_0; + case 1: goto save_env_in_heap_return_1; + default: goto save_env_in_heap_return_2; + }} + + pop_args_GlistS: { + start_60X = merged_arg0K0; + count_61X = merged_arg0K1;{ + space_1037X = 3 * count_61X; + v_1038X = AVAILABLEp(space_1037X); + if (v_1038X) { + arg2K0 = 1; + arg0K1 = start_60X; + goto L16050;} + else { + merged_arg0K0 = start_60X; + collect_saving_temp_return_tag = 31; + goto collect_saving_temp; + collect_saving_temp_return_31: + temp_1039X = collect_saving_temp0_return_value; + v_1040X = AVAILABLEp(space_1037X); + if (v_1040X) { + arg2K0 = 1; + arg0K1 = temp_1039X; + goto L16050;} + else { + arg2K0 = 0; + arg0K1 = temp_1039X; + goto L16050;}}} + L16050: { + okayP_1041X = arg2K0; + temp_1042X = arg0K1; + if (okayP_1041X) { + arg0K0 = temp_1042X; + goto L16024;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = temp_1042X; + goto L16024;}} + L16024: { + start_1043X = arg0K0; + arg0K0 = start_1043X; + arg0K1 = count_61X; + goto L16033;} + L16033: { + args_1044X = arg0K0; + count_1045X = arg0K1; + if ((0 == count_1045X)) { + pop_args_GlistS0_return_value = args_1044X; + goto pop_args_GlistS_return;} + else { + SstackS = ((SstackS) + 4); + a_1046X = *((long *) (SstackS)); + addr_1047X = ALLOCATE_SPACE(0, 12); + *((long *) addr_1047X) = 2050; + x_1048X = 3 + (((long) (addr_1047X + 4))); + *((long *) (((char *) (-3 + x_1048X)))) = a_1046X; + *((long *) ((((char *) (-3 + x_1048X))) + 4)) = args_1044X; + arg0K0 = x_1048X; + arg0K1 = (-1 + count_1045X); + goto L16033;}} + pop_args_GlistS_return: + switch (pop_args_GlistS_return_tag) { + case 0: goto pop_args_GlistS_return_0; + case 1: goto pop_args_GlistS_return_1; + case 2: goto pop_args_GlistS_return_2; + case 3: goto pop_args_GlistS_return_3; + case 4: goto pop_args_GlistS_return_4; + default: goto pop_args_GlistS_return_5; + }} + + copy_listS: { + list_58X = merged_arg0K0; + length_59X = merged_arg0K1;{ + if ((0 == length_59X)) { + copy_listS0_return_value = 25; + goto copy_listS_return;} + else { + space_1049X = 3 * length_59X; + v_1050X = AVAILABLEp(space_1049X); + if (v_1050X) { + arg2K0 = 1; + arg0K1 = list_58X; + goto L15930;} + else { + merged_arg0K0 = list_58X; + collect_saving_temp_return_tag = 32; + goto collect_saving_temp; + collect_saving_temp_return_32: + temp_1051X = collect_saving_temp0_return_value; + v_1052X = AVAILABLEp(space_1049X); + if (v_1052X) { + arg2K0 = 1; + arg0K1 = temp_1051X; + goto L15930;} + else { + arg2K0 = 0; + arg0K1 = temp_1051X; + goto L15930;}}}} + L15930: { + okayP_1053X = arg2K0; + temp_1054X = arg0K1; + if (okayP_1053X) { + arg0K0 = temp_1054X; + goto L15888;} + else { + ps_error("Scheme48 heap overflow", 0); + arg0K0 = temp_1054X; + goto L15888;}} + L15888: { + list_1055X = arg0K0; + a_1056X = *((long *) (((char *) (-3 + list_1055X)))); + addr_1057X = ALLOCATE_SPACE(0, 12); + *((long *) addr_1057X) = 2050; + x_1058X = 3 + (((long) (addr_1057X + 4))); + *((long *) (((char *) (-3 + x_1058X)))) = a_1056X; + *((long *) ((((char *) (-3 + x_1058X))) + 4)) = 25; + arg0K0 = (*((long *) ((((char *) (-3 + list_1055X))) + 4))); + arg0K1 = x_1058X; + goto L15903;} + L15903: { + l_1059X = arg0K0; + last_1060X = arg0K1; + if ((25 == l_1059X)) { + copy_listS0_return_value = x_1058X; + goto copy_listS_return;} + else { + a_1061X = *((long *) (((char *) (-3 + l_1059X)))); + addr_1062X = ALLOCATE_SPACE(0, 12); + *((long *) addr_1062X) = 2050; + x_1063X = 3 + (((long) (addr_1062X + 4))); + *((long *) (((char *) (-3 + x_1063X)))) = a_1061X; + *((long *) ((((char *) (-3 + x_1063X))) + 4)) = 25; + addr_1064X = (((char *) (-3 + last_1060X))) + 4; + WRITE_BARRIER(addr_1064X, x_1063X); + *((long *) addr_1064X) = x_1063X; + arg0K0 = (*((long *) ((((char *) (-3 + l_1059X))) + 4))); + arg0K1 = x_1063X; + goto L15903;}} + copy_listS_return: + switch (copy_listS_return_tag) { + case 0: goto copy_listS_return_0; + case 1: goto copy_listS_return_1; + case 2: goto copy_listS_return_2; + default: goto copy_listS_return_3; + }} + + collect_saving_temp: { + value_57X = merged_arg0K0;{ + pc_1065X = ((((Scode_pointerS) - (((char *) (-3 + (*((long *) (((char *) (-3 + (StemplateS)))))))))))<<2); + begin_collection(); + v_1066X = trace_value((StemplateS)); + StemplateS = v_1066X; + v_1067X = trace_value((SvalS)); + SvalS = v_1067X; + v_1068X = trace_value((Scurrent_threadS)); + Scurrent_threadS = v_1068X; + v_1069X = trace_value((Ssession_dataS)); + Ssession_dataS = v_1069X; + v_1070X = trace_value((Sexception_handlersS)); + Sexception_handlersS = v_1070X; + v_1071X = trace_value((Sexception_templateS)); + Sexception_templateS = v_1071X; + v_1072X = trace_value((Sinterrupt_handlersS)); + Sinterrupt_handlersS = v_1072X; + v_1073X = trace_value((Sinterrupt_templateS)); + Sinterrupt_templateS = v_1073X; + v_1074X = trace_value((Sinterrupted_templateS)); + Sinterrupted_templateS = v_1074X; + v_1075X = trace_value((Sfinalize_theseS)); + Sfinalize_theseS = v_1075X; + env_1076X = trace_value((SenvS)); + SenvS = env_1076X; + v_1077X = trace_value((Spending_channels_headS)); + Spending_channels_headS = v_1077X; + v_1078X = trace_value((Spending_channels_tailS)); + Spending_channels_tailS = v_1078X; + if ((Sstack_warningPS)) { + arg1K0 = (Sstack_beginS); + goto L5992;} + else { + goto L6025;}} + L5992: { + a_1079X = arg1K0; + if ((252645135 == (*((long *) a_1079X)))) { + arg1K0 = (a_1079X + 4); + goto L5992;} + else { + unused_1080X = (((a_1079X - (Sstack_beginS)))>>2); + if ((unused_1080X < 30)) { + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + ps_write_string("[Alert: stack overconsumption (", (stderr)); + ps_write_integer(unused_1080X, (stderr)); + ps_write_string("); please inform the Scheme 48 implementors]", (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + Sstack_warningPS = 0; + goto L6025;} + else { + goto L6025;}}} + L6025: { + arg1K0 = ((SstackS) + 4); + arg0K1 = 0; + goto L6090;} + L6090: { + p_1081X = arg1K0; + i_1082X = arg0K1; + if ((2 == (3 & (*((long *) p_1081X))))) { + if ((54 == (*((long *) p_1081X)))) { + arg0K0 = (-1 + i_1082X); + goto L6027;} + else { + arg0K0 = i_1082X; + goto L6027;}} + else { + arg1K0 = (p_1081X + 4); + arg0K1 = (1 + i_1082X); + goto L6090;}} + L6027: { + arg_count_1083X = arg0K0; + trace_locationsB(((SstackS) + 4), ((SstackS) + (4 + (((arg_count_1083X)<<2))))); + p_1084X = SenvS; + if ((3 == (3 & p_1084X))) { + if ((p_1084X < (((long) (Sstack_beginS))))) { + goto L6043;} + else { + if (((((long) (Sstack_endS))) < p_1084X)) { + goto L6043;} + else { + env_1085X = SenvS; + arg0K0 = env_1085X; + goto L6203;}}} + else { + goto L6043;}} + L6043: { + v_1086X = trace_value((SenvS)); + SenvS = v_1086X; + goto L6048;} + L6203: { + env_1087X = arg0K0; + if ((3 == (3 & env_1087X))) { + if ((env_1087X < (((long) (Sstack_beginS))))) { + goto L6048;} + else { + if (((((long) (Sstack_endS))) < env_1087X)) { + goto L6048;} + else { + trace_stob_contentsB(env_1087X); + arg0K0 = (*((long *) (((char *) (-3 + env_1087X))))); + goto L6203;}}} + else { + goto L6048;}} + L6048: { + arg0K0 = (ScontS); + arg0K1 = 0; + goto L6053;} + L6053: { + cont_1088X = arg0K0; + last_env_1089X = arg0K1; + env_1090X = *((long *) ((((char *) (-3 + cont_1088X))) + 12)); + trace_stob_contentsB(cont_1088X); + if ((env_1090X == last_env_1089X)) { + goto L6071;} + else { + arg0K0 = env_1090X; + goto L6158;}} + L6071: { + if ((cont_1088X == (Sbottom_of_stackS))) { + value_1091X = trace_value(value_57X); + okay_1092X = do_gc((Sfinalizer_alistS), &sickly_1093X); + Sfinalizer_alistS = okay_1092X; + l2_1094X = Sfinalize_theseS; + if ((25 == sickly_1093X)) { + arg0K0 = l2_1094X; + goto L14850;} + else { + arg0K0 = sickly_1093X; + goto L14873;}} + else { + arg0K0 = (*((long *) (((char *) (-3 + cont_1088X))))); + arg0K1 = env_1090X; + goto L6053;}} + L6158: { + env_1095X = arg0K0; + if ((3 == (3 & env_1095X))) { + if ((env_1095X < (((long) (Sstack_beginS))))) { + goto L6071;} + else { + if (((((long) (Sstack_endS))) < env_1095X)) { + goto L6071;} + else { + trace_stob_contentsB(env_1095X); + arg0K0 = (*((long *) (((char *) (-3 + env_1095X))))); + goto L6158;}}} + else { + goto L6071;}} + L14850: { + v_1096X = arg0K0; + Sfinalize_theseS = v_1096X; + end_collection(); + arg0K0 = 0; + goto L14139;} + L14873: { + l_1097X = arg0K0; + if ((25 == (*((long *) ((((char *) (-3 + l_1097X))) + 4))))) { + addr_1098X = (((char *) (-3 + l_1097X))) + 4; + WRITE_BARRIER(addr_1098X, l2_1094X); + *((long *) addr_1098X) = l2_1094X; + arg0K0 = sickly_1093X; + goto L14850;} + else { + arg0K0 = (*((long *) ((((char *) (-3 + l_1097X))) + 4))); + goto L14873;}} + L14139: { + i_1099X = arg0K0; + if ((i_1099X == (Snumber_of_channelsS))) { + tem_1100X = StemplateS; + StemplateS = tem_1100X; + Scode_pointerS = ((((char *) (-3 + (*((long *) (((char *) (-3 + tem_1100X)))))))) + (((pc_1065X)>>2))); + Spending_interruptsS = (4 | (Spending_interruptsS)); + if ((0 == ((Spending_interruptsS) & (Senabled_interruptsS)))) { + Spending_interruptPS = 0; + if ((Spending_eventsPS)) { + Spending_interruptPS = 1; + collect_saving_temp0_return_value = value_1091X; + goto collect_saving_temp_return;} + else { + collect_saving_temp0_return_value = value_1091X; + goto collect_saving_temp_return;}} + else { + Spending_interruptPS = 1; + collect_saving_temp0_return_value = value_1091X; + goto collect_saving_temp_return;}} + else { + channel_1101X = *((Svm_channelsS) + i_1099X); + if ((1 == channel_1101X)) { + goto L14175;} + else { + header_1102X = *((long *) ((((char *) (-3 + channel_1101X))) + -4)); + if ((3 == (3 & header_1102X))) { + arg0K0 = header_1102X; + goto L14168;} + else { + if ((0 == (*((long *) (((char *) (-3 + channel_1101X))))))) { + arg0K0 = 1; + goto L14168;} + else { + id_1103X = *((long *) ((((char *) (-3 + channel_1101X))) + 4)); + if ((0 == (3 & id_1103X))) { + arg0K0 = id_1103X; + goto L13247;} + else { + if ((3 == (3 & (*((long *) ((((char *) (-3 + id_1103X))) + -4)))))) { + arg0K0 = (*((long *) ((((char *) (-3 + id_1103X))) + -4))); + goto L13247;} + else { + arg0K0 = id_1103X; + goto L13247;}}}}}}} + L14175: { + arg0K0 = (1 + i_1099X); + goto L14139;} + L14168: { + new_1104X = arg0K0; + *((Svm_channelsS) + i_1099X) = new_1104X; + goto L14175;} + L13247: { + id_1105X = arg0K0; + merged_arg0K0 = channel_1101X; + close_channelB_return_tag = 1; + goto close_channelB; + close_channelB_return_1: + status_1106X = close_channelB0_return_value; + if ((status_1106X == NO_ERRORS)) { + goto L13262;} + else { + merged_arg0K0 = status_1106X; + merged_arg0K1 = (*((long *) ((((char *) (-3 + channel_1101X))) + 8))); + merged_arg0K2 = id_1105X; + channel_close_error_return_tag = 1; + goto channel_close_error; + channel_close_error_return_1: + goto L13262;}} + L13262: { + ps_write_string("Channel closed: ", (stderr)); + if ((0 == (3 & id_1105X))) { + ps_write_integer((((id_1105X)>>2)), (stderr)); + goto L13280;} + else { + ps_write_string((((char *)(((char *) (-3 + id_1105X))))), (stderr)); + goto L13280;}} + L13280: { + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + arg0K0 = 1; + goto L14168;} + collect_saving_temp_return: + switch (collect_saving_temp_return_tag) { + case 0: goto collect_saving_temp_return_0; + case 1: goto collect_saving_temp_return_1; + case 2: goto collect_saving_temp_return_2; + case 3: goto collect_saving_temp_return_3; + case 4: goto collect_saving_temp_return_4; + case 5: goto collect_saving_temp_return_5; + case 6: goto collect_saving_temp_return_6; + case 7: goto collect_saving_temp_return_7; + case 8: goto collect_saving_temp_return_8; + case 9: goto collect_saving_temp_return_9; + case 10: goto collect_saving_temp_return_10; + case 11: goto collect_saving_temp_return_11; + case 12: goto collect_saving_temp_return_12; + case 13: goto collect_saving_temp_return_13; + case 14: goto collect_saving_temp_return_14; + case 15: goto collect_saving_temp_return_15; + case 16: goto collect_saving_temp_return_16; + case 17: goto collect_saving_temp_return_17; + case 18: goto collect_saving_temp_return_18; + case 19: goto collect_saving_temp_return_19; + case 20: goto collect_saving_temp_return_20; + case 21: goto collect_saving_temp_return_21; + case 22: goto collect_saving_temp_return_22; + case 23: goto collect_saving_temp_return_23; + case 24: goto collect_saving_temp_return_24; + case 25: goto collect_saving_temp_return_25; + case 26: goto collect_saving_temp_return_26; + case 27: goto collect_saving_temp_return_27; + case 28: goto collect_saving_temp_return_28; + case 29: goto collect_saving_temp_return_29; + case 30: goto collect_saving_temp_return_30; + case 31: goto collect_saving_temp_return_31; + default: goto collect_saving_temp_return_32; + }} + + channel_close_error: { + status_54X = merged_arg0K0; + index_55X = merged_arg0K1; + id_56X = merged_arg0K2;{ + ps_write_string("Error: ", (stderr)); + ps_write_string((ps_error_string(status_54X)), (stderr)); + { long ignoreXX; + PS_WRITE_CHAR(10, (stderr), ignoreXX) } + ps_write_string(" while closing port ", (stderr)); + if ((3 == (3 & id_56X))) { + if ((19 == (31 & ((((*((long *) ((((char *) (-3 + id_56X))) + -4))))>>2))))) { + ps_write_string((((char *)(((char *) (-3 + id_56X))))), (stderr)); + goto L11894;} + else { + goto L11888;}} + else { + goto L11888;}} + L11894: { + PS_WRITE_CHAR(10, (stderr), v_1107X) + channel_close_error0_return_value = v_1107X; + goto channel_close_error_return;} + L11888: { + ps_write_integer((((index_55X)>>2)), (stderr)); + goto L11894;} + channel_close_error_return: + switch (channel_close_error_return_tag) { + case 0: goto channel_close_error_return_0; + default: goto channel_close_error_return_1; + }} + + close_channelB: { + channel_53X = merged_arg0K0;{ + os_index_1108X = (((*((long *) ((((char *) (-3 + channel_53X))) + 8))))>>2); + v_1109X = *((long *) (((char *) (-3 + channel_53X)))); + if ((4 == v_1109X)) { + goto L6653;} + else { + if ((12 == (*((long *) (((char *) (-3 + channel_53X))))))) { + goto L6653;} + else { + v_1110X = ps_close_fd(os_index_1108X); + arg0K0 = v_1110X; + goto L6660;}}} + L6653: { + v_1111X = ps_close_fd(os_index_1108X); + arg0K0 = v_1111X; + goto L6660;} + L6660: { + status_1112X = arg0K0; + *((Svm_channelsS) + os_index_1108X) = 1; + addr_1113X = ((char *) (-3 + channel_53X)); + WRITE_BARRIER(addr_1113X, 0); + *((long *) addr_1113X) = 0; + close_channelB0_return_value = status_1112X; + goto close_channelB_return;} + close_channelB_return: + switch (close_channelB_return_tag) { + case 0: goto close_channelB_return_0; + default: goto close_channelB_return_1; + }} + + real_next_id: { + thing_51X = merged_arg0K0; + decode_vector_52X = merged_arg0K1;{ + next_available_1114X = *((long *) (((char *) (-3 + decode_vector_52X)))); + extracted_1115X = ((next_available_1114X)>>2); + v_1116X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + decode_vector_52X))) + -4))))>>8))))>>2); + if ((extracted_1115X < v_1116X)) { + next_1117X = *((long *) ((((char *) (-3 + decode_vector_52X))) + (((extracted_1115X)<<2)))); + addr_1118X = (((char *) (-3 + decode_vector_52X))) + (((extracted_1115X)<<2)); + WRITE_BARRIER(addr_1118X, thing_51X); + *((long *) addr_1118X) = thing_51X; + arg0K0 = next_1117X; + goto L9867;} + else { + old_1119X = Snew_id_hotelS; + start_1120X = Sother_hpS; + *((long *) (start_1120X + 4)) = (((long) old_1119X)); + Sother_hpS = (start_1120X + 8); + *((long *) start_1120X) = thing_51X; + Snew_id_hotelS = start_1120X; + arg0K0 = (4 + (((extracted_1115X)<<2))); + goto L9867;}} + L9867: { + next_1121X = arg0K0; + addr_1122X = ((char *) (-3 + decode_vector_52X)); + WRITE_BARRIER(addr_1122X, next_1121X); + *((long *) addr_1122X) = next_1121X; + real_next_id0_return_value = next_available_1114X; + goto real_next_id_return;} + real_next_id_return: + switch (real_next_id_return_tag) { + case 0: goto real_next_id_return_0; + case 1: goto real_next_id_return_1; + case 2: goto real_next_id_return_2; + case 3: goto real_next_id_return_3; + case 4: goto real_next_id_return_4; + default: goto real_next_id_return_5; + }} + + encode_object: { + thing_50X = merged_arg0K0;{ + h_1123X = *((long *) ((((char *) (-3 + thing_50X))) + -4)); + if ((3 == (3 & h_1123X))) { + encode_object0_return_value = h_1123X; + goto encode_object_return;} + else { + temp_1124X = 31 & (((h_1123X)>>2)); + if ((1 == temp_1124X)) { + uid_1125X = *((long *) (((char *) (-3 + thing_50X)))); + if ((1 == uid_1125X)) { + merged_arg0K0 = thing_50X; + merged_arg0K1 = (*((long *) ((((char *) (-3 + (Sour_address_spaceS)))) + 4))); + real_next_id_return_tag = 0; + goto real_next_id; + real_next_id_return_0: + uid_1126X = real_next_id0_return_value; + addr_1127X = ((char *) (-3 + thing_50X)); + WRITE_BARRIER(addr_1127X, uid_1126X); + *((long *) addr_1127X) = uid_1126X; + arg0K0 = uid_1126X; + goto L13687;} + else { + arg0K0 = uid_1125X; + goto L13687;}} + else { + if ((13 == temp_1124X)) { + uid_1128X = *((long *) ((((char *) (-3 + thing_50X))) + 8)); + if ((1 == uid_1128X)) { + merged_arg0K0 = thing_50X; + merged_arg0K1 = (*((long *) ((((char *) (-3 + (Sour_address_spaceS)))) + 4))); + real_next_id_return_tag = 1; + goto real_next_id; + real_next_id_return_1: + uid_1129X = real_next_id0_return_value; + addr_1130X = (((char *) (-3 + thing_50X))) + 8; + WRITE_BARRIER(addr_1130X, uid_1129X); + *((long *) addr_1130X) = uid_1129X; + arg0K0 = uid_1129X; + goto L13693;} + else { + arg0K0 = uid_1128X; + goto L13693;}} + else { + if ((16 == temp_1124X)) { + uid_1131X = *((long *) (((char *) (-3 + thing_50X)))); + if ((1 == uid_1131X)) { + merged_arg0K0 = thing_50X; + merged_arg0K1 = (*((long *) ((((char *) (-3 + (Sour_address_spaceS)))) + 4))); + real_next_id_return_tag = 2; + goto real_next_id; + real_next_id_return_2: + uid_1132X = real_next_id0_return_value; + addr_1133X = ((char *) (-3 + thing_50X)); + WRITE_BARRIER(addr_1133X, uid_1132X); + *((long *) addr_1133X) = uid_1132X; + arg0K0 = uid_1132X; + goto L13699;} + else { + arg0K0 = uid_1131X; + goto L13699;}} + else { + if ((11 == temp_1124X)) { + uid_1134X = *((long *) ((((char *) (-3 + thing_50X))) + 8)); + if ((1 == uid_1134X)) { + merged_arg0K0 = thing_50X; + merged_arg0K1 = (*((long *) ((((char *) (-3 + (Sour_address_spaceS)))) + 4))); + real_next_id_return_tag = 3; + goto real_next_id; + real_next_id_return_3: + uid_1135X = real_next_id0_return_value; + addr_1136X = (((char *) (-3 + thing_50X))) + 8; + WRITE_BARRIER(addr_1136X, uid_1135X); + *((long *) addr_1136X) = uid_1135X; + arg0K0 = uid_1135X; + goto L10043;} + else { + arg0K0 = uid_1134X; + goto L10043;}} + else { + if ((4 == temp_1124X)) { + uid_1137X = *((long *) (((char *) (-3 + thing_50X)))); + if ((1 == uid_1137X)) { + merged_arg0K0 = thing_50X; + merged_arg0K1 = (*((long *) ((((char *) (-3 + (Sour_address_spaceS)))) + 4))); + real_next_id_return_tag = 4; + goto real_next_id; + real_next_id_return_4: + uid_1138X = real_next_id0_return_value; + addr_1139X = ((char *) (-3 + thing_50X)); + WRITE_BARRIER(addr_1139X, uid_1138X); + *((long *) addr_1139X) = uid_1138X; + arg0K0 = uid_1138X; + goto L10043;} + else { + arg0K0 = uid_1137X; + goto L10043;}} + else { + if ((14 == temp_1124X)) { + if ((((Stransmit_hpS) + 12) < (Smax_hpS))) { + data_1140X = *((long *) (((char *) (-3 + thing_50X)))); + new_1141X = 15 + (((((Stransmit_hpS) - (SstartS)))<<8)); + owner_1142X = *((long *) ((((char *) (-3 + data_1140X))) + 4)); + if ((1 == owner_1142X)) { + arg0K0 = 4; + goto L13740;} + else { + arg0K0 = (*((long *) (((char *) (-3 + owner_1142X))))); + goto L13740;}} + else { + Stransmit_hpS = (Smax_hpS); + encode_object0_return_value = 0; + goto encode_object_return;}} + else { + if ((((Stransmit_hpS) + (-4 & (3 + ((long)(((unsigned long)h_1123X)>>8))))) < (Smax_hpS))) { + new_1143X = 3 + (((((Stransmit_hpS) - (SstartS)))<<8)); + *((long *) (Stransmit_hpS)) = h_1123X; + Stransmit_hpS = ((Stransmit_hpS) + 4); + *((long *) ((((char *) (-3 + thing_50X))) + -4)) = new_1143X; + old_1144X = Sheartbreak_hotelS; + start_1145X = Sother_hpS; + *((long *) (start_1145X + 8)) = (((long) old_1144X)); + Sother_hpS = (start_1145X + 12); + *((long *) start_1145X) = thing_50X; + *((long *) (start_1145X + 4)) = h_1123X; + Sheartbreak_hotelS = start_1145X; + new_hp_1146X = (Stransmit_hpS) + (-4 & (3 + ((long)(((unsigned long)h_1123X)>>8)))); + arg1K0 = (((char *) (-3 + thing_50X))); + goto L6393;} + else { + Stransmit_hpS = (Smax_hpS); + encode_object0_return_value = 0; + goto encode_object_return;}}}}}}}}} + L13687: { + p_1147X = arg0K0; + encode_object0_return_value = (7 + ((((-4 & p_1147X))<<6))); + goto encode_object_return;} + L13693: { + p_1148X = arg0K0; + encode_object0_return_value = (7 + ((((-4 & p_1148X))<<6))); + goto encode_object_return;} + L13699: { + p_1149X = arg0K0; + encode_object0_return_value = (7 + ((((-4 & p_1149X))<<6))); + goto encode_object_return;} + L10043: { + uid_1150X = arg0K0; + if ((((Stransmit_hpS) + 8) < (Smax_hpS))) { + new_1151X = 11 + (((((Stransmit_hpS) - (SstartS)))<<8)); + if ((3 == (3 & uid_1150X))) { + if ((0 == (31 & ((((*((long *) ((((char *) (-3 + uid_1150X))) + -4))))>>2))))) { + *((long *) (Stransmit_hpS)) = (*((long *) (((char *) (-3 + uid_1150X))))); + Stransmit_hpS = ((Stransmit_hpS) + 4); + *((long *) (Stransmit_hpS)) = (*((long *) ((((char *) (-3 + uid_1150X))) + 4))); + Stransmit_hpS = ((Stransmit_hpS) + 4); + encode_object0_return_value = new_1151X; + goto encode_object_return;} + else { + goto L10067;}} + else { + goto L10067;}} + else { + Stransmit_hpS = (Smax_hpS); + encode_object0_return_value = 0; + goto encode_object_return;}} + L13740: { + descriptor_1152X = arg0K0; + *((long *) (Stransmit_hpS)) = descriptor_1152X; + Stransmit_hpS = ((Stransmit_hpS) + 4); + uid_1153X = *((long *) (((char *) (-3 + data_1140X)))); + if ((1 == uid_1153X)) { + merged_arg0K0 = data_1140X; + merged_arg0K1 = (*((long *) ((((char *) (-3 + (Sour_address_spaceS)))) + 8))); + real_next_id_return_tag = 5; + goto real_next_id; + real_next_id_return_5: + uid_1154X = real_next_id0_return_value; + addr_1155X = ((char *) (-3 + data_1140X)); + WRITE_BARRIER(addr_1155X, uid_1154X); + *((long *) addr_1155X) = uid_1154X; + arg0K0 = uid_1154X; + goto L13744;} + else { + arg0K0 = uid_1153X; + goto L13744;}} + L6393: { + o_1156X = arg1K0; + if (((Stransmit_hpS) < new_hp_1146X)) { + *((long *) (Stransmit_hpS)) = (*((long *) o_1156X)); + Stransmit_hpS = ((Stransmit_hpS) + 4); + arg1K0 = (o_1156X + 4); + goto L6393;} + else { + encode_object0_return_value = new_1143X; + goto encode_object_return;}} + L10067: { + *((long *) (Stransmit_hpS)) = 4; + Stransmit_hpS = ((Stransmit_hpS) + 4); + *((long *) (Stransmit_hpS)) = uid_1150X; + Stransmit_hpS = ((Stransmit_hpS) + 4); + encode_object0_return_value = new_1151X; + goto encode_object_return;} + L13744: { + descriptor_1157X = arg0K0; + *((long *) (Stransmit_hpS)) = descriptor_1157X; + Stransmit_hpS = ((Stransmit_hpS) + 4); + owner_1158X = *((long *) ((((char *) (-3 + data_1140X))) + 4)); + if ((owner_1158X == 1)) { + goto L7757;} + else { + if ((8 == (*((long *) (((char *) (-3 + owner_1158X))))))) { + arg0K0 = 0; + goto L13748;} + else { + goto L7757;}}} + L7757: { + count_1159X = (((*((long *) ((((char *) (-3 + data_1140X))) + 12))))>>2); + if ((1 < count_1159X)) { + if ((count_1159X < 8192)) { + arg0K0 = ((long)(((unsigned long)count_1159X)>>1)); + goto L7782;} + else { + arg0K0 = 4096; + goto L7782;}} + else { + old_1160X = Slosing_proxy_hotelS; + start_1161X = Sother_hpS; + *((long *) (start_1161X + 4)) = (((long) old_1160X)); + Sother_hpS = (start_1161X + 8); + *((long *) start_1161X) = data_1140X; + Slosing_proxy_hotelS = start_1161X; + arg0K0 = 1; + goto L7782;}} + L13748: { + descriptor_1162X = arg0K0; + *((long *) (Stransmit_hpS)) = descriptor_1162X; + Stransmit_hpS = ((Stransmit_hpS) + 4); + encode_object0_return_value = new_1141X; + goto encode_object_return;} + L7782: { + send_1163X = arg0K0; + val_1164X = (((count_1159X - send_1163X))<<2); + addr_1165X = (((char *) (-3 + data_1140X))) + 12; + WRITE_BARRIER(addr_1165X, val_1164X); + *((long *) addr_1165X) = val_1164X; + arg0K0 = (((send_1163X)<<2)); + goto L13748;} + encode_object_return: + switch (encode_object_return_tag) { + case 0: goto encode_object_return_0; + default: goto encode_object_return_1; + }} + + extend_decode_vector: { + address_space_48X = merged_arg0K0; + proxiesP_49X = merged_arg2K2;{ + if (proxiesP_49X) { + arg0K0 = (*((long *) ((((char *) (-3 + address_space_48X))) + 8))); + goto L13026;} + else { + arg0K0 = (*((long *) ((((char *) (-3 + address_space_48X))) + 4))); + goto L13026;}} + L13026: { + decode_vector_1166X = arg0K0; + old_length_1167X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + decode_vector_1166X))) + -4))))>>8))))>>2); + minimum_new_length_1168X = (((*((long *) (((char *) (-3 + decode_vector_1166X))))))>>2); + x_1169X = ((old_length_1167X)<<1); + if ((x_1169X < minimum_new_length_1168X)) { + arg0K0 = minimum_new_length_1168X; + goto L13042;} + else { + arg0K0 = x_1169X; + goto L13042;}} + L13042: { + want_length_1170X = arg0K0; + v_1171X = AVAILABLEp((1 + want_length_1170X)); + if (v_1171X) { + arg0K0 = want_length_1170X; + goto L13060;} + else { + v_1172X = AVAILABLEp((1 + minimum_new_length_1168X)); + if (v_1172X) { + arg0K0 = minimum_new_length_1168X; + goto L13060;} + else { + arg0K0 = 0; + goto L13060;}}} + L13060: { + new_length_1173X = arg0K0; + if ((0 == new_length_1173X)) { + extend_decode_vector0_return_value = 0; + goto extend_decode_vector_return;} + else { + len_1174X = ((new_length_1173X)<<2); + addr_1175X = ALLOCATE_SPACE(2, (4 + len_1174X)); + *((long *) addr_1175X) = (10 + (((len_1174X)<<8))); + new_vector_1176X = 3 + (((long) (addr_1175X + 4))); + p_1177X = *((long *) (((char *) (-3 + decode_vector_1166X)))); + new_length_1178X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + new_vector_1176X))) + -4))))>>8))))>>2); + old_length_1179X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + decode_vector_1166X))) + -4))))>>8))))>>2); + next_uid_1180X = ((p_1177X)>>2); + arg0K0 = 0; + goto L11691;}} + L11691: { + i_1181X = arg0K0; + if ((i_1181X == old_length_1179X)) { + start_1182X = Snew_id_hotelS; + arg1K0 = start_1182X; + arg0K1 = (-1 + next_uid_1180X); + goto L11770;} + else { + value_1183X = *((long *) ((((char *) (-3 + decode_vector_1166X))) + (((i_1181X)<<2)))); + addr_1184X = (((char *) (-3 + new_vector_1176X))) + (((i_1181X)<<2)); + WRITE_BARRIER(addr_1184X, value_1183X); + *((long *) addr_1184X) = value_1183X; + arg0K0 = (1 + i_1181X); + goto L11691;}} + L11770: { + ptr_1185X = arg1K0; + data_1186X = arg0K1; + if ((ptr_1185X == NULL)) { + arg0K0 = next_uid_1180X; + goto L11734;} + else { + next_1187X = *((long *) ptr_1185X); + if ((3 == (3 & next_1187X))) { + arg2K0 = (15 == (31 & ((((*((long *) ((((char *) (-3 + next_1187X))) + -4))))>>2)))); + goto L11714;} + else { + arg2K0 = 0; + goto L11714;}}} + L11734: { + i_1188X = arg0K0; + if ((i_1188X == new_length_1178X)) { + if (proxiesP_49X) { + addr_1189X = (((char *) (-3 + address_space_48X))) + 8; + WRITE_BARRIER(addr_1189X, new_vector_1176X); + *((long *) addr_1189X) = new_vector_1176X; + extend_decode_vector0_return_value = 1; + goto extend_decode_vector_return;} + else { + addr_1190X = (((char *) (-3 + address_space_48X))) + 4; + WRITE_BARRIER(addr_1190X, new_vector_1176X); + *((long *) addr_1190X) = new_vector_1176X; + extend_decode_vector0_return_value = 1; + goto extend_decode_vector_return;}} + else { + value_1191X = 4 + (((i_1188X)<<2)); + addr_1192X = (((char *) (-3 + new_vector_1176X))) + (((i_1188X)<<2)); + WRITE_BARRIER(addr_1192X, value_1191X); + *((long *) addr_1192X) = value_1191X; + arg0K0 = (1 + i_1188X); + goto L11734;}} + L11714: { + is_proxyP_1193X = arg2K0; + if (proxiesP_49X) { + if (is_proxyP_1193X) { + goto L11725;} + else { + arg0K0 = data_1186X; + goto L11773;}} + else { + if (is_proxyP_1193X) { + arg0K0 = data_1186X; + goto L11773;} + else { + goto L11725;}}} + L11725: { + addr_1194X = (((char *) (-3 + new_vector_1176X))) + (((data_1186X)<<2)); + WRITE_BARRIER(addr_1194X, next_1187X); + *((long *) addr_1194X) = next_1187X; + arg0K0 = (-1 + data_1186X); + goto L11773;} + L11773: { + v_1195X = arg0K0; + arg1K0 = (((char *) (*((long *) (ptr_1185X + 4))))); + arg0K1 = v_1195X; + goto L11770;} + extend_decode_vector_return: + switch (extend_decode_vector_return_tag) { + case 0: goto extend_decode_vector_return_0; + case 1: goto extend_decode_vector_return_1; + default: goto extend_decode_vector_return_2; + }} + + encode: { + thing_45X = merged_arg0K0; + address_space_46X = merged_arg0K1; + pair_47X = merged_arg0K2;{ + start_hp_1196X = heap_limits(&v_1197X, ¤t_end_1198X, &other_begin_1199X, &v_1200X); + Sour_address_spaceS = address_space_46X; + SstartS = start_hp_1196X; + Stransmit_hpS = (start_hp_1196X + 12); + end_1201X = start_hp_1196X + 16777220; + if ((end_1201X < current_end_1198X)) { + arg1K0 = end_1201X; + goto L15563;} + else { + arg1K0 = current_end_1198X; + goto L15563;}} + L15563: { + x_1202X = arg1K0; + Smax_hpS = (x_1202X + -4); + Sother_hpS = other_begin_1199X; + Sheartbreak_hotelS = NULL; + Snew_id_hotelS = NULL; + Slosing_proxy_hotelS = NULL; + merged_arg0K0 = thing_45X; + encode_object_return_tag = 0; + goto encode_object; + encode_object_return_0: + code_1203X = encode_object0_return_value; + *((long *) (start_hp_1196X + 8)) = code_1203X; + if (((Stransmit_hpS) < (Smax_hpS))) { + arg1K0 = (start_hp_1196X + 12); + goto L15757;} + else { + goto L15607;}} + L15757: { + start_1204X = arg1K0; + end_1205X = Stransmit_hpS; + arg1K0 = start_1204X; + goto L14994;} + L15607: { + start_1206X = Sheartbreak_hotelS; + arg1K0 = start_1206X; + goto L15682;} + L14994: { + addr_1207X = arg1K0; + if ((addr_1207X < end_1205X)) { + thing_1208X = *((long *) addr_1207X); + next_1209X = addr_1207X + 4; + if ((2 == (3 & thing_1208X))) { + if (((31 & (((thing_1208X)>>2))) < 19)) { + goto L15009;} + else { + arg1K0 = (next_1209X + (-4 & (3 + ((long)(((unsigned long)thing_1208X)>>8))))); + goto L14994;}} + else { + goto L15009;}} + else { + if (((Stransmit_hpS) < (Smax_hpS))) { + if ((end_1205X < (Stransmit_hpS))) { + arg1K0 = end_1205X; + goto L15757;} + else { + *((long *) start_hp_1196X) = (82 + (((((Stransmit_hpS) - (start_hp_1196X + 4)))<<8))); + *((long *) (start_hp_1196X + 4)) = ((Stransmit_hpS) - (start_hp_1196X + 4)); + set_heap_pointerB((Stransmit_hpS)); + start_1210X = Sheartbreak_hotelS; + arg1K0 = start_1210X; + goto L15716;}} + else { + goto L15607;}}} + L15682: { + ptr_1211X = arg1K0; + if ((ptr_1211X == NULL)) { + goto L5572;} + else { + *((long *) ((((char *) (-3 + (*((long *) ptr_1211X))))) + -4)) = (*((long *) (ptr_1211X + 4))); + arg1K0 = (((char *) (*((long *) (ptr_1211X + 8))))); + goto L15682;}} + L15009: { + if ((3 == (3 & thing_1208X))) { + merged_arg0K0 = thing_1208X; + encode_object_return_tag = 1; + goto encode_object; + encode_object_return_1: + x2_1212X = encode_object0_return_value; + *((long *) addr_1207X) = x2_1212X; + arg1K0 = next_1209X; + goto L14994;} + else { + arg1K0 = next_1209X; + goto L14994;}} + L15716: { + ptr_1213X = arg1K0; + if ((ptr_1213X == NULL)) { + old_proxy_1214X = *((long *) ((((char *) (-3 + address_space_46X))) + 8)); + old_decode_1215X = *((long *) ((((char *) (-3 + address_space_46X))) + 4)); + p_1216X = *((long *) (((char *) (-3 + old_proxy_1214X)))); + y_1217X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + old_proxy_1214X))) + -4))))>>8))))>>2); + if ((y_1217X < (((p_1216X)>>2)))) { + arg2K0 = 0; + goto L14044;} + else { + arg2K0 = 1; + goto L14044;}} + else { + *((long *) ((((char *) (-3 + (*((long *) ptr_1213X))))) + -4)) = (*((long *) (ptr_1213X + 4))); + arg1K0 = (((char *) (*((long *) (ptr_1213X + 8))))); + goto L15716;}} + L5572: { + start_1218X = Snew_id_hotelS; + arg1K0 = start_1218X; + goto L5615;} + L14044: { + proxy_okayP_1219X = arg2K0; + if ((((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + old_decode_1215X))) + -4))))>>8))))>>2)) < ((((*((long *) (((char *) (-3 + old_decode_1215X))))))>>2)))) { + merged_arg0K0 = address_space_46X; + merged_arg1K1 = other_begin_1199X; + merged_arg2K2 = 0; + extend_decode_vector_return_tag = 0; + goto extend_decode_vector; + extend_decode_vector_return_0: + v_1220X = extend_decode_vector0_return_value; + if (v_1220X) { + if (proxy_okayP_1219X) { + goto L15629;} + else { + merged_arg0K0 = address_space_46X; + merged_arg1K1 = other_begin_1199X; + merged_arg2K2 = 1; + extend_decode_vector_return_tag = 1; + goto extend_decode_vector; + extend_decode_vector_return_1: + temp_1221X = extend_decode_vector0_return_value; + if (temp_1221X) { + goto L15629;} + else { + addr_1222X = (((char *) (-3 + address_space_46X))) + 8; + WRITE_BARRIER(addr_1222X, old_proxy_1214X); + *((long *) addr_1222X) = old_proxy_1214X; + goto L5572;}}} + else { + goto L5572;}} + else { + if (proxy_okayP_1219X) { + goto L15629;} + else { + merged_arg0K0 = address_space_46X; + merged_arg1K1 = other_begin_1199X; + merged_arg2K2 = 1; + extend_decode_vector_return_tag = 2; + goto extend_decode_vector; + extend_decode_vector_return_2: + v_1223X = extend_decode_vector0_return_value; + if (v_1223X) { + goto L15629;} + else { + goto L5572;}}}} + L5615: { + ptr_1224X = arg1K0; + if ((ptr_1224X == NULL)) { + encode0_return_value = 0; + goto encode_return;} + else { + thing_1225X = *((long *) ptr_1224X); + temp_1226X = 31 & ((((*((long *) ((((char *) (-3 + thing_1225X))) + -4))))>>2)); + if ((1 == temp_1226X)) { + addr_1227X = ((char *) (-3 + thing_1225X)); + WRITE_BARRIER(addr_1227X, 1); + *((long *) addr_1227X) = 1; + goto L5620;} + else { + if ((11 == temp_1226X)) { + addr_1228X = (((char *) (-3 + thing_1225X))) + 8; + WRITE_BARRIER(addr_1228X, 1); + *((long *) addr_1228X) = 1; + goto L5620;} + else { + if ((13 == temp_1226X)) { + addr_1229X = (((char *) (-3 + thing_1225X))) + 8; + WRITE_BARRIER(addr_1229X, 1); + *((long *) addr_1229X) = 1; + goto L5620;} + else { + if ((16 == temp_1226X)) { + addr_1230X = ((char *) (-3 + thing_1225X)); + WRITE_BARRIER(addr_1230X, 1); + *((long *) addr_1230X) = 1; + goto L5620;} + else { + if ((16 == temp_1226X)) { + addr_1231X = ((char *) (-3 + thing_1225X)); + WRITE_BARRIER(addr_1231X, 1); + *((long *) addr_1231X) = 1; + goto L5620;} + else { + if ((4 == temp_1226X)) { + addr_1232X = ((char *) (-3 + thing_1225X)); + WRITE_BARRIER(addr_1232X, 1); + *((long *) addr_1232X) = 1; + goto L5620;} + else { + if ((14 == temp_1226X)) { + addr_1233X = ((char *) (-3 + (*((long *) (((char *) (-3 + thing_1225X))))))); + WRITE_BARRIER(addr_1233X, 1); + *((long *) addr_1233X) = 1; + addr_1234X = (((char *) (-3 + (*((long *) (((char *) (-3 + thing_1225X)))))))) + 12; + WRITE_BARRIER(addr_1234X, 67108864); + *((long *) addr_1234X) = 67108864; + goto L5620;} + else { + goto L5620;}}}}}}}}} + L15629: { + start_1235X = Slosing_proxy_hotelS; + arg1K0 = start_1235X; + arg0K1 = 25; + goto L10524;} + L5620: { + arg1K0 = (((char *) (*((long *) (ptr_1224X + 4))))); + goto L5615;} + L10524: { + ptr_1236X = arg1K0; + data_1237X = arg0K1; + if ((ptr_1236X == NULL)) { + if ((1 == data_1237X)) { + encode0_return_value = 0; + goto encode_return;} + else { + val_1238X = 3 + (((long) (start_hp_1196X + 4))); + addr_1239X = ((char *) (-3 + pair_47X)); + WRITE_BARRIER(addr_1239X, val_1238X); + *((long *) addr_1239X) = val_1238X; + addr_1240X = (((char *) (-3 + pair_47X))) + 4; + WRITE_BARRIER(addr_1240X, data_1237X); + *((long *) addr_1240X) = data_1237X; + encode0_return_value = 1; + goto encode_return;}} + else { + v_1241X = AVAILABLEp(3); + if (v_1241X) { + a_1242X = *((long *) ptr_1236X); + addr_1243X = ALLOCATE_SPACE(0, 12); + *((long *) addr_1243X) = 2050; + x_1244X = 3 + (((long) (addr_1243X + 4))); + *((long *) (((char *) (-3 + x_1244X)))) = a_1242X; + *((long *) ((((char *) (-3 + x_1244X))) + 4)) = data_1237X; + arg0K0 = x_1244X; + goto L10527;} + else { + arg0K0 = 1; + goto L10527;}}} + L10527: { + v_1245X = arg0K0; + arg1K0 = (((char *) (*((long *) (ptr_1236X + 4))))); + arg0K1 = v_1245X; + goto L10524;} + encode_return: + switch (encode_return_tag) { + case 0: goto encode_return_0; + default: goto encode_return_1; + }} + + copy_continuation_from_heapB: { + cont_44X = merged_arg0K0;{ + top_1246X = (((char *) (-3 + (Sbottom_of_stackS)))) + (-8 - (-4 & (3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + cont_44X))) + -4))))>>8))))); + new_cont_1247X = 3 + (((long) (top_1246X + 4))); + SstackS = (top_1246X + -4); + ScontS = new_cont_1247X; + v_1248X = (((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + cont_44X))) + -4))))>>8))))>>2); + memcpy((void *)top_1246X, (void *)((((char *) (-3 + cont_44X))) + -4),(4 + (((v_1248X)<<2)))); + *((long *) (((char *) (-3 + (Sbottom_of_stackS))))) = (*((long *) (((char *) (-3 + new_cont_1247X))))); + *((long *) (((char *) (-3 + new_cont_1247X)))) = (Sbottom_of_stackS); + copy_continuation_from_heapB0_return_value = new_cont_1247X; + goto copy_continuation_from_heapB_return;} + copy_continuation_from_heapB_return: + switch (copy_continuation_from_heapB_return_tag) { + case 0: goto copy_continuation_from_heapB_return_0; + default: goto copy_continuation_from_heapB_return_1; + }} + + get_current_port: { + marker_43X = merged_arg0K0;{ + thread_1249X = Scurrent_threadS; + if ((3 == (3 & thread_1249X))) { + if ((8 == (31 & ((((*((long *) ((((char *) (-3 + thread_1249X))) + -4))))>>2))))) { + if ((1 < ((((3 + ((long)(((unsigned long)(*((long *) ((((char *) (-3 + thread_1249X))) + -4))))>>8))))>>2)))) { + arg0K0 = (*((long *) ((((char *) (-3 + thread_1249X))) + 4))); + goto L11155;} + else { + v_1250X = enter_string("bad record"); + get_current_port0_return_value = v_1250X; + goto get_current_port_return;}} + else { + v_1251X = enter_string("bad record"); + get_current_port0_return_value = v_1251X; + goto get_current_port_return;}} + else { + v_1252X = enter_string("bad record"); + get_current_port0_return_value = v_1252X; + goto get_current_port_return;}} + L11155: { + env_1253X = arg0K0; + if ((3 == (3 & env_1253X))) { + if ((0 == (31 & ((((*((long *) ((((char *) (-3 + env_1253X))) + -4))))>>2))))) { + obj_1254X = *((long *) (((char *) (-3 + env_1253X)))); + if ((3 == (3 & obj_1254X))) { + if ((0 == (31 & ((((*((long *) ((((char *) (-3 + obj_1254X))) + -4))))>>2))))) { + if ((marker_43X == (*((long *) (((char *) (-3 + (*((long *) (((char *) (-3 + env_1253X)))))))))))) { + get_current_port0_return_value = (*((long *) ((((char *) (-3 + (*((long *) (((char *) (-3 + env_1253X)))))))) + 4))); + goto get_current_port_return;} + else { + arg0K0 = (*((long *) ((((char *) (-3 + env_1253X))) + 4))); + goto L11155;}} + else { + goto L11211;}} + else { + goto L11211;}} + else { + goto L11211;}} + else { + goto L11211;}} + L11211: { + if ((25 == env_1253X)) { + v_1255X = enter_string("null"); + get_current_port0_return_value = v_1255X; + goto get_current_port_return;} + else { + v_1256X = enter_string("not pair"); + get_current_port0_return_value = v_1256X; + goto get_current_port_return;}} + get_current_port_return: + switch (get_current_port_return_tag) { + case 0: goto get_current_port_return_0; + case 1: goto get_current_port_return_1; + default: goto get_current_port_return_2; + }} + + okay_argument_list: { + list_42X = merged_arg0K0;{ + arg0K0 = list_42X; + arg0K1 = 0; + arg0K2 = list_42X; + arg2K3 = 0; + goto L10176;} + L10176: { + fast_1257X = arg0K0; + len_1258X = arg0K1; + slow_1259X = arg0K2; + move_slowP_1260X = arg2K3; + if ((25 == fast_1257X)) { + okay_argument_list0_return_value = 1; + okay_argument_list1_return_value = len_1258X; + goto okay_argument_list_return;} + else { + if ((3 == (3 & fast_1257X))) { + if ((0 == (31 & ((((*((long *) ((((char *) (-3 + fast_1257X))) + -4))))>>2))))) { + if (move_slowP_1260X) { + if ((fast_1257X == slow_1259X)) { + okay_argument_list0_return_value = 0; + okay_argument_list1_return_value = 0; + goto okay_argument_list_return;} + else { + arg0K0 = (*((long *) ((((char *) (-3 + fast_1257X))) + 4))); + arg0K1 = (1 + len_1258X); + arg0K2 = (*((long *) ((((char *) (-3 + slow_1259X))) + 4))); + arg2K3 = 0; + goto L10176;}} + else { + arg0K0 = (*((long *) ((((char *) (-3 + fast_1257X))) + 4))); + arg0K1 = (1 + len_1258X); + arg0K2 = slow_1259X; + arg2K3 = 1; + goto L10176;}} + else { + okay_argument_list0_return_value = 0; + okay_argument_list1_return_value = 0; + goto okay_argument_list_return;}} + else { + okay_argument_list0_return_value = 0; + okay_argument_list1_return_value = 0; + goto okay_argument_list_return;}}} + okay_argument_list_return: + switch (okay_argument_list_return_tag) { + case 0: goto okay_argument_list_return_0; + default: goto okay_argument_list_return_1; + }} + + push_exception_continuationB: { + exception_40X = merged_arg0K0; + instruction_size_41X = merged_arg0K1;{ + opcode_1261X = *((unsigned char *) (Scode_pointerS)); + *((long *) (SstackS)) = (((instruction_size_41X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((exception_40X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (StemplateS); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((((Scode_pointerS) - (((char *) (-3 + (*((long *) (((char *) (-3 + (StemplateS)))))))))))<<2)); + SstackS = ((SstackS) + -4); + tem_1262X = Sexception_templateS; + StemplateS = tem_1262X; + Scode_pointerS = (((char *) (-3 + (*((long *) (((char *) (-3 + tem_1262X)))))))); + arg1K0 = ((SstackS) + 4); + arg0K1 = 0; + goto L9759;} + L9759: { + p_1263X = arg1K0; + i_1264X = arg0K1; + if ((2 == (3 & (*((long *) p_1263X))))) { + if ((54 == (*((long *) p_1263X)))) { + arg0K0 = (-1 + i_1264X); + goto L9700;} + else { + arg0K0 = i_1264X; + goto L9700;}} + else { + arg1K0 = (p_1263X + 4); + arg0K1 = (1 + i_1264X); + goto L9759;}} + L9700: { + v_1265X = arg0K0; + merged_arg1K0 = (Scode_pointerS); + merged_arg0K1 = v_1265X; + push_continuationB_return_tag = 3; + goto push_continuationB; + push_continuationB_return_3: + *((long *) (SstackS)) = (((opcode_1261X)<<2)); + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = (((exception_40X)<<2)); + SstackS = ((SstackS) + -4); + goto push_exception_continuationB_return;} + push_exception_continuationB_return: + switch (push_exception_continuationB_return_tag) { + case 0: goto push_exception_continuationB_return_0; + case 1: goto push_exception_continuationB_return_1; + case 2: goto push_exception_continuationB_return_2; + case 3: goto push_exception_continuationB_return_3; + case 4: goto push_exception_continuationB_return_4; + case 5: goto push_exception_continuationB_return_5; + case 6: goto push_exception_continuationB_return_6; + case 7: goto push_exception_continuationB_return_7; + case 8: goto push_exception_continuationB_return_8; + case 9: goto push_exception_continuationB_return_9; + case 10: goto push_exception_continuationB_return_10; + case 11: goto push_exception_continuationB_return_11; + case 12: goto push_exception_continuationB_return_12; + case 13: goto push_exception_continuationB_return_13; + case 14: goto push_exception_continuationB_return_14; + case 15: goto push_exception_continuationB_return_15; + case 16: goto push_exception_continuationB_return_16; + case 17: goto push_exception_continuationB_return_17; + case 18: goto push_exception_continuationB_return_18; + case 19: goto push_exception_continuationB_return_19; + case 20: goto push_exception_continuationB_return_20; + case 21: goto push_exception_continuationB_return_21; + case 22: goto push_exception_continuationB_return_22; + case 23: goto push_exception_continuationB_return_23; + case 24: goto push_exception_continuationB_return_24; + case 25: goto push_exception_continuationB_return_25; + case 26: goto push_exception_continuationB_return_26; + case 27: goto push_exception_continuationB_return_27; + case 28: goto push_exception_continuationB_return_28; + case 29: goto push_exception_continuationB_return_29; + case 30: goto push_exception_continuationB_return_30; + case 31: goto push_exception_continuationB_return_31; + case 32: goto push_exception_continuationB_return_32; + case 33: goto push_exception_continuationB_return_33; + case 34: goto push_exception_continuationB_return_34; + case 35: goto push_exception_continuationB_return_35; + case 36: goto push_exception_continuationB_return_36; + case 37: goto push_exception_continuationB_return_37; + case 38: goto push_exception_continuationB_return_38; + case 39: goto push_exception_continuationB_return_39; + case 40: goto push_exception_continuationB_return_40; + case 41: goto push_exception_continuationB_return_41; + case 42: goto push_exception_continuationB_return_42; + case 43: goto push_exception_continuationB_return_43; + case 44: goto push_exception_continuationB_return_44; + case 45: goto push_exception_continuationB_return_45; + case 46: goto push_exception_continuationB_return_46; + case 47: goto push_exception_continuationB_return_47; + case 48: goto push_exception_continuationB_return_48; + case 49: goto push_exception_continuationB_return_49; + case 50: goto push_exception_continuationB_return_50; + case 51: goto push_exception_continuationB_return_51; + case 52: goto push_exception_continuationB_return_52; + case 53: goto push_exception_continuationB_return_53; + case 54: goto push_exception_continuationB_return_54; + case 55: goto push_exception_continuationB_return_55; + case 56: goto push_exception_continuationB_return_56; + case 57: goto push_exception_continuationB_return_57; + case 58: goto push_exception_continuationB_return_58; + case 59: goto push_exception_continuationB_return_59; + case 60: goto push_exception_continuationB_return_60; + case 61: goto push_exception_continuationB_return_61; + case 62: goto push_exception_continuationB_return_62; + case 63: goto push_exception_continuationB_return_63; + case 64: goto push_exception_continuationB_return_64; + case 65: goto push_exception_continuationB_return_65; + case 66: goto push_exception_continuationB_return_66; + case 67: goto push_exception_continuationB_return_67; + case 68: goto push_exception_continuationB_return_68; + case 69: goto push_exception_continuationB_return_69; + case 70: goto push_exception_continuationB_return_70; + case 71: goto push_exception_continuationB_return_71; + case 72: goto push_exception_continuationB_return_72; + case 73: goto push_exception_continuationB_return_73; + case 74: goto push_exception_continuationB_return_74; + case 75: goto push_exception_continuationB_return_75; + case 76: goto push_exception_continuationB_return_76; + case 77: goto push_exception_continuationB_return_77; + case 78: goto push_exception_continuationB_return_78; + case 79: goto push_exception_continuationB_return_79; + case 80: goto push_exception_continuationB_return_80; + case 81: goto push_exception_continuationB_return_81; + case 82: goto push_exception_continuationB_return_82; + case 83: goto push_exception_continuationB_return_83; + case 84: goto push_exception_continuationB_return_84; + case 85: goto push_exception_continuationB_return_85; + case 86: goto push_exception_continuationB_return_86; + case 87: goto push_exception_continuationB_return_87; + case 88: goto push_exception_continuationB_return_88; + case 89: goto push_exception_continuationB_return_89; + case 90: goto push_exception_continuationB_return_90; + case 91: goto push_exception_continuationB_return_91; + case 92: goto push_exception_continuationB_return_92; + case 93: goto push_exception_continuationB_return_93; + case 94: goto push_exception_continuationB_return_94; + case 95: goto push_exception_continuationB_return_95; + case 96: goto push_exception_continuationB_return_96; + case 97: goto push_exception_continuationB_return_97; + case 98: goto push_exception_continuationB_return_98; + case 99: goto push_exception_continuationB_return_99; + case 100: goto push_exception_continuationB_return_100; + case 101: goto push_exception_continuationB_return_101; + case 102: goto push_exception_continuationB_return_102; + case 103: goto push_exception_continuationB_return_103; + case 104: goto push_exception_continuationB_return_104; + case 105: goto push_exception_continuationB_return_105; + case 106: goto push_exception_continuationB_return_106; + case 107: goto push_exception_continuationB_return_107; + case 108: goto push_exception_continuationB_return_108; + case 109: goto push_exception_continuationB_return_109; + case 110: goto push_exception_continuationB_return_110; + case 111: goto push_exception_continuationB_return_111; + case 112: goto push_exception_continuationB_return_112; + case 113: goto push_exception_continuationB_return_113; + case 114: goto push_exception_continuationB_return_114; + case 115: goto push_exception_continuationB_return_115; + case 116: goto push_exception_continuationB_return_116; + case 117: goto push_exception_continuationB_return_117; + case 118: goto push_exception_continuationB_return_118; + case 119: goto push_exception_continuationB_return_119; + case 120: goto push_exception_continuationB_return_120; + case 121: goto push_exception_continuationB_return_121; + case 122: goto push_exception_continuationB_return_122; + case 123: goto push_exception_continuationB_return_123; + case 124: goto push_exception_continuationB_return_124; + case 125: goto push_exception_continuationB_return_125; + case 126: goto push_exception_continuationB_return_126; + case 127: goto push_exception_continuationB_return_127; + case 128: goto push_exception_continuationB_return_128; + case 129: goto push_exception_continuationB_return_129; + case 130: goto push_exception_continuationB_return_130; + case 131: goto push_exception_continuationB_return_131; + case 132: goto push_exception_continuationB_return_132; + case 133: goto push_exception_continuationB_return_133; + case 134: goto push_exception_continuationB_return_134; + case 135: goto push_exception_continuationB_return_135; + case 136: goto push_exception_continuationB_return_136; + case 137: goto push_exception_continuationB_return_137; + case 138: goto push_exception_continuationB_return_138; + case 139: goto push_exception_continuationB_return_139; + case 140: goto push_exception_continuationB_return_140; + case 141: goto push_exception_continuationB_return_141; + case 142: goto push_exception_continuationB_return_142; + case 143: goto push_exception_continuationB_return_143; + case 144: goto push_exception_continuationB_return_144; + case 145: goto push_exception_continuationB_return_145; + case 146: goto push_exception_continuationB_return_146; + case 147: goto push_exception_continuationB_return_147; + case 148: goto push_exception_continuationB_return_148; + case 149: goto push_exception_continuationB_return_149; + case 150: goto push_exception_continuationB_return_150; + case 151: goto push_exception_continuationB_return_151; + case 152: goto push_exception_continuationB_return_152; + case 153: goto push_exception_continuationB_return_153; + case 154: goto push_exception_continuationB_return_154; + case 155: goto push_exception_continuationB_return_155; + case 156: goto push_exception_continuationB_return_156; + case 157: goto push_exception_continuationB_return_157; + case 158: goto push_exception_continuationB_return_158; + case 159: goto push_exception_continuationB_return_159; + case 160: goto push_exception_continuationB_return_160; + case 161: goto push_exception_continuationB_return_161; + case 162: goto push_exception_continuationB_return_162; + case 163: goto push_exception_continuationB_return_163; + case 164: goto push_exception_continuationB_return_164; + case 165: goto push_exception_continuationB_return_165; + case 166: goto push_exception_continuationB_return_166; + case 167: goto push_exception_continuationB_return_167; + case 168: goto push_exception_continuationB_return_168; + case 169: goto push_exception_continuationB_return_169; + case 170: goto push_exception_continuationB_return_170; + case 171: goto push_exception_continuationB_return_171; + case 172: goto push_exception_continuationB_return_172; + case 173: goto push_exception_continuationB_return_173; + case 174: goto push_exception_continuationB_return_174; + case 175: goto push_exception_continuationB_return_175; + case 176: goto push_exception_continuationB_return_176; + case 177: goto push_exception_continuationB_return_177; + case 178: goto push_exception_continuationB_return_178; + case 179: goto push_exception_continuationB_return_179; + case 180: goto push_exception_continuationB_return_180; + case 181: goto push_exception_continuationB_return_181; + case 182: goto push_exception_continuationB_return_182; + case 183: goto push_exception_continuationB_return_183; + case 184: goto push_exception_continuationB_return_184; + case 185: goto push_exception_continuationB_return_185; + case 186: goto push_exception_continuationB_return_186; + case 187: goto push_exception_continuationB_return_187; + case 188: goto push_exception_continuationB_return_188; + case 189: goto push_exception_continuationB_return_189; + case 190: goto push_exception_continuationB_return_190; + case 191: goto push_exception_continuationB_return_191; + case 192: goto push_exception_continuationB_return_192; + case 193: goto push_exception_continuationB_return_193; + case 194: goto push_exception_continuationB_return_194; + case 195: goto push_exception_continuationB_return_195; + case 196: goto push_exception_continuationB_return_196; + case 197: goto push_exception_continuationB_return_197; + case 198: goto push_exception_continuationB_return_198; + case 199: goto push_exception_continuationB_return_199; + case 200: goto push_exception_continuationB_return_200; + case 201: goto push_exception_continuationB_return_201; + case 202: goto push_exception_continuationB_return_202; + case 203: goto push_exception_continuationB_return_203; + case 204: goto push_exception_continuationB_return_204; + case 205: goto push_exception_continuationB_return_205; + case 206: goto push_exception_continuationB_return_206; + case 207: goto push_exception_continuationB_return_207; + case 208: goto push_exception_continuationB_return_208; + case 209: goto push_exception_continuationB_return_209; + default: goto push_exception_continuationB_return_210; + }} + + push_continuationB: { + code_pointer_38X = merged_arg1K0; + size_39X = merged_arg0K1;{ + pc_1266X = (((code_pointer_38X - (((char *) (-3 + (*((long *) (((char *) (-3 + (StemplateS)))))))))))<<2); + template_1267X = StemplateS; + SstackS = ((SstackS) + -20); + *((long *) ((SstackS) + 4)) = (4134 + (((size_39X)<<10))); + cont_1268X = 3 + (((long) ((SstackS) + 8))); + *((long *) ((((char *) (-3 + cont_1268X))) + 4)) = pc_1266X; + *((long *) ((((char *) (-3 + cont_1268X))) + 8)) = template_1267X; + *((long *) ((((char *) (-3 + cont_1268X))) + 12)) = (SenvS); + *((long *) (((char *) (-3 + cont_1268X)))) = (ScontS); + ScontS = cont_1268X; + goto push_continuationB_return;} + push_continuationB_return: + switch (push_continuationB_return_tag) { + case 0: goto push_continuationB_return_0; + case 1: goto push_continuationB_return_1; + case 2: goto push_continuationB_return_2; + default: goto push_continuationB_return_3; + }} + + get_error_string: { + status_37X = merged_arg0K0;{ + string_1269X = ps_error_string(status_37X); + x_1270X = strlen((char *) string_1269X); + if ((x_1270X < 256)) { + arg0K0 = x_1270X; + goto L9616;} + else { + arg0K0 = 256; + goto L9616;}} + L9616: { + len_1271X = arg0K0; + len_1272X = 1 + len_1271X; + addr_1273X = ALLOCATE_SPACE(19, (4 + len_1272X)); + *((long *) addr_1273X) = (78 + (((len_1272X)<<8))); + string_1274X = 3 + (((long) (addr_1273X + 4))); + *((unsigned char *) ((((char *) (-3 + string_1274X))) + len_1271X)) = 0; + arg0K0 = 0; + goto L9626;} + L9626: { + i_1275X = arg0K0; + if ((i_1275X == len_1271X)) { + get_error_string0_return_value = string_1274X; + goto get_error_string_return;} + else { + *((unsigned char *) ((((char *) (-3 + string_1274X))) + i_1275X)) = ((*(string_1269X + i_1275X))); + arg0K0 = (1 + i_1275X); + goto L9626;}} + get_error_string_return: + switch (get_error_string_return_tag) { + case 0: goto get_error_string_return_0; + case 1: goto get_error_string_return_1; + case 2: goto get_error_string_return_2; + case 3: goto get_error_string_return_3; + default: goto get_error_string_return_4; + }} + + pop_continuationB: { +{ cont_1276X = ScontS; + tem_1277X = *((long *) ((((char *) (-3 + cont_1276X))) + 8)); + pc_1278X = *((long *) ((((char *) (-3 + cont_1276X))) + 4)); + StemplateS = tem_1277X; + Scode_pointerS = ((((char *) (-3 + (*((long *) (((char *) (-3 + tem_1277X)))))))) + (((pc_1278X)>>2))); + SenvS = (*((long *) ((((char *) (-3 + cont_1276X))) + 12))); + ScontS = (*((long *) (((char *) (-3 + cont_1276X))))); + SstackS = ((((char *) (-3 + cont_1276X))) + 12); + goto pop_continuationB_return;} + pop_continuationB_return: + switch (pop_continuationB_return_tag) { + case 0: goto pop_continuationB_return_0; + case 1: goto pop_continuationB_return_1; + default: goto pop_continuationB_return_2; + }} + +} +long call_startup_procedure(long startup_proc_1279X, char **startup_vector_1280X, long startup_vector_length_1281X) +{ + long arg0K0; + long code_1314X; + char * addr_1313X; + long x_1312X; + char * addr_1311X; + long b_1310X; + long channel_1309X; + long x_1308X; + char * addr_1307X; + long b_1306X; + long channel_1305X; + long x_1304X; + char * addr_1303X; + long b_1302X; + long channel_1301X; + long i_1300X; + long length_1299X; + long *v_1298X; + long v_1297X; + long v_1296X; + long y_1295X; + long x_1294X; + long v_1293X; + long x_1292X; + long y_1291X; + long x_1290X; + long y_1289X; + long tem_1288X; + char * addr_1287X; + long value_1286X; + long i_1285X; + long vector_1284X; + char * addr_1283X; + long len_1282X; + { len_1282X = ((startup_vector_length_1281X)<<2); + addr_1283X = ALLOCATE_SPACE(2, (4 + len_1282X)); + *((long *) addr_1283X) = (10 + (((len_1282X)<<8))); + vector_1284X = 3 + (((long) (addr_1283X + 4))); + arg0K0 = 0; + goto L21178;} + L21178: { + i_1285X = arg0K0; + if ((i_1285X < startup_vector_length_1281X)) { + value_1286X = enter_string((*(startup_vector_1280X + i_1285X))); + addr_1287X = (((char *) (-3 + vector_1284X))) + (((i_1285X)<<2)); + WRITE_BARRIER(addr_1287X, value_1286X); + *((long *) addr_1287X) = value_1286X; + arg0K0 = (1 + i_1285X); + goto L21178;} + else { + SstackS = ((((char *) (-3 + (Sbottom_of_stackS)))) + -8); + *((long *) (((char *) (-3 + (Sbottom_of_stackS))))) = 1; + ScontS = (Sbottom_of_stackS); + SenvS = 13; + tem_1288X = Sinterrupt_templateS; + StemplateS = tem_1288X; + Scode_pointerS = (((char *) (-3 + (*((long *) (((char *) (-3 + tem_1288X)))))))); + SvalS = 13; + Scurrent_threadS = 25; + Ssession_dataS = 25; + Sexception_handlersS = 25; + Sinterrupt_handlersS = 25; + Senabled_interruptsS = 0; + Sfinalizer_alistS = 25; + Sfinalize_theseS = 25; + Spending_interruptsS = 0; + Spending_interruptPS = 0; + Sinterrupted_templateS = 1; + *((long *) (SstackS)) = vector_1284X; + SstackS = ((SstackS) + -4); + y_1289X = fileno((stderr)); + x_1290X = fileno((stdout)); + if ((x_1290X < y_1289X)) { + arg0K0 = y_1289X; + goto L12418;} + else { + arg0K0 = x_1290X; + goto L12418;}}} + L12418: { + y_1291X = arg0K0; + x_1292X = fileno((stdin)); + if ((x_1292X < y_1291X)) { + arg0K0 = y_1291X; + goto L12420;} + else { + arg0K0 = x_1292X; + goto L12420;}} + L12420: { + v_1293X = arg0K0; + x_1294X = Snumber_of_channelsS; + y_1295X = 1 + v_1293X; + if ((x_1294X < y_1295X)) { + arg0K0 = y_1295X; + goto L12422;} + else { + arg0K0 = x_1294X; + goto L12422;}} + L12422: { + v_1296X = arg0K0; + Snumber_of_channelsS = v_1296X; + v_1297X = fileno((stdin)); + Svm_channelsS = ((long*)malloc(sizeof(long) * (Snumber_of_channelsS))); + Spending_channels_headS = 1; + Spending_channels_tailS = 1; + if ((NULL == (Svm_channelsS))) { + ps_error("out of memory, unable to continue", 0); + goto L12444;} + else { + goto L12444;}} + L12444: { + v_1298X = Svm_channelsS; + length_1299X = Snumber_of_channelsS; + arg0K0 = 0; + goto L12486;} + L12486: { + i_1300X = arg0K0; + if ((i_1300X < length_1299X)) { + *(v_1298X + i_1300X) = 1; + arg0K0 = (1 + i_1300X); + goto L12486;} + else { + channel_1301X = fileno((stdin)); + b_1302X = enter_string("standard input"); + addr_1303X = ALLOCATE_SPACE(5, 24); + *((long *) addr_1303X) = 5142; + x_1304X = 3 + (((long) (addr_1303X + 4))); + *((long *) (((char *) (-3 + x_1304X)))) = 4; + *((long *) ((((char *) (-3 + x_1304X))) + 4)) = b_1302X; + *((long *) ((((char *) (-3 + x_1304X))) + 8)) = (((channel_1301X)<<2)); + *((long *) ((((char *) (-3 + x_1304X))) + 12)) = 1; + *((long *) ((((char *) (-3 + x_1304X))) + 16)) = 1; + *((Svm_channelsS) + channel_1301X) = x_1304X; + channel_1305X = fileno((stderr)); + b_1306X = enter_string("standard error"); + addr_1307X = ALLOCATE_SPACE(5, 24); + *((long *) addr_1307X) = 5142; + x_1308X = 3 + (((long) (addr_1307X + 4))); + *((long *) (((char *) (-3 + x_1308X)))) = 8; + *((long *) ((((char *) (-3 + x_1308X))) + 4)) = b_1306X; + *((long *) ((((char *) (-3 + x_1308X))) + 8)) = (((channel_1305X)<<2)); + *((long *) ((((char *) (-3 + x_1308X))) + 12)) = 1; + *((long *) ((((char *) (-3 + x_1308X))) + 16)) = 1; + *((Svm_channelsS) + channel_1305X) = x_1308X; + channel_1309X = fileno((stdout)); + b_1310X = enter_string("standard output"); + addr_1311X = ALLOCATE_SPACE(5, 24); + *((long *) addr_1311X) = 5142; + x_1312X = 3 + (((long) (addr_1311X + 4))); + *((long *) (((char *) (-3 + x_1312X)))) = 8; + *((long *) ((((char *) (-3 + x_1312X))) + 4)) = b_1310X; + *((long *) ((((char *) (-3 + x_1312X))) + 8)) = (((channel_1309X)<<2)); + *((long *) ((((char *) (-3 + x_1312X))) + 12)) = 1; + *((long *) ((((char *) (-3 + x_1312X))) + 16)) = 1; + *((Svm_channelsS) + channel_1309X) = x_1312X; + *((long *) (SstackS)) = x_1304X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_1312X; + SstackS = ((SstackS) + -4); + *((long *) (SstackS)) = x_1308X; + SstackS = ((SstackS) + -4); + addr_1313X = ALLOCATE_SPACE(20, 6); + *((long *) addr_1313X) = 594; + code_1314X = 3 + (((long) (addr_1313X + 4))); + *((unsigned char *) (((char *) (-3 + code_1314X)))) = 24; + *((unsigned char *) ((((char *) (-3 + code_1314X))) + 1)) = 4; + Scode_pointerS = (((char *) (-3 + code_1314X))); + return restart(startup_proc_1279X);}} +}void +scheme48_init(void) +{ +Snumber_of_channelsS = 100; +Spending_channels_headS = 1; +Spending_channels_tailS = 1; +Sstack_warningPS = 1; +Slosing_opcodeS = 0; +Spending_eventsPS = 0; +} diff --git a/c/scheme48vm.h b/c/scheme48vm.h new file mode 100644 index 0000000..cb1f8c0 --- /dev/null +++ b/c/scheme48vm.h @@ -0,0 +1,40 @@ +#include +#include + +#define SMALL_MULTIPLY(x,y) ((x) * (y)) + +#define bool char /* boolean type */ +#define TRUE (0 == 0) +#define FALSE (! TRUE) +#define NO_ERRORS 0 /* extension to errno.h */ + +typedef long scheme_value; + +extern scheme_value extended_vm(long, scheme_value), + lookup_external_name(char *, char *); + +#include "scheme48heap.h" +#include "event.h" +#include "fd-io.h" + + +/* + * The following are hand-written macro versions of procedures + * in scheme48heap.c. + */ + +extern char *ShpS, + *SlimitS; + +#define AVAILABLEp(cells) (ShpS + ((cells)<<2) < SlimitS) + + +static char *HHallocate_temp; + +#define ALLOCATE_SPACE(type, len) \ + (HHallocate_temp = ShpS, \ + ShpS += ((len)+3) & ~3, \ + HHallocate_temp) + + +#define WRITE_BARRIER(address, value) ((void)0) diff --git a/c/socket.h b/c/socket.h new file mode 100644 index 0000000..8254c42 --- /dev/null +++ b/c/socket.h @@ -0,0 +1,13 @@ +/* + * Procedures exported from socket.c. + * Note, sysdep.h must be included before this file. + */ +#if defined(HAVE_SOCKET) + +extern int internet_stream_socket(void), + socket_bind(int sock, int port), + socket_accept(int sock), + socket_connect(int sock, char *mach, int port), + socket_nodelay(int sock, int nodelay); /* added for Kali */ + +#endif diff --git a/c/sysdep.h.in b/c/sysdep.h.in new file mode 100644 index 0000000..5cbb90e --- /dev/null +++ b/c/sysdep.h.in @@ -0,0 +1,99 @@ +/* c/sysdep.h.in. Generated automatically from configure.in by autoheader. */ + +/* Define to empty if the keyword does not work. */ +#undef const + +/* Define if you need to in order for stat and other things to work. */ +#undef _POSIX_SOURCE + +/* Define as the return type of signal handlers (int or void). */ +#undef RETSIGTYPE + +/* + * HAVE_SIGACTION is defined iff sigaction() is available. + */ +#undef HAVE_SIGACTION + +/* + * HAVE_STRERROR is defined iff the standard libraries provide strerror(). + */ +#undef HAVE_STRERROR + +/* + * NLIST_HAS_N_NAME is defined iff a struct nlist has an n_name member. + * If it doesn't then we assume it has an n_un member which, in turn, + * has an n_name member. + */ +#undef NLIST_HAS_N_NAME + +/* + * USCORE is defined iff C externals are prepended with an underscore. + */ +#undef USCORE + +/* Define if you have the chroot function. */ +#undef HAVE_CHROOT + +/* Define if you have the dlopen function. */ +#undef HAVE_DLOPEN + +/* Define if you have the ftime function. */ +#undef HAVE_FTIME + +/* Define if you have the gettimeofday function. */ +#undef HAVE_GETTIMEOFDAY + +/* Define if you have the nlist function. */ +#undef HAVE_NLIST + +/* Define if you have the select function. */ +#undef HAVE_SELECT + +/* Define if you have the setitimer function. */ +#undef HAVE_SETITIMER + +/* Define if you have the sigaction function. */ +#undef HAVE_SIGACTION + +/* Define if you have the socket function. */ +#undef HAVE_SOCKET + +/* Define if you have the header file. */ +#undef HAVE_LIBGEN_H + +/* Define if you have the header file. */ +#undef HAVE_POSIX_TIME_H + +/* Define if you have the header file. */ +#undef HAVE_SYS_SELECT_H + +/* Define if you have the header file. */ +#undef HAVE_SYS_TIMEB_H + +/* Define if you have the dl library (-ldl). */ +#undef HAVE_LIBDL + +/* Define if you have the elf library (-lelf). */ +#undef HAVE_LIBELF + +/* Define if you have the gen library (-lgen). */ +#undef HAVE_LIBGEN + +/* Define if you have the m library (-lm). */ +#undef HAVE_LIBM + +/* Define if you have the mld library (-lmld). */ +#undef HAVE_LIBMLD + +/* Define if you have the nsl library (-lnsl). */ +#undef HAVE_LIBNSL + +/* Define if you have the socket library (-lsocket). */ +#undef HAVE_LIBSOCKET + +/* Define if you have the sun library (-lsun). */ +#undef HAVE_LIBSUN + +#include "fake/sigact.h" +#include "fake/strerror.h" +#include "fake/sys-select.h" diff --git a/c/unix/dynamo.c b/c/unix/dynamo.c new file mode 100644 index 0000000..fbe5a7b --- /dev/null +++ b/c/unix/dynamo.c @@ -0,0 +1,236 @@ +/* + * Lookup external names in the running scheme virtual machine and, on + * machines which support it, do dynamic loading. + */ +#include +#include +#include "sysdep.h" +#include "kali.h" + + +#if defined(HAVE_DLOPEN) + +#include + +#if defined(HAVE_LIBGEN_H) && defined(HAVE_LIBGEN) +#include +#endif + +#if defined(RTLD_NOW) +#define DLOPEN_MODE RTLD_NOW +#elif defined(RTLD_LAZY) +#define DLOPEN_MODE (RTLD_LAZY) +#else +#define DLOPEN_MODE (1) +#endif + +#endif /* defined(HAVE_DLOPEN) */ + + +#define bool char /* boolean type */ +#define TRUE (0 == 0) +#define FALSE (! TRUE) + + +#if defined(HAVE_DLOPEN) + +static bool dynamic_load(char *name); +static char *resolve(char *name); + + +/* + * Linked list of dynamically loaded libraries. + */ +static struct dlob { + struct dlob *next; + char *name; + void *handle; +} *dlobs; + + +/* + * Lookup an external name (either in a dynamically loaded library, or + * in the running executable). + * On success we return TRUE, having set *(long *)svlocp to the location. + * On failure, we return FALSE. + */ +long +lookup_external_name(long svname, long svlocp) +{ + struct dlob *dp; + void *res; + static void *self; + + for (dp = dlobs; dp != NULL; dp = dp->next) { + res = dlsym(dp->handle, (char *)svname); + if (dlerror() == NULL) { + *(long *)svlocp = (long)res; + return (TRUE); + } + } + if (self == NULL) { + self = dlopen((char *)NULL, DLOPEN_MODE); + if (dlerror() != NULL) + return (FALSE); + } + res = dlsym(self, (char *)svname); + if (dlerror() == NULL) { + *(long *)svlocp = (long)res; + return (TRUE); + } + return (FALSE); +} + + +/* + * External to load a library. + * On success we return #T, on failure #F. + * Note, if you load the same file a second time, afterwards you must + * evaluate (lookup-all-externals) in package externals to update any + * externals the pointed to the old version of the library. + */ +long +s48_dynamic_load(long argc, long argv[]) +{ + long arg; + + if (argc != 1) + return (SCHFALSE); + arg = argv[0]; + if (! STRINGP(arg)) + return (SCHFALSE); + return (dynamic_load(&STRING_REF(arg, 0)) ? SCHTRUE : SCHFALSE); +} + + +static bool +dynamic_load(char *name) +{ + struct dlob **dpp, + *dp; + void *handle; + + name = resolve(name); + for (dpp = &dlobs;; dpp = &dp->next) { + dp = *dpp; + if (dp == NULL) { + handle = dlopen(name, DLOPEN_MODE); + if (dlerror() != NULL) + return (FALSE); + dp = (struct dlob *)malloc(sizeof(*dp) + strlen(name) + 1); + if (dp == NULL) { + dlclose(handle); + return (FALSE); + } + dp->next = dlobs; + dlobs = dp; + dp->name = (char *)(dp + 1); + strcpy(dp->name, name); + dp->handle = handle; + return (TRUE); + } else if (strcmp(name, dp->name) == 0) { + dlclose(dp->handle); + dp->handle = dlopen(name, DLOPEN_MODE); + if (dlerror() != NULL) { + *dpp = dp->next; + free((void *)dp); + return (FALSE); + } + return (TRUE); + } + } +} + + +static char * +resolve(char *name) +{ +#if defined(HAVE_LIBGEN_H) && defined(HAVE_LIBGEN) + char *res, + *path; + + path = getenv("S48_EXTERN_PATH"); + if (path != NULL) { + res = pathfind(path, name, "r"); + if (res != NULL) + return (res); + } + path = getenv("LD_LIBRARY_PATH"); + if (path != NULL) { + res = pathfind(path, name, "r"); + if (res != NULL) + return (res); + } +#endif + return (name); +} + + +#elif defined(HAVE_NLIST) + +#include + +#ifdef USCORE +#include +#endif + +#if ! defined(NLIST_HAS_N_NAME) +#define n_name n_un.n_name +#endif + +long +lookup_external_name(long svname, long svlocation) +{ + struct nlist names[2]; + int status; + char *name; + long *location; + extern char *object_file; +#ifdef USCORE + int len; + char *tmp, + buff[40]; +#endif + + name = (char *)svname; + location = (long *)svlocation; + if (object_file == NULL) + return (FALSE); +#ifdef USCORE + len = 1 + strlen(name) + 1; + if (len <= sizeof(buff)) + tmp = buff; + else { + tmp = (char *)malloc(len); + if (tmp == NULL) + return (FALSE); + } + tmp[0] = '_'; + strcpy(tmp+1, name); + name = tmp; +#endif + names[0].n_name = name; + names[0].n_value = 0; /* for Linux */ + names[0].n_type = 0; /* for Linux */ + names[1].n_name = NULL; + status = nlist(object_file, names); +#ifdef USCORE + if (tmp != buff) + free(tmp); +#endif + if ((status != 0) + || (names[0].n_value == 0 && names[0].n_type == 0)) + return (FALSE); + *location = names[0].n_value; + return (TRUE); +} + +#else /* neither HAVE_DLOPEN nor HAVE_NLIST defined */ + +long +lookup_external_name(long svname, long svlocation) +{ + return (FALSE); +} + +#endif diff --git a/c/unix/event.c b/c/unix/event.c new file mode 100644 index 0000000..1eaaec5 --- /dev/null +++ b/c/unix/event.c @@ -0,0 +1,575 @@ +#include /* for sigaction() (POSIX.1) */ +#include +#include +#include +#include +#include /* for errno, (POSIX?/ANSI) */ +#include "sysdep.h" +#include "scheme48vm.h" + + +/* turning interrupts and I/O readiness into events */ + +#define block_interrupts() +#define allow_interrupts() + + +static void when_keyboard_interrupt(); +static void when_alarm_interrupt(); +static void when_sigpipe_interrupt(); +static bool setcatcher(int signum, void (*catcher)(int)); +static void start_alarm_interrupts(void); + + +void +sysdep_init(void) +{ + if (!setcatcher(SIGINT, when_keyboard_interrupt) + || !setcatcher(SIGALRM, when_alarm_interrupt) + || !setcatcher(SIGPIPE, when_sigpipe_interrupt)) { + fprintf(stderr, + "Failed to install signal handlers, errno = %d\n", + errno); + exit(1); + } + start_alarm_interrupts(); +} + + +/* + * Unless a signal is being ignored, set up the handler. + * If we return FALSE, something went wrong and errno is set to what. + */ +static bool +setcatcher(int signum, void (*catcher)(int)) +{ + struct sigaction sa; + + if (sigaction(signum, (struct sigaction *)NULL, &sa) != 0) + return (FALSE); + if (sa.sa_handler == SIG_IGN) + return (TRUE); + sa.sa_handler = catcher; + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + if (sigaction(signum, &sa, (struct sigaction *)NULL) != 0) + return (FALSE); + return (TRUE); +} + +extern unsigned char Spending_eventsPS; +extern unsigned char Spending_interruptPS; + + +/* + * Fix (HCC) NOTE_EVENT so that it will act like a single + * statement. + */ +#define NOTE_EVENT \ + do { \ + Spending_eventsPS = 1; \ + Spending_interruptPS = 1; \ + } while (0) + +static long keyboard_interrupt_count = 0; + +static void +when_keyboard_interrupt(int ign) +{ + keyboard_interrupt_count += 1; + NOTE_EVENT; + return; +} + +/* + We turn off SIGPIPE interrupts by installing a handler that does nothing. + Turning them off affects exec()'ed programs, so we don't want to do that. + Any actual pipe problems are caught when we try to read or write to them. + + We thank Olin Shivers for this hack. +*/ + +static void +when_sigpipe_interrupt(int ign) +{ + return; +} + +long current_time = 0; /* ticks since last timer-interrupt request */ +static long alarm_time = -1; +static long poll_time = -1; +static long poll_interval = 5; + +static void +when_alarm_interrupt(int ign) +{ + current_time += 1; + /* fprintf(stderr, "[tick]"); */ + if ((alarm_time >= 0 && alarm_time <= current_time) || + (poll_time >= 0 && poll_time <= current_time)) { + NOTE_EVENT; + }; + return; +} + +#define USEC_PER_POLL (1000000 / POLLS_PER_SECOND) + +/* delta is in ticks, 0 cancels current alarm */ + +long +schedule_alarm_interrupt(long delta) +{ + long old; + /* + fprintf(stderr, "\n", current_time, + delta/TICKS_PER_POLL); + */ + /* get remaining time */ + if (alarm_time == -1) + old = -1; + else + old = (alarm_time - current_time) * TICKS_PER_POLL; + + /* decrement poll_time and reset current_time */ + if (poll_time != -1) + poll_time -= current_time; + current_time = 0; + + /* set alarm_time */ + if (delta == 0) { + NOTE_EVENT; + alarm_time = 0; } + else + alarm_time = delta / TICKS_PER_POLL; + + return old; +} + +/* The next two procedures return times in seconds and ticks */ + +long real_time(long *ticks) +{ + struct timeval tv; + static struct timeval tv_orig; + static int initp = 0; + if (!initp) { + gettimeofday(&tv_orig, NULL); + initp = 1; + }; + gettimeofday(&tv, NULL); + *ticks = (tv.tv_usec - tv_orig.tv_usec)/(1000000/TICKS_PER_SECOND); + return tv.tv_sec - tv_orig.tv_sec; +} + +long run_time(long *ticks) +{ + struct tms time_buffer; + static long clock_tick = 0; + long cpu_time; + + if (clock_tick == 0) + clock_tick = sysconf(_SC_CLK_TCK); /* POSIX.1, POSIX.2 */ + times(&time_buffer); /* On Sun, getrusage() would be better */ + + cpu_time = time_buffer.tms_utime + time_buffer.tms_stime; + + *ticks = (cpu_time % clock_tick) * TICKS_PER_SECOND / clock_tick; + return cpu_time / clock_tick; +} + +static void +start_alarm_interrupts(void) +{ + struct itimerval new, old; + + new.it_value.tv_sec = 0; + new.it_value.tv_usec = USEC_PER_POLL; + new.it_interval.tv_sec = 0; + new.it_interval.tv_usec = USEC_PER_POLL; + if (0 != setitimer(ITIMER_REAL, &new, &old)) { + perror("setitimer"); + exit(-1); } +} + +static void +stop_alarm_interrupts(void) +{ + struct itimerval new, old; + + new.it_value.tv_sec = 0; + new.it_value.tv_usec = 0; + new.it_interval.tv_sec = 0; + new.it_interval.tv_usec = 0; + if (0 != setitimer(ITIMER_REAL, &new, &old)) { + perror("setitimer"); + exit(-1); } +} + + +/* + * ; Scheme version of the get-next-event procedure + * ; + * ; 1. If there has been a keyboard interrupt, return it. + * ; 2. Check for ready ports if enough time has passed since the last check. + * ; 3. If there is a ready port, return it. + * ; 4. If an alarm is due, return it. + * ; 5. If no events are pending, clear the event flags. + * (define (get-next-event) + * (cond ((> *keyboard-interrupt-count* 0) + * (without-interrupts + * (lambda () + * (set! *keyboard-interrupt-count* + * (- *keyboard-interrupt-count* 1)))) + * (values (enum event-type keyboard-interrupt) #f #f)) + * (else + * (cond ((>= *current_time* *poll-time*) + * (queue-ready-ports) + * (set! *poll-time* (+ *time* *poll-interval*)))) + * (cond ((not (queue-empty? ready-ports)) + * (values (enum event-type i/o-completion) + * (dequeue! ready-ports))) + * ((>= *current_time* *alarm-time*) + * (set! *alarm-time* max-integer) + * (values (enum event-type alarm-interrupt) #f)) + * (else + * (without-interrupts + * (lambda () + * (if (and (= *keyboard-interrupt-count* 0) + * (> *alarm-time* *current_time*) + * (> *poll-time* *current_time*)) + * (set! *pending-event?* #f)))) + * (values (enum event-type no-event) #f)))))) + */ + +static bool there_are_ready_ports(void); +static int next_ready_port(void); +static int queue_ready_ports(bool wait, long seconds, long ticks); + +int +get_next_event(long *ready_fd, long *status) +{ + int io_poll_status; + /* + fprintf(stderr, "[poll at %d (waiting for %d)]\n", current_time, alarm_time); + */ + if (keyboard_interrupt_count > 0) { + block_interrupts(); + --keyboard_interrupt_count; + allow_interrupts(); + /* fprintf(stderr, "[keyboard interrupt]\n"); */ + return (KEYBOARD_INTERRUPT_EVENT); + } + if (poll_time != -1 && current_time >= poll_time) { + io_poll_status = queue_ready_ports(FALSE, 0, 0); + if (io_poll_status == NO_ERRORS) + poll_time = current_time + poll_interval; + else if (io_poll_status != EINTR) { + *status = io_poll_status; + return (ERROR_EVENT); + } + } + if (there_are_ready_ports()) { + *ready_fd = next_ready_port(); + *status = 0; /* chars read or written */ + /* fprintf(stderr, "[i/o completion]\n"); */ + return (IO_COMPLETION_EVENT); + } + if (alarm_time != -1 && current_time >= alarm_time) { + alarm_time = -1; + /* fprintf(stderr, "[alarm]\n"); */ + return (ALARM_EVENT); + } + block_interrupts(); + if ((keyboard_interrupt_count == 0) + && (alarm_time == -1 || current_time < alarm_time) + && (poll_time == -1 || current_time < poll_time)) + Spending_eventsPS = FALSE; + allow_interrupts(); + return (NO_EVENT); +} + + +/* + * We keep two queues of ports: those that have a pending operation, and + * those whose operation has completed. Periodically, we call select() on + * the pending ports and move any that are ready onto the other queue and + * signal an event. + */ +#define FD_QUIESCENT 0 /* idle */ +#define FD_READY 1 /* I/O ready to be performed */ +#define FD_PENDING 2 /* waiting */ + +typedef struct fd_struct { + int fd, /* file descriptor */ + status; /* one of the FD_* constants */ + bool is_input; /* iff input */ + struct fd_struct *next; /* next on same queue */ +} fd_struct; + + +/* + * A queue of fd_structs is empty iff the first field is NULL. In + * that case, lastp points to first. + */ +typedef struct fdque { + fd_struct *first, + **lastp; +} fdque; + + +static fd_struct *fds[FD_SETSIZE]; +static fdque ready = { + NULL, + &ready.first + }, + pending = { + NULL, + &pending.first + }; + + +static void findrm(fd_struct *entry, fdque *que); +static fd_struct *rmque(fd_struct **link, fdque *que); +static void addque(fd_struct *entry, fdque *que); +static fd_struct *add_fd(int fd, bool is_input); + + +/* + * Find a fd_struct in a queue, and remove it. + */ +static void +findrm(fd_struct *entry, fdque *que) +{ + fd_struct **fp, + *f; + + for (fp = &que->first; (f = *fp) != entry; fp = &f->next) + if (f == NULL) { + fprintf(stderr, "ERROR: findrm fd %d, status %d not on queue.\n", + entry->fd, entry->status); + return; + } + rmque(fp, que); +} + + +/* + * Given a pointer to the link of a fd_struct, and a pointer to + * the queue it is on, remove the entry from the queue. + * The entry removed is returned. + */ +static fd_struct * +rmque(fd_struct **link, fdque *que) +{ + fd_struct *res; + + res = *link; + *link = res->next; + if (res->next == NULL) + que->lastp = link; + return (res); +} + + +/* + * Add a fd_struct to a queue. + */ +static void +addque(fd_struct *entry, fdque *que) +{ + *que->lastp = entry; + entry->next = NULL; + que->lastp = &entry->next; +} + + +static bool +there_are_ready_ports(void) +{ + return (ready.first != NULL); +} + + +static int +next_ready_port(void) +{ + fd_struct *p; + + p = rmque(&ready.first, &ready); + p->status = FD_QUIESCENT; + return (p->fd); +} + + +/* + * Put fd on to the queue of ports with pending operations. + * Return TRUE if successful, and FALSE otherwise. + */ +bool +add_pending_fd(int fd, bool is_input) +{ + fd_struct *data; + + if (! (0 <= fd && fd < FD_SETSIZE)) { + fprintf(stderr, "ERROR: add_pending fd %d not in [0, %d)\n", + fd, + FD_SETSIZE); + return (FALSE); + } + data = fds[fd]; + if (data == NULL) { + data = add_fd(fd, is_input); + if (data == NULL) + return (FALSE); /* no more memory */ + } else if (data->status == FD_PENDING) + return (TRUE); /* fd is already pending */ + else if (data->status == FD_READY) + findrm(data, &ready); + data->status = FD_PENDING; + addque(data, &pending); + if (poll_time == -1) + poll_time = current_time + poll_interval; + return TRUE; +} + + +/* + * Add a new fd_struct for fd. + */ +static fd_struct * +add_fd(int fd, bool is_input) +{ + struct fd_struct *new; + + new = (struct fd_struct *)malloc(sizeof(*new)); + if (new != NULL) { + new->fd = fd; + new->status = FD_QUIESCENT; + new->is_input = is_input; + new->next = NULL; + fds[fd] = new; + } + return (new); +} + + +/* + * Remove fd from any queues it is on. Returns true if the FD was on a queue + * and false if it wasn't. + */ +bool +remove_fd(int fd) +{ + struct fd_struct *data; + + if (! (0 <= fd && fd < FD_SETSIZE)) { + fprintf(stderr, "ERROR: remove_fd fd %d not in [0, %d)\n", + fd, + FD_SETSIZE); + return FALSE; + } + data = fds[fd]; + if (data == NULL) + return FALSE; + if (data->status == FD_PENDING) { + findrm(data, &pending); + if (pending.first == NULL) + poll_time = -1; + } else if (data->status == FD_READY) + findrm(data, &ready); + free((void *)data); + fds[fd] = NULL; + return TRUE; +} + + +int +wait_for_event(long max_wait, bool is_minutes) +{ + int status; + long seconds, + ticks; + + /* fprintf(stderr, "[waiting]\n"); */ + + stop_alarm_interrupts(); + ticks = 0; + if (max_wait == -1) + seconds = -1; + else if (is_minutes) + seconds = max_wait * 60; + else { + seconds = max_wait / TICKS_PER_SECOND; + ticks = max_wait % TICKS_PER_SECOND; + } + if (keyboard_interrupt_count > 0) + status = NO_ERRORS; + else { + status = queue_ready_ports(TRUE, seconds, ticks); + if (there_are_ready_ports()) + NOTE_EVENT; + } + start_alarm_interrupts(); + return (status); +} + + +/* + * Call select() on the pending ports and move any ready ones to the ready + * queue. If wait is true, seconds is either -1 (wait forever) or the + * maximum number of seconds to wait (with ticks any additional ticks). + * The returned value is a status code. + */ +static int +queue_ready_ports(bool wait, long seconds, long ticks) +{ + fd_set reads, + writes, + alls; + int limfd; + fd_struct *fdp, + **fdpp; + struct timeval tv, + *tvp; + int left; + + if ((! wait) + && (pending.first == NULL)) + return (NO_ERRORS); + FD_ZERO(&reads); + FD_ZERO(&writes); + FD_ZERO(&alls); + limfd = 0; + for (fdp = pending.first; fdp != NULL; fdp = fdp->next) { + FD_SET(fdp->fd, fdp->is_input ? &reads : &writes); + FD_SET(fdp->fd, &alls); + if (limfd <= fdp->fd) + limfd = fdp->fd + 1; + } + tvp = &tv; + if (wait) + if (seconds == -1) + tvp = NULL; + else { + tv.tv_sec = seconds; + tv.tv_usec = ticks * (1000000 / TICKS_PER_SECOND); + } + else + timerclear(&tv); + left = select(limfd, &reads, &writes, &alls, tvp); + if (left <= 0) + return (left == 0 ? NO_ERRORS : errno); + fdpp = &pending.first; + while (left > 0 && (fdp = *fdpp) != NULL) + if ((FD_ISSET(fdp->fd, &alls)) + || (FD_ISSET(fdp->fd, fdp->is_input ? &reads : &writes))) { + --left; + rmque(fdpp, &pending); + fdp->status = FD_READY; + addque(fdp, &ready); + } else + fdpp = &fdp->next; + if (pending.first == NULL) + poll_time = -1; + return (NO_ERRORS); +} diff --git a/c/unix/fd-io.c b/c/unix/fd-io.c new file mode 100644 index 0000000..ca3235a --- /dev/null +++ b/c/unix/fd-io.c @@ -0,0 +1,175 @@ +#include +#include +#include +#include +#include +#include /* for errno, (POSIX?/ANSI) */ +#include "sysdep.h" +#include "scheme48vm.h" + + +/* Non-blocking I/O on file descriptors. + + There appear to be two ways to get non-blocking input and output. One + is to open files with the O_NONBLOCK flag (and to use fcntl() to do the + same to stdin and stdout), the other is to call select() on each file + descriptor before doing the I/O operation. O_NONBLOCK has the problem + of being a property of the file descriptor, and its use with stdin and + stdout can lead to horrible results. + + We use a mixture of both. For input files we call select() before doing + a read(), because read() will return immediately if there are any bytes + available at all, and using O_NONBLOCK on stdin is a very bad idea. + Output files are opened using O_NONBLOCK and stdout is left alone. + +*/ + +int +ps_open_fd(char *filename, bool is_input, long *status) +{ +#define FILE_NAME_SIZE 1024 +#define PERMISSION 0666 /* read and write for everyone */ + + char filename_temp[FILE_NAME_SIZE]; + char *expanded; + extern char *expand_file_name(char *, char *, int); + + int flags; + mode_t mode; + + expanded = expand_file_name(filename, filename_temp, FILE_NAME_SIZE); + if (expanded == NULL) + return -1; + + if (is_input) { + flags = O_RDONLY; + mode = 0; } + else { + flags = O_WRONLY | O_CREAT | O_TRUNC | O_NONBLOCK; + mode = PERMISSION; } + + /* keep trying if interrupted */ + while(TRUE) { + int fd = open(expanded, flags, mode); + if (fd != -1) { + *status = NO_ERRORS; + return fd; } + else if (errno != EINTR) { + *status = errno; + return -1; } + } +} + +int +ps_close_fd(long fd_as_long) +{ + int fd = (int)fd_as_long; + + /* keep retrying if interrupted */ + while(TRUE) { + int status = close(fd); + if (status != -1) { + remove_fd(fd); + return NO_ERRORS; } + else if (errno != EINTR) + return errno; + } +} + +long +ps_read_fd(long fd_as_long, char *buffer, long max, bool waitp, + bool *eofp, bool *pending, long *status) +{ + int got, ready; + void *buf = (void *)buffer; + int fd = (int)fd_as_long; + + struct timeval timeout; + fd_set readfds; + + FD_ZERO(&readfds); + FD_SET(fd, &readfds); + timerclear(&timeout); + + /* for the normal return */ + *eofp = FALSE; + *pending = FALSE; + *status = NO_ERRORS; + + while(TRUE) { + ready = select(fd + 1, &readfds, NULL, &readfds, &timeout); + if (ready == 0) { + if (!waitp) + return 0; + else if (add_pending_fd(fd, TRUE)) { + *pending = TRUE; + return 0; } + else { + *status = ENOMEM; /* as close as POSIX gets */ + return 0; }} + else if (ready == -1) { + if (errno != EINTR) { + *status = errno; + return 0; } } + else { /* characters waiting */ + + got = read(fd, buf, max); + + if (got > 0) { /* all is well */ + return got; } + else if (got == 0) { /* end of file */ + *eofp = TRUE; + return 0; } + else if (errno == EINTR) { /* HCC */ + return 0; } + else if (errno == EAGAIN) { /* HCC */ + if (!waitp) + return 0; + else if (add_pending_fd(fd, TRUE)) { + *pending = TRUE; + return 0; } + else { + *status = ENOMEM; /* as close as POSIX gets */ + return 0; } } + else { + *status = errno; + return 0; } } } +} + +long +ps_write_fd(long fd_as_long, char *buffer, long max, bool *pending, long *status) +{ + int sent; + int fd = (int)fd_as_long; + void *buf = (void *)buffer; + + *pending = FALSE; + *status = NO_ERRORS; + + sent = write(fd, buf, max); + if (sent > 0) + {} + else if (errno == EINTR || errno == EAGAIN) { /* HCC */ + if (add_pending_fd(fd, FALSE)) + *pending = TRUE; + else + *status = ENOMEM; /* as close as POSIX gets */ + sent = 0; } + else { + *status = errno; + sent = 0; } + + return sent; +} + +long +ps_abort_fd_op(long fd_as_long) +{ + int fd = (int)fd_as_long; + + if (!remove_fd(fd)) + fprintf(stderr, "Error: ps_abort_fd_op, no pending operation on fd %d\n", + fd); + return 0; /* because we do not actually do any I/O in parallel the + status is always zero: no characters transfered. */ +} diff --git a/c/unix/io.c b/c/unix/io.c new file mode 100644 index 0000000..512313a --- /dev/null +++ b/c/unix/io.c @@ -0,0 +1,294 @@ +#include +#include +#include +#include +#include +#include "io.h" + +#define TRUE (0 == 0) +#define FALSE (! TRUE) +#define bool char + +#define NO_ERRORS 0 /* errno value */ + +/* read a character while ignoring interrupts */ + +#define READ_CHAR(PORT,RESULT) \ +{ \ + FILE * TTport = PORT; \ + int TTchar; \ + if (EOF == (TTchar = getc(TTport))) \ + RESULT = read_char(TTport); \ + else \ + RESULT = TTchar; \ +} + +/* +Helper procedure for the READ_CHAR macro. If the getc was interrupted +we clear the error bit and try again. +*/ + +int +read_char(FILE *port) +{ + int result; + + while(TRUE) { + if (ferror(port) && errno == EINTR) { + clearerr(port); + result = getc(port); + if (EOF != result) + return result; } + else + return EOF; } +} + +/* called when getc(port) returned EOF */ + +char +ps_read_char(FILE *port, bool *eofp, long *status, bool peekp) +{ + bool errorp; + int result; + + result = read_char(port); /* read past any interruptions */ + if (result != EOF) { + if (peekp) + ungetc(result, port); + *eofp = FALSE; + *status = NO_ERRORS; + return result; } + else { + errorp = ferror(port); + clearerr(port); + if (errorp) { + *eofp = FALSE; + *status = errno; + return 0; } + else { + *eofp = TRUE; + *status = NO_ERRORS; + return 0; } } +} + +long +ps_read_integer(FILE *port, bool *eofp, long *status) +{ + long result; + int ch; + bool negate; + bool errorp; + + /* eat whitespace */ + do { READ_CHAR(port, ch); } + while (ch == ' ' || ch == '\t' || ch == '\n'); + + /* read optional sign */ + if (ch == '-') { + negate = TRUE; + READ_CHAR(port, ch); } + else + negate = FALSE; + + if (ch < '0' || '9' < ch) { + if (ch != EOF) { + *eofp = FALSE; + *status = EINVAL; } /* has to be something */ + else { + errorp = ferror(port); + clearerr(port); + if (errorp) { + *eofp = FALSE; + *status = errno; } + else { + *eofp = TRUE; + *status = 0; } } + result = 0; } + else { + result = ch - '0'; + while(1) { + READ_CHAR(port, ch); + if (ch < '0' || '9' < ch) + break; + result = (10 * result) + (ch - '0'); } + if (ch != EOF) + ungetc(ch, port); + *eofp = FALSE; + *status = 0; } + return (negate ? -result : result); +} + +/* write a character regardless of interrupts */ + +#define WRITE_CHAR(CH,PORT,RESULT) \ +{ \ + char TTch = CH; \ + FILE * TTport = PORT; \ + if (putc(TTch, TTport) != EOF) \ + RESULT = 0; \ + else \ + RESULT = ps_write_char(TTch, TTport); \ +} + +/* called when putc(char, port) returned EOF */ + +long +ps_write_char(char ch, FILE *port) +{ + + while(TRUE) { + clearerr(port); + if (errno != EINTR) + return errno; + else if (putc(ch, port) != EOF) + return 0; } +} + +long +ps_write_integer(long n, FILE *port) +{ + int status; + + long write_integer(unsigned long n, FILE *port); + + if (n == 0) { + WRITE_CHAR('0', port, status); + return status; } + else if (n > 0) + return write_integer(n, port); + else { + WRITE_CHAR('-', port, status); + if (status == 0) + return write_integer(- n, port); + else + return status; } +} + +long +write_integer(unsigned long n, FILE *port) +{ + char ch; + long status; + + if (n == 0) + status = 0; + else { + status = write_integer(n / 10, port); + if (status == 0) { + ch = (n % 10) + '0'; + WRITE_CHAR(ch, port,status); } } + return status; +} + +long +ps_write_string(char *string, FILE *port) +{ + while (TRUE) { + if (EOF != fputs(string, port)) + return (0); + clearerr(port); + if (errno != EINTR) + return (errno); + } +} + +long +ps_read_block(FILE *port, char *buffer, long count, bool *eofp, long *status) +{ + int got = 0; + bool errorp; + + while(TRUE) { + got += fread(buffer, sizeof(char), count - got, port); + if (got == count) { + *eofp = FALSE; + *status = NO_ERRORS; + return got;} + else if (ferror(port) && errno == EINTR) + clearerr(port); + else { + *eofp = feof(port); + errorp = ferror(port); + clearerr(port); + if (errorp) + *status = errno; + else + *status = NO_ERRORS; + return got;} }; +} + +long +ps_write_block(FILE *port, char *buffer, long count) +{ + int sent = 0; + + while(TRUE) { + sent += fwrite(buffer, sizeof(char), count - sent, port); + if (sent == count) + return NO_ERRORS; + else if (ferror(port) && errno == EINTR) + clearerr(port); + else { + clearerr(port); + return errno; } } +} + +void +ps_error(char *message, long count, ...) +{ + va_list ap; + + va_start(ap, count); + fputs(message, stderr); + for(; count > 0; --count) + fprintf(stderr, " %ld", va_arg(ap, long)); + putc('\n', stderr); + exit(-1); +} + +static FILE * +ps_really_open_file(char *filename, long *status, char *mode) +{ +#define FILE_NAME_SIZE 1024 + + char filename_temp[FILE_NAME_SIZE]; + char *expanded; + extern char *expand_file_name(char *, char *, int); + + FILE *new; + + expanded = expand_file_name(filename, filename_temp, FILE_NAME_SIZE); + if (expanded == NULL) { + *status = EDOM; /* has to be something */ + return NULL; } + + new = fopen(expanded, mode); + + if (new == NULL) { + *status = errno; + return NULL; } + + *status = NO_ERRORS; + return new; +} + +FILE * +ps_open_input_file(char *name, long *status) +{ + return ps_really_open_file(name, status, "r"); +} + +FILE * +ps_open_output_file(char *name, long *status) +{ + return ps_really_open_file(name, status, "w"); +} + +long +ps_close(FILE *stream) +{ + if (0 == fclose(stream)) + return 0; + else + return errno; +} diff --git a/c/unix/misc.c b/c/unix/misc.c new file mode 100644 index 0000000..4c6bde4 --- /dev/null +++ b/c/unix/misc.c @@ -0,0 +1,126 @@ +#include +#include /* for getenv(), etc. (POSIX?/ANSI) */ +#include /* for strncpy(), etc. (POSIX/ANSI) */ +#include /* for getpwnam() (POSIX.1) */ +#include /* for sysconf(), etc. (POSIX.1/.2)*/ +#include +#include "sysdep.h" + + +#define TRUE (0 == 0) +#define FALSE (0 == 1) + +/* + Expanding Unix filenames + Unix Sucks + Richard Kelsey Wed Jan 17 21:40:26 EST 1990 + Later modified by others who wish to remain anonymous + + Expands initial ~ and ~/ in string `name', leaving the result in `buffer'. + `buffer_len' is the length of `buffer'. + + Note: strncpy(x, y, n) copies from y to x. +*/ + +char *expand_file_name (name, buffer, buffer_len) + char *name, *buffer; + int buffer_len; +{ +#define USER_NAME_SIZE 256 + char *dir, *p, user_name[USER_NAME_SIZE]; + struct passwd *user_data; + int dir_len, i; + extern char *getenv(); + int name_len = strlen(name); + + dir = 0; + + if (name[0] == '~') { + name++; name_len--; + + if (name[0] == '/' || name[0] == 0) { + dir = getenv("HOME"); } + + else { + for (i = 0, p = name; i < name_len && *p != '/'; i++, p++) + if (i > (USER_NAME_SIZE - 2)) { + fprintf(stderr, + "\nexpand_file_name: user name longer than %d characters\n", + USER_NAME_SIZE - 3); + return(NULL); }; + strncpy(user_name, name, i); + user_name[i] = 0; + user_data = getpwnam(user_name); + if (!user_data) { + fprintf(stderr, "\nexpand_file_name: unknown user \"%s\"\n", + user_name); + return(NULL); }; + name_len -= i; + name = p; + dir = user_data->pw_dir; } } + + else if (name[0] == '$') { + name++; name_len--; + + for (i = 0, p = name; i < name_len && *p != '/'; i++, p++) + if (i > (USER_NAME_SIZE - 2)) { + fprintf(stderr, + "\nexpand_file_name: environment variable longer than %d characters\n", + USER_NAME_SIZE - 3); + return(NULL); }; + strncpy(user_name, name, i); + user_name[i] = 0; + + name_len -= i; + name = p; + dir = getenv(user_name); } + + if (dir) { + dir_len = strlen(dir); + if ((name_len + dir_len + 1) > buffer_len) { + fprintf(stderr, "\nexpand_file_name: supplied buffer is too small\n"); + return(NULL); }; + strncpy(buffer, dir, dir_len); + strncpy(buffer + dir_len, name, name_len); + buffer[name_len + dir_len] = 0; } + + else { + if ((name_len + 1) > buffer_len) { + fprintf(stderr, "\nexpand_file_name: supplied buffer is too small\n"); + return(NULL); }; + strncpy(buffer, name, name_len); + buffer[name_len] = 0; } + + return(buffer); +} + +/* test routine +main(argc, argv) + int argc; + char *argv[]; +{ + char buffer[32]; + expand_file_name(argv[1], buffer, 32); + printf("%s\n", buffer); + return(0); +} +*/ + + +/* Driver loop for tail-recursive calls */ + +long TTreturn_value; + +long +TTrun_machine(long (*proc) (void)) +{ + while (proc != 0) + proc = (long (*) (void)) (*proc)(); + return TTreturn_value; +} + +unsigned char * +ps_error_string(long errno) +{ + return((unsigned char *)strerror(errno)); +} diff --git a/c/unix/socket.c b/c/unix/socket.c new file mode 100644 index 0000000..9abdb57 --- /dev/null +++ b/c/unix/socket.c @@ -0,0 +1,178 @@ +/* + * Socket support for Scheme 48. Note, the division of labor is rather + * silly. Given that socket_connect() creates it's own socket, there is + * no reason for socket_bind() to not do the same (and to eliminate + * internet_stream_socket()). The interface to extension() is a little + * easier this way, because it never has to return two values. + * This code was written by a loyal member of the state. As such, I of + * course ask nothing in return. From each according to their ability, + * to each according to their need. I have what I need. + * I don't need a copyright. + */ +#include "sysdep.h" + +#if defined(HAVE_SOCKET) + +#include +#include +#include +#include +#include +#include +#include +#include /* Kali only: for TCP_NODELAY */ +#include +#include +#include +#include +#include +#include +#include +#include +#include "socket.h" +#include "scheme48vm.h" + + +#define LISTENQ 5 + + +/* + * Create an internet-domain stream (reliable, sequenced) socket. + * We return the socket (a small non-negative integer) on success + * or a negative integer on failure. + * Note, the socket has been made non-blocking. + */ +int +internet_stream_socket(void) +{ + int res; + + res = socket(AF_INET, SOCK_STREAM, 0); + if (res < 0) + return (res); + fcntl(res, F_SETFL, O_NONBLOCK); + return (res); +} + + +/* + * Given an internet-domain stream socket and a port number, bind + * the socket to the port and prepare to receive connections. If + * the port number is 0 then we bind the socket to any available + * port. If all goes well, we return the port number we are bound + * to. It not, we return -1. + */ +int +socket_bind(int sock, int port) +{ + struct sockaddr_in addr; + int len; + + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = htonl(INADDR_ANY); + addr.sin_port = htons(port); + if ((bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) + || (listen(sock, LISTENQ) < 0)) + return (-1); + if (port == 0) { + len = sizeof(addr); + if ((getsockname(sock, (struct sockaddr *)&addr, &len) < 0) + || (addr.sin_family != AF_INET)) + return (-1); + port = htons(addr.sin_port); + } + return (port); +} + + +/* + * Given an internet-domain stream socket which has been bound (via + * socket_bind), accept a connection and return the resulting socket + * (a small, non-negative integer). + * If this fails because the client hasn't connected yet, then we add + * the socket to the pending queue and return -2. If it fails for some + * other reason, then we return -1. + * Note, if all goes well, the socket returned has been made non-blocking. + */ +int +socket_accept(int sock) +{ + int len, + res; + struct sockaddr_in addr; + + len = sizeof(addr); + res = accept(sock, (struct sockaddr *)&addr, &len); + if (res >= 0) { + fcntl(res, F_SETFL, O_NONBLOCK); + return (res); + } + if ((errno == EWOULDBLOCK || errno == EINTR || errno == EAGAIN) + && (add_pending_fd(sock, TRUE))) + return (-2); + return (-1); +} + + +/* + * Given an internet-domain stream socket, a machine name and a port number, + * connect the socket to that machine/port. If the machine name is the empty + * string, use the local machine. + * If this succeeds return a small non-negative integer. + * If it fails because the connect would block, add the socket to the pending + * queue (for output) and return -2. If it fails for some other reason, + * return -1. + */ +int +socket_connect(int sock, char *mach, int port) +{ + char mbuff[MAXHOSTNAMELEN]; + struct hostent *hp; + struct sockaddr_in addr; + + if (*mach == '\0') { + if (gethostname(mbuff, sizeof(mbuff)) < 0) + return (-1); + mach = mbuff; + } + hp = gethostbyname(mach); + if (hp == NULL) + return (-1); + memset((void *)&addr, 0, sizeof(addr)); + addr.sin_family = hp->h_addrtype; + if (hp->h_length > sizeof(addr.sin_addr)) + return (-1); + memcpy((void *)&addr.sin_addr, (void *)hp->h_addr, hp->h_length); + addr.sin_port = htons(port); + if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) >= 0) + return (sock); + if (errno == EISCONN) /* somewhat questionable */ + return (sock); + if ((errno == EWOULDBLOCK + || errno == EINTR + || errno == EINPROGRESS + || errno == EALREADY + || errno == EAGAIN) + && (add_pending_fd(sock, FALSE))) + return (-2); + return (-1); +} + + +/* + * Given a TCP/IP socket, set it's TCP_NODELAY mode according to our + * argument. We return TRUE if all is ok, and otherwise FALSE. + * Note, this procedure only exists in Kali. + */ +int +socket_nodelay(int sock, int nodelay) +{ + int stat; + + nodelay = nodelay != 0; /* just to be safe */ + stat = setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &nodelay, + sizeof(nodelay)); + return (stat == 0); +} + +#endif /* HAVE_SOCKET */ diff --git a/configure b/configure new file mode 100755 index 0000000..be73f2e --- /dev/null +++ b/configure @@ -0,0 +1,1925 @@ +#! /bin/sh + +# Guess values for system-dependent variables and create Makefiles. +# Generated automatically using autoconf version 2.10 +# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc. +# +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. + +# Defaults: +ac_help= +ac_default_prefix=/usr/local +# Any additions from configure.in: + +# Initialize some variables set by options. +# The variables have the same names as the options, with +# dashes changed to underlines. +build=NONE +cache_file=./config.cache +exec_prefix=NONE +host=NONE +no_create= +nonopt=NONE +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +target=NONE +verbose= +x_includes=NONE +x_libraries=NONE +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datadir='${prefix}/share' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +libdir='${exec_prefix}/lib' +includedir='${prefix}/include' +oldincludedir='/usr/include' +infodir='${prefix}/info' +mandir='${prefix}/man' + +# Initialize some other variables. +subdirs= +MFLAGS= MAKEFLAGS= + +ac_prev= +for ac_option +do + + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval "$ac_prev=\$ac_option" + ac_prev= + continue + fi + + case "$ac_option" in + -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) ac_optarg= ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case "$ac_option" in + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir="$ac_optarg" ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build="$ac_optarg" ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file="$ac_optarg" ;; + + -datadir | --datadir | --datadi | --datad | --data | --dat | --da) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ + | --da=*) + datadir="$ac_optarg" ;; + + -disable-* | --disable-*) + ac_feature=`echo $ac_option|sed -e 's/-*disable-//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then + { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; } + fi + ac_feature=`echo $ac_feature| sed 's/-/_/g'` + eval "enable_${ac_feature}=no" ;; + + -enable-* | --enable-*) + ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then + { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; } + fi + ac_feature=`echo $ac_feature| sed 's/-/_/g'` + case "$ac_option" in + *=*) ;; + *) ac_optarg=yes ;; + esac + eval "enable_${ac_feature}='$ac_optarg'" ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix="$ac_optarg" ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he) + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat << EOF +Usage: configure [options] [host] +Options: [defaults in brackets after descriptions] +Configuration: + --cache-file=FILE cache test results in FILE + --help print this message + --no-create do not create output files + --quiet, --silent do not print \`checking...' messages + --version print the version of autoconf that created configure +Directory and file names: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [same as prefix] + --bindir=DIR user executables in DIR [EPREFIX/bin] + --sbindir=DIR system admin executables in DIR [EPREFIX/sbin] + --libexecdir=DIR program executables in DIR [EPREFIX/libexec] + --datadir=DIR read-only architecture-independent data in DIR + [PREFIX/share] + --sysconfdir=DIR read-only single-machine data in DIR [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data in DIR + [PREFIX/com] + --localstatedir=DIR modifiable single-machine data in DIR [PREFIX/var] + --libdir=DIR object code libraries in DIR [EPREFIX/lib] + --includedir=DIR C header files in DIR [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc in DIR [/usr/include] + --infodir=DIR info documentation in DIR [PREFIX/info] + --mandir=DIR man documentation in DIR [PREFIX/man] + --srcdir=DIR find the sources in DIR [configure dir or ..] + --program-prefix=PREFIX prepend PREFIX to installed program names + --program-suffix=SUFFIX append SUFFIX to installed program names + --program-transform-name=PROGRAM + run sed PROGRAM on installed program names +EOF + cat << EOF +Host type: + --build=BUILD configure for building on BUILD [BUILD=HOST] + --host=HOST configure for HOST [guessed] + --target=TARGET configure for TARGET [TARGET=HOST] +Features and packages: + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --x-includes=DIR X include files are in DIR + --x-libraries=DIR X library files are in DIR +EOF + if test -n "$ac_help"; then + echo "--enable and --with options recognized:$ac_help" + fi + exit 0 ;; + + -host | --host | --hos | --ho) + ac_prev=host ;; + -host=* | --host=* | --hos=* | --ho=*) + host="$ac_optarg" ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir="$ac_optarg" ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir="$ac_optarg" ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir="$ac_optarg" ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir="$ac_optarg" ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst \ + | --locals | --local | --loca | --loc | --lo) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* \ + | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) + localstatedir="$ac_optarg" ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir="$ac_optarg" ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir="$ac_optarg" ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix="$ac_optarg" ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix="$ac_optarg" ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix="$ac_optarg" ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name="$ac_optarg" ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir="$ac_optarg" ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir="$ac_optarg" ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site="$ac_optarg" ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir="$ac_optarg" ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir="$ac_optarg" ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target="$ac_optarg" ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers) + echo "configure generated by autoconf version 2.10" + exit 0 ;; + + -with-* | --with-*) + ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then + { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; } + fi + ac_package=`echo $ac_package| sed 's/-/_/g'` + case "$ac_option" in + *=*) ;; + *) ac_optarg=yes ;; + esac + eval "with_${ac_package}='$ac_optarg'" ;; + + -without-* | --without-*) + ac_package=`echo $ac_option|sed -e 's/-*without-//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then + { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; } + fi + ac_package=`echo $ac_package| sed 's/-/_/g'` + eval "with_${ac_package}=no" ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes="$ac_optarg" ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries="$ac_optarg" ;; + + -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; } + ;; + + *) + if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then + echo "configure: warning: $ac_option: invalid host type" 1>&2 + fi + if test "x$nonopt" != xNONE; then + { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } + fi + nonopt="$ac_option" + ;; + + esac +done + +if test -n "$ac_prev"; then + { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; } +fi + +trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 + +# File descriptor usage: +# 0 standard input +# 1 file creation +# 2 errors and warnings +# 3 some systems may open it to /dev/tty +# 4 used on the Kubota Titan +# 6 checking for... messages and results +# 5 compiler messages saved in config.log +if test "$silent" = yes; then + exec 6>/dev/null +else + exec 6>&1 +fi +exec 5>./config.log + +echo "\ +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. +" 1>&5 + +# Strip out --no-create and --no-recursion so they do not pile up. +# Also quote any args containing shell metacharacters. +ac_configure_args= +for ac_arg +do + case "$ac_arg" in + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c) ;; + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;; + *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*) + ac_configure_args="$ac_configure_args '$ac_arg'" ;; + *) ac_configure_args="$ac_configure_args $ac_arg" ;; + esac +done + +# NLS nuisances. +# Only set LANG and LC_ALL to C if already set. +# These must not be set unconditionally because not all systems understand +# e.g. LANG=C (notably SCO). +if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi +if test "${LANG+set}" = set; then LANG=C; export LANG; fi + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -rf conftest* confdefs.h +# AIX cpp loses on an empty file, so make sure it contains at least a newline. +echo > confdefs.h + +# A filename unique to this package, relative to the directory that +# configure is in, which we can look for to find out if srcdir is correct. +ac_unique_file=c/scheme48vm.c + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then its parent. + ac_prog=$0 + ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'` + test "x$ac_confdir" = "x$ac_prog" && ac_confdir=. + srcdir=$ac_confdir + if test ! -r $srcdir/$ac_unique_file; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r $srcdir/$ac_unique_file; then + if test "$ac_srcdir_defaulted" = yes; then + { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; } + else + { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; } + fi +fi +srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'` + +# Prefer explicitly selected file to automatically selected ones. +if test -z "$CONFIG_SITE"; then + if test "x$prefix" != xNONE; then + CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" + else + CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" + fi +fi +for ac_site_file in $CONFIG_SITE; do + if test -r "$ac_site_file"; then + echo "loading site script $ac_site_file" + . "$ac_site_file" + fi +done + +if test -r "$cache_file"; then + echo "loading cache $cache_file" + . $cache_file +else + echo "creating cache $cache_file" + > $cache_file +fi + +ac_ext=c +# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. +ac_cpp='$CPP $CPPFLAGS' +ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5' +ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5' + +if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then + # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu. + if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then + ac_n= ac_c=' +' ac_t=' ' + else + ac_n=-n ac_c= ac_t= + fi +else + ac_n= ac_c='\c' ac_t= +fi + + + + oldCFLAGS="$CFLAGS" + # Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" + for ac_dir in $PATH; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_CC="gcc" + break + fi + done + IFS="$ac_save_ifs" +fi +fi +CC="$ac_cv_prog_CC" +if test -n "$CC"; then + echo "$ac_t""$CC" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" + ac_prog_rejected=no + for ac_dir in $PATH; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + break + fi + done + IFS="$ac_save_ifs" +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# -gt 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + set dummy "$ac_dir/$ac_word" "$@" + shift + ac_cv_prog_CC="$@" + fi +fi +fi +fi +CC="$ac_cv_prog_CC" +if test -n "$CC"; then + echo "$ac_t""$CC" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + + test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; } +fi + +echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.c <&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then + ac_cv_prog_gcc=yes +else + ac_cv_prog_gcc=no +fi +fi + +echo "$ac_t""$ac_cv_prog_gcc" 1>&6 +if test $ac_cv_prog_gcc = yes; then + GCC=yes + if test "${CFLAGS+set}" != set; then + echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_prog_gcc_g'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + echo 'void f(){}' > conftest.c +if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then + ac_cv_prog_gcc_g=yes +else + ac_cv_prog_gcc_g=no +fi +rm -f conftest* + +fi + +echo "$ac_t""$ac_cv_prog_gcc_g" 1>&6 + if test $ac_cv_prog_gcc_g = yes; then + CFLAGS="-g -O" + else + CFLAGS="-O" + fi + fi +else + GCC= + test "${CFLAGS+set}" = set || CFLAGS="-g" +fi + + if test "z$oldCFLAGS" = z; then + if test "z$GCC" = z; then + CFLAGS='-O' + else + CFLAGS='-O2' + fi + fi + + echo $ac_n "checking for POSIXized ISC""... $ac_c" 1>&6 +if test -d /etc/conf/kconfig.d && + grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1 +then + echo "$ac_t""yes" 1>&6 + ISC=yes # If later tests want to check for ISC. + cat >> confdefs.h <<\EOF +#define _POSIX_SOURCE 1 +EOF + + if test "$GCC" = yes; then + CC="$CC -posix" + else + CC="$CC -Xp" + fi +else + echo "$ac_t""no" 1>&6 + ISC= +fi + + # If we cannot run a trivial program, we must be cross compiling. +echo $ac_n "checking whether cross-compiling""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_c_cross'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test "$cross_compiling" = yes; then + ac_cv_c_cross=yes +else +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } +if test -s conftest && (./conftest; exit) 2>/dev/null; then + ac_cv_c_cross=no +else + ac_cv_c_cross=yes +fi +fi +rm -fr conftest* +fi + +echo "$ac_t""$ac_cv_c_cross" 1>&6 +cross_compiling=$ac_cv_c_cross + +if test "$cross_compiling" = yes; then + true +else +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } +if test -s conftest && (./conftest; exit) 2>/dev/null; then + : +fi +fi +rm -fr conftest* + if test "z$GCC" = z; then + echo $ac_n "checking -cckr""... $ac_c" 1>&6 + oldCFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -cckr" + if test "$cross_compiling" = yes; then + echo "$ac_t""no" 1>&6 + CFLAGS="$oldCFLAGS" +else +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } +if test -s conftest && (./conftest; exit) 2>/dev/null; then + echo "$ac_t""yes" 1>&6 +else + echo "$ac_t""no" 1>&6 + CFLAGS="$oldCFLAGS" +fi +fi +rm -fr conftest* + fi + + ac_aux_dir= +for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do + if test -f $ac_dir/install-sh; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f $ac_dir/install.sh; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + fi +done +if test -z "$ac_aux_dir"; then + { echo "configure: error: can not find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." 1>&2; exit 1; } +fi +ac_config_guess=$ac_aux_dir/config.guess +ac_config_sub=$ac_aux_dir/config.sub +ac_configure=$ac_aux_dir/configure # This should be Cygnus configure. + +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# ./install, which can be erroneously created by make from ./install.sh. +echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6 +if test -z "$INSTALL"; then +if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" + for ac_dir in $PATH; do + # Account for people who put trailing slashes in PATH elements. + case "$ac_dir/" in + /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + for ac_prog in ginstall installbsd scoinst install; do + if test -f $ac_dir/$ac_prog; then + if test $ac_prog = install && + grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + # OSF/1 installbsd also uses dspmsg, but is usable. + : + else + ac_cv_path_install="$ac_dir/$ac_prog -c" + break 2 + fi + fi + done + ;; + esac + done + IFS="$ac_save_ifs" + +fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL="$ac_cv_path_install" + else + # As a last resort, use the slow shell script. We don't cache a + # path for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the path is relative. + INSTALL="$ac_install_sh" + fi +fi +echo "$ac_t""$INSTALL" 1>&6 + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + + echo $ac_n "checking for -lm""... $ac_c" 1>&6 +ac_lib_var=`echo m'_'main | tr './+\055' '__p_'` +if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + ac_save_LIBS="$LIBS" +LIBS="-lm $LIBS" +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=yes" +else + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=no" +fi +rm -f conftest* +LIBS="$ac_save_LIBS" + +fi +if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_lib=HAVE_LIB`echo m | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi + + echo $ac_n "checking for -ldl""... $ac_c" 1>&6 +ac_lib_var=`echo dl'_'main | tr './+\055' '__p_'` +if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + ac_save_LIBS="$LIBS" +LIBS="-ldl $LIBS" +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=yes" +else + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=no" +fi +rm -f conftest* +LIBS="$ac_save_LIBS" + +fi +if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_lib=HAVE_LIB`echo dl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi + + echo $ac_n "checking for -lmld""... $ac_c" 1>&6 +ac_lib_var=`echo mld'_'main | tr './+\055' '__p_'` +if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + ac_save_LIBS="$LIBS" +LIBS="-lmld $LIBS" +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=yes" +else + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=no" +fi +rm -f conftest* +LIBS="$ac_save_LIBS" + +fi +if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_lib=HAVE_LIB`echo mld | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi + + echo $ac_n "checking for -lnsl""... $ac_c" 1>&6 +ac_lib_var=`echo nsl'_'main | tr './+\055' '__p_'` +if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + ac_save_LIBS="$LIBS" +LIBS="-lnsl $LIBS" +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=yes" +else + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=no" +fi +rm -f conftest* +LIBS="$ac_save_LIBS" + +fi +if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_lib=HAVE_LIB`echo nsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi + + echo $ac_n "checking for -lgen""... $ac_c" 1>&6 +ac_lib_var=`echo gen'_'main | tr './+\055' '__p_'` +if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + ac_save_LIBS="$LIBS" +LIBS="-lgen $LIBS" +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=yes" +else + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=no" +fi +rm -f conftest* +LIBS="$ac_save_LIBS" + +fi +if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_lib=HAVE_LIB`echo gen | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi + + echo $ac_n "checking for -lsocket""... $ac_c" 1>&6 +ac_lib_var=`echo socket'_'main | tr './+\055' '__p_'` +if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + ac_save_LIBS="$LIBS" +LIBS="-lsocket $LIBS" +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=yes" +else + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=no" +fi +rm -f conftest* +LIBS="$ac_save_LIBS" + +fi +if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_lib=HAVE_LIB`echo socket | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi + + echo $ac_n "checking for -lsun""... $ac_c" 1>&6 +ac_lib_var=`echo sun'_'getpwnam | tr './+\055' '__p_'` +if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + ac_save_LIBS="$LIBS" +LIBS="-lsun $LIBS" +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=yes" +else + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=no" +fi +rm -f conftest* +LIBS="$ac_save_LIBS" + +fi +if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_lib=HAVE_LIB`echo sun | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi + + echo $ac_n "checking for -lelf""... $ac_c" 1>&6 +ac_lib_var=`echo elf'_'main | tr './+\055' '__p_'` +if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + ac_save_LIBS="$LIBS" +LIBS="-lelf $LIBS" +cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=yes" +else + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=no" +fi +rm -f conftest* +LIBS="$ac_save_LIBS" + +fi +if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_lib=HAVE_LIB`echo elf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi + + echo checking for RISC/OS POSIX library lossage +if test -f /usr/posix/usr/lib/libc.a; then + LIBS="${LIBS} /usr/posix/usr/lib/libc.a" +fi + + echo $ac_n "checking for working const""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext <j = 5; +} +{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ + const int foo = 10; +} + +; return 0; } +EOF +if { (eval echo configure:1195: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + ac_cv_c_const=yes +else + rm -rf conftest* + ac_cv_c_const=no +fi +rm -f conftest* + +fi + +echo "$ac_t""$ac_cv_c_const" 1>&6 +if test $ac_cv_c_const = no; then + cat >> confdefs.h <<\EOF +#define const +EOF + +fi + + echo $ac_n "checking return type of signal handlers""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_type_signal'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +#include +#ifdef signal +#undef signal +#endif +#ifdef __cplusplus +extern "C" void (*signal (int, void (*)(int)))(int); +#else +void (*signal ()) (); +#endif + +int main() { return 0; } +int t() { +int i; +; return 0; } +EOF +if { (eval echo configure:1237: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + ac_cv_type_signal=void +else + rm -rf conftest* + ac_cv_type_signal=int +fi +rm -f conftest* + +fi + +echo "$ac_t""$ac_cv_type_signal" 1>&6 +cat >> confdefs.h <&6 +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then +if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + # This must be in double quotes, not single quotes, because CPP may get + # substituted into the Makefile and "${CC-cc}" will confuse make. + CPP="${CC-cc} -E" + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. + cat > conftest.$ac_ext < +Syntax Error +EOF +ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +{ (eval echo configure:1275: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } +ac_err=`grep -v '^ *+' conftest.out` +if test -z "$ac_err"; then + : +else + echo "$ac_err" >&5 + rm -rf conftest* + CPP="${CC-cc} -E -traditional-cpp" + cat > conftest.$ac_ext < +Syntax Error +EOF +ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +{ (eval echo configure:1290: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } +ac_err=`grep -v '^ *+' conftest.out` +if test -z "$ac_err"; then + : +else + echo "$ac_err" >&5 + rm -rf conftest* + CPP=/lib/cpp +fi +rm -f conftest* +fi +rm -f conftest* + ac_cv_prog_CPP="$CPP" +fi + CPP="$ac_cv_prog_CPP" +else + ac_cv_prog_CPP="$CPP" +fi +echo "$ac_t""$CPP" 1>&6 + +for ac_hdr in libgen.h sys/timeb.h posix/time.h +do +ac_safe=`echo "$ac_hdr" | tr './\055' '___'` +echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +EOF +ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +{ (eval echo configure:1323: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } +ac_err=`grep -v '^ *+' conftest.out` +if test -z "$ac_err"; then + rm -rf conftest* + eval "ac_cv_header_$ac_safe=yes" +else + echo "$ac_err" >&5 + rm -rf conftest* + eval "ac_cv_header_$ac_safe=no" +fi +rm -f conftest* +fi +if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_hdr=HAVE_`echo $ac_hdr | tr 'abcdefghijklmnopqrstuvwxyz./\055' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ___'` + cat >> confdefs.h <&6 +fi +done + + for ac_hdr in sys/select.h +do +ac_safe=`echo "$ac_hdr" | tr './\055' '___'` +echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +EOF +ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +{ (eval echo configure:1360: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } +ac_err=`grep -v '^ *+' conftest.out` +if test -z "$ac_err"; then + rm -rf conftest* + eval "ac_cv_header_$ac_safe=yes" +else + echo "$ac_err" >&5 + rm -rf conftest* + eval "ac_cv_header_$ac_safe=no" +fi +rm -f conftest* +fi +if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_hdr=HAVE_`echo $ac_hdr | tr 'abcdefghijklmnopqrstuvwxyz./\055' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ___'` + cat >> confdefs.h <&6 +fi +done + + for ac_func in dlopen gettimeofday ftime nlist select setitimer sigaction +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { return 0; } +int t() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:1415: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* + +fi +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + for ac_func in socket chroot +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { return 0; } +int t() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:1468: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* + +fi +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + echo $ac_n "checking for strerror""... $ac_c" 1>&6 +if eval "test \"`echo '$''{'ac_cv_func_strerror'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char strerror(); + +int main() { return 0; } +int t() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_strerror) || defined (__stub___strerror) +choke me +#else +strerror(); +#endif + +; return 0; } +EOF +if { (eval echo configure:1519: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + eval "ac_cv_func_strerror=yes" +else + rm -rf conftest* + eval "ac_cv_func_strerror=no" +fi +rm -f conftest* + +fi +if eval "test \"`echo '$ac_cv_func_'strerror`\" = yes"; then + echo "$ac_t""yes" 1>&6 + cat >> confdefs.h <<\EOF +#define HAVE_STRERROR 1 +EOF + +else + echo "$ac_t""no" 1>&6 +LIBOBJS="$LIBOBJS c/fake/strerror.o" +fi + + echo $ac_n "checking n_name""... $ac_c" 1>&6 + cat > conftest.$ac_ext < +int main() { return 0; } +int t() { +struct nlist name_list; + name_list.n_name = "foo"; +; return 0; } +EOF +if { (eval echo configure:1551: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + cat >> confdefs.h <<\EOF +#define NLIST_HAS_N_NAME 1 +EOF + + echo "$ac_t""yes" 1>&6 +else + rm -rf conftest* + echo "$ac_t""no" 1>&6 +fi +rm -f conftest* + + echo $ac_n "checking __NEXT__""... $ac_c" 1>&6 + cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; }; then + rm -rf conftest* + CC="$CC -posix" + cat >> confdefs.h <<\EOF +#define HAVE_SIGACTION 1 +EOF + + echo "$ac_t""yes" 1>&6 +else + rm -rf conftest* + echo "$ac_t""no" 1>&6 +fi +rm -f conftest* + + echo $ac_n "checking underscore before symbols""... $ac_c" 1>&6 + echo 'main() { return 0; } fnord() {}' >conftest.c + if ${CC} ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c ${LIBS} && + nm a.out | grep _fnord >/dev/null; then + echo "$ac_t""yes" 1>&6 + cat >> confdefs.h <<\EOF +#define USCORE 1 +EOF + + else + echo "$ac_t""no" 1>&6 + fi + rm -f conftest.c a.out + + echo $ac_n "checking link with -rdynamic""... $ac_c" 1>&6 + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + echo "$ac_t""no" 1>&6 +else + rm -rf conftest* + echo "$ac_t""yes" 1>&6 + LDFLAGS="$LDFLAGS -rdynamic" +fi +rm -f conftest* + + + + + +trap '' 1 2 15 +cat > confcache <<\EOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs. It is not useful on other systems. +# If it contains results you don't want to keep, you may remove or edit it. +# +# By default, configure uses ./config.cache as the cache file, +# creating it if it does not exist already. You can give configure +# the --cache-file=FILE option to use a different cache file; that is +# what configure does when it calls configure scripts in +# subdirectories, so they share the cache. +# Giving --cache-file=/dev/null disables caching, for debugging configure. +# config.status only pays attention to the cache file if you give it the +# --recheck option to rerun configure. +# +EOF +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +(set) 2>&1 | + sed -n "s/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=\${\1='\2'}/p" \ + >> confcache +if cmp -s $cache_file confcache; then + : +else + if test -w $cache_file; then + echo "updating cache $cache_file" + cat confcache > $cache_file + else + echo "not updating unwritable cache $cache_file" + fi +fi +rm -f confcache + +trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +# Any assignment to VPATH causes Sun make to only execute +# the first set of double-colon rules, so remove it if not needed. +# If there is a colon in the path, we need to keep it. +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[^:]*$/d' +fi + +trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15 + +DEFS=-DHAVE_CONFIG_H + +# Without the "./", some shells look in PATH for config.status. +: ${CONFIG_STATUS=./config.status} + +echo creating $CONFIG_STATUS +rm -f $CONFIG_STATUS +cat > $CONFIG_STATUS </dev/null | sed 1q`: +# +# $0 $ac_configure_args +# +# Compiler output produced by configure, useful for debugging +# configure, is in ./config.log if it exists. + +ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]" +for ac_option +do + case "\$ac_option" in + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion" + exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;; + -version | --version | --versio | --versi | --vers | --ver | --ve | --v) + echo "$CONFIG_STATUS generated by autoconf version 2.10" + exit 0 ;; + -help | --help | --hel | --he | --h) + echo "\$ac_cs_usage"; exit 0 ;; + *) echo "\$ac_cs_usage"; exit 1 ;; + esac +done + +ac_given_srcdir=$srcdir +ac_given_INSTALL="$INSTALL" + +trap 'rm -fr `echo "Makefile c/sysdep.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15 +EOF +cat >> $CONFIG_STATUS < conftest.subs <<\\CEOF +$ac_vpsub +$extrasub +s%@CFLAGS@%$CFLAGS%g +s%@CPPFLAGS@%$CPPFLAGS%g +s%@CXXFLAGS@%$CXXFLAGS%g +s%@DEFS@%$DEFS%g +s%@LDFLAGS@%$LDFLAGS%g +s%@LIBS@%$LIBS%g +s%@exec_prefix@%$exec_prefix%g +s%@prefix@%$prefix%g +s%@program_transform_name@%$program_transform_name%g +s%@bindir@%$bindir%g +s%@sbindir@%$sbindir%g +s%@libexecdir@%$libexecdir%g +s%@datadir@%$datadir%g +s%@sysconfdir@%$sysconfdir%g +s%@sharedstatedir@%$sharedstatedir%g +s%@localstatedir@%$localstatedir%g +s%@libdir@%$libdir%g +s%@includedir@%$includedir%g +s%@oldincludedir@%$oldincludedir%g +s%@infodir@%$infodir%g +s%@mandir@%$mandir%g +s%@CC@%$CC%g +s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g +s%@INSTALL_DATA@%$INSTALL_DATA%g +s%@CPP@%$CPP%g +s%@LIBOBJS@%$LIBOBJS%g + +CEOF +EOF +cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF +for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then + # Support "outfile[:infile]", defaulting infile="outfile.in". + case "$ac_file" in + *:*) ac_file_in=`echo "$ac_file"|sed 's%.*:%%'` + ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; + *) ac_file_in="${ac_file}.in" ;; + esac + + # Adjust relative srcdir, etc. for subdirectories. + + # Remove last slash and all that follows it. Not all systems have dirname. + ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` + if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then + # The file is in a subdirectory. + test ! -d "$ac_dir" && mkdir "$ac_dir" + ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`" + # A "../" for each directory in $ac_dir_suffix. + ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'` + else + ac_dir_suffix= ac_dots= + fi + + case "$ac_given_srcdir" in + .) srcdir=. + if test -z "$ac_dots"; then top_srcdir=. + else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;; + /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;; + *) # Relative path. + srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix" + top_srcdir="$ac_dots$ac_given_srcdir" ;; + esac + + case "$ac_given_INSTALL" in + [/$]*) INSTALL="$ac_given_INSTALL" ;; + *) INSTALL="$ac_dots$ac_given_INSTALL" ;; + esac + echo creating "$ac_file" + rm -f "$ac_file" + configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure." + case "$ac_file" in + *Makefile*) ac_comsub="1i\\ +# $configure_input" ;; + *) ac_comsub= ;; + esac + sed -e "$ac_comsub +s%@configure_input@%$configure_input%g +s%@srcdir@%$srcdir%g +s%@top_srcdir@%$top_srcdir%g +s%@INSTALL@%$INSTALL%g +" -f conftest.subs $ac_given_srcdir/$ac_file_in > $ac_file +fi; done +rm -f conftest.subs + +# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where +# NAME is the cpp macro being defined and VALUE is the value it is being given. +# +# ac_d sets the value in "#define NAME VALUE" lines. +ac_dA='s%^\([ ]*\)#\([ ]*define[ ][ ]*\)' +ac_dB='\([ ][ ]*\)[^ ]*%\1#\2' +ac_dC='\3' +ac_dD='%g' +# ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE". +ac_uA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' +ac_uB='\([ ]\)%\1#\2define\3' +ac_uC=' ' +ac_uD='\4%g' +# ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE". +ac_eA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' +ac_eB='$%\1#\2define\3' +ac_eC=' ' +ac_eD='%g' + +CONFIG_HEADERS=${CONFIG_HEADERS-"c/sysdep.h"} +for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then + # Support "outfile[:infile]", defaulting infile="outfile.in". + case "$ac_file" in + *:*) ac_file_in=`echo "$ac_file"|sed 's%.*:%%'` + ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; + *) ac_file_in="${ac_file}.in" ;; + esac + + echo creating $ac_file + + rm -f conftest.frag conftest.in conftest.out + cp $ac_given_srcdir/$ac_file_in conftest.in + +EOF + +# Transform confdefs.h into a sed script conftest.vals that substitutes +# the proper values into config.h.in to produce config.h. And first: +# Protect against being on the right side of a sed subst in config.status. +# Protect against being in an unquoted here document in config.status. +rm -f conftest.vals +cat > conftest.hdr <<\EOF +s/[\\&%]/\\&/g +s%[\\$`]%\\&%g +s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp +s%ac_d%ac_u%gp +s%ac_u%ac_e%gp +EOF +sed -n -f conftest.hdr confdefs.h > conftest.vals +rm -f conftest.hdr + +# This sed command replaces #undef with comments. This is necessary, for +# example, in the case of _POSIX_SOURCE, which is predefined and required +# on some systems where configure will not decide to define it. +cat >> conftest.vals <<\EOF +s%^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */% +EOF + +# Break up conftest.vals because some shells have a limit on +# the size of here documents, and old seds have small limits too. +# Maximum number of lines to put in a single here document. +ac_max_here_lines=12 + +rm -f conftest.tail +while : +do + ac_lines=`grep -c . conftest.vals` + # grep -c gives empty output for an empty file on some AIX systems. + if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi + # Write a limited-size here document to conftest.frag. + echo ' cat > conftest.frag <> $CONFIG_STATUS + sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS + echo 'CEOF + sed -f conftest.frag conftest.in > conftest.out + rm -f conftest.in + mv conftest.out conftest.in +' >> $CONFIG_STATUS + sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail + rm -f conftest.vals + mv conftest.tail conftest.vals +done +rm -f conftest.vals + +cat >> $CONFIG_STATUS <<\EOF + rm -f conftest.frag conftest.h + echo "/* $ac_file. Generated automatically by configure. */" > conftest.h + cat conftest.in >> conftest.h + rm -f conftest.in + if cmp -s $ac_file conftest.h 2>/dev/null; then + echo "$ac_file is unchanged" + rm -f conftest.h + else + # Remove last slash and all that follows it. Not all systems have dirname. + ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` + if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then + # The file is in a subdirectory. + test ! -d "$ac_dir" && mkdir "$ac_dir" + fi + rm -f $ac_file + mv conftest.h $ac_file + fi +fi; done + + + +exit 0 +EOF +chmod +x $CONFIG_STATUS +rm -fr confdefs* $ac_clean_files +test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1 + diff --git a/configure.in b/configure.in new file mode 100644 index 0000000..54fd344 --- /dev/null +++ b/configure.in @@ -0,0 +1,127 @@ +dnl Process this file with autoconf to produce a configure script. +dnl +dnl We might want AC_WORDS_BIGENDIAN in the future. +dnl We might want AC_CHAR_UNSIGNED in the future. +dnl +dnl The -cckr (K&R) flag is for the IRIX C compiler. If this is left +dnl out, scheme48vm.c breaks because the rather pedantic SGI compiler +dnl decides that a char is not the same thing as an unsigned char. +dnl - Bryan O'Sullivan 3/94 +dnl Note, this test didn't work correctly on Sun's which take -cckr as a +dnl synonym for -c. (HCC) +define(S48_CFLAG_CKR, [dnl + if test "z$GCC" = z; then + AC_MSG_CHECKING([-cckr]) + oldCFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -cckr" + AC_TRY_RUN([int main() { return 0;}], + [AC_MSG_RESULT(yes)], + [AC_MSG_RESULT(no) + CFLAGS="$oldCFLAGS"], + [AC_MSG_RESULT(no) + CFLAGS="$oldCFLAGS"]) + fi +])dnl +dnl +define(S48_POSIX_LIBC, [dnl +echo checking for RISC/OS POSIX library lossage +if test -f /usr/posix/usr/lib/libc.a; then + LIBS="${LIBS} /usr/posix/usr/lib/libc.a" +fi +])dnl +dnl +dnl Run AC_PROG_CC, but don't accept it's changes to CFLAGS. +dnl For some insane reason, it sets CFLAGS to either `-O' or `-g -O' for gcc. +dnl I don't want the silly -g (because if you are using nlist, you can't strip +dnl the binary), I want -O2 for gcc and -O for other C compilers. +define(S48_PROG_CC, [dnl + oldCFLAGS="$CFLAGS" + AC_PROG_CC + if test "z$oldCFLAGS" = z; then + if test "z$GCC" = z; then + CFLAGS='-O' + else + CFLAGS='-O2' + fi + fi +])dnl +dnl +dnl Linux/ELF systems need the -rdynamic flag when linking so that +dnl dlsym() can find symbols in the executable. +dnl Note, on some Sun's, you can link with -rdynamic but the resulting +dnl a.out always core dumps. +define(S48_RDYNAMIC, [dnl + AC_MSG_CHECKING([link with -rdynamic]) + AC_TRY_COMPILE([], +[#if defined(__linux__) && defined(__ELF__) + this must not compile +#endif], + [AC_MSG_RESULT(no)], + [AC_MSG_RESULT(yes) + LDFLAGS="$LDFLAGS -rdynamic"]) +])dnl +dnl +define(S48_USCORE, [dnl + AC_MSG_CHECKING([underscore before symbols]) + echo 'main() { return 0; } fnord() {}' >conftest.c + if ${CC} ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c ${LIBS} && + nm a.out | grep _fnord >/dev/null; then + AC_MSG_RESULT([yes]) + AC_DEFINE(USCORE) + else + AC_MSG_RESULT([no]) + fi + rm -f conftest.c a.out +])dnl +dnl +AC_INIT(c/scheme48vm.c) + AC_CONFIG_HEADER(c/sysdep.h) + S48_PROG_CC + AC_ISC_POSIX + dnl set the cross-compile flag before we try anything. + AC_TRY_RUN([int main() { return 0;}], [], [], [true]) + S48_CFLAG_CKR + AC_PROG_INSTALL + AC_CHECK_LIB(m, main) + AC_CHECK_LIB(dl, main) + AC_CHECK_LIB(mld, main) + AC_CHECK_LIB(nsl, main) + AC_CHECK_LIB(gen, main) + AC_CHECK_LIB(socket, main) + AC_CHECK_LIB(sun, getpwnam) + dnl Solaris 2.3 seems to need -lelf for nlist(). (tnx Bryan O'Sullivan) + AC_CHECK_LIB(elf, main) + S48_POSIX_LIBC + AC_CONST + AC_RETSIGTYPE + AC_CHECK_HEADERS(libgen.h sys/timeb.h posix/time.h) + AC_CHECK_HEADERS(sys/select.h) + AC_CHECK_FUNCS(dlopen gettimeofday ftime nlist select setitimer sigaction) + AC_CHECK_FUNCS(socket chroot) + AC_CHECK_FUNC(strerror, AC_DEFINE(HAVE_STRERROR), + [LIBOBJS="$LIBOBJS c/fake/strerror.o"]) + AC_MSG_CHECKING([n_name]) + AC_TRY_LINK([#include ], + [struct nlist name_list; + name_list.n_name = "foo";], + AC_DEFINE(NLIST_HAS_N_NAME) + AC_MSG_RESULT([yes]), + AC_MSG_RESULT([no])) + AC_MSG_CHECKING([__NEXT__]) + AC_TRY_LINK(,[ +#ifdef __NeXT__ +return 0; +#else +fail +#endif +], + CC="$CC -posix" + AC_DEFINE(HAVE_SIGACTION) + AC_MSG_RESULT([yes]), + AC_MSG_RESULT([no])) + S48_USCORE + S48_RDYNAMIC + AC_SUBST(CFLAGS) + AC_SUBST(LIBOBJS) + AC_SUBST(LDFLAGS) +AC_OUTPUT(Makefile) diff --git a/doc/big-scheme.txt b/doc/big-scheme.txt new file mode 100644 index 0000000..0f03197 --- /dev/null +++ b/doc/big-scheme.txt @@ -0,0 +1,309 @@ + + Documentation for Big Scheme + + +Big Scheme is a set of generally useful facilities. + +Easiest way to access these things: + + > ,open big-scheme + Load structure big-scheme (y/n)? y + ... + +A better way is to use the module system. + +----- + +Ascii conversions + +(CHAR->ASCII ) => +(ASCII->CHAR ) => + These are identical to CHAR->INTEGER and INTEGER->CHAR except that + they use the ASCII encoding. + +----- + +Bitwise operations + +(BITWISE-NOT ) => +(BITWISE-AND ) => +(BITWISE-IOR ) => +(BITWISE-XOR ) => + These perform various logical operations on integers on a bit-by-bit + basis, using a two's-complement representation. + +(ARITHMETIC-SHIFT ) => + Shift the integer by the given bit count, shifting left for positive + counts and right for negative ones. A two's complement + representation is used. + +----- + +Hash tables + +(MAKE-TABLE) => +(MAKE-STRING-TABLE) => + Make a new, empty table. MAKE-TABLE returns a table that uses EQ? + for comparing keys and an ad-hoc hash function. String tables uses + strings for keys. + +(MAKE-TABLE-MAKER ) => + Returns a procedure of no arguments that makes tables that use the + given comparison and hash procedures. + ( ) => + ( ) => + +(TABLE? ) => + True if is a table. + +(TABLE-REF
) => + Return the value for in
, or #F if there is none. + should be of a type appropriate for
. + +(TABLE-SET!
) => + Make be the value of in
. should be of a + type appropriate for
. + +(TABLE-WALK
) => + Apply , which must accept two arguments, to every + associated key and value in
. + +----- + +Enumerations + +(DEFINE-ENUMERATION ( ...)) *SYNTAX* + Defines to be an enumeration with components + .... Also defines -COUNT to be the number of + components. + +(ENUM ) => *SYNTAX* + Evaluates to the value of within the enumeration + . For example, if (DEFINE-ENUMERATION COLOR (GREEN + RED)), then (ENUM COLOR GREEN) is zero and (ENUM COLOR RED) is one. + The mapping from name to integer is done at macro-expansion time, so + there is no run-time overhead. + +(ENUMERAND->NAME ) => + Returns the name associated with within . + E.g. (ENUMERAND->NAME 1 COLOR) => 'RED. + +(NAME->ENUMERAND ) => + Returns the integer associated with within . + E.g. (ENUMERAND->NAME 'GREEN COLOR) => 0. + +----- + +Port extensions + +(MAKE-TRACKING-INPUT-PORT ) => +(MAKE-TRACKING-OUTPUT-PORT ) => + These return ports that keep track of the current row and column and + are otherwise identical to their arguments. + +(MAKE-STRING-INPUT-PORT ) => + Returns a port that reads characters from the supplied string. + +(CALL-WITH-STRING-OUTPUT-PORT ) => + The procedure is called on a port. When it returns, CALL-WITH-STRING- + OUTPUT-PORT returns a string containing the characters written to the port. + +(WRITE-ONE-LINE ) => + The procedure is called on an output port. Output written to that + port is copied to until characters + have been written, at which point WRITE-ONE-LINE returns. + +(CURRENT-ROW ) => or #f +(CURRENT-COLUMN ) => or #f + These return the current read or write location of the port. #F is + returned if the port does not keep track of its location. + +(FRESH-LINE ) => + Write a newline character to if its current column is not 0. + +(INPUT-PORT? ) => +(OUTPUT-PORT? ) => + These are versions of the standard Scheme predicates that answer true for + extended ports. + +----- + +Queues + +(MAKE-QUEUE) => + Returns a new, empty queue. + +(ENQUEUE! ) => + Puts on the queue. + +(DEQUEUE! ) => + Removes and returns the first element of the queue. + +(QUEUE-EMPTY? ) => + True if the queue is empty. + +(QUEUE? ) => + True if is a queue. + +(QUEUE->LIST ) => + Returns a list of the elements of the queue, in order. + +(QUEUE-LENGTH ) => + The number of elements currently on the queue. + +(DELETE-FROM-QUEUE! ) => + Removes the first occurance of from the queue, returning true if + it was found and false otherwise. + +----- + +Little utility procedures + +(ATOM? ) => + (ATOM? x) == (NOT (PAIR? x)) + +(NULL-LIST? ) => + Returns #t for the empty list, #f for a pair, and signals an error + otherwise. + +(NEQ? ) => + (NEQ? x y) is the same as (NOT (EQ? x y)). + +(N= ) => + (N= x y) is the same as (NOT (= x y)). + +(IDENTITY ) => +(NO-OP ) => + These both just return their argument. NO-OP is guaranteed not to + be compiled in-line, IDENTITY may be. + +----- + +List utilities + +(MEMQ? ) => + Returns true if is in , false otherwise. + +(ANY? ) => + Returns true if is true for any element of . + +(EVERY? ) => + Returns true if is true for every element of . + +(ANY ) +(FIRST ) + ANY returns some element of for which is true, or + #F if there are none. FIRST does the same except that it returns + the first element for which is true. + +(FILTER ) +(FILTER! ) + Returns a list containing all of the elements of for which + is true. The order of the elements is preserved. + FILTER! may reuse the storage of . + +(FILTER-MAP ) + The same as FILTER except the returned list contains the results of + applying instead of elements of . (FILTER-MAP p + l) is the same as (FILTER IDENTITY (MAP p l)). + +(PARTITION-LIST ) => +(PARTITION-LIST! ) => + The first return value contains those elements for which + is true, the second contains the remaining elements. + The order of the elements is preserved. PARTITION-LIST! may resuse + the storage of the . + +(REMOVE-DUPLICATES ) => + Returns its argument with all duplicate elements removed. The first + instance of each element is preserved. + +(DELQ ) => +(DELQ! ) => +(DELETE ) => + All three of these return with some elements removed. DELQ + removes all elements EQ? to . DELQ! does the same and may + modify the list argument. DELETE removes all elements for which + is true. Both DELQ and DELETE may reuse some of the + storage in the list argument, but won't modify it. + +(REVERSE! ) => + Destructively reverses . + +(SORT-LIST ) => +(SORT-LIST! ) => + Returns a sorted copy of . The sorting algorithm is stable. + (SORT-LIST '(6 5 1 3 2 4) <) => '(1 2 3 4 5 6) + +----- + +Additional syntax + +(DESTRUCTURE (( ) ...) ...) *SYNTAX* + The s are evaluated and their values are dissasembled + according to the corresponding patterns, with identifiers in the + patterns being bound to fresh locations holding the corresponding + part, and the body is evaluated in the extended environment. + Patterns may be any of the following: + + #f Discard the corresponding part. + Bind the to the part. + ( ...) The part must be a list at least as long as the + pattern. + ( ... . ) + The same thing, except that the final CDR of the + part is dissasembled according to . + #( ...) The part must be a vector at least as long as the + pattern. + +(RECEIVE ...) *SYNTAX* + => (CALL-WITH-VALUES (LAMBDA () ) (LAMBDA ...)) + Bind to the values returned by , and evaluate the + body in the resulting environment. + +----- + +Printing and related procedures + +(CONCATENATE-SYMBOL . ) + Returns the symbol whose name is produced by concatenating the DISPLAYed + representations of . + (CONCATENATE-SYMBOL 'abc "-" 4) => 'abc-4 + +(FORMAT . ) => or + Prints the arguments to the port as directed by the string. + should be either: + An output port. The output is written directly to the port. The result + of the call to FORMAT is undefined. + #T. The output is written to the current output port. The result of the + call to FORMAT is undefined. + #F. The output is written to a string, which is then the value returned + from the call to FORMAT. + Characters in which are not preceded by a ~ are written + directly to the output. Characters preceded by a ~ have the following + meaning (case is irrelevant; ~a and ~A have the same meaning): + ~~ prints a single ~ + ~A prints the next argument using DISPLAY + ~D prints the next argument as a decimal number + ~S prints the next argument using WRITE + ~% prints a newline character + ~& prints a NEWLINE character if the previous printed character was not one + (this is implemented using FRESH-LINE) + ~? performs a recursive call to FORMAT using the next two arguments as the + string and the list of arguments + +(ERROR . ) +(BREAKPOINT . ) + Signals an error or breakpoint condition, passing it the result of + applying FORMAT to the arguments. + +(P ) +(P ) +(PRETTY-PRINT ) + Pretty-print . The current output port is used if no port is + specified. is the starting offset. will be + pretty-printed to the right of this column. + + +Original by RK, 26 Jan 1993. +Minor changes by JAR, 5 Dec 1993. diff --git a/doc/call-back.txt b/doc/call-back.txt new file mode 100644 index 0000000..69ddd2e --- /dev/null +++ b/doc/call-back.txt @@ -0,0 +1,87 @@ +Date: Fri, 25 Jun 93 13:31:50 -0400 +From: Jonathan Rees +To: sheldon@lcs.mit.edu +Cc: jar@martigny.ai.mit.edu +Subject: call-back +Message-Id: <9306251331.aa11673@mintaka.lcs.mit.edu> + + +Hmm... I think the convention is: + + 1. Scheme calls C (e.g. the rpc server) as usual using EXTERNAL-CALL. + 2. C calls the VM's entry point restart(value). + 3. That causes the original Scheme code to think that your C function + has returned value, when in fact it hasn't. + 4. If Scheme later executes a VM-RETURN instruction, then + the C call to restart() will return with the specified value. + +So you need to write some Scheme code that looks vaguely like this: + + (let ((communication-block (make-vector 100))) + (let loop ((status (external-call rpc-server communication-block))) + (if status ;Boolean + (begin (store-somewhere-in-communication-block! + (apply (choose-a-procedure ...) + (extract-some-arguments ...))) + ;; communication-block might be moved by GC; give new + ;; address back to C + (loop (vm-return 0 communication-block)))))) + +The procedure, number of arguments, and the arguments themselves must +be encoded in the argument block somehow. You must not put Scheme +values (including the argument block) in C variables that are live +across calls to the VM. Therefore the procedures have to numbered +(stored in a vector, say) or something. + +Apparently the first argument to VM-RETURN is ignored. + + (define-primitive op/vm-return (fixnum-> any->) ;from vm/prim.scm + (lambda (key value) + (set! *val* value) + ;; TTreturn_value = 0; + ;; return(0L);} + return-option/exit)) ; the VM returns this value + +The relevant code from scheme48vm.c (actually, the source from +vm/resume.scm): + + long restart(long value) + { + (set! *val* value) + (let loop () + (let ((option (interpret))) + ;; option_880X = TTrun_machine((long)Tinterpret); + (cond ((= option return-option/exit) + *val*) + ((= option return-option/external-call) + (set! *val* (call-external-value ; type inference hack + (fetch (address-after-header + (external-value *val*))) + *nargs* + (pointer-to-top-of-stack))) + (stack-add (- 0 (+ *nargs* 1))) ; remove proc and args + (loop)) + (else + (error "unkown VM return option" option) + -1)))) + } + + +The relevant code from unix.c: + + call_external_value( long proc, long nargs, long *args ) + { + return ((long(*)())proc)(nargs, args); + } + + /* Driver loop for tail-recursive calls */ + + long TTreturn_value; + + long TTrun_machine(proc) + long (*proc) (void); + { + while (proc != 0) + proc = (long (*) (void)) (*proc)(); + return TTreturn_value; + } diff --git a/doc/external.txt b/doc/external.txt new file mode 100644 index 0000000..02aa9fd --- /dev/null +++ b/doc/external.txt @@ -0,0 +1,92 @@ + + External function calls + + +(GET-EXTERNAL string) +Returns an external pointer to the given name. + +(LOOKUP-ALL-EXTERNALS) +Looks up all externals in the currently job. Ideally this should be called +automatically on startup. + +(EXTERNAL-CALL external arg1 arg2 ...) +Calls the external value, passing it the number of arguments (as a long), +and a pointer to a C array containing the rest of the arguments (also +a long). Don't mess with the array, it is really the Scheme 48 argument +stack. The arguments are in reverse order. + + +The file dynload.c contains the function s48_dynamic_load which can +be called using EXTERNAL-CALL. To make it work you need to do the +following: + + 1) If you're using ultrix, link the VM using -N. + + 2) When invoking the VM, use the -o flag to pass it the name of the + executable file containing the VM. [This is done automatically by + the shell script created by "make".] + + 3) If your OS supports shared libraries, do as appropriate to arrange + for your C code to be position-independent and to create a shared + library. + +If dynamic loading doesn't work you can always link the external stuff +in with the VM. The dynamic loading code has problems. I am not much +of a Unix hacker. + +Here is a transcript on SunOS 4.something: + + kama$ gcc -fpic -c test.c + kama$ /bin/ld -assert pure-text -o test.so test.o + kama$ file test.so + test.so: sparc demand paged shared library executable not stripped + kama$ + kama$ scheme48 + Welcome to Scheme 48 0.31 (made by jar on Sun Feb 13 18:33:57 EST 1994). + Copyright (c) 1993, 1994 by Richard Kelsey and Jonathan Rees. + Please report bugs to scheme-48-bugs@altdorf.ai.mit.edu. + Type ,? (comma question-mark) for help. + > ,open externals + Load structure externals (y/n)? y + [externals + /usr/public/sun4/lib/scheme48/big/external.scm .............. + ] + > (define dynamic-load (get-external "s48_dynamic_load")) + > (external-call dynamic-load "test.so") + #t + > (define test (get-external "test")) + > (external-call test "yow" 3) + string: yow + fixnum: 3 + #t + > + +If using cc instead of gcc, do "cc -pic -c ...". + +(get-external "_s48_dynamic_load") and (get-external "_test") might be +required on some versions of Unix (like maybe SGI). + +Here is file test.c: + + #include "/usr/local/include/scheme48.h" + #include + + scheme_value test (argc, argv) + long argc; scheme_value *argv; + { + int i; + for (i = argc-1; i >= 0; i--) { + scheme_value arg = argv[i]; + if (STRINGP(arg)) { + printf ("string: "); + fwrite(&STRING_REF(arg, 0), 1, STRING_LENGTH(arg), stdout); + printf ("\n"); + } + else if (FIXNUMP(arg)) { + printf("fixnum: %d\n", EXTRACT_FIXNUM(arg)); + } + else + printf("?\n"); + } + return SCHTRUE; + } diff --git a/doc/hacking.txt b/doc/hacking.txt new file mode 100644 index 0000000..081d7e5 --- /dev/null +++ b/doc/hacking.txt @@ -0,0 +1,290 @@ + +,bench +,load-package linker +,new-package =link= linker debuginfo defpackage +,load scripts.scm +(link-initial-system) + + +To change between initial image starting in mini-command (MINI) and +command (MAXI): + + 1. Definition of initial system's command module in comp-packages.scm: + MINI: (make-mini-command scheme) + MAXI: (make-command scheme) + 2. Location of (define-module (make-command ...)...): + MINI: more-packages.scm + MAXI: comp-packages.scm + 3. Location of (define-interface command-interface ...): + MINI: more-interfaces.scm + MAXI: interfaces.scm + + + + +> ,new-package z architecture primitives packages table enumerated debug-data +z> (let ((i 0)) + (table-walk (lambda (x y) (set! i (+ i 1))) + location-name-table) + i) +1385 +z> (vector-length (find-all-xs (name->enumerand 'location stob))) +1259 +(vector-length (find-all-xs (name->enumerand 'record stob))) +2150 + +(find-all-xs (name->enumerand 'record stob)) +z> (do ((i 0 (+ i 1)) + (j 0 (if (package? (vector-ref rs i)) (+ j 1) j))) ((= i (vector-length rs)) j)) +72 +z> + + + + +> ,new-package z architecture primitives compiler table +z> (vector-ref stob 10) +'template +z> stob +'#(pair symbol vector closure location port ratio record continuation extended-number template weak-pointer external unused-d-header1 unused-d-header2 string code-vector double bignum) +z> (vector-ref stob 7) +'record +z> (define rs (find-all-xs 7)) +z> (vector-length rs) +2178 +z> (define ls (find-all-xs 4)) +z> (vector-length ls) +1266 +z> + + + + +To get a fresh config package: + +,in config (define-structures ((config1 (export))) + (open defpackage built-in-structures more-structures)) +,config-package-is config1 + + +To load a linker with a fresh new compiler: + x48 -i new-scheme48.image -h 10000000 ,in reification reify-structures +'#{Procedure 8447 reify-structures} +debug-config> (define reify-structures ##) +debug-config> make-simple-package + +Error: undefined variable + make-simple-package + (package debug-config) +1 debug-config> +debug-config> (define-structures ((p (export start))) (open initial-system scheme-level-2 packages)) +debug-config> (define go (in p `(start ,(reify-structures (desirable-packages) (lambda (loc) `',loc))))) + + + +### Small images for exercising the linker and/or runtime system + +debug/tiny.image: debug/tiny.scm $(LINKER_IMAGE) + ($(START_LINKER_RUNNABLE) \ + echo "(load \"debug/tiny-packages.scm\")"; \ + echo "(link-simple-system '(debug tiny) 'start tiny-system)") \ + | $(LINKER_RUNNABLE) -i $(LINKER_IMAGE) + +debug/little.image: $(LINKER_IMAGE) $(CONFIG_FILES) $(little-files) + ($(START_LINKER_RUNNABLE) \ + echo "(load \"scripts.scm\")"; \ + echo "(link-little-system)") \ + | $(LINKER_RUNNABLE) -i $(LINKER_IMAGE) $(BIG_HEAP) + +debug/medium.image: $(LINKER_IMAGE) $(CONFIG_FILES) $(medium-files) + ($(START_LINKER_RUNNABLE) \ + echo "(load \"scripts.scm\")"; \ + echo "(link-medium-system)") \ + | $(LINKER_RUNNABLE) -i $(LINKER_IMAGE) $(BIG_HEAP) + + + echo "(define l-f (package-all-filenames little-system))"; \ + echo "(define m-f (package-all-filenames medium-system))"; \ + + 'little-files l-f 'medium-files m-f \ + + +[The following is from June 1992, and probably not quite compatible +with the current compiler internals.] + +To eliminate use of the stack GC to implement tail recursion, change +comp.scm as follows: + +(define (compile-unknown-call exp cenv depth cont) + (note-source-code + exp + (maybe-push-continuation (sequentially + (push-all (cdr exp) cenv 0) + (compile (car exp) + cenv + (length (cdr exp)) + (fall-through-cont)) + (instruction (if (return-cont? cont) + op/move-args-and-call + op/call) + (length (cdr exp)))) + depth + cont))) + + +-------------------- + +Here's another cool thing. 6/28/93 + +(define-interface evaluation-interface + (export eval load eval-from-file)) + +(define-structure run evaluation-interface + (open scheme-level-2 syntactic packages scan + environments + signals + locations + features ;force-output + table + fluids) + (files (debug run))) + +,load-package run +,in run +,in package-commands (environment-for-syntax-promise) +(define cool (make-simple-package (list scheme) eval ## 'cool)) +,in command set-environment-for-commands! +(## cool) + +cool> ,inspect (lambda (x) x) +'#{Procedure 6394} + + [0: exp] '(lambda (x) x) + [1: env] '#{Package 286 cool} +inspect: +inspect: q +cool> + + + +(define (z s) + (define (show-type name static) + (write name) + (display " : ") + (write (static-type static)) + (newline)) + (if (package? s) + (for-each-definition (lambda (name static loc) + (show-type name static)) + s) + (interface-walk (lambda (name type) + (show-type name + (car (structure-lookup + s name #t)))) + (structure-interface s)))) + +; ,open expander syntactic packages reconstruction + +(define (e x) + (let ((p (interaction-environment))) + (let ((node (expand-form x p))) + (write (node-type node (package->environment p))) + (newline) + (eval node p)))) + + + +> (define hunk3 (lap hunk3 + 0 (check-nargs= 3) + 2 (pop) + 3 (make-stored-object 3 0) + 6 (return))) +> (hunk3 1 2 3) +'(1 . 2) +> (define cxr (lap cxr + 0 (check-nargs= 2) + 2 (pop) + 3 (stored-object-indexed-ref 0) + 5 (return))) +> (cxr (hunk3 1 2 3) 2) +3 +> + + +(define-syntax %cons + (lambda (e r c) + (let ((n (cadr e)) + (kind (caddr e))) + `(,(r 'lap) (%cons ,n ,kind) + (check-nargs= ,n) + (pop) + (make-stored-object ,n ,kind) + (return))))) + + +(define (& x) + (or (node-ref x 'uid) + (begin (set! *n* (+ *n* 1)) + (node-set! x 'uid *n*) + *n*)) + x) + +(define (uid n) (node-ref (& n) 'uid)) + +(define *n* 0) diff --git a/doc/install.txt b/doc/install.txt new file mode 100644 index 0000000..7ffcada --- /dev/null +++ b/doc/install.txt @@ -0,0 +1,159 @@ +-*- Mode: Indented-text; -*- + +Here are some remarks to complement what's in the INSTALL file. + +----- + +When running "make", don't worry if the ".notify" target fails. Its +only purpose is to send an email message to +scheme-48-notifications@martigny.ai.mit.edu, so that we can get a +rough idea of how much Scheme 48 is being used and by whom. We +promise not to use your name or email address for any commercial +purpose. If you don't want us to know, just do "make -t .notify" +first. + +----- + +Customizing the installation + + 1. If you don't believe in configure scripts, or don't have a + /bin/sh that can handle the configure script, you can make + sysdep.h and Makefile manually from sysdep.h.in and Makefile.in. + The technique is fairly obvious. For Makefile, just give + reasonable values for all of the variables at the top that are + defined as "foo = @foo@", e.g. srcdir=., CC=cc, LIBS=-lm, + INSTALL=cp, etc. For sysdep.h, read the comments. If your OS is + Posix compliant, you should be able to copy sysdep.h.in to + sysdep.h unmodified and everything should work. + + 2. If you definitely won't be installing Scheme 48, you should set + libdir to the distribution directory (e.g. "make libdir=`pwd`"). + This will make the ,open and ,load-package commands work for the + library packages defined in more-packages.scm. + + 3. If desired, customize the contents of the development environment + heap image by editing the definitions of USUAL-COMMANDS and/or + USUAL-FEATURES in more-packages.scm; see below. + + 4. If you're using a DEC MIPS, and want to use the foreign function + interface, specify LDFLAGS=-N (with e.g. "make LDFLAGS=-N"). + +----- + +Customizing scheme48.image + +By default, the image consists of a core Scheme system (Revised^5 +Scheme plus a very minimal read-eval-print loop) together with a +standard set of "options" (command processor, debugging commands, +inspector, disassembler, generic arithmetic). The set of options is +controlled by the definitions of USUAL-COMMANDS and USUAL-FEATURES in +more-packages.scm. If you make the (open ...) clause empty, then +"make scheme48.image" will create a Scheme system without any extras +(such as error recovery), and the image will be smaller. The files +are listed in approximate order of decreasing desirability; you'll +probably want at least these: + + package-commands, build + - necessary for the scheme48.image script to work + debuginfo, disclosers + - necessary if you want error messages to be at all helpful + debugging + - defines important debugging commands such as ,preview and ,trace + +After editing the definition of usual-features, simply + + make scheme48.image + +to rebuild the image. + +----- + +Deeper changes to the system -- for example, edits to most of the +files in the rts/ directory -- will require using the static linker to +make a new initial.image. After you have a working scheme48.image +(perhaps a previous version of Scheme 48), you can create a linker +image with + + make linker + +after which you can say + + make image + +to get the linker to build a new initial.image and initial.debug. +scheme48.image will then be built from those. + +You might think that "make scheme48.image" ought to do this, but the +circular dependencies + + scheme48.image on initial.image + initial.image on link/linker.image + link/linker.image on scheme48.image + +needs to be broken somewhere, or else make will (justifiably) barf. I +chose to break the cycle by making scheme48.image not depend on +initial.image, since this is most robust for installation purposes. + +----- + +Editor support + +We recommend interacting with the Scheme 48 command processor using the +emacs/scheme interface written by Olin Shivers at CMU. Copies of the +relevant .el files, together with a "cmuscheme48.el", are in the +emacs/ subdirectory of the release. Usage information is in +doc/user-guide.txt. + +You will probably want to byte-compile the .el files to get .elc +files. Use M-x byte-compile-file to do this. + +----- + +Performance + +If you don't have a C compiler that optimizes as well as gcc does, +then performance may suffer. Take a look at the automatically +generated code in scheme48vm.c to find out why. With a good register +allocator, all those variables (including some of the virtual +machine's virtual registers) get allocated to hardware registers, and +it really flies. Without one, performance can be pretty bad. + +The configure script automatically sets the Makefile variable CFLAGS +to -O2 -g if gcc is available, or to -O if it isn't. This can be +overriden by specifying a different CFLAGS, e.g. "make CFLAGS=-g" for +no optimization. + +Even if you do have a good compiler, you should be able to improve +overall performance even more, maybe about 6-10%, by removing the +range check from the interpreter's instruction dispatch. To do this, +use the -S flag to get assembly code for scheme48vm.c, then find the +instructions in scheme48vm.s corresponding to the big dispatch in +restart(): + + L19173: { + code_pointer_83X = arg1K0; + switch ((*((unsigned char *) code_pointer_83X))) { + ... } + +There will be one or two comparison instructions to see whether the +opcode is in range; just remove them. For the 68000 I use a "sed" + script + + /cmpl #137,d0/ N + /cmpl #137,d0\n jhi L/ d + +but of course the constant will probably have to change when a new +release comes along. + +See the user's guide for information on the ,bench command, which +makes programs run faster. + +----- + +filenames.make is "include"d by the Makefile, but is automatically +generated from the module dependencies laid out in the various +configuration files (*-packages.scm). If you edit any of these .scm +files, you may want to do a "make filenames.make" before you do any +further "make"s in order to update the depedencies. This step isn't +necessary if you're using Gnu make, because Gnu make will make +included files automatically. diff --git a/doc/io.txt b/doc/io.txt new file mode 100644 index 0000000..239e1d2 --- /dev/null +++ b/doc/io.txt @@ -0,0 +1,201 @@ + +There are two types of I/O objects in Scheme 48, channels and ports. +Channels are the raw, unbuffered ports of the operating system. The +only I/O operations the VM supports for channels are block reads and +writes. Ports are the actual Scheme ports and are implemented in Scheme, +with some support from the VM for READ-CHAR, PEEK-CHAR, and WRITE-CHAR +for efficiency. The run-time system provides ports that are buffered +versions of channels. Other sorts of ports are in big/more-port.scm. + +Source files: + + rts/port.scm port operations and port handlers + rts/current-port.scm current-input-port, etc. + rts/channel.scm blocking on channels and handling i/o interrupts + rts/channel-port.scm ports that read and write to channels + rts/low.scm CHANNEL-READ and CHANNEL-WRITE + big/more-port.scm additional kinds of ports + vm/arch.scm fields of ports and channels + vm/prim-io.scm VM i/o opcodes + vm/vmio.scm implementation of channels + +---------------------------------------------------------------- + +CHANNELS + +The VM instructions that deal with channels are: + + (OPEN-CHANNEL ) -> channel + is a from the enumeration OPEN-CHANNEL-OPTION in arch.scm. + is either a filename (as a string) or an OS port (as a one-word + code-vector), depending on the mode. + + (CLOSE-CHANNEL ) -> unspecific + + (CHANNEL-MAYBE-READ + ) + -> number of bytes read or the eof-object + (CHANNEL-MAYBE-WRITE ) + -> number of bytes written + These read or write up to the specified number of characters or bytes + from or to the string or code-vector, with the first character or byte + going at . + + (CHANNEL-ABORT ) -> number of bytes read or written or + the eof-object + This aborts any pending read or write operation on the channel. The return + value reflects any partial completion. + +CHANNEL-MAYBE-READ and CHANNEL-MAYBE-WRITE do not block. If the read or +write cannot be completed immediately a PENDING-CHANNEL-I/O exception is +raised. It is then up to the run-time system to either wait or run some +other thread. The VM raises an I/O-COMPLETION interrupt whenever an i/o +operation completes. + +Because CHANNEL-MAYBE-READ and CHANNEL-MAYBE-WRITE are awkward to use, +the RTS defines somewhat simpler versions: + + (CHANNEL-READ ) + -> number of bytes read or the eof-object + (CHANNEL-WRITE ) + -> unspecified + is either a string or code vector and is the index of the + first character read or written. is one of: + N > 0 : the call returns when this many characters has been read or + an EOF is reached. + 'IMMEDIATE : the call reads as many characters as are available and + returns immediately. + 'ANY : the call returns as soon as at least one character has been read + or an EOF is reached. + is the number of characters to be written. CHANNEL-READ will read + the requested number of characters unless an EOF is reached. CHANNEL-WRITE + will write the requested number of characters. + +---------------------------------------------------------------- + +PORTS + +Ports are actual Scheme port and are (usually) buffered. They are fully +exposed to the run-time system. The VM instructions on ports could be +implemented in Scheme; they are in the VM for efficiency. Buffers are +code-vectors (this is a micro-hack; strings have a slightly higher overhead +because of the null terminating byte for C compatibility) (code-vectors are +just vectors of bytes). + +The fields of a port are: + + PORT-STATUS: a bit set represented as a fixnum. + Indices into this bit set are from the PORT-STATUS-OPTIONS + enumeration in arch.scm. The current bits are: input, output, + open-for-input, open-for-output (the last two are for things like + sockets, on which you need to block but which do not support + normal reading or writing). + + PORT-HANDLER: a record containing three procedures. These handle + printing the port, closing the port, and filling (for input ports) + or emptying (for output ports) buffers. + + PORT-DATA: ? + Whatever stuff the handler needs. + + PORT-LOCKED?, PORT-LOCK: used by the system to guarentee the atomicity + of i/o operations. + + PORT-BUFFER: a code-vector. The input or output buffer of the port. + + PORT-INDEX: a fixnum. The index of the next byte to read or written. + + PORT-LIMIT: a fixnum. One past the end of the valid/available buffer space. + + PORT-PENDING-EOF?: true if the next read to this port should return EOF. + +Additional operations on ports: + + (READ-BLOCK string-or-code-vector start count input-port) + Read COUNT bytes into STRING-OR-CODE-VECTOR starting at index START. + Returns the number of bytes read. Only an end-of-file will prevent + the requested number of bytes from being read. + + (WRITE-STRING string output-port) + Write the characters in the string to the port. + + (WRITE-BLOCK string-or-code-vector start count output-port) + The output counterpart to READ-BLOCK. This always writes out the + requested number of bytes. Its return value is unspecified. + + (FORCE_OUTPUT output-port) + Causes any buffered characters to be written out. + + (CURRENT-ERROR-PORT) + The current error port, analogous to Scheme's CURRENT-INPUT-PORT + and CURRENT-OUTPUT-PORT. + +The system maintains a list of output ports whose buffers should be +periodically flushed. The default output port and ports made by +OPEN-OUTPUT-FILE are on this list. (PERIODICALLY-FORCE-OUTPUT! ) +may be used to add others. + +---------------------------------------------------------------- + +PORT HANDLERS + +Every port has a handler with three procedures. The first two are used +for printing and closing ports and have the same type for all ports: + + (DISCLOSE port-data) -> disclose list + (CLOSE port-data) -> unspecific + +For CLOSE, The system takes care of modifying the port's status. + +The third procedure is used to fill and empty buffers. Its arguments +and return values depend on the kind of port: + + Buffered output ports: + (BUFFER-PROC port-data buffer start-index byte-count) -> unspecific + BYTE-COUNT bytes should be copied from the buffer beginning at + START-INDEX. The buffer may be either a string or a code-vector. + + Unbuffered output ports: + (BUFFER-PROC port-data char) -> unspecific + Write out the given character. The system uses this for the default + error port. + + Input ports: + (BUFFER-PROC data buffer start-index needed-bytes) + -> EOF or number of bytes read (before an EOF) + Bytes should be copied into the buffer starting at START-INDEX. The + buffer may be either a string or a code-vector. NEEDED-BYTES is one of: + + 'IMMEDIATE + The call should return immediately after transfering whatever number + of bytes are currently available, possibly none (this is used for + CHAR-READY?). The maximum number of characters is determined by the + length of BUFFER. + + 'ANY + The call should wait until at least one byte is available or an EOF + occurs (used for READ-CHAR and PEEK-CHAR). The maximum number of + characters is determined by the length of BUFFER. + + N > 0 + The call should wait until N bytes have been copied into the buffer + or an EOF occurs. If the return value is less than NEEDED-BYTES the + port code inserts an EOF after the last byte. + +---------------------------------------------------------------- + +Ports and the Virtual Machine + +Ports could be implemented entirely in Scheme, with no support from +the VM. For efficiency reasons VM instructions are supplied for +three port operations: + + (READ-CHAR ) + (PEEK-CHAR ) + (WRITE-CHAR ) + +For each of these, if there is sufficient data or space in the +appropriate buffer the VM performs the operation. Otherwise a +buffer-full/empty exception is raised and the exception handler +uses the buffer procedure from the port's handler to fill or +empty the buffer. diff --git a/doc/kali.html b/doc/kali.html new file mode 100644 index 0000000..d324e50 --- /dev/null +++ b/doc/kali.html @@ -0,0 +1,254 @@ + + + + +A Quick Guide to Kali + + + + + +

A Quick Guide to Kali

+

Richard A. Kelsey
NEC Research Institute
kelsey@research.nj.nec.com

+ +

Address spaces and servers

+

Address-spaces are an abstraction of Unix processes. +An address space is identified by the machine on which it runs and the + socket on which it listens + for connections from other address spaces. +New address spaces can be added as a Kali program runs. +

All of the procedures described in this section are in structure kali. +

     
  • (start-server) +
+This starts a server for the current process, making it an address space. +The socket that the server is listening on is printed out. +Normally the server is started as a separate thread, using spawn + from structure threads. +
+> ,open kali threads
+> (spawn start-server 'kali-server)
+Waiting for connection on port 1228
+>
+
+
     
  • (socket-id->address-space machine-name socket) -> address-space + 
  • (address-space? thing) -> boolean + 
  • (remote-run! address-space procedure arg0 ...) + 
  • (remote-apply address-space procedure arg0 ...) -> values +
+Socket-id->address-space returns the address-space corresponding to + the process whose server is listening at socket on machine-name. +Socket should be the socket number printed out by the call to + start-server that created the address space. +

Address-space? is the predicate for address spaces. +

Remote-run! and remote-apply transport procedure + and arguments to address-space and do the application there. +Remote-run! returns immediately, while remote-apply blocks until + procedure returns, and then returns whatever values procedure + returned. +Procedure, arguments, and values + are all transmitted by copying, with the exception of proxies and symbols. +Objects are shared within a particular message, including the message that + send procedure and arguments and the message returning + values. +Objects are not shared between messages. +

+  (let ((x (list 1 2)))
+    (remote-apply a1 eq? x x))
+    -> #t
+
+  (let ((x (list 1 2)))
+    (eq? x (remote-apply a1 (lambda () x))))
+    -> #f
+
+  (let ((x (list 1)))
+    (remote-apply a1 (lambda () (set-car! x 2)))
+    (car x))
+    -> 1
+
+If address-space is the local address space, no messages are + sent and no copying occurs. +For a remote-run! where address-space is the local address space, + a separate thread is spawned to do the application of procedure to + arguments. +

There is currently no mechanism for GCing address spaces. +Kali makes socket connections between address spaces only as needed, but once + made they stay forever. +

Proxies

+

Proxies are globally-unique, distributed cells. Every proxy potentially has a +distinct value in every address space. +

These procedures are in structure kali. +

     
  • (make-proxy value) -> proxy + 
  • (proxy? thing) -> boolean + 
  • (proxy-owner proxy) -> address-space + 
  • (proxy-local-ref proxy) -> value + 
  • (proxy-local-set! proxy value) + 
  • (proxy-remote-ref proxy) -> value + 
  • (proxy-remote-set! proxy value) + 
  • (any-proxy-value proxy) -> value +
+Make-proxy makes a new proxy, whose value in the current address space + is value. +Initially the new proxy has no value on other address spaces. +Proxy-owner returns the address space on which the proxy + was created. +

Proxy-local-ref and proxy-local-set! access and set the value of + the proxy in the current address space. +Proxy-remote-ref and proxy-remote-set! do the same for the + value on the address space on which the proxy was created. +They could be defined as follows: +

+  (define proxy-remote-ref
+    (lambda (proxy)
+      (remote-apply (proxy-owner proxy)
+                    proxy-local-ref
+                    proxy)))
+
+  (define proxy-remote-set!
+    (lambda (proxy value)
+      (remote-run! (proxy-owner proxy)
+                   proxy-local-set!
+                   proxy
+                   value)))
+
+Any-proxy-value returns either the local value of proxy, if there + is one, or the value on the proxy's owner. +

Note that the remote values may be transmitted between nodes and thus may be + a copy of the original value. +Each proxy is itself a unique global object and is never copied. +

+  (let ((x (make-proxy #f)))
+    (eq? x (remote-apply a1 (lambda () x))))
+   -> #t
+
+

Typically, a proxy only has a value on the owning address space. +Local values, via Proxy-local-ref and proxy-local-set!, + are only used when a per-address-space cell is needed. +An example might be a per-address-space queue of tasks. +

A proxy is required whenever a remote-run! or remote-apply may + refer to an object that should not be copied. +This includes lexically bound variables that are set!. +

+  (let* ((call-count 0)
+         (f (lambda ()
+              (set! call-count (+ 1 call-count)))))
+
+    (remote-apply a1 (lambda () (f) (f) (f)))
+
+    call-count)
+   -> 0 if a1 is not the local address space, 3 if it is.
+
+  (let* ((call-count (make-proxy 0))
+         (f (lambda ()
+              (proxy-remote-set!
+                call-count
+                (+ 1 (proxy-remote-ref call-count))))))
+
+    (remote-apply a1 (lambda () (f) (f) (f)))
+
+    (proxy-remote-ref call-count))
+   -> 3
+
+

Many system-supplied data structures, including locks, tables, queues, + placeholders and so forth should be put in proxies if they are used remotely. +

The current proxy GC algorithm does not collect proxies that are given values + on remote nodes. +All other proxies are eventually GC'ed when no longer referenced. +

Debugging Kali programs

+

Kali programs run in a distributed, multithreaded environment, making debugging + a non-trivial task. +As described in doc/threads.txt, when any thread raises an + error, Scheme 48 stops running all of the threads at that command level. +Kali does not extend this between address spaces, so other address spaces will + keep running as if nothing had happened. +Messages to the stopped address space are buffered until the user restarts + the stopped command level. +

Another difficulty in debugging Kali programs is that redefinitions are not + propagated between address spaces. +A redefinition is handled as a set! to the local cell for the variable. +Other address space have their own copies of the cell, which are not updated +automatically. The following example shows this effect. +

+> (define (f) 10)
+> (define (g) (f))
+> (g)
+10
+> (remote-apply a1 g)
+10
+> (define (f) 20)
+> (g)
+20
+> (remote-apply a1 g)
+10
+
+The remote application of g gets the original value of f, + not the new one. +The remote f can be updated by hand. +
+> (remote-run! a1 (lambda (x) (set! f x)) f)
+> (remote-apply a1 g)
+20
+
+Note that the argument to remote-run! is evaluated in the local address + space, and so gets the new value of f. +Doing +
+(remote-run! a1 (lambda () (set! f f)))
+
+would have had no effect. +Both occurrences of f would refer to the binding on the remote + address space. +When in doubt it is best to restart the program from scratch. +

The following procedure is useful in debugging multi-threaded programs. +

     
  • (debug-message element0 ...) +
+Debug-message prints the elements to `stderr', followed by a + newline. +The only types of values that debug-message prints in full are small + integers (fixnums), strings, characters, symbols, boolean, and the empty list. +Values of other types are abbreviated as follows. +
+ + + + +
+ + pair (...)
+vector #(...)
+procedure #{procedure}
+record #{<name of record type>}
+all others ???
+
+ +

The great thing about debug-message is that it bypasses Scheme 48's + I/O and thread handling. The message appears immediately, with no delays + or errors. +

Debug-message is exported by the structure debug-messages. +

Code sharing between address spaces

+

In Kali, Scheme code in one address space is treated as distinct from code +in all other address spaces. If the same file is loaded into two different +address spaces, each will have its own copy. If these two address spaces +both run that code in a third address space, that third space will get two +copies of the code. To avoid duplication, it is a good idea to load a +file into only one address space. +

The same lack of sharing occurs if, after a file is loaded, an image is +dumped and then used to start two address spaces. The two spaces are each +considered to have loaded the file. To circumvent this, +each Kali image contains a table of loaded code that can be shared between +address spaces, assuming that all spaces are using the same table. Address +spaces started with different tables are assumed to have nothing in common, +and all code needed for remote evaluation must be copied to the remote + address space. +The following procedure, from the structure address-spaces, can be used + to rebuild the shared-code table after loading additional code. +

     
  • (initialize-shared-address-space!) +
+This creates a table containing all existing code and and proxies. +This table is shared between all address spaces that are started from the + current image. +Code loaded before the call to initialize-shared-address-space! will + not be copied between address spaces. +
kelsey@research.nj.nec.com

+ diff --git a/doc/kali.ps b/doc/kali.ps new file mode 100644 index 0000000..3f536d3 Binary files /dev/null and b/doc/kali.ps differ diff --git a/doc/meeting.ps b/doc/meeting.ps new file mode 100644 index 0000000..3fcb07d Binary files /dev/null and b/doc/meeting.ps differ diff --git a/doc/module.ps b/doc/module.ps new file mode 100644 index 0000000..9ef281b Binary files /dev/null and b/doc/module.ps differ diff --git a/doc/news.txt b/doc/news.txt new file mode 100644 index 0000000..bbf9e57 --- /dev/null +++ b/doc/news.txt @@ -0,0 +1,681 @@ +-*- Mode: Indented-text; -*- + +Recent changes to Scheme 48. + +2/12/99 (Kali version 0.52.1) + Fixed a bug in the uid-request code. + Fixed the proxy vectors in shared address spaces. + +11/17/98 (Kali version 0.52) + Brought flat-environment code up-to-date. + The inspector now works with flat environments. + Kali has a new communication layer and a somewhat different interface; + see doc/kali.{ps|html}. + Proxies without remote values are now GC'ed. + The fluid-smashing hack is no longer used. Instead, the system saves + away the initial stretch of the dynamic environment for use with all + threads. + USER-MESSAGE has been renamed DEBUG-MESSAGE. + The C version of the VM can now be made from Kali. + Old Kali 0.46 images will not work with 0.52, due to all of the + architecture changes between 0.46 and 0.52. + +7/22/98 (version 0.52) + Bug fixes: + Fixed problems with unbound variables in SET! and the inliner. + Made macro expansion a bit less eager; this should reduce the amount + of heap space needed for compilation. + +6/29/98 (version 0.51) + Incompatible changes: + BIG-SCHEME no longer exports its version of DEFINE-RECORD-TYPE (but + it is available from the structure DEFRECORD). I am slowly removing + all uses of this version of DEFINE-RECORD-TYPE from the sources. + The version of DEFINE-RECORD-TYPE exported by DEFINE-RECORD-TYPES + checks that every constructor argument corresponds to a field. + Uses of LAP must list their free variables (see env/assem.scm). + Changes: + The functions exported by BIG-SCHEME that were not available elsewhere + are now exported by BIG-UTIL as well. + MAKE-RANDOM now checks its argument (but is still a fairly poor + source of pseudo-randomness). + SIGPIPE no longer kills the S48 process (this was done earlier but + not listed here). + The macro/module/compiler code has been reorganized. Hopefully + the only noticable difference is in the babble written when loading + files and packages. + Added CODE-QUOTE (in its own structure of the same name) for use + in writing hygienic macro-generating macros. CODE-QUOTE is the + same as QUOTE except that it does not strip off any of the macro + system's name annotations. + The FLOATNUMS package now exports FLOATNUM?. + Bug fixes: + Fixed phony stack-overflow bug. + Fixed a bug in thread time-debit mechanism. + Made floating point numbers always print as inexact. + Got rid of bogus type-error warnings when using floatnums. + Fixed declaration of call_startup_procedure in c/main.c. + +2/11/98 (version 0.50) + Fixed bug in closed-compiled version of READ-CHAR. + Fixed negative-key bug in integer tables. + +11/18/97 (version 0.49) + Removed some non-portable Kali code that had been accidentally + included in c/extension.c. + +10/29/97 (version 0.48) + The VM's calling convention now has the caller doing protocol checking, + instead of the callee. The *NARGS* register no longer exists. + Scheme's variable-arity procedures (APPLY, MAKE-VECTOR, +, -, etc.) + are usually handled without raising an exception. Calls with an + `atypical' number of arguments are now much faster. + Opcodes were added for >, <=, and >=. + Procedures can take up to about 8k arguments. The limit is determined + by the value of AVAILABLE-STACK-SPACE in scheme/vm/arch.scm. + Compiler detects wrong number of arguments in ((lambda ...) ...). + Removed the dynamic point from the dynamic environment to make + DYNAMIC-WIND behave reasonably with threads. + KILL-THREAD! should work more reliably. + The I/O primitives now pass OS error messages to the exception handlers. + I/O errors when flushing buffers no longer crash the system. + The Pre-Scheme compiler's hack for shadowing global variables with + local copies is no longer used. + Incompatible changes: + The internal thread interface was simplified. + There are some architecture changes; .image files will have to + be rebuilt. + ACCESS-SCHEME-48 and scheme/misc/slib-init.scm have been removed + (thanks to Mike Sperber's updating of slib). + +1/27/97 (version 0.47) + Fixed ,exit and added ,exit-when-done. + CASE now uses EQV? exclusively. + +11/5/96 (version 0.46) + Fixed a few minor thread problems. + opt/analyze.scm now writes to current-noise-port. + DELQ and DELETE now delete every instance, as the documentation claims. + There should be no more spurious heap-overflow interrupts. + Fixed bugs that caused the system to die if stdout blocked. + Template offsets have been increased to two bytes. + Disassembly of flat-lambda now works (fix from Michael Sperber). + +8/23/96 (version 0.45) + Fixed various problems with thread termination and nested schedulers. + Changed thread-internal interface to make schedulers easier to write. + BITWISE-{AND,IOR,XOR} now take an arbitrary number of arguments. + Output ports have their buffers flushed when Scheme 48 terminates. + In keeping with RnRS, CLOSE-{IN,OUT}PUT-PORT are now idempotent. + MODULO now handles negative arguments properly. + +6/20/96 (version 0.44) + The VM's byte-code interpreter and storage management code are + now compiled to separate C files. + The socket code works again. + +5/10/96 (version 0.42-0.43) + Various fixes to the thread and I/O systems. + The Unix interface code is more portable. + EOF (control-D) now resumes running all non-broken threads on + resumed command level. Thus EOF after a keyboard interrupt + (control-C) resumes running the interrupted thread. + +11/30/95 (version 0.41) + The distribution has been reorganized to reduce the number of files + in the top-level directory. + The threads implementation has been replaced with one based on engines + to allow for nested schedulers. + Threads are now included in the initial image. + The I/O system has been fixed and automatic periodic output buffer + flushing has been reinstalled. + Command levels have been integrated with the threads system to ensure + that at most one REPL is active at any time. + CONDVAR has been changed to PLACEHOLDER (condition variables being + something quite different). + ,profile no longer works, it will be fixed in a later version. + MIN and MAX now do inexact contagion. + +4/13/95 (version 0.40) + Renamed error-output-port to current-error-port. + Reinstated ".gdbinit"... + segment->template now takes parent templates debug data as an + argument. + Automatic periodic output buffer flushing has been + temporarily disabled. A future version of the I/O system + will fix it. + Fixed expansion of named LET. + The bummed-define-record-types structure is now gone; use + define-record-types instead. + There is somewhat better syntax checking now. + +8/12/94 (versions 0.38-0.39) + ,profile prints out profiling information + An interrupt is raised after ever GC; the default handler checks + to see if some reasonable amount of storage was reclaimed. + Some of the standard Scheme procedures, including LENGTH, FOR-EACH, + VECTOR, and ASSQ, are now significantly faster. + Making, accessing, and setting records is faster. + tar file now includes the top-level directory + The "scheme-level-2-internal" structure has been renamed to + "usual-resumer". + ` ( . ' is now illegal (as required by the R4RS grammar). + Made DELAY and FORCE comply with R4RS. + The EXPAND optimizer does a topological sort on definitions. + (optimize flat-environments) causes the compiler to produce + flat (instead of nested) lexical environments. + The I/O system has been rewritten to do its own buffering. There + are significant changes to unix.c to support this. See doc/io.txt. + (ERROR-OUTPUT) is now available from the structure i/o. + jar-defrecord has been replaced with a modified bummed-jar-defrecord + Files load about 25% faster, for a number of reasons. + Removed the copy of vm/arch.scm from the rts directory. + Threads and sockets work together; SOCKET-ACCEPT no longer blocks. + The compiler no longer prints out .'s as it compiles definitions. + +7/5/94 (version 0.37) + I/O opcodes now raise an interrupt instead of blocking (they still + block if no corresponding interrupt handler has been installed). + The threads code has been rewritten; threads that block on I/O + do not busy wait and THREAD-READ-CHAR and THREAD-PEEK-CHAR have + been removed. + Attempting to obtain a lock twice or to release an unowned lock + now signal errors. + READ-CHAR-WITH-TIMEOUT returns #F if the timeout occurs. + The socket structure is back in more-packages.scm. + Renamed .gdbinit to gdbinit + tar file now contains a top-level directory + +3/22/94 (version 0.36) + Removed doc/lsc.ps for copyright reasons. + Fixed (* 47123 46039) multiply bug. + Modified vm/README to make it easier to run the VM. + +3/16/94 (version 0.35) + Fixed (exact->inexact 0.1) -> 0..1. bug. + Fixed VM bug that permitted the creation of stored objects with + negative sizes. + +3/8/94 (version 0.34) + "make check" target tests out various features. + Fixes for SGI IRIX 4.0.5 and MIPS RISC/OS 4.51, courtesy + Bryan O'Sullivan. + debug/run.scm and the "medium system" work again now. + misc/static.scm should work on the 68000. + Command processor no longer fluid-binds (interaction-environment) + on recursive entry. + +2/24/94 (version 0.33) + Fixed bug in VM's interrupt system. + Made non-local srcdir work in Makefile. + Added (load-package 'bigbit) to vm/README. + +2/23/94 (version 0.32) + Some incompatible changes to the VM; .image files will have + to be rebuilt. + Improvements to configuration script and to unix.c to support + a wider variety of Unixes. The system should now work + under any Posix-compliant Unix (except maybe for + char-ready?; see comments in unix.c). + Upped the default heap size from 4 meg (2 per semispace) to 6 + meg (3 per semispace). + New command line argument -s for specifying size of + stack buffer. Default is 2500 (words). + $@ -> "$@" in script (thanks to Paul Stodghill for this fix). + Obscure interrupt/exception VM bug fixed. + It is now possible to put an initial heap image into static + memory (effectively allocated by OS process creation). + Immutable initial objects go into static read-only memory, + and mutable initial objects go into static read-write + memory. Initial objects not copied by the GC. There is no + documentation yet, but look at the rules for little and + debug/little.o in the Makefile if you're interested. + +2/13/94 (version 0.31) + Incompatible changes: + In interfaces, all exported syntactic keywords must be + given type :syntax. For example, + (define-interface my-macros + (export (my-macro :syntax) ...)) + Image entry procedures for the ,build command are now + passed a list of strings, not just a single string, for + the command line arguments following -a. + The names of the macros defined in scheme48.h + (pairp, car, string_length, etc.) are now all upper case. + New "configure" script generates Makefile from Makefile.in + and sysdep.h from sysdep.h.in (thanks to Gnu autoconf). + See INSTALL and doc/install.txt. + Bug fixes: + Can now make vectors (strings, etc.) as big as the amount + of heap space available (but you're still screwed if you + try to make one bigger than 2^23-1 bytes - don't do it). + Non-ANSI-ness fixed in scheme48vm.c (jump out of, then + back into, a block expected block-local variables to be + unchanged). + Fixed big/external.scm (had VECTOR-POSQ instead of ENUM). + In (define-syntax foo bar) you got an error if bar was a + variable reference. + Plugged a storage leak (file-environments table in + env/debug.scm). Images made with ,build were too large. + Flushed extraneous delay from make-reflective-tower. + Renamed variables in Makefile to resemble Gnu standards. + Fixed definition of LINKER_RUNNABLE in Makefile. + Added doc/call-back.txt. + Fixed define-enumerated documentation (doc/big-scheme.txt). + Environment maps no longer retained for things in initial.image + and scheme48.image. This makes scheme48.image about 170K + smaller. + +2/3/94 (version 0.30) + Faster EXPT. + FLOATNUMS improvement: (inexact->exact ) should now + work, e.g. + (inexact->exact (/ 1. 3.)) => 6004799503160661/18014398509481984 + Reinstated ACCESS-SCHEME-48 for the benefit of PSD (portable + scheme debugger) and a certain other software package that + shall remain nameless. It only knows about a small number of + procedures, including things like ERROR and FORCE-OUTPUT. + Various changes to support the Pre-Scheme compiler, notably + SET-REFLECTIVE-TOWER-MAKER!. + Incompatible change to the ENUMERATED structure: the names + foo/bar no longer become defined. Write (enum foo bar) + instead. This will macro expand into the correct small + integer. + +1/30/94 (version 0.29) + Fixed ps_run_time() to call sysconf() to find out how many + ticks there are per second. It used to assume 60. This + affects the output of the ,time command, so don't try + comparing numbers from this version with numbers from older + versions. + ,time command will now accept a command, e.g. + ,time ,load foo.scm. + It appears that if multiple arguments follow -a on the + argument line, they are concatenated together with spaces + separating them and passed to the startup procedure. I + don't know how long this has worked. This will change in + the future so that the startup procedure gets a list of + strings. + Installed what used to be called the GENERAL-TABLES structure + as the TABLES structure used by the system. This allows + the use of other comparison predicates besides EQ?, and + eliminates some code that had a restrictive copyright + notice. + ENUM, NAME->ENUMERAND, and ENUMERAND->NAME are all macros. + Enumerated types themselves are now macros as well. + +1/23/94 Fixed bad multiplication bug in VM: (* 214760876 10) was + returning 125112. + Moved RECORD-TYPE? and RECORD-TYPE-FIELD-NAMES from the + RECORDS-INTERNAL interface to the RECORDS interface, for + a somewhat closer approximation to MIT Scheme. + Various type system improvements. + Still no documentation for the ,exec package, but see + link/load-linker.exec for an example. + New generic function feature, exported by the METHODS + interface (see interfaces.scm), almost like in a certain + dynamic object-oriented language. + +1/11/94 (version 0.27) + Change: + The isomorphism used by CHAR->INTEGER and INTEGER->CHAR is + no longer ASCII. This change was introduced in order to + assist the development of portable programs. If you need + ASCII encoding, you should open the ASCII structure and + use the procedures CHAR->ASCII and ASCII->CHAR. + Features: + The help system is somewhat improved. + New form DEFINE-STRUCTURE defines a single structure. + Incompatible changes to package system: + Renamed DEFINE-PACKAGE to DEFINE-STRUCTURES + Renamed DEFINE-STRUCTURE to DEFINE + Renamed all the base types from FOO to :FOO. E.g. + :SYNTAX, :VALUE, :PAIR, etc. + Other: + Removed socket support due to restrictive copyright on some + of the C code that was in extension.c. + +12/21/93 ,take has been flushed in favor of ,exec ,load. Commands are + now accessed via a distinguished package instead of a table. + Documentation pending. + Postscript (.ps) files now included in doc/ subdirectory. (I + thought they had been there all along, but apparently I was + wrong.) + Enhanced, but still kludgey, floating point support. Use + ,open floatnum. + +12/12/93 (version 0.26) + NetBSD port. + Hacked write-level and write-depth for inspecting circular + structure. + Recursive FORCEs signal errors, e.g. + (force (letrec ((loser (delay (force loser)))) loser)) + +12/7/93 (version 0.25) + Bug fix: + filenames.make can now be remade using initial.image. This + means that you can snarf a distribution and then edit + USUAL-FEATURES before making scheme48.image. + + +12/6/93 Incompatible changes: + Change of terminology: "signature" --> "interface". + This means that DEFINE-SIGNATURE is now called + DEFINE-INTERFACE, etc. + Some structures have been renamed: + condition -> conditions + continuation -> continuations + exception -> exceptions + queue -> queues + port -> ports + record -> records, record-internal -> records-internal + table -> tables + template -> templates + The ,load-into command has been removed. Use ,in ... ,load + instead (see below), e.g. + ,in mumble ,load myfile.scm + The heap size for -h is specified in words, not bytes. As + before, the size must account for both semispaces; -h 2n + means n words per semispace. This change was actually + made a while ago, but I was confused as to what it meant. + Bug fixes: + #e1.7 reads as 17/10, (exact? 1+1.0i) => #f, and 1.0+i prints. + Features: + Things like ((structure-ref scheme if) 1 2 3) work. + The following commands now take arbitrary commands to execute + in the specified package, not just forms: + ,config ,user ,for-syntax ,in + For example, you can say + ,in mumble ,trace foo + This subsumes the functionality of the ,load-into and + ,load-config commands. + Dynamic loading of shared libraries for System V systems + (untested). + Documentation: + Somewhat improved. user-guide.txt now lists most of the + interesting built-in packages. lsc.ps is a draft of "A + Tractable Scheme Implementation," a paper submitted to Lisp + and Symbolic Computation. See also doc/big-scheme.txt, + doc/thread.txt, and doc/external.txt. + + +10/30/93 LET-SYNTAX and LETREC-SYNTAX. + Arrays (see big/array.scm). + Lots of internal changes. + +7/20/93 Features: + Type system. See doc/types.txt. + +7/4/93 Features: + New define-package clause (for-syntax *). + E.g. (define-package ((my-package ...)) + (open ...) + (for-syntax (open scheme my-utilities) + (files more-crud-for-syntax)) + ...) + A file name to package map is now used by the emacs + interface. Whenever you load a file, or zap from a file that + hasn't been previously loaded or zapped, the package in + which forms are being evaluated is remembered in a table. + The next time you zap some forms from the same file, they + will be evaluated in that package. + Sometimes you may get an association you don't want. In that + situation, you can use the ,forget command to delete an + entry in the table. + A new ,push command goes to a deeper command level. + Experimental "command preferred" command processor mode: if + you give the command ",form-preferred off", commands will + be "preferred" to forms, meaning that you don't need to + type a comma before giving a command. To see the value + of a variable FOO you have to say (begin foo). + Experimental "no levels" command processor mode: if you + give the command ",levels off", then an error will not + push a new command level. If you want to ignore an + error, you don't need to take any action - further + evaluations will happen at top level. If you want to + enter the inspector or get a preview, you can issue these + commands or a ,push command immediately after the error + occurs (more precisely, any time until the focus object + is set by some other command). + All of the mode-control commands (batch, bench, + break-on-warnings, form-preferred, and levels) take + an optional argument. When no argument is given, they + will toggle the corresponding mode. With an argument of + ON or OFF, they turn the mode on or off. + The ,flush and ,keep commands have been made more flexible + and verbose. + + +6/18/93 Incompatible changes: + The access-scheme48 procedure has gone away. Use ,open + or the module system instead. + The user, configuration, and for-syntax packages no longer + have variables bound to them in the configuration package. + Where previously you said: Now you should say: + ,in user
,user + ,in config ,config + ,in for-syntax ,for-syntax + ,load-into config ,load-config + ,load-into for-syntax ,for-syntax (load "file") + + Features: + There is an ,expand command for debugging macros. + The ,open command takes any number of structure names, and opens + them all (like ,new-package). + New procedure DEFINE-INDENTATION exported by the PP structure. + E.g. (define-indentation 'let-fluid 1) is like Gnu emacs's + (put 'let-fluid 'scheme-indent-hook 1). + The inspector simplifies generated names in continuation + source code display. E.g. when formerly it said + "Waiting for (#{Generated lambda} () (x->node (car exps)))" + now it says + "Waiting for (lambda () (x->node (car exps)))" + Macros can signal syntax errors by returning input expression + unchanged. (Comparison uses EQ?.) + + Documentation: + The doc/ directory contains a draft of a "Scheme 48 + Progress Report." + + Cleanup: + Procedure NULL-TERMINATE added to structure EXTERNALS's + signature. + "Vulgar Scheme" renamed to "Big Scheme". + Two new subdirectories, env/ (for programming environment) + and big/ (for Big Scheme), now contain most of what was + in the misc/ directory. + Several source files that were in the top level and link/ + directories have moved to the env/ and alt/ directories. + + +5/6/93 Bug fixes: + Fixed -h command line switch. The size was being improperly + divided by 4, so if you asked for an N megabyte heap, you'd + actually only get an N/4 megabyte heap. + Nested backquotes were broken for a while; should be fixed + now. + + Features: + Quoted structure is read-only: e.g. (set-car! '(a b) 3) will + produce an exception. + ,config [] and ,user [] are like ,in . + Unix socket support; see misc/socket.scm. + Now using gzip instead of compress for distributions. + ,open command offers to load packages. + A .gdbinit file sets a breakpoint at CM's exception raising + code, and defines a handy "preview" command. + +1/18/93 Feature: + Scheme 48 distributions now have version numbers. The + version number is printed in the image startup message. + Please include it in bug reports. + The module system is now documented. See doc/module.tex. + +12/17/92 Bug fixes: + Macro templates of the form (x ... y) are supported. + Macro templates are now less fussy about meta-variable + rank: you can do "(x y) ..." even when the rank of either + x or y (but not both) is too low; the low-ranking text + will be copied as many times as necessary. (A + meta-variable's "rank" is the number of ...'s it sits + under in the left-hand side of the rewrite rule.) + SYNTAX-RULES is now itself hygienic. This means you can + have a meta-variable named CAR, for instance. + + New development environment features: + Commands now start with comma (",") instead of colon + (":"). (Easier to type since it's not shifted.) + values, call-with-values, dynamic-wind, eval, + interaction-environment, and scheme-report-environment + added per upcoming Revised^5 Scheme report. See + doc/meeting.tex. + Modifications to quoted structure will now be detected and + reported as errors. + An interrupt will occur if an insufficient amount of memory + is reclaimed by a garbage collection. + Inspector now accepts arbitrary command processor commands + (with or without leading comma) + ,keep command controls retention of debugging information. + + Features removed: + #\page and #\tab. These aren't in the Scheme report. + Their absence in Scheme 48 will encourage portability. + access-scheme48 works with fewer names than before. Use the + package system instead. + Complex numbers not in the system, by default. Get them + back by changing usual-features in more-packages.scm. + + Features changed: + Many changes to package system. See doc/module.tex. + The :identify-image command is gone. Instead, supply a + second argument (optional) to the ,dump command. + The inspector's TEM command has been shortened to T. + + Internal changes and features: + Stored objects types are now part of the virtual machine + architecture, i.e. known to the byte-code compiler. + Run-time system is split up into many little modules. + File names are retained in debug database. (But not used for + anything yet...) + Tweaks to table package reduce standard image size by 50K + and increase compiler speed by 7%. + Immutability bit in object headers. + Weak pointers. + +7/18/92 Features removed: + Table package's default hash function no longer supports + string, pairs, or vectors. + +7/9/92 Bug fixes: + (- 0 -536870912) + Inspector now uses command i/o ports instead of current ones + Inexact integers print as N. instead of #iN + Throwing back into a call-with-....put-port now produces a + warning instead of an error + + Feature fixes: + In DEFINE-PACKAGE, OPEN no longer implies ACCESS. + misc/receive.scm renamed to rts/values.scm, made to conform + with Revised^5 Report, and installed internally. + + Features: + New :load-package command. Uses file names in (file ...) clause + of a define-package. These are interpreted relative to the + directory in which the file containing the define-package + was found. + #\tab and #\page now print this way. + + +6/17/92 Bug fixes: + Fixed bug in modulo. + Flushed LAST-PAIR (which disappeared between R^3 and R^4). + DEFINE-SYNTAX and SYNTAX-RULES now exist. + CEILING, FLOOR, and ROUND now exist. + GCD and LCM are now n-ary. + STRING-CI=? and STRING-COPY fixed. + STRING->SYMBOL now copies its argument before handing it to + INTERN. + =, <, etc. now work with more than two arguments. + CHAR-READY? exists. + Calls via APPLY are now tail-recursive. + DISPLAY of vectors and lists works (ugh). + + Development environment improvements: + Type ? at inspector to get list of inspector commands. + Inspector D command goes to next continuation. + Inspector M command shows more of a long menu. + Inspector TEM command goes to a continuation's or closure's + template. + For closures and continuations, inspector displays local + variables with their names. + For continuations, inspector displays source code for + expression into which control will return. + Multiple command loop levels. EOF (control-D) now only pops + out a single level. :reset pops all the way out. :level n + goes out to level n. + Can disable benchmark mode. + Procedures made with (let ((f (lambda ...))) ...) now print + with names. + + Features: + Package system: special forms define-package and package-ref; + command processor commands :set-package, :load-into, + :clear-package, :new-package, :export, :open-package, etc. + In misc directory: threads, queues, extended ports, format, etc. + + Changes to system environment: + user-initial-environment -> user-package + record-updator -> record-modifier + primitive-throw superseded by with-continuation + ash -> arithmetic-shift + New bootstrap regime. + Support for threads: alarm clock interrupt, etc. + + Etc.: + Liberal COPYRIGHT file, and a little notice in each source file. + INSTALL and NEWS split off from README. + doc.txt renamed to user-guide.txt. + The Makefile now provides two ways to make "s48" for + installation. One depends on the exec #! script execution + feature and the other doesn't. + "make" targets for testsys.image and little.image. + Runs Jaffer's test suite and library. + Flushed s48.el. Use cmuscheme instead. + + +9/5/90 Command processor argument parser revamped. + :load, :trace, and :untrace commands take arbitrary number + of arguments. Argument to :proceed is optional. + New (but undocumented) :identify-image command. + Better error messages: wrong number of arguments, undefined + variable. + +, *, min, max, apply are now n-ary; -, /, make-string, + make-vector, read-char, peek-char, write-char have + appropriate argument optionality. + Better internal support for macros; not yet ready for release. + Added STRING as per R^3.99RS. + More testing of Scheme version of bytecode interpreter. + Better scoping of ##; files can't see command processor context. + OR and CASE don't cons closures. + VM checks for non-existent heap image file, gives error + message instead of "bus error". + Numerous internal changes in compiler and exception system. + Fixed charnumber. + +8/26/90 Tested (link-system) inside of T; seems to work. + Benchmark mode available via :BENCH command. + System is 15K bigger due to new fatter global environment + representations. + Inspector abbreviation improved. + Disassembler now works on continuations, sort of. + +7/26/90 ((lambda ...) ...) no longer makes a closure + Features now in default system: + :inspect + :dis[assemble] + Generic arithmetic: bignums, rationals, complexes + rationalize + :time command is more verbose + MOREFILES variable in Makefile for loading extra stuff + Default heap size increased to 2 megabytes per semispace diff --git a/doc/no-leaf-env.txt b/doc/no-leaf-env.txt new file mode 100644 index 0000000..87a6967 --- /dev/null +++ b/doc/no-leaf-env.txt @@ -0,0 +1,175 @@ +Return-Path: +Date: Mon, 14 Jun 93 14:34:40 -0400 +To: jar@cs.cornell.edu +Subject: environments for leaf procedures +From: kelsey@flora.ccs.neu.edu +Sender: kelsey@ccs.neu.edu + + +I merged the no-leaf-environments code back into the system, and this +time it may be worth it. Loading pp.scm sped up by 2%, even though +the compiler is doing more work. Benchmark times (in seconds): + + old new speedup +quicksort 1.48 1.39 6% +towers 1.05 1.05 0% +matrix-multiply 3.32 3.10 7% +matrix-multiply2 1.94 1.80 7% + +Local variable names are screwed up: + + > (define (f x) (let ((y 4)) (+ x y))) + > (f 'a) + + Error: exception + (+ 'a 4) + 1> ,debug + '#{Continuation (pc 13) f} + + [0] 4 + [1: y] 'a + inspect: + +There is probably a simple fix for this. + +Here is the diff: + +% diff comp.scm comp.scm.save +26d25 +< (define $compiling-leaf (make-fluid 'no)) +28,33d26 +< (define (note-not-leaf!) +< (set-fluid! $compiling-leaf 'no)) +< +< (define (compiling-leaf?) +< (eq? 'yes (fluid $compiling-leaf))) +< +63,82c56,66 +< (deliver-value (if (env-ref? den) +< (local-variable den cenv depth #f) +< (instruction-with-variable op/global exp den #f)) +< cont))) +< +< (define (local-variable den cenv depth set?) +< (let ((back (env-ref-back den cenv)) +< (over (env-ref-over den))) +< (if (and (compiling-leaf?) +< (= back 0)) +< (instruction (if set? op/stack-set! op/stack-ref) +< (+ (- over 1) depth)) +< (let ((back (if (compiling-leaf?) (- back 1) back))) +< (if set? +< (instruction op/set-local! back over) +< (case back +< ((0) (instruction op/local0 over)) ;+++ +< ((1) (instruction op/local1 over)) ;+++ +< ((2) (instruction op/local2 over)) ;+++ +< (else (instruction op/local back over)))))))) +--- +> (if (env-ref? den) +> (let ((back (env-ref-back den cenv)) +> (over (env-ref-over den))) +> (deliver-value (case back +> ((0) (instruction op/local0 over)) ;+++ +> ((1) (instruction op/local1 over)) ;+++ +> ((2) (instruction op/local2 over)) ;+++ +> (else (instruction op/local back over))) +> cont)) +> (deliver-value (instruction-with-variable op/global exp den #f) +> cont)))) +143,145c127,132 +< (if (env-ref? den) +< (local-variable den cenv depth #t) +< (instruction-with-variable op/set-global! name den #t))) +--- +> (cond ((env-ref? den) +> (instruction op/set-local! +> (env-ref-back den cenv) +> (env-ref-over den))) +> (else +> (instruction-with-variable op/set-global! name den #t)))) +203d189 +< (note-not-leaf!) ; this isn't strictly necessary, but it keeps things simpler +222,231c208,215 +< (cond ((return-cont? cont) +< code) +< (else +< (note-not-leaf!) ; this isn't strictly necessary, but it keeps things simpler +< (sequentially (instruction-with-offset&byte op/make-cont +< (segment-size code) +< depth) +< (note-source-code (cont-source-info cont) +< code) +< (cont-segment cont))))) +--- +> (if (return-cont? cont) +> code +> (sequentially (instruction-with-offset&byte op/make-cont +> (segment-size code) +> depth) +> (note-source-code (cont-source-info cont) +> code) +> (cont-segment cont)))) +264d247 +< (note-not-leaf!) +280,315c263,284 +< (let-fluids $compiling-leaf 'maybe +< (lambda () +< (let ((code (really-compile-lambda-code formals body cenv name))) +< (if (eq? (fluid $compiling-leaf) 'maybe) +< (let-fluids $compiling-leaf 'yes +< (lambda () +< (really-compile-lambda-code formals body cenv name))) +< code))))) +< +< (define (really-compile-lambda-code formals body cenv name) +< (let* ((nargs (number-of-required-args formals)) +< (vars (normalize-formals formals)) +< (cenv (if (null? formals) +< cenv ;+++ +< (bind-vars vars cenv)))) +< (sequentially +< (cond ((n-ary? formals) +< (sequentially +< (instruction op/make-rest-list nargs) +< (instruction op/push) +< (if (compiling-leaf?) +< empty-segment +< (instruction op/make-env (+ nargs 1))))) +< ((null? formals) +< (note-not-leaf!) ; no point if no variables +< empty-segment) +< ((compiling-leaf?) +< empty-segment) +< (else +< (instruction op/make-env nargs))) +< (note-environment +< vars +< (compile-body body +< cenv +< 0 +< (return-cont name)))))) +--- +> (if (null? formals) +> (compile-body body ;+++ Don't make null environment +> cenv +> 0 +> (return-cont name)) +> (sequentially +> (let ((nargs (number-of-required-args formals))) +> (if (n-ary? formals) +> (sequentially +> (instruction op/make-rest-list nargs) +> (instruction op/push) +> (instruction op/make-env (+ nargs 1))) +> (instruction op/make-env nargs))) +> (let* ((vars (normalize-formals formals)) +> (cenv (bind-vars vars cenv))) +> (note-environment +> vars +> (compile-body body +> cenv +> 0 +> (return-cont name))))))) +> + diff --git a/doc/package.txt b/doc/package.txt new file mode 100644 index 0000000..0532411 --- /dev/null +++ b/doc/package.txt @@ -0,0 +1,81 @@ +-- this file is probably obsolete -- + +The package system interface. Much too complicated. + +Signatures + + make-simple-signature + make-compound-signature + signature? + signature-ref + signature-walk + +Structures + + make-structure + structure? + structure-signature + structure-package + structure-name + +Packages + + make-package + make-simple-package ;start.scm + +Lookup and definition operations + + package-lookup + package-lookup-type ;comp.scm + package-find-location ;rts/env.scm + package-lookup-location ;segment.scm + probe-package + package-check-assigned + package-check-variable + + package-define! + package-define-type! ;hmm. + package-ensure-defined! + +Things needed by the form/file/package scanner + + for-each-definition ;for integrate-all-primitives! + package-accesses ;for scan-package + package-clauses ;for scan-package + package-file-name ;for scan-package + package-opens ;for scan-package + package-evaluator ;for define-syntax + package-for-syntax ;for define-syntax + +Miscellaneous + + $note-undefined ;eval.scm + noting-undefined-variables ;eval.scm, etc. + package-uid ;eval.scm + set-shadow-action! ;eval.scm + verify-later! ;for the define-structures macro + reset-packages-state! ;Makefile - for linker + initialize-reified-package! ;for reification + transform-for-structure-ref ;for reification ? + +Inessential (for package mutation, programming environment) + + check-structure + package-integrate? ;env/debug.scm + set-package-integrate?! ;env/debug.scm + package-loaded? ;env/load-package.scm + set-package-loaded?! ;env/load-package.scm + package-name ;env/command.scm + package-name-table ;env/debuginfo.scm + package-open! ;env/debug.scm + package-system-sentinel ;env/command.scm + package-unstable? ;env/pacman.scm + package? ;env/command.scm + undefined-variables ;env/debug.scm + +Location names (also inessential) + + flush-location-names + location-name + location-name-table + location-package-name diff --git a/doc/scheme48.man b/doc/scheme48.man new file mode 100644 index 0000000..6463bae --- /dev/null +++ b/doc/scheme48.man @@ -0,0 +1,81 @@ +.TH LS48 1 +.\" File scheme48.man: Manual page template for Scheme 48. +.\" Replace LS48 with the name of your default image and LLIB with the +.\" directory containing scheme48vm and default image. +.SH NAME +LS48 \- a Scheme interpreter +.SH SYNOPSIS +.B LS48 +[-i image] [-h heapsize] [-a argument] +.SH DESCRIPTION +.B LS48 +is an implementation of the Scheme programming language as described in +the +.I "Revised^4 Report on the Algorithmic Language Scheme." +A runnable system requires two parts, an executable program that implements +the Scheme 48 virtual machine, and an image that is used to initialize +the store of the virtual machine. +.B LS48 +is a shell script that starts the virtual machine with an image that runs +in a Scheme command loop. +.PP +The +.B LS48 +command loop reads Scheme expressions, +evaluates them, and prints their results. +It also executes commands, which are identified by an initial comma character. +Type the command +.I ,help +to receive a list of available commands. +.PP +The +.B \-h +option causes +.IR heapsize +words to be allocated for both semispaces of the copying garbage +collector. One word is four bytes. Cons cells are currently 3 words, +so if you want to make sure you can allocate, say, a million cons +cells, you should specify +.B \-h +6000000 (actually a little more, to account for the initial heap +image and breathing room). +.PP +The +.I ,dump +and +.I ,build +commands put heap images in files. +The +.B \-i +option causes the initial heap image to be taken from file +.IR image . +The +.B \-a +option causes a list of strings to be passed as the argument +to an image generated using the +.I ,build +command. The first argument to +.I ,build +is a procedure that is passed +the arguments following +.B \-a +and which should return an integer (which is the +return value of the Scheme 48 process). +.PP +.nf + > ,build (lambda (a) (display a) (newline) 0) foo.image + > ,exit + $ LS48 -i foo.image -a mumble + mumble + $ +.PP +.fi +.SH FILES +.TP 40 +.B LLIB/scheme48vm +the virtual machine. +.TP +.B LLIB/LS48.image +the default image. +.SH BUGS +Procedure calls with more than 63 explicit arguments might not work. diff --git a/doc/src/code.tex b/doc/src/code.tex new file mode 100644 index 0000000..aa8de05 --- /dev/null +++ b/doc/src/code.tex @@ -0,0 +1,94 @@ +% Latex Macros for Lisp code in text. +% Based on macros found in C. Rich's library. + +\makeatletter + +% \vobeyspaces turns all spaces into non-breakable spaces. +% Note: this is like \@vobeyspaces except without spurious space in defn. + +{\catcode`\ =\active\gdef\vobeyspaces{\catcode`\ =\active\let =\@xobeysp}} + +% \def\vobeytabs turns all tabs into 8 non-breakable spaces + +{\catcode`\^^I=\active\gdef\vobeytabs{\catcode`\^^I=\active\let^^I=\xvobeytabs}} + +\def\xvobeytabs{\@xobeysp\@xobeysp\@xobeysp\@xobeysp\@xobeysp\@xobeysp\@xobeysp\@xobeysp} + +% \vobeylines turns all cr's into non-breakable \par's + +{\catcode`\^^M=\active\gdef\vobeylines{\catcode`\^^M=\active\let^^M=\xvobeylines}} + +\def\xvobeylines{\par\penalty10000} + +% \obeycrsp turns cr's into non-breakable spaces + +{\catcode`\^^M=\active\gdef\obeycrsp{\catcode`\^^M=\active\let^^M=\@xobeysp}} + +%% \@noligs prevents ?` and !` from being treated as ligatures +%% added 19 April 86 [copied from Latex sources] + +\begingroup +\catcode``=13 +\gdef\@noligs{\let`=\@lquote} +\endgroup + +% Set up code environment, in which most of the common special characters +% appearing in code are treated verbatim, namely: _ # & ^ $ ~ @ " % +% *** JAR NEEDED $ AND _ IN SOME CODE *** + +% Note: \ { } are still enabled so that macros can be called in this +% environment. Use \\, \{ and \} to use these characters verbatim +% in this environment. + +% Note: this environment allows no breaking of lines whatsoever; not +% at spaces or hypens. To arrange for a break use the standard \- macro, +% or the \= macro which breaks, but inserts nothing. This is useful, +% for example for allowing hypenated identifiers to be broken, e.g. +% FOO-\=BAR. + +\def\setupcode{\parsep=0pt\parindent=0pt + \tt\frenchspacing\catcode``=13\@noligs% + \def\\{\char`\\}% + \@makeother\#\@makeother\&\@makeother\^%\@makeother\_\@makeother\$% + \@makeother\`\@makeother\'% + \@makeother\~\@makeother\@\@makeother\"\@makeother\%\vobeytabs\vobeyspaces} + +% Code environment as described above. Note that blank lines are +% not preserved, and lines are not kept on one page. Code is +% indented by the same amount as quotes. +% Note: to increase left margin, use \leftmargini=1in. +% was {\list{}{\parsep=0pt}\item[]\setupcode\obeylines}% +% then {\list{\parsep=0pt\listparindent=0pt\leftmargin=0pt}{}\item[]\setupcode% + +\newenvironment{bigcode}% + {\list{}{\parsep=0pt\leftmargin=0pt\labelwidth=0pt\itemindent=0pt% +\listparindent=0pt}\item[]\setupcode% +\obeylines}% + {\endlist} + +% Code is just like bigcode, but everything inside is kept on one page +% Note: This actually works by setting a huge penalty for breaking +% between lines of code. +% was {\list{}{\parsep=0pt}\item[]\setupcode\vobeylines}% + +\newenvironment{code}% + {\list{}{\parsep=0pt\leftmargin=0pt\labelwidth=0pt\itemindent=0pt% +\listparindent=0pt}\item[]\setupcode% +\vobeylines}% + {\endlist} + +% Reasonable separation between lines of code + +\newcommand{\codeskip}{\penalty0\vspace{2ex}} + +% \cd is used to build a code environment in the middle of text. +% Note: only difference from display code is that cr's are taken +% as unbreakable spaces instead of \par's. + +\newcommand{\cd}{\begingroup\setupcode\obeycrsp\startcode} + +\newcommand{\startcode}[1]{#1\endgroup} + +%\setbox0\hbox{\@xobeysp}\hline{43\wd0} + +\makeatother diff --git a/doc/src/hyperlatex.sty b/doc/src/hyperlatex.sty new file mode 100644 index 0000000..b6ef1b3 --- /dev/null +++ b/doc/src/hyperlatex.sty @@ -0,0 +1,253 @@ +%% +%% LaTeX style to handle hyperlatex files, version 2.3 +%% +%% $Modified: Fri May 9 13:40:27 1997 by otfried $ +%% +%% This code has GNU copyleft, 1994-1998 Otfried Cheong +%% +\NeedsTeXFormat{LaTeX2e} + +\ProvidesPackage{hyperlatex} +[1998/09/08 v2.3 LaTeX2e package for Hyperlatex mode] + +\typeout{Package: 'hyperlatex' v2.3 Otfried Cheong} + +\RequirePackage{verbatim} +\chardef\other=12 + +%% +%% Comments, +%% +{\obeylines\gdef\Hlx@W#1^^M{\endgroup\ignorespaces}} +\def\W{\begingroup\obeylines\catcode`\{=\other\catcode`\}=\other\Hlx@W} + +\newcommand{\htmlonly}[1]{} +\newcommand{\texorhtml}[2]{#1} +\newenvironment{iftex}{}{} +\newenvironment{latexonly}{}{} +\newcommand{\texonly}[1]{#1} +\newcommand{\T}{} + +%% +%% Treatment of special characters +%% + +\def\Hlx@nonspecials{} +\def\NotSpecial{\def\Hlx@nonspecials} +\def\Hlx@turnon{\let\do=\@makeother\Hlx@nonspecials} +\AtBeginDocument{\Hlx@turnon} + +\let\htmltab=& + +%% +%% \begin{tex} ... \end{tex} escapes into raw Tex temporarily. +%% you can write {\tex .....} as well, if already escaped from Html +%% +\newenvironment{tex}{\catcode `\$=3 \catcode `\&=4 \catcode `\#=6 +\catcode `\^=7 \catcode `\_=8 \catcode `\%=14}{} + +%% +%% \back +%% + +\newcommand{\back}{{\tt\char`\\}} + +%% +%% \math +%% + +\def\math{\@ifnextchar [{\@math}{\@math[]}} +\def\@math[#1]{\begingroup\tex\@@math} +\def\@@math#1{$#1$\endgroup} + +%% +%% Commands that don't do anything interesting in Latex +%% + +\def\Hlx@pass{\begingroup\let\protect\@unexpandable@noexpand\@sanitize} + +\def\Hlx@directory{.} + +\newcommand{\htmldirectory}[1]{\gdef\Hlx@directory{#1}} +\newcommand{\htmlname}[1]{} +\newcommand{\htmldepth}[1]{} +\newcommand{\htmltopname}[1]{} +\newcounter{htmldepth} +\newcommand{\htmltitle}[1]{} +\newcommand{\htmladdress}[1]{} +\newcommand{\html}{\Hlx@pass\@html} +\def\@html#1{\endgroup} + +\newcommand{\htmlsym}[1]{} +\def\htmlrule{\@ifnextchar [{\@htmlrule}{\@htmlrule[]}} +\def\@htmlrule{\Hlx@pass\@@htmlrule} +\def\@@htmlrule[#1]{\endgroup} + +\newcommand{\htmllevel}[1]{} +\newcommand{\htmlmenu}[1]{} +\newcommand{\htmlautomenu}[1]{} +\newcounter{htmlautomenu} +\newcommand{\htmlprintindex}{} +\newcommand{\htmlfootnotes}{} +\newcommand{\htmlmathitalic}[1]{} + +\def\htmlimage{\@ifnextchar [{\@htmlimage}{\@htmlimage[]}} +\def\@htmlimage{\Hlx@pass\@@htmlimage} +\def\@@htmlimage[#1]#2{\endgroup} + +\newcommand{\xname}{\Hlx@pass\Hlx@ignore} +\def\Hlx@ignore#1{\endgroup} + +\newcommand{\htmlpanel}[1]{} +\newcommand{\htmlheading}{\@ifnextchar[{\@htmlheading}{\@htmlheading[]}} +\def\@htmlheading[#1]#2{} + +\newcommand{\htmlcaption}[1]{} + +\def\htmlattributes{\@ifstar{\@htmlattributes}{\@htmlattributes}} +\def\@htmlattributes{\Hlx@pass\@@htmlattributes} +\def\@@htmlattributes#1#2{\endgroup} + +%% +%% GIF environment, +%% will generate bitmaps when `\makegifs' is defined +%% + +\newif\if@makegifs +\@ifundefined{makegifs}{\@makegifsfalse}{\@makegifstrue} + +\def\gif{\@ifnextchar[{\@gif}{\@gif[b]}} +\def\@gif[#1]{\@ifnextchar[{\@@gif}{\@@gif[100]}} +\def\@@gif[#1]{\gdef\gif@resolution{#1}\@ifnextchar[{\@@@gif}{\@@@gif[300]}} +\def\@@@gif[#1]#2{\gdef\gif@dpi{#1}\gdef\gif@name{#2}\@@@@gif} + +\if@makegifs +\typeout{**********************************************} +\typeout{* Making GIF bitmaps from Hyperlatex source! *} +\typeout{**********************************************} +\newwrite\@makegifcmds +\immediate\openout\@makegifcmds=\jobname.makegif +\newbox\@gifbox +\newcount\@gifcount\@gifcount=10000 +\def\@@@@gif{\setbox\@gifbox=\vbox\bgroup\tex} +\def\endgif{\egroup + {\global\advance\@gifcount by 1\count0=\@gifcount + \immediate\write\@makegifcmds{dvips\space -f\space -p\space + \the\@gifcount\space -n\space 1\space -E\space -D\space \gif@dpi\space + \jobname.dvi\space>\space\gif@name.ps^^J% + ps2gif\space -res\space \gif@resolution\space \gif@name.ps^^J% + mv\space \gif@name.gif\space \Hlx@directory^^J} + \shipout\copy\@gifbox}\unvbox\@gifbox} +\else +\def\@@@@gif{\tex} +\def\endgif{} +\fi +%% +%% Font style definitions +%% + +\let\cit=\textit +\let\code=\texttt +\let\kbd=\texttt +\let\samp=\texttt +\let\strong=\textbf +\let\var=\textsl +\let\dfn=\textit +\let\file=\textit + +%% +%% \begin{example} ... \end{example} obeys spaces and lines +%% +%% the indent can be controlled by \exampleindent +%% +\newdimen\exampleindent +\setlength{\exampleindent}{7mm} +\def\Hlx@example{\do\$\do\&\do\#\do\^\do\_\do\~} +{\obeyspaces + \gdef\turnon@spaces{\let =\ \obeyspaces\catcode``=\active\@noligs}} +{\obeylines% + \gdef\turnon@lines{\obeylines\def^^M{\par\def^^M{\leavevmode\par}}}} + +\def\example{\list{}{\leftmargin\exampleindent + \itemindent\z@ \rightmargin\z@ \parsep \z@ plus\p@}\item[]\tt + \turnon@spaces\turnon@lines\let\do\@makeother\Hlx@example} +\let\endexample=\endlist + +%% +%% font problem: math in example environment seems to need this: +%% +\DeclareFontFamily{OMS}{cmtt}{} +\DeclareFontShape{OMS}{cmtt}{m}{n}{ <-> ssub * cmsy/m/n }{} + +\newenvironment{menu}{\list{$\bullet$}{\itemsep0pt\parsep0pt}}{\endlist} +\newenvironment{ifhtml}{\comment}{\endcomment} +\newenvironment{rawhtml}{\comment}{\endcomment} + +\def\htmlinclude#1{} + +\def\Hlx@empty{} +\def\Hlx@zero{0} +\newif\if@Hlx + +\def\Hlx@setclear#1{\@ifundefined{#1}{\@Hlxfalse}{% + \expandafter\ifx\csname#1\endcsname\Hlx@empty\@Hlxfalse + \else\expandafter\ifx\csname#1\endcsname\Hlx@zero\@Hlxfalse + \else\@Hlxtrue\fi\fi}} + +\def\ifclear#1{\Hlx@setclear{#1} + \if@Hlx + %% arg empty -> skip + \let\endifset\endcomment\let\Hlx@comment\comment + \else + %% arg set -> ignore begin and end + \let\endifset\relax\let\Hlx@comment\relax + \fi\Hlx@comment} + +\def\ifset#1{\Hlx@setclear{#1} + \if@Hlx + % arg empty -> ignore begin and end + \let\endifclear\relax\let\Hlx@comment\relax + \else + % arg set -> skip environment + \let\endifclear\endcomment\let\Hlx@comment\comment + \fi\Hlx@comment} + +%% +%% Define \link and \xlink macros +%% +\newcommand{\Hlx@label}{} + +\newcommand{\Ref}{\ref{\Hlx@label}} +\newcommand{\Pageref}{\pageref{\Hlx@label}} +\newcommand{\Cite}{\cite{\Hlx@label}} + +\newenvironment{Label}[1]{\def\Hlx@Label@label{\label{#1}}\ignorespaces}% +{\Hlx@Label@label\ignorespaces} + +\newcommand{\htmlcite}[1]{\cite{#1}} + +\def\link{\@ifstar{\@star@link}{\@@link}} +\def\@@link#1{#1\@@@link} +\def\@star@link#1{\@@@link} +\def\@@@link{\@ifnextchar [{\@link}% ] balance + {\@link[]}} +\def\@link[#1]#2{\gdef\Hlx@label{#2}#1} + +\def\xlink{\@ifstar{\@star@xlink}{\@@xlink}} +\def\@@xlink#1{\@@@xlink{#1}} +\def\@star@xlink#1{\@@@xlink{}} +\def\@@@xlink#1{\@ifnextchar [{\@xlink{#1}}{\@xlink{#1}[]}} +\def\@xlink#1[#2]#3{\formatxlink{#1#2}{#3}} +\newcommand{\formatxlink}[2]{#1} + +% +% index from latex.tex, and changed to include optional argument +% +\def\cindex{\@bsphack\begingroup + \let\protect\@unexpandable@noexpand + \@sanitize + \@ifnextchar [{\Hlx@argwrindex}% balance ] + {\@wrindex}} +\def\Hlx@argwrindex[#1]#2{\@wrindex{#1@#2}} + +%% end of hyperlatex.sty diff --git a/doc/src/kali.tex b/doc/src/kali.tex new file mode 100644 index 0000000..1e4b540 --- /dev/null +++ b/doc/src/kali.tex @@ -0,0 +1,358 @@ +\documentclass{article} +\usepackage{hyperlatex} + +\setcounter{htmldepth}{1} + +\newcommand{\xsubsection}[1]{% +\texonly{\subsection{#1}}% +\htmlonly{\strong{#1}\\}% +} + +\newcommand{\evalsto}{% +\texonly{$\rightarrow$}% +\htmlonly{\code{->}}% +} + +\newcommand{\cvar}[1]{% +\texonly{{\em{#1}}}% +\htmlonly{\code{\var{#1}}}% +} + +%%%%%%%%%%%%%%%% Latex prototypes +\texonly{ +\newenvironment{protos}{\list{$\bullet$} +{\leftmargin1.2em\rightmargin0pt\itemsep0pt\parsep0pt\partopsep-2pt}} +{\endlist} + +% The following is for prototypes that have return types. +% (foo int int) -> int + +\newcommand{\proto}[3]{\item\noindent\unskip% +\cindex{\code{#1}}% +\hbox{\spaceskip=0.5em\code{({#1}{\it#2\/})} {$\rightarrow$} {\it#3}}} + +% TeX (or LaTeX, who can say?) is such a piece of crap. This has to be put at +% the end of each block of prototypes to avoid a spurious warning. +%\newcommand{\postproto}{\hspace*{\fill}} + +\newcommand{\protonoresult}[2]{\item\noindent\unskip% +\hbox{\spaceskip=0.5em\code{(\hbox{#1}{\it#2\/})}}} + +% Syntax prototypes + +\newcommand{\syntaxprotonoresult}[2]{\item\noindent\unskip% +\hbox{\spaceskip=0.5em\code{(\hbox{#1}{#2})}}\hfill\penalty 0% +\hbox{ }\nobreak\hfill\hbox{\rm syntax}} + +\newcommand{\syntaxproto}[3]{\syntaxprotonoresult{#1}{#2}% +\hspace*{24pt}{$\rightarrow$} {\it#3}} + +% This can be reduced + +\newcommand{\pconstproto}[2]{\noindent\unskip% +\hbox{\spaceskip=0.5em#1}\code\hfill\penalty 0% +\hbox{ }\nobreak\hfill\hbox{\rm #2}} + +% Variable prototype +\newcommand{\constproto}[2]{\pconstproto{#1}{#2}} + +} +%%%%%%%%%%%%%%%% end of Latex proto definitions + +%%%%%%%%%%%%%%%% HTML prototypes +\htmlonly{ +\newenvironment{protos}{\begin{itemize}}{\end{itemize}} + +% The following is for prototypes that have return types. +% (foo int int) -> int + +\newcommand{\proto}[3]{% +\cindex{\code{#1}}% +\item\noindent\code{({#1}{\var{#2}\/})~-->~{\var{#3}}}} + +\newcommand{\protonoresult}[2]{% +\cindex{\code{#1}}% +\item\noindent\code{({#1}{\var{#2}\/})}} + +} +%%%%%%%%%%%%%%%% end of HTML proto definitions + +\makeindex + +\htmltitle{A Quick Guide to Kali} +\htmladdress{kelsey@research.nj.nec.com} + +\title{A Quick Guide to Kali} +\author{Richard A. Kelsey \\ NEC Research Institute \\ kelsey@research.nj.nec.com} + +\date{} + +\begin{document} +\maketitle + +\section{Address spaces and servers} + +Address-spaces are an abstraction of Unix processes. +An address space is identified by the machine on which it runs and the + socket on which it listens + for connections from other address spaces. +New address spaces can be added as a Kali program runs. + +All of the procedures described in this section are in structure \code{kali}. + +\begin{protos} +\protonoresult{start-server}{} +\end{protos} +This starts a server for the current process, making it an address space. +The socket that the server is listening on is printed out. +Normally the server is started as a separate thread, using \code{spawn} + from structure \code{threads}. + +\begin{example} +> ,open kali threads +> (spawn start-server 'kali-server) +Waiting for connection on port 1228 +> +\end{example} + +\begin{protos} +\proto{socket-id->address-space}{ machine-name socket}{address-space} +\proto{address-space?}{ thing}{boolean} +\protonoresult{remote-run!}{ address-space procedure arg$_0$ \ldots} +\proto{remote-apply}{ address-space procedure arg$_0$ \ldots}{values} +\end{protos} +\code{Socket-id->address-space} returns the address-space corresponding to + the process whose server is listening at \cvar{socket} on \cvar{machine-name}. +\cvar{Socket} should be the socket number printed out by the call to + \code{start-server} that created the address space. + +\code{Address-space?} is the predicate for address spaces. + +\code{Remote-run!} and \code{remote-apply} transport \cvar{procedure} + and \cvar{arguments} to \cvar{address-space} and do the application there. +\code{Remote-run!} returns immediately, while \code{remote-apply} blocks until + \cvar{procedure} returns, and then returns whatever values \cvar{procedure} + returned. +\cvar{Procedure}, \cvar{arguments}, and \cvar{values} + are all transmitted by copying, with the exception of proxies and symbols. +Objects are shared within a particular message, including the message that + send \cvar{procedure} and \cvar{arguments} and the message returning + \cvar{values}. +Objects are not shared between messages. +\begin{example} + (let ((x (list 1 2))) + (remote-apply a1 eq? x x)) + \evalsto \#t + + (let ((x (list 1 2))) + (eq? x (remote-apply a1 (lambda () x)))) + \evalsto \#f + + (let ((x (list 1))) + (remote-apply a1 (lambda () (set-car! x 2))) + (car x)) + \evalsto 1 +\end{example} +\noindent If \cvar{address-space} is the local address space, no messages are + sent and no copying occurs. +For a \code{remote-run!} where \cvar{address-space} is the local address space, + a separate thread is spawned to do the application of \cvar{procedure} to + \cvar{arguments}. + +There is currently no mechanism for GCing address spaces. +Kali makes socket connections between address spaces only as needed, but once + made they stay forever. + +\section{Proxies} + +Proxies are globally-unique, distributed cells. Every proxy potentially has a +distinct value in every address space. + +These procedures are in structure \code{kali}. + +\begin{protos} +\proto{make-proxy}{ value}{proxy} +\proto{proxy?}{ thing}{boolean} +\proto{proxy-owner}{ proxy}{address-space} +\proto{proxy-local-ref}{ proxy}{value} +\protonoresult{proxy-local-set!}{ proxy value} +\proto{proxy-remote-ref}{ proxy}{value} +\protonoresult{proxy-remote-set!}{ proxy value} +\proto{any-proxy-value}{ proxy}{value} +\end{protos} +\code{Make-proxy} makes a new proxy, whose value in the current address space + is \cvar{value}. +Initially the new proxy has no value on other address spaces. +\code{Proxy-owner} returns the address space on which the proxy + was created. + +\code{Proxy-local-ref} and \code{proxy-local-set!} access and set the value of + the proxy in the current address space. +\code{Proxy-remote-ref} and \code{proxy-remote-set!} do the same for the + value on the address space on which the proxy was created. +They could be defined as follows: +\begin{example} + (define proxy-remote-ref + (lambda (proxy) + (remote-apply (proxy-owner proxy) + proxy-local-ref + proxy))) + + (define proxy-remote-set! + (lambda (proxy value) + (remote-run! (proxy-owner proxy) + proxy-local-set! + proxy + value))) +\end{example} +\code{Any-proxy-value} returns either the local value of \cvar{proxy}, if there + is one, or the value on the proxy's owner. + +Note that the remote values may be transmitted between nodes and thus may be + a copy of the original value. +Each proxy is itself a unique global object and is never copied. +\begin{example} + (let ((x (make-proxy \#f))) + (eq? x (remote-apply a1 (lambda () x)))) + \evalsto \#t +\end{example} + +Typically, a proxy only has a value on the owning address space. +Local values, via \code{Proxy-local-ref} and \code{proxy-local-set!}, + are only used when a per-address-space cell is needed. +An example might be a per-address-space queue of tasks. + +A proxy is required whenever a \code{remote-run!} or \code{remote-apply} may + refer to an object that should not be copied. +This includes lexically bound variables that are \code{set!}. +\begin{example} + (let* ((call-count 0) + (f (lambda () + (set! call-count (+ 1 call-count))))) + + (remote-apply a1 (lambda () (f) (f) (f))) + + call-count) + \evalsto 0 \textit{if} \code{a1} \textit{is not the local address space,} \code{3} \textit{if it is.} + + (let* ((call-count (make-proxy 0)) + (f (lambda () + (proxy-remote-set! + call-count + (+ 1 (proxy-remote-ref call-count)))))) + + (remote-apply a1 (lambda () (f) (f) (f))) + + (proxy-remote-ref call-count)) + \evalsto 3 +\end{example} + +Many system-supplied data structures, including locks, tables, queues, + placeholders and so forth should be put in proxies if they are used remotely. + +The current proxy GC algorithm does not collect proxies that are given values + on remote nodes. +All other proxies are eventually GC'ed when no longer referenced. + +\section{Debugging Kali programs} + +Kali programs run in a distributed, multithreaded environment, making debugging + a non-trivial task. +As described in doc/threads.txt, when any thread raises an + error, Scheme 48 stops running all of the threads at that command level. +Kali does not extend this between address spaces, so other address spaces will + keep running as if nothing had happened. +Messages to the stopped address space are buffered until the user restarts + the stopped command level. + +Another difficulty in debugging Kali programs is that redefinitions are not + propagated between address spaces. +A redefinition is handled as a \code{set!} to the local cell for the variable. +Other address space have their own copies of the cell, which are not updated +automatically. The following example shows this effect. +\begin{example} +> (define (f) 10) +> (define (g) (f)) +> (g) +10 +> (remote-apply a1 g) +10 +> (define (f) 20) +> (g) +20 +> (remote-apply a1 g) +10 +\end{example} +The remote application of \code{g} gets the original value of \code{f}, + not the new one. +The remote \code{f} can be updated by hand. +\begin{example} +> (remote-run! a1 (lambda (x) (set! f x)) f) +> (remote-apply a1 g) +20 +\end{example} +Note that the argument to \code{remote-run!} is evaluated in the local address + space, and so gets the new value of \code{f}. +Doing +\begin{example} +(remote-run! a1 (lambda () (set! f f))) +\end{example} +would have had no effect. +Both occurrences of \code{f} would refer to the binding on the remote + address space. +When in doubt it is best to restart the program from scratch. + +The following procedure is useful in debugging multi-threaded programs. +\begin{protos} +\protonoresult{debug-message}{ element$_0$ \ldots} +\end{protos} +\code{Debug-message} prints the elements to `\code{stderr}', followed by a + newline. +The only types of values that \code{debug-message} prints in full are small + integers (fixnums), strings, characters, symbols, boolean, and the empty list. +Values of other types are abbreviated as follows. + +\begin{tabular}{ll} + pair & \code{(...)}\\ + vector & \code{\#(...)}\\ + procedure & \code{\#\{procedure\}}\\ + record & \code{\#\{\}}\\ + all others & \code{???}\\ +\end{tabular} + +The great thing about \code{debug-message} is that it bypasses Scheme~48's + I/O and thread handling. The message appears immediately, with no delays + or errors. + +\code{Debug-message} is exported by the structure \code{debug-messages}. + +\section{Code sharing between address spaces} + +In Kali, Scheme code in one address space is treated as distinct from code +in all other address spaces. If the same file is loaded into two different +address spaces, each will have its own copy. If these two address spaces +both run that code in a third address space, that third space will get two +copies of the code. To avoid duplication, it is a good idea to load a +file into only one address space. + +The same lack of sharing occurs if, after a file is loaded, an image is +dumped and then used to start two address spaces. The two spaces are each +considered to have loaded the file. To circumvent this, +each Kali image contains a table of loaded code that can be shared between +address spaces, assuming that all spaces are using the same table. Address +spaces started with different tables are assumed to have nothing in common, +and all code needed for remote evaluation must be copied to the remote + address space. +The following procedure, from the structure \code{address-spaces}, can be used + to rebuild the shared-code table after loading additional code. + +\begin{protos} +\protonoresult{initialize-shared-address-space!}{} +\end{protos} +This creates a table containing all existing code and and proxies. +This table is shared between all address spaces that are started from the + current image. +Code loaded before the call to \code{initialize-shared-address-space!} will + not be copied between address spaces. + +\end{document} diff --git a/doc/src/latex-stuff.tex b/doc/src/latex-stuff.tex new file mode 100644 index 0000000..9ceb43d --- /dev/null +++ b/doc/src/latex-stuff.tex @@ -0,0 +1,45 @@ + +% Latex macros for The Scheme of Things + +\newcommand{\ev}{\hbox{$\longrightarrow$}} +\newcommand{\asterisk}{\hbox{$\ast$}} +\newcommand{\foo}{\discretionary{}{}{}} +\newcommand{\var}[1]{\hbox{\em{}#1}} +\newcommand{\piece}[1]{\subsubsection*{#1}} +\newcommand{\syn}[1]{\hbox{$\langle$\rm#1$\rangle$}} +\newcommand{\xform}{\hbox{$\Longrightarrow$}} +\newcommand{\etc}{$\ldots$} +\newcommand{\ok}{\discretionary{}{}{}} + +\newcommand{\separator}{ +\vspace{1ex} +\begin{center} +\noindent \asterisk\hspace{1em}\asterisk\hspace{1em}\asterisk +\end{center} +\vspace{1ex}} + + +% ----------------------------------------------------------------------------- + %% doframeit draws a box around it argument by manipulating boxes. It + %% is used in the frame environments. + %% + %% Rene' Seindal (seindal@diku.dk) Fri Feb 12 16:03:07 1988 + %% added \fboxrule and \fboxsep to \doframeit + +\def\doframeit#1{\vbox{% + \hrule height\fboxrule + \hbox{% + \vrule width\fboxrule \kern\fboxsep + \vbox{\kern\fboxsep #1\kern\fboxsep }% + \kern\fboxsep \vrule width\fboxrule }% + \hrule height\fboxrule }} + + %% The frameit and Frameit environments formats text within a single + %% Anything can be framed, including verbatim text. + +\def\frameit{\smallskip \advance \linewidth by -7.5pt \setbox0=\vbox \bgroup +\strut \ignorespaces } + +\def\endframeit{\ifhmode \par \nointerlineskip \fi \egroup +\doframeit{\box0}} +% ----------------------------------------------------------------------------- diff --git a/doc/src/meeting.tex b/doc/src/meeting.tex new file mode 100644 index 0000000..4a696cb --- /dev/null +++ b/doc/src/meeting.tex @@ -0,0 +1,439 @@ +\documentstyle[11pt,twoside]{article} + +\input{code} +\input{latex-stuff} + +\advance \textheight by 2ex + +\begin{document} + +\begin{center} +{\Large\bf The Scheme of Things:} \\ +\vspace{2ex} +{\Large\bf The June 1992 Meeting$^{\hbox{\scriptsize 1}}$} \\ +\vspace{3ex} +Jonathan Rees \\ +Cornell University \\ +{\tt jar@cs.cornell.edu} +\end{center} + +\vspace{3ex} + +\footnotetext[1]{To appear in {\em Lisp Pointers} V(4), +October--December 1992.} + + +An informally constituted group of people interested in the future of +the Scheme programming language met at the Xerox Palo Alto Research +Center on 25 June 1992. The main purpose of the meeting was to work +on the technical content of the next revision of the Scheme report. + +We made progress on several fronts: +\begin{itemize} +\item Some differences with the IEEE Scheme standard were resolved. + +\item Proposals for multiple return values and {\tt dynamic-wind} were +adopted. + +\item A proposal for an {\tt eval} procedure was adopted. + +\item The high-level macro facility described in the +Revised$^4$ Report's appendix will be moved into the report proper. +\end{itemize} + +Two subcommittees were formed: one to work on exceptions, and one to +charter the formation of a standard library. The subcommittees will +report back to the group with proposals for inclusion in the report. + +It had been hoped that there would be progress on some other fronts +(user-defined types, dynamic binding, improvements to ``rest'' +parameters), but after inconclusive discussion these topics were +dropped. These topics will probably be taken up again in the future. + +Norman Adams was appointed the Revised$^5$ Report's editor. It is +hoped that it will be ready by early 1993, so as to precede the +reconstitution of the IEEE standard group. + +This article is my own interpretation of what transpired, and should +not be construed as definitive. + + +\piece{Agreement with the IEEE Scheme standard} + +Until now, the Scheme reports have encouraged but not required the +empty list {\tt()} and the boolean false value {\tt\#f} to be +distinct. It has been the intent ever since the Revised Revised +Report, however, that this distinction would eventually be required. +The IEEE Scheme standard bit the bullet in 1990, and now the +Revised$^5$ report follows. + +The standard also dropped the distinction between essential and +not-essential language features; most features that were formerly not +essential, such as n-ary {\tt+} and {\tt apply}, are now required. +The Revised$^5$ Report will adopt this stance, at least as regards +language features that are shared with the IEEE standard. +Non-essential non-IEEE oddities such as {\tt transcript-on} and {\tt +transcript-off} and the proposed {\tt interaction-\ok{}environment} (see +below) were not discussed at the meeting, however, and consensus on +their status will have to be reached via electronic mail. + +A third aspect of the standard that was adopted was a certain obscure +paragraph regarding assignments to top-level variables (section 6, +paragraph 2). The effect of this is that if a program contains an +assignment to any top-level variable, then the program must contain a +{\tt define} for that variable; it is not sufficient that the variable +be bound. This has been the case for most variables, but the rule +applies as well to variables such as {\tt car} that have built-in +bindings. In addition, it is clarified that if a program makes such a +definition or assignment, then the behavior of built-in procedures +will not be affected. For example, redefining {\tt length} cannot +affect the behavior of the built-in {\tt list->vector} procedure. +If in some particular implementation {\tt list->vector} is written +in Scheme and calls {\tt length}, then it must be sure to call the +built-in {\tt length} procedure, not whatever happens to be the value +of the variable {\tt length}. + + +\piece{Multiple return values} + +The {\tt call-with-values} and {\tt values} procedures were described +in an earlier Scheme of Things ({\em Lisp Pointers}, volume IV, number +1), but I'll review them here. The following is adapted from John Ramsdell's +concise description: + +\begin{list}{}{}{}\item + {\tt(values \var{object} $\ldots$)} + \hfill {\rm essential procedure} + + {\tt values} delivers all of its arguments to its continuation. + + \vspace{2ex} + + {\tt(call-with-values \var{thunk} \var{receiver})} + \hfill {\rm essential procedure} + + {\tt call-with-values} calls its \var{thunk} argument with a + continuation that, when passed some values, calls the + \var{receiver} procedure with those values as arguments. + The continuation for the call to \var{receiver} is the + continuation of the call to {\tt call-with-values}. +\end{list} + +Except for continuations created by the {\tt call-with-values} +procedure, all continuations take exactly one value, as now; the +effect of passing no value or more than one value to continuations +that were not created by {\tt call-with-values} is unspecified (as +indeed it is unspecified now). + +{\tt values} might be defined as follows: +\begin{code} + (define (values . things) + (call-with-current-continuation + (lambda (cont) (apply cont things)))) +\end{code} +That is, the procedures supplied by {\tt +call-with-current-continuation} must be passed the same number of +arguments as values expected by the continuation. + +Because the behavior of a number-of-values mismatch between a +continuation and its invoker is unspecified, some implementations may +assign some specific meaning to such situations; for example, extra +values might be ignored, or defaults might be supplied for missing +values. Thus this multiple return value proposal is compatible with +Common Lisp's multiple values, but strictly more conservative than it. +The behavior of programs in such situations was a point of contention +among the authors, which is why only the least common denominator +behavior was specified. + + +\piece{Unwind/wind protection} + +{\tt dynamic-wind}, which was described previously in this column (when it +was The Scheme Environment; {\em Lisp Pointers}, volume I, number 2), +is already implemented in many Scheme dialects. {\tt dynamic-wind} +takes three arguments, all of which are thunks (procedures of no arguments). +It behaves as if it were defined with +\begin{code} + (define (dynamic-wind before during after) + (before) + (call-with-values during + (lambda results + (after) + (apply values results)))) +\end{code} +except that the execution of the {\tt during} thunk is ``protected'' +against non-local entries and exits: a throw out of the execution +of {\tt during} will cause the {\tt after} thunk to be invoked, and a +throw from outside back in will cause the {\tt before} thunk to be +invoked. (By ``throw'' I mean an invocation of an explicit +continuation as obtained from {\tt call-with-current-continuation}.) + +For details, the earlier Scheme Environment column refers the reader +to Friedman and Haynes's paper ``Constraining Control'' in POPL 1985, +but to save you the trouble of looking that up, I have supplied a more +direct implementation of {\tt dynamic-wind} in an appendix to the +present column. + +{\tt dynamic-wind} was adopted with the following clarifications: The +semantics of {\tt(dynamic-wind \var{before} \var{during} \var{after})} +should leave unspecified what happens if a throw occurs out of {\em +before} or {\em after}\/; and it is best to defer interrupts during {\em +before} and {\em after}. + + + +\piece{Evaluating computed expressions} + +The original 1975 memo on Scheme described {\tt evaluate}, +which was analogous to Lisp's traditional {\tt eval} function. {\tt +evaluate} took a single argument, an S-expression, and invoked an +interpreter on it. For example: +\begin{code} + (let ((name '+)) (evaluate (list name 2 3))) + \ev 5 +\end{code} +Scheme being lexically scoped, however, there was some confusion over +which environment the expression was to be evaluated in. Should +\begin{code} + (let ((name '+)) + (let ((+ *)) + (evaluate (list name 2 3)))) +\end{code} +evaluate to 5 or to 6? + +To clarify matters, the Revised Report replaced {\tt evaluate} with +{\tt enclose}, which took two arguments, a {\tt lambda}-expression and +a representation of an environment from which to supply bindings of the +{\tt lambda}-expression's free variables. For example: +\begin{code} + (let ((name '+)) + (let ((+ *)) + ((enclose (list 'lambda '() (list name 2 3)) + (list (cons '+ +)))))) + \ev 6 +\end{code} +This forced the programmer to be explicit about the {\tt +lambda}-expression's enclosing environment. + +For various technical and practical reasons, there was no {\tt eval} +analogue in subsequent Scheme reports. The major stumbling blocks +were how to describe {\tt eval} formally and how to define something +that makes sense in all extant variants of the language. Some Scheme +implementations contain a distinguished top-level environment, while +others extend the language by providing ways to create multiple +environments, any of which might serve equally well. + +The {\tt eval} proposal adopted at the June meeting, which I reproduce +here, is one that comes from Bill Rozas. + +\begin{list}{}{}{}\item + + {\tt(eval \var{expression} \var{environment-specifier})} + \hfill {\rm essential procedure} + + {\tt eval} evaluates \var{expression} in the environment indicated + by {\em environment-\discretionary{}{}{}specifier}. {\em + environment-specifier} may be the return value of one of the three + procedures described below, or implementation-specific extensions. + No other operations on environment specifiers are defined by this + proposal. + + Implementations may allow non-expression programs (i.e.\ + definitions) as the first argument to {\tt eval} \var{only} when + the second argument is the return value of {\tt interaction-environment} + or some implementation extension. In other words, {\tt eval} will never + create new bindings in the return value of {\tt null-environment} or + {\tt scheme-report-environment}. + + \vspace{2ex} + + {\tt(scheme-report-environment \var{version})} + \hfill {\rm essential procedure} + + {\em Version} must be an exact non-negative integer corresponding to a + version of one of the Revised$^n$ Reports on Scheme. This procedure + returns a specifier for an environment that contains exactly the + set of bindings specified in the corresponding report that the + implementation supports. Not all versions may be available in all + implementations at all times. However, an implementation that + conforms to version $n$ of the Revised$^n$ Reports on Scheme must + accept version $n$. If {\tt scheme-report-environment} is + available, but the specified version is not, the procedure will + signal an error. + + The effect of assigning (through the use of {\tt eval}) a variable + bound in a {\tt scheme-report-environment} (e.g.\ {\tt car}) is + unspecified. Thus the environments specified by the return + values of {\tt scheme-report-environment} may be immutable. + + \vspace{2ex} + + {\tt(null-environment)} + \hfill {\rm essential procedure} + + This procedure returns a specifier for an environment that contains no + variable bindings, but contains (syntactic) bindings for all the + syntactic keywords defined in the report, and no others. + + \vspace{2ex} + %\newpage %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + {\tt(interaction-environment)} + \hfill {\rm procedure} + + This procedure returns a specifier for an environment that + contains imple\-men\-ta\-tion-defined bindings, typically a superset of + those listed in the report. The intent is that this procedure + will return a specifier for the environment in which the + implementation would evaluate expressions dynamically typed by the + user. + +\end{list} + +Rozas explains: +``The proposal does not imply the existence or support of first-class +environments, although it is compatible with them. +The proposal only requires a way of associating tags with a finite set +of distinguished environments which the implementations can maintain +implicitly (without reification). + +``\,`Pascal-like' implementations can support both {\tt null-environment} and +%\penalty0 +{\tt scheme-report-environment} since the environments specified by +the return values of these procedures need not share any bindings with +the current program. A version of {\tt eval} that supports these but +not {\tt interaction-environment} can be written portably, +but can be better written by the implementor, since it can share code +with the default evaluator or compiler.'' + +Here ``Pascal-like'' refers to implementations that are restricted to +static compilation and linking. Because an {\tt eval} that doesn't +support +\penalty0 +{\tt interaction-\discretionary{}{}{}environment} can be written +entirely in the Scheme language described by the rest of the report, +it raises no troublesome questions about its formal semantics. + + +\piece{Macros} + +The consensus of the meeting was that {\tt define-syntax}, {\tt +syntax-rules}, {\tt let-\discretionary{}{}{}syntax}, and {\tt +letrec-syntax} should be moved out of the report's appendix into the +main body of the report. Although everyone agrees that a low-level +macro facility is important, the subject is too contentious at +present, with three or more competing proposals at present. The +disposition of the rest of the appendix and of the other low-level +proposals will be left up to the report's editor. + + +\piece{Committee work} + +There is a strong sense that some kind of exception system is needed. +However, no specific proposal was ready at the time of the meeting. A +committee has been formed to work on one. What seems to be in the +air might be described as a highly distilled version of the condition +system that Kent Pitman developed for Common Lisp. I hope that I'll +be able to report on this in a future column. + + +On the subject of libraries, Will Clinger's minutes report that +``the authors perceive a need to give some library official status. In +fact, we need to give official sanction to multiple libraries. There +is reason to distinguish between accepted (or standard) libraries, +experimental libraries, and proposals. The accepted libraries can +reduce the intellectual size of the language by removing things like +{\tt string->list} from the report. The experimental libraries would +contain solid implementations of experimental features, including +things that might never deserve to be in the report. The proposal +libraries could contain anything implemented in portable Scheme.'' + + +Among the content of the accepted libraries, some features (such as +those that may be moved out of the body of the report) may be required +to be built in to implementations, while others will be expected to be +available on demand (perhaps using something similar to, but not the +same as, {\tt require} as found in Common Lisp and GNU Emacs). + +A librarian was appointed (Rees), and a library committee is +developing proposals for the charter, structure, and content of the +libraries. + + +\separator + +I would like to acknowledge Will Clinger, who prepared the minutes of +the meeting, and the various people who contributed proposals, +including Bill Rozas and John Ramsdell. Any errors here are my +responsibility, however. Thanks also to Norman Adams and Richard +Kelsey for corrections to a draft of this article. + +I would also like to belatedly acknowledge Norman Adams, Pavel +Curtis, Bruce Donald, and Richard Kelsey for their comments on drafts of +my previous column. + +For future columns, I am entertaining various topic possibilities, +including {\tt eval}, threads, {\tt amb}, and monads. +If you have other ideas, and particularly if you think the written +record on the language is particularly poor in certain areas, please +write and let me know. + +\vspace{2ex} + +%\newpage + +%\bgroup \small + +\piece{Appendix: An implementation of {\tt dynamic-wind}} + +This program is based on my vague recollection of an ancient +manuscript by Chris Hanson and John Lamping. I apologize for the lack +of data abstraction, but the code is more concise this way. + +A state space is a tree with the current state at the root. Each node other +than the root is a triple $\langle\var{before}, \var{after}, +\var{parent}\rangle$, represented in this implementation as two pairs +{\tt((\var{before} .\ \var{after}) .\ \var{parent})}. +Navigating between states requires re-rooting the tree by reversing +parent-child links. + +Since {\tt dynamic-wind} interacts with {\tt +call-with-current-continuation}, this implementation must replace the +usual definition of the latter. + +\begin{code} +(define *here* (list #f)) +\codeskip +(define original-cwcc call-with-current-continuation) +\codeskip +(define (call-with-current-continuation proc) + (let ((here *here*)) + (original-cwcc (lambda (cont) + (proc (lambda results + (reroot! here) + (apply cont results))))))) +\codeskip +(define (dynamic-wind before during after) + (let ((here *here*)) + (reroot! (cons (cons before after) here)) + (call-with-values during + (lambda results + (reroot! here) + (apply values results))))) +\codeskip +(define (reroot! there) + (if (not (eq? *here* there)) + (begin (reroot! (cdr there)) + (let ((before (caar there)) + (after (cdar there))) + (set-car! *here* (cons after before)) + (set-cdr! *here* there) + (set-car! there #f) + (set-cdr! there '()) + (set! *here* there) + (before))))) +\end{code} + +%\egroup + +\end{document} diff --git a/doc/src/module.tex b/doc/src/module.tex new file mode 100644 index 0000000..212d948 --- /dev/null +++ b/doc/src/module.tex @@ -0,0 +1,728 @@ +\documentstyle[11pt]{article} + +\include{code} +\include{latex-stuff} + +\newcommand{\goesto}{\hbox{$\longrightarrow$}} +\newcommand{\alt}{$\vert$} +\newcommand{\arbno}[1]{{{#1}$^*$}} +\newcommand{\hack}{Scheme~48} + +\begin{document} + +\begin{center} +{\Large\bf Another Module System for Scheme} + +\vspace{2ex} +Jonathan Rees \\ +3 January 1993 (updated 15 January 1994) +\end{center} + +\vspace{3ex} + +This memo describes a module system for the Scheme programming +language. The module system is unique in the extent to which it +supports both static linking and rapid turnaround during program +development. The design was influenced by Standard ML +modules\cite{MacQueen:Modules} and by the module system for Scheme +Xerox\cite{Curtis-Rauen:Modules}. It has also been shaped by the +needs of \hack{}, a virtual-machine-based Scheme implementation +designed to run both on workstations and on relatively small (less +than 1 Mbyte) embedded controllers. + +Except where noted, everything described here is implemented in +\hack{}, and exercised by the \hack{} implementation and a few +application programs. + +Unlike the Common Lisp package system, the module system described +here controls the mapping of names to denotations, not the +mapping of strings to symbols. + + +\subsection*{Introduction} + +The module system supports the structured division of a corpus of +Scheme software into a set of modules. Each module has its own +isolated namespace, with visibility of bindings controlled by module +descriptions written in a special {\em configuration language.} + +A module may be instantiated multiple times, producing several {\em +packages}, just as a lambda-expression can be instantiated multiple +times to produce several different procedures. Since single +instantiation is the normal case, I will defer discussion of multiple +instantiation until a later section. For now you can think of a +package as simply a module's internal environment mapping names to +denotations. + +A module exports bindings by providing views onto the underlying +package. Such a view is called a {\em structure} (terminology from +Standard ML). One module may provide several different views. A +structure is just a subset of the package's bindings. The particular +set of names whose bindings are exported is the structure's {\em +interface}. + +A module imports bindings from other modules by either {\em opening} +or {\em accessing} some structures that are built on other packages. +When a structure is opened, all of its exported bindings are visible +in the client package. On the other hand, bindings from an accessed +structure require explicitly qualified references written with the +{\tt structure-ref} operator. + +For example: +\begin{code} + (define-structure foo (export a c cons) + (open scheme) + (begin (define a 1) + (define (b x) (+ a x)) + (define (c y) (* (b a) y)))) +\codeskip + (define-structure bar (export d) + (open scheme foo) + (begin (define (d w) (+ a (c w))))) +\end{code} +This configuration defines two structures, {\tt foo} and {\tt bar}. +{\tt foo} is a view on a package in which the {\tt scheme} structure's +bindings (including {\tt define} and {\tt +}) are visible, together +with bindings for {\tt a}, {\tt b}, +and {\tt c}. {\tt foo}'s interface is {\tt (export a c cons)}, so of +the bindings in its underlying package, {\tt foo} only exports those +three. Similarly, structure {\tt bar} consists of the binding of {\tt +d} from a package in which both {\tt scheme}'s and {\tt foo}'s +bindings are visible. {\tt foo}'s binding of {\tt cons} is imported +from the Scheme structure and then re-exported. + +A module's body, the part following {\tt begin} in the above example, +is evaluated in an isolated lexical scope completely specified by the +package definition's {\tt open} and {\tt access} clauses. In +particular, the binding of the syntactic operator {\tt define-structure} +is not visible unless it comes from some opened structure. Similarly, +bindings from the {\tt scheme} structure aren't visible unless they +become so by {\tt scheme} (or an equivalent structure) being opened. + + +\subsection*{The configuration language} + +The configuration language consists of top-level defining forms for +modules and interfaces. Its syntax is given in figure~1. + +\setbox0\hbox{\goesto} +\newcommand{\altz}{\hbox to 1\wd0{\hfil\alt}} + +%%%%% Put the figure inside a box ? + +\begin{figure} +%\begin{frameit} +\begin{tabbing} + \syn{configuration} \=\goesto{}~\arbno{\syn{definition}} \\ + \syn{definition} \=\goesto{}~ + \tt(define-structure \syn{name} \syn{interface} + \arbno{\syn{clause}}) \\ + \>\altz{}~ \tt(define-structures (\arbno{(\syn{name} \syn{interface})}) + \arbno{\syn{clause}}) \\ + \>\altz{}~ \tt(define-interface \syn{name} \syn{interface}) \\ + \>\altz{}~ \tt(define-syntax \syn{name} \syn{transformer-spec}) \\ + \syn{clause} \=\goesto{}~ \tt(open \arbno{\syn{name}}) \\ + \>\altz{}~ \tt(access \arbno{\syn{name}}) \\ + \>\altz{}~ \tt(begin \syn{program}) \\ + \>\altz{}~ \tt(files \arbno{\syn{filespec}}) \\ + \>\altz{}~ \tt(optimize \arbno{\syn{optimize-spec}}) \\ + \>\altz{}~ \tt(for-syntax \arbno{\syn{clause}}) \\ + \syn{interface} \=\goesto{}~ \tt(export \arbno{\syn{item}}) \\ + \>\altz{}~ \syn{name} \\ + \>\altz{}~ \tt(compound-interface \arbno{\syn{interface}}) \\ + \syn{item} \=\goesto{}~ \syn{name}~ + \alt{}~ \tt(\syn{name} \syn{type}) + \alt{}~ \tt((\arbno{\syn{name}}) \syn{type}) +\end{tabbing} +\caption{The configuration language.} +%\end{frameit} +\end{figure} + + +A {\tt define-structure} form introduces a binding of a name to a +structure. A structure is a view on an underlying package which is +created according to the clauses of the {\tt define-structure} form. +Each structure has an interface that specifies which bindings in the +structure's underlying package can be seen via that structure in other +packages. + +An {\tt open} clause specifies which structures will be opened up for +use inside the new package. At least one package must be specified or +else it will be impossible to write any useful programs inside the +package, since {\tt define}, {\tt lambda}, {\tt cons}, {\tt +structure-ref}, etc.\ will be unavailable. Typical packages to list +in the {\tt open} clause are {\tt scheme}, which exports all bindings +appropriate to Revised$^5$ Scheme, and {\tt structure-refs}, which +exports the {\tt structure-ref} operator (see below). For building +structures that export structures, there is a {\tt defpackage} package +that exports the operators of the configuration language. Many other +structures, such as record and hash table facilities, are also +available in the \hack{} implementation. + +An {\tt access} clause specifies which bindings of names to structures +will be visible inside the package body for use in {\tt structure-ref} +forms. {\tt structure-\ok{}ref} has the following syntax: +\begin{tabbing} +\qquad \syn{expression} \goesto{}~ + \tt(structure-ref \syn{struct-name} \syn{name}) +\end{tabbing} +The \syn{struct-name} must be the name of an {\tt access}ed structure, +and \syn{name} must be something that the structure exports. Only +structures listed in an {\tt access} clause are valid in a {\tt +structure-ref}. If a package accesses any structures, it should +probably open the {\tt structure-refs} structure so that the {\tt +structure-ref} operator itself will be available. + +The package's body is specified by {\tt begin} and/or {\tt files} +clauses. {\tt begin} and {\tt files} have the same semantics, except +that for {\tt begin} the text is given directly in the package +definition, while for {\tt files} the text is stored somewhere in the +file system. The body consists of a Scheme program, that is, a +sequence of definitions and expressions to be evaluated in order. In +practice, I always use {\tt files} in preference to {\tt begin}; {\tt +begin} exists mainly for expository purposes. + +A name's imported binding may be lexically overridden or {\em shadowed} +by simply defining the name using a defining form such as {\tt define} +or {\tt define-\ok{}syntax}. This will create a new binding without having +any effect on the binding in the opened package. For example, one can +do {\tt(define car 'chevy)} without affecting the binding of the name +{\tt car} in the {\tt scheme} package. + +Assignments (using {\tt set!})\ to imported and undefined variables +are not allowed. In order to {\tt set!}\ a top-level variable, the +package body must contain a {\tt define} form defining that variable. +Applied to bindings from the {\tt scheme} structure, this restriction +is compatible with the requirements of the Revised$^5$ Scheme report. + +It is an error for two of a package's opened structures to export two +different bindings for the same name. However, the current +implementation does not check for this situation; a name's binding is +always taken from the structure that is listed first within the {\tt +open} clause. This may be fixed in the future. + +File names in a {\tt files} clause can be symbols, strings, or lists +(Maclisp-style ``namelists''). A ``{\tt.scm}'' file type suffix is +assumed. Symbols are converted to file names by converting to upper +or lower case as appropriate for the host operating system. A +namelist is an operating-system-indepedent way to specify a file +obtained from a subdirectory. For example, the namelist {\tt(rts +record)} specifies the file {\tt record.scm} in the {\tt rts} +subdirectory. + +If the {\tt define-structure} form was itself obtained from a file, +then file names in {\tt files} clauses are interpreted relative to the +directory in which the file containing the {\tt define-structure} form +was found. You can't at present put an absolute path name in the {\tt +files} list. + + +\subsection*{Interfaces} + +An interface can be thought of as the type of a structure. In its +basic form it is just a list of variable names, written {\tt(export +\var{name} \etc)}. However, in place of +a name one may write {\tt(\var{name} \var{type})}, indicating the type +of \var{name}'s binding. Currently the type field is ignored, except +that exported macros must be indicated with type {\tt :syntax}. + +Interfaces may be either anonymous, as in the example in the +introduction, or they may be given names by a {\tt define-interface} +form, for example +\begin{code} + (define-interface foo-interface (export a c cons)) + (define-structure foo foo-interface \etc) +\end{code} +In principle, interfaces needn't ever be named. If an interface +had to be given at the point of a structure's use as well as at the +point of its definition, it would be important to name interfaces in +order to avoid having to write them out twice, with risk of mismatch +should the interface ever change. But they don't. + +Still, there are several reasons to use {\tt define-interface}: +\begin{enumerate} +\item It is important to separate the interface definition from the +package definitions when there are multiple distinct structures that +have the same interface --- that is, multiple implementations of the +same abstraction. + +\item It is conceptually cleaner, and useful for documentation +purposes, to separate a module's specification (interface) from its +implementation (package). + +\item My experience is that configurations that are separated into +interface definitions and package definitions are easier to read; the +long lists of exported bindings just get in the way most of the time. +\end{enumerate} + +The {\tt compound-interface} operator forms an interface that is the +union of two or more component interfaces. For example, +\begin{code} + (define-interface bar-interface + (compound-interface foo-interface (export mumble))) +\end{code} +defines {\tt bar-interface} to be {\tt foo-interface} with the name +{\tt mumble} added. + + +\subsection*{Macros} + +Hygienic macros, as described in +\cite{Clinger-Rees:Macros,Clinger-Rees:R4RS}, are implemented. +Structures may export macros; auxiliary names introduced into the +expansion are resolved in the environment of the macro's definition. + +For example, the {\tt scheme} structure's {\tt delay} macro +is defined by the rewrite rule +\begin{code} + (delay \var{exp}) \xform (make-promise (lambda () \var{exp}))\rm. +\end{code} +The variable {\tt make-promise} is defined in the {\tt scheme} +structure's underlying package, but is not exported. A use of the +{\tt delay} macro, however, always accesses the correct definition +of {\tt make-promise}. Similarly, the {\tt case} macro expands into +uses of {\tt cond}, {\tt eqv?}, and so on. These names are exported +by {\tt scheme}, but their correct bindings will be found even if they +are shadowed by definitions in the client package. + + +\subsection*{Higher-order modules} + +There are {\tt define-module} and {\tt define} forms for +defining modules that are intended to be instantiated multiple times. +But these are pretty kludgey --- for example, compiled code isn't +shared between the instantiations --- so I won't describe them yet. +If you must know, figure it out from the following grammar. +\begin{tabbing} +\qquad + \syn{definition} \=\goesto{}~ + \tt(d\=\tt{}efine-module (\syn{name} \arbno{(\syn{name} \syn{interface})}) \\ + \> \>\arbno{\syn{definition}} \\ + \> \>\syn{name}\tt) \\ + \>\altz{}~ \tt(define \syn{name} + (\syn{name} \arbno{\syn{name}})) +\end{tabbing} + + +\subsection*{Compiling and linking} + +\hack{} has a static linker that produces stand-alone heap images +from module descriptions. One specifies a particular procedure in a +particular structure to be the image's startup procedure (entry +point), and the linker traces dependency links as given by {\tt open} +and {\tt access} clauses to determine the composition of the heap +image. + +There is not currently any provision for separate compilation; the +only input to the static linker is source code. However, it will not +be difficult to implement separate compilation. The unit of +compilation is one module (not one file). Any opened or accessed +structures from which macros are obtained must be processed to the +extent of extracting its macro definitions. The compiler knows from +the interface of an opened or accessed structure which of its exports +are macros. Except for macros, a module may be compiled without any +knowledge of the implementation of its opened and accessed structures. +However, inter-module optimization will be available as an option. + +The main difficulty with separate compilation is resolution of +auxiliary bindings introduced into macro expansions. The module +compiler must transmit to the loader or linker the search path by +which such bindings are to be resolved. In the case of the {\tt delay} +macro's auxiliary {\tt make-promise} (see example above), the loader +or linker needs to know that the desired binding of {\tt make-promise} +is the one apparent in {\tt delay}'s defining package, not in the +package being loaded or linked. + +[I need to describe structure reification.] + + +\subsection*{Semantics of configuration mutation} + +During program development it is often desirable to make changes to +packages and interfaces. In static languages it may be necessary to +recompile and re-link a program in order for such changes to be +reflected in a running system. Even in interactive Common Lisp +implementations, a change to a package's exports often requires +reloading clients that have already mentioned names whose bindings +change. Once {\tt read} resolves a use of a name to a symbol, that +resolution is fixed, so a change in the way that a name resolves to a +symbol can only be reflected by re-{\tt read}ing all such references. + +The \hack{} development environment supports rapid turnaround in +modular program development by allowing mutations to a program's +configuration, and giving a clear semantics to such mutations. The +rule is that variable bindings in a running program are always +resolved according to current structure and interface bindings, even +when these bindings change as a result of edits to the configuration. +For example, consider the following: +\begin{code} + (define-interface foo-interface (export a c)) + (define-structure foo foo-interface + (open scheme) + (begin (define a 1) + (define (b x) (+ a x)) + (define (c y) (* (b a) y)))) + (define-structure bar (export d) + (open scheme foo) + (begin (define (d w) (+ (b w) a)))) +\end{code} +This program has a bug. The variable {\tt b}, which is free in the +definition of {\tt d}, has no binding in {\tt bar}'s package. Suppose +that {\tt b} was supposed to be exported by {\tt foo}, but was omitted +from {\tt foo-interface} by mistake. It is not necessary to +re-process {\tt bar} or any of {\tt foo}'s other clients at this point. +One need only change {\tt foo-interface} and inform the development +system of that one change (using, say, an appropriate Emacs command), +and {\tt foo}'s binding of {\tt b} will be found when procedure {\tt +d} is called. + +Similarly, it is also possible to replace a structure; clients of the +old structure will be modified so that they see bindings from the new +one. Shadowing is also supported in the same way. Suppose that a +client package $C$ opens a structure {\tt foo} that exports a name +{\tt x}, and {\tt foo}'s implementation obtains the binding of {\tt x} +as an import from some other structure {\tt bar}. Then $C$ will see +the binding from {\tt bar}. If one then alters {\tt foo} so that it +shadows {\tt bar}'s binding of {\tt x} with a definition of its own, +then procedures in $C$ that reference {\tt x} will automatically see +{\tt foo}'s definition instead of the one from {\tt bar} that they saw +earlier. + +This semantics might appear to require a large amount of computation +on every variable reference: The specified behavior requires scanning +the package's list of opened structures, examining their interfaces, +on every variable reference, not just at compile time. However, the +development environment uses caching with cache invalidation to make +variable references fast. + + +\subsection*{Command processor support} + +While it is possible to use the \hack{} static linker for program +development, it is far more convenient to use the development +environment, which supports rapid turnaround for program changes. The +programmer interacts with the development environment through a {\em +command processor}. The command processor is like the usual Lisp +read-eval-print loop in that it accepts Scheme forms to evaluate. +However, all meta-level operations, such as exiting the Scheme system +or requests for trace output, are handled by {\em commands,} which are +lexically distinguished from Scheme forms. This arrangement is +borrowed from the Symbolics Lisp Machine system, and is reminiscent of +non-Lisp debuggers. Commands are a little easier to type than Scheme +forms (no parentheses, so you don't have to shift), but more +importantly, making them distinct from Scheme forms ensures that +programs' namespaces aren't clutterred with inappropriate bindings. +Equivalently, the command set is available for use regardless of what +bindings happen to be visible in the current program. This is +especially important in conjunction with the module system, which puts +strict controls on visibility of bindings. + +The \hack{} command processor supports the module system with a +variety of special commands. For commands that require structure +names, these names are resolved in a designated configuration package +that is distinct from the current package for evaluating Scheme forms +given to the command processor. The command processor interprets +Scheme forms in a particular current package, and there are commands +that move the command processor between different packages. + +Commands are introduced by a comma ({\tt,}) and end at the end of +line. The command processor's prompt consists of the name of the +current package followed by a greater-than ({\tt>}). + +\begin{list}{}{}{} + +\item +\begin{code} +,config +\end{code} + The {\tt,config} command sets the command processor's current + package to be the current configuration package. Forms entered at + this point are interpreted as being configuration language forms, + not Scheme forms. + +\item +\begin{code} +,config \var{command} +\end{code} + This form of the {\tt,config} command executes another command in + the current configuration package. For example, +\begin{code} + ,config ,load foo.scm +\end{code} + interprets configuration language forms from the file {\tt + foo.scm} in the current configuration package. + +\item +\begin{code} +,in \var{struct-name} +\end{code} + The {\tt ,in} command moves the command processor to a specified + structure's underlying package. For example: +\begin{code} + user> ,config + config> (define-structure foo (export a) + (open scheme)) + config> ,in foo + foo> (define a 13) + foo> a + 13 +\end{code} + In this example the command processor starts in a package called + {\tt user}, but the {\tt ,config} command moves it into the + configuration package, which has the name {\tt config}. The {\tt + define-structure} form binds, in {\tt config}, the name {\tt foo} to + a structure that exports {\tt a}. Finally, the command {\tt ,in + foo} moves the command processor into structure {\tt foo}'s + underlying package. + + A package's body isn't executed (evaluated) until the package is + {\em loaded}, which is accomplished by the {\tt ,load-package} + command. + +\item +\begin{code} +,in \var{struct-name} \var{command} +\end{code} + This form of the {\tt,in} command executes a single command in the + specified package without moving the command processor into that + package. Example: +\begin{code} + ,in mumble (cons 1 2) + ,in mumble ,trace foo +\end{code} + +\item +\begin{code} +,user $[$\var{command}$]$ +\end{code} + This is similar to the {\tt ,config} and {\tt ,in} commands. It + moves to or executes a command in the user package (which is the + default package when the \hack{} command processor starts). + +\item +\begin{code} +,for-syntax $[$\var{command}$]$ +\end{code} + This is similar to the {\tt ,config} and {\tt ,in} commands. It + moves to or executes a command in the current package's ``package + for syntax,'' which is the package in which the forms $f$ in + {\tt (define-syntax \var{name} $f$)} are evaluated. + +\item +\begin{code} +,load-package \var{struct-name} +\end{code} + The {\tt,load-package} command ensures that the specified structure's + underlying package's program has been loaded. This + consists of (1) recursively ensuring that the packages of any + opened or accessed structures are loaded, followed by (2) + executing the package's body as specified by its definition's {\tt + begin} and {\tt files} forms. + +\item +\begin{code} +,reload-package \var{struct-name} +\end{code} + This command re-executes the structure's package's program. It + is most useful if the program comes from a file or files, when + it will update the package's bindings after mutations to its + source file. + +\item +\begin{code} +,load \var{filespec} \etc +\end{code} + The {\tt,load} command executes forms from the specified file or + files in the current package. {\tt,load \var{filespec}} is similar + to {\tt(load "\var{filespec}")} + except that the name {\tt load} needn't be bound in the current + package to Scheme's {\tt load} procedure. + +\item +\begin{code} +,structure \var{name} \var{interface} +\end{code} + The {\tt,structure} command defines \var{name} in the + configuration package to be a structure with interface + \var{interface} based on the current package. + +\item +\begin{code} +,open \arbno{\var{struct-name}} +\end{code} + The {\tt,open} command opens a new structure in the current + package, as if the package's definition's {\tt open} clause + had listed \var{struct-name}. + +\end{list} + + + +\subsection*{Configuration packages} + +It is possible to set up multiple configuration packages. The default +configuration package opens the following structures: +\begin{itemize} +\item {\tt module-system}, which exports {\tt define-structure} and the + other configuration language keywords, as well as standard types + and type constructors ({\tt :syntax}, {\tt :value}, {\tt proc}, etc.). +\item {\tt built-in-structures}, which exports structures that are + built into the initial \hack{} image; these include {\tt + scheme}, {\tt tables}, and {\tt records}. +\item {\tt more-structures}, which exports additional structures that + are available in the development environment; these include + {\tt sort}, {\tt random}, and {\tt threads}. +\end{itemize} +Note that it does not open {\tt scheme}. + +You can define other configuration packages by simply making a package +that opens {\tt module-system} and, optionally, {\tt +built-in-\ok{}structures}, {\tt more-\ok{}structures}, or other structures that +export structures and interfaces. + +For example: +\begin{code} + > ,config (define-structure foo (export ) + (open module-system + built-in-structures + more-structures)) + > ,in foo + foo> (define-structure x (export a b) + (open scheme) + (files x)) + foo> +\end{code} + +\begin{list}{}{}{} +\item +\begin{code} +,config-package-is \var{struct-name} +\end{code} + The {\tt,config-package-is} command designates a new configuration + package for use by the {\tt,config} command and resolution of + \var{struct-name}s for other commands such as {\tt,in} and + {\tt,open}. +\end{list} + + + +\subsection*{Discussion} + +This module system was not designed as the be-all and end-all of +Scheme module systems; it was only intended to help Richard Kelsey and +me to organize the \hack{} system. Not only does the module system +help avoid name clashes by keeping different subsystems in different +namespaces, it has also helped us to tighten up and generalize +\hack{}'s internal interfaces. \hack{} is unusual among Lisp +implementations in admitting many different possible modes of +operation. Examples of such multiple modes include the following: +\begin{itemize} + \item Linking can be either static or dynamic. + + \item The development environment (compiler, debugger, and command + processor) can run either in the same address space as the program + being developed or in a different address space. The environment and + user program may even run on different processors under different + operating systems\cite{Rees-Donald:Program}. + + \item The virtual machine can be supported by either + of two implementations of its implementation language, Prescheme. +\end{itemize} +The module system has been helpful in organizing these multiple modes. +By forcing us to write down interfaces and module dependencies, the +module system helps us to keep the system clean, or at least to keep +us honest about how clean or not it is. + +The need to make structures and interfaces second-class instead of +first-class results from the requirements of static program analysis: +it must be possible for the compiler and linker to expand macros and +resolve variable bindings before the program is executed. Structures +could be made first-class (as in FX\cite{Sheldon-Gifford:Static}) if a +type system were added to Scheme and the definitions of exported +macros were defined in interfaces instead of in module bodies, but +even in that case types and interfaces would remain second-class. + +The prohibition on assignment to imported bindings makes substitution +a valid optimization when a module is compiled as a block. The block +compiler first scans the entire module body, noting which variables +are assigned. Those that aren't assigned (only {\tt define}d) may be +assumed never assigned, even if they are exported. The optimizer can +then perform a very simple-minded analysis to determine automatically +that some procedures can and should have their calls compiled in line. + +The programming style encouraged by the module system is consistent +with the unextended Scheme language. Because module system features +do not generally show up within module bodies, an individual module +may be understood by someone who is not familiar with the module +system. This is a great aid to code presentation and portability. If +a few simple conditions are met (no name conflicts between packages, +no use of {\tt structure-ref}, and use of {\tt files} in preference to +{\tt begin}), then a multi-module program can be loaded into a Scheme +implementation that does not support the module system. The \hack{} +static linker satisfies these conditions, and can therefore run in +other Scheme implementations. \hack{}'s bootstrap process, which is +based on the static linker, is therefore nonincestuous. This +contrasts with most other integrated programming environments, such as +Smalltalk-80, where the system can only be built using an existing +version of the system itself. + +Like ML modules, but unlike Scheme Xerox modules, this module system +is compositional. That is, structures are constructed by single +syntactic units that compose existing structures with a body of code. +In Scheme Xerox, the set of modules that can contribute to an +interface is open-ended --- any module can contribute bindings to any +interface whose name is in scope. The module system implementation is +a cross-bar that channels definitions from modules to interfaces. The +module system described here has simpler semantics and makes +dependencies easier to trace. It also allows for higher-order +modules, which Scheme Xerox considers unimportant. + +%[Discuss use of module system in the \hack{} implementation? Maybe +%give an extended excerpt from \hack{}'s configuration files?] +% +%[Discuss or flush OPTIMIZE clause.] +% +%[Future work: ideas for anonymous structures and more of a module +%calculus; dealing with name conflicts; interface subtraction.] + + +\begin{thebibliography}{10} + +\bibitem{Clinger-Rees:Macros} +William Clinger and Jonathan~Rees. +\newblock Macros that work. +\newblock {\em Principles of Programming Languages}, January 1991. + +\bibitem{Clinger-Rees:R4RS} +William Clinger and Jonathan~Rees (editors). +\newblock Revised${}^4$ report on the algorithmic language {S}cheme. +\newblock {\em LISP Pointers} IV(3):1--55, July-September 1991. + +\bibitem{Curtis-Rauen:Modules} +Pavel Curtis and James Rauen. +\newblock A module system for Scheme. +\newblock {\em ACM Conference on Lisp and Functional Programming,} +pages 13--19, 1990. + +\bibitem{MacQueen:Modules} +David MacQueen. +\newblock Modules for Standard ML. +\newblock {\em ACM Conference on Lisp and Functional Programming,} +1984. + +\bibitem{Rees-Donald:Program} +Jonathan Rees and Bruce Donald. +\newblock Program mobile robots in Scheme. +\newblock {\em International Conference on Robotics and +Automation,} IEEE, 1992. + +\bibitem{Sheldon-Gifford:Static} +Mark A.~Sheldon and David K.~Gifford. +\newblock Static dependent types for first-class modules. +\newblock {\em ACM Conference on Lisp and Functional Programming,} +pages 20--29, 1990. + +\end{thebibliography} + + +\end{document} diff --git a/doc/src/summary.tex b/doc/src/summary.tex new file mode 100644 index 0000000..17c8555 --- /dev/null +++ b/doc/src/summary.tex @@ -0,0 +1,83 @@ +\documentstyle[11pt]{article} + +\pagestyle{empty} +\setlength{\textheight}{9in} +\setlength{\footheight}{0.0in} +\setlength{\topmargin}{0in} + +%Defaults from art10.sty: +%\textwidth 345pt \columnsep 10pt \columnseprule 0pt +%\oddsidemargin 63pt + +\advance\textwidth by 0.5in +\advance\oddsidemargin by -0.25in + + +\begin{document} + +\vspace*{-0.3in} + +\begin{center} +{\large\bf Scheme 48} \\ +\vspace{1ex} +Richard Kelsey ({\tt kelsey@corwin.ccs.northeastern.edu}) \\ +Jonathan Rees ({\tt jar@cs.cornell.edu}) \\ +June 1992 +\end{center} + +\vspace{1ex} + +Scheme 48 is an implementation of the Scheme programming language based +on a virtual machine architecture. The following is an overview of +the project. + +\paragraph{Goals} + +\begin{itemize} +\setlength{\itemsep}{0pt} +\item Straightforward, minimal implementation. +\item Flexible experimental apparatus for research in programming + language design and implementation. +\item Easy to make changes to internal data representations, memory + management, and compilation strategy. +\item High reliability. +\item Fast and complete enough to be a good + development environment for Scheme programs. +\end{itemize} + + +\paragraph{Virtual machine} + +The virtual machine executes a simple byte-code instruction set +similar to the target of the Scheme 311 compiler [Clinger, LFP 1984]. +The interpreter for the virtual instruction set is itself written in +PreScheme, a systems programming dialect of Scheme. A PreScheme +compiler applies intensive source-to-source rewrites to the +interpreter source code and emits low-level C code. When the output +is then compiled by an optimizing C compiler such as gcc, the result +is a very efficient and portable emulator. + +\paragraph{Run-time system} + +The virtual machine is initialized from a specified memory image +containing byte-compiled Scheme code and data. Images (including +small stand-alone applications) are built either by a linker or by +writing out the state of an executing program. A standard memory +image contains a Scheme run-time library ({\tt append}, {\tt read}, +{\tt write}, etc.), a compiler from Scheme to the virtual instruction +set, and a command processor and debugger. In this way Scheme 48 can +be configured to look like a conventional Lisp interpreter. + +In addition to the Scheme run-time library and development +environment, library software includes support for multitasking, +modules (packages), hygienic macros (as described in the Revised$^4$ +Scheme report), records, and exception handling. + +\paragraph{Applications} + +The Scheme 48 system is being used at several sites for research in +memory management, embedded systems, multiprocessing, and computer +system verification. Scheme 48 was chosen as the platform for these +projects because of its internal tractability and flexibility. + +\end{document} diff --git a/doc/threads.txt b/doc/threads.txt new file mode 100644 index 0000000..875efce --- /dev/null +++ b/doc/threads.txt @@ -0,0 +1,89 @@ + + Threads + +The following are exported by the THREADS structure. + +(SPAWN thunk) +(SPAWN thunk name) + Create and schedule a new thread that will execute . The optional + name is used when printing the thread. + +(RELINQUISH-TIMESLICE) + Let other threads run for a while. + +(SLEEP time) + Sleep for