Copy disabled (too large)
Download .txt
Showing preview only (57,056K chars total). Download the full file to get everything.
Repository: larcenists/larceny
Branch: master
Commit: fef550c7d392
Files: 3022
Total size: 53.0 MB
Directory structure:
gitextract_1uoc4hss/
├── .gitattributes
├── .gitignore
├── COPYRIGHT
├── README-COMMON-LARCENY.txt
├── README-FIRST.txt
├── README.md
├── compile-larceny
├── compile-stale
├── doc/
│ ├── .gitignore
│ ├── CommonLarceny/
│ │ ├── image-teachpack.html
│ │ ├── image-teachpack.txt
│ │ ├── user-manual.txt
│ │ ├── world-teachpack.html
│ │ └── world-teachpack.txt
│ ├── DevManual/
│ │ ├── auxlib.txt
│ │ ├── bdw.txt
│ │ ├── bytevectors.txt
│ │ ├── compiling.txt
│ │ ├── concept.txt
│ │ ├── control.txt
│ │ ├── developing.txt
│ │ ├── environ.txt
│ │ ├── ephemeral.txt
│ │ ├── lowlevel.txt
│ │ ├── memstats.txt
│ │ ├── nasm-representations.txt
│ │ ├── procidx.txt
│ │ ├── repl.txt
│ │ ├── starting.txt
│ │ └── structures.txt
│ ├── HOWTO-BUILD
│ ├── HOWTO-ERR5RS
│ ├── HOWTO-FENCE
│ ├── HOWTO-INSTALL
│ ├── HOWTO-R6RS
│ ├── HOWTO-R7RS
│ ├── HOWTO-SCRIPT
│ ├── HOWTO-SLIB
│ ├── HOWTO-SRFI
│ ├── KNOWN-BUGS
│ ├── LarcenyNotes/
│ │ ├── generic-add.html
│ │ ├── larceny-notes.txt
│ │ ├── note1-timer.html
│ │ ├── note10-primops.html
│ │ ├── note11-bdw.html
│ │ ├── note12-procinfo.html
│ │ ├── note13-malcode.html
│ │ ├── note14-petit.html
│ │ ├── note2-repr.html
│ │ ├── note3-arithmetic.html
│ │ ├── note4-exceptions.html
│ │ ├── note5-heap.html
│ │ ├── note6-sparc.html
│ │ ├── note7-ffi.html
│ │ ├── note8-release.html
│ │ ├── note9-iosys.html
│ │ ├── noteX-gc.html
│ │ ├── noteX-newgc.html
│ │ ├── noteX-petit.html
│ │ ├── noteX-rts.html
│ │ ├── noteX-sc-heap.html
│ │ └── template.html
│ ├── Makefile
│ ├── OldDocs/
│ │ ├── BUGS
│ │ ├── BUGS-FIXED
│ │ ├── BUGS-RETIRED
│ │ ├── HOWTO-BUILD
│ │ ├── HOWTO-CVS
│ │ ├── HOWTO-I386
│ │ ├── HOWTO-MACOSX
│ │ ├── HOWTO-PETIT
│ │ ├── HOWTO-PPC
│ │ ├── HOWTO-SCREEN
│ │ ├── HOWTO-SPARC
│ │ ├── HOWTO-UNIX
│ │ ├── HOWTO-WIN32
│ │ ├── TODO
│ │ ├── TODO-PETIT
│ │ ├── TODO-RAINYDAY
│ │ ├── TODO-RELEASE
│ │ └── USER-REQUESTS
│ ├── UserManual/
│ │ ├── benchmarking.txt
│ │ ├── bytevectors.txt
│ │ ├── compiler.txt
│ │ ├── compiling.txt
│ │ ├── debugging.txt
│ │ ├── draft.txt
│ │ ├── entry.txt
│ │ ├── err5rs.txt
│ │ ├── ffi.txt
│ │ ├── fixnums.txt
│ │ ├── hashtable.txt
│ │ ├── ieee-std.txt
│ │ ├── intro.txt
│ │ ├── io.txt
│ │ ├── lexical.txt
│ │ ├── libraries.txt
│ │ ├── load.txt
│ │ ├── naming.txt
│ │ ├── numbers.txt
│ │ ├── os.txt
│ │ ├── pairs_lists.txt
│ │ ├── parameters.txt
│ │ ├── procedures.txt
│ │ ├── procidx.txt
│ │ ├── proplist.txt
│ │ ├── r6rs.txt
│ │ ├── r7rs.txt
│ │ ├── records.txt
│ │ ├── recprinter.txt
│ │ ├── running.txt
│ │ ├── slib.txt
│ │ ├── sorting.txt
│ │ ├── sparc-cache.txt
│ │ ├── srfi.txt
│ │ ├── starting.txt
│ │ ├── strings.txt
│ │ ├── symbols.txt
│ │ ├── syscontrol.txt
│ │ ├── template.txt
│ │ ├── unprovided.txt
│ │ ├── user-manual.txt
│ │ └── vectors.txt
│ ├── index.html
│ └── larcenydoc.conf
├── examples/
│ └── CommonLarceny/
│ ├── event-handling-demo1.sch
│ ├── event-handling-demo2.sch
│ └── form-graphics.sch
├── include/
│ ├── Nasm/
│ │ └── i386-instr.ah
│ ├── Shared/
│ │ ├── i386-machine.ah
│ │ ├── millicode.h
│ │ ├── petit-config.h
│ │ └── petit-machine.h
│ ├── Standard-C/
│ │ └── petit-instr.h
│ └── Sys/
│ ├── larceny-types.h
│ └── macros.h
├── lib/
│ ├── Base/
│ │ ├── defaults.sch
│ │ ├── dotnet-compile-file.sch
│ │ ├── format.sch
│ │ ├── io.sch
│ │ ├── list.sch
│ │ ├── load.sch
│ │ ├── macros.sch
│ │ ├── misc.sch
│ │ ├── osdep-macos.sch
│ │ ├── osdep-unix.sch
│ │ ├── osdep-win32.sch
│ │ ├── petit-compile-file.sch
│ │ ├── pp.sch
│ │ ├── process-stats.sch
│ │ ├── shivers-syntax.sch
│ │ ├── std-ffi.sch
│ │ ├── string.sch
│ │ ├── unix-functions.sch
│ │ └── vector.sch
│ ├── Broken/
│ │ ├── nonblocking-console.sch
│ │ ├── read-circular.sch
│ │ ├── read-source.sch
│ │ ├── task-test.sch
│ │ ├── task-test2.sch
│ │ ├── transcript.sch
│ │ └── unix-descriptor.sch
│ ├── Debugger/
│ │ ├── call-cc.sch
│ │ ├── countcalls.sch
│ │ ├── debug-info.txt
│ │ ├── debug.sch
│ │ ├── debugging.txt
│ │ ├── inspect-cont.sch
│ │ ├── new-debugger.sch
│ │ ├── profile.sch
│ │ ├── trace.sch
│ │ └── variables.sch
│ ├── Experimental/
│ │ ├── Beginning/
│ │ │ ├── beginning.txt
│ │ │ ├── colors.txt
│ │ │ ├── interpreter.sch
│ │ │ ├── loadall.sch
│ │ │ ├── posn.sch
│ │ │ ├── primops.sch
│ │ │ ├── stepper.sch
│ │ │ ├── syntax.sch
│ │ │ └── tests.sch
│ │ ├── DotNet/
│ │ │ ├── collections.sch
│ │ │ ├── dotnet-ffi-lcg.sch
│ │ │ ├── example.sch
│ │ │ ├── gui-inspection.sch
│ │ │ ├── maybe-read.sch
│ │ │ ├── protoobj.sch
│ │ │ ├── simple-inspection.sch
│ │ │ ├── simple-reflection.sch
│ │ │ ├── stepper-gui.sch
│ │ │ ├── stepper-menus.sch
│ │ │ ├── stepper-overrides.sch
│ │ │ ├── toolsmith-form.sch
│ │ │ ├── toolsmith-shared.sch
│ │ │ └── toolsmith-stepper.sch
│ │ ├── Makefile
│ │ ├── accum-profile.sch
│ │ ├── applyhook.sch
│ │ ├── applyhook0.mal
│ │ ├── apropos.sch
│ │ ├── exception.sch
│ │ ├── finger.sch
│ │ ├── glut.sch
│ │ ├── ia32parser.sch
│ │ ├── iosys.txt
│ │ ├── match.sch
│ │ ├── object-behavior/
│ │ │ ├── compute-object-behavior.sch
│ │ │ ├── hash.sch
│ │ │ ├── hashtable.sch
│ │ │ └── plot-profile.sch
│ │ ├── object-id.sch
│ │ ├── opengl-constants.sch
│ │ ├── opengl-enums.sch
│ │ ├── opengl-functions.sch
│ │ ├── opengl.sch
│ │ ├── poll.sch
│ │ ├── print-circular.sch
│ │ ├── scheme-source.sch
│ │ ├── smtp.sch
│ │ ├── socket-offset.c
│ │ ├── socket-support.c
│ │ ├── socket.sch
│ │ ├── system-stuff.sch
│ │ ├── task-test0.sch
│ │ ├── tasking-extra.sch
│ │ ├── tasking-notes.txt
│ │ ├── tasking-unix.sch
│ │ ├── tasking-with-io.sch
│ │ ├── tasking.sch
│ │ ├── twobit-benchmark.sch
│ │ ├── twobit-pass-times.sch
│ │ ├── twobit-timer.sch
│ │ ├── unix-support.c
│ │ ├── unix.sch
│ │ ├── weak.sch
│ │ ├── webclient/
│ │ │ ├── README
│ │ │ ├── browser.sch
│ │ │ ├── datastore.sch
│ │ │ ├── es-aux.sch
│ │ │ ├── es-cg.sch
│ │ │ ├── es-lexer.sch
│ │ │ ├── es-parser.sch
│ │ │ ├── es-runtime.sch
│ │ │ ├── html-entities.sch
│ │ │ ├── html-format.sch
│ │ │ ├── html-parser-test.sch
│ │ │ ├── html-parser.sch
│ │ │ └── wget.sch
│ │ ├── webserver/
│ │ │ ├── web-fun.sch
│ │ │ ├── web-server.sch
│ │ │ └── web-utils.sch
│ │ ├── winsock-descriptor.sch
│ │ └── winsock.sch
│ ├── Ffi/
│ │ ├── README
│ │ ├── arm-abi.txt
│ │ ├── bdw-memory.sch
│ │ ├── ffi-i386.sch
│ │ ├── ffi-linux-x86.sch
│ │ ├── ffi-load.sch
│ │ ├── ffi-lower.sch
│ │ ├── ffi-macosx.sch
│ │ ├── ffi-sparc.sch
│ │ ├── ffi-sunos4.sch
│ │ ├── ffi-sunos5.sch
│ │ ├── ffi-upper.sch
│ │ ├── ffi-util.sch
│ │ ├── ffi-win32.sch
│ │ ├── i386-abi.txt
│ │ ├── memory.sch
│ │ ├── sparc-abi.txt
│ │ └── tramp.sch
│ ├── MzScheme/
│ │ ├── class.sch
│ │ ├── compress.sch
│ │ ├── cont.sch
│ │ ├── custodian.sch
│ │ ├── dotnet-ffi.sch
│ │ ├── dotnet.sch
│ │ ├── envaux.sch
│ │ ├── excel-demo.sch
│ │ ├── exn.sch
│ │ ├── generic.sch
│ │ ├── gprint.sch
│ │ ├── hash-compat.sch
│ │ ├── identifier.sch
│ │ ├── init.sch
│ │ ├── inspector.sch
│ │ ├── instance.sch
│ │ ├── instance0.mal
│ │ ├── macros.sch
│ │ ├── misc.sch
│ │ ├── namespace.sch
│ │ ├── parameters.sch
│ │ ├── record.sch
│ │ ├── simple-macros/
│ │ │ ├── mzmacros.sch
│ │ │ ├── r5rs.sch
│ │ │ ├── simple-macros-tests.sch
│ │ │ ├── simple-macros.sch
│ │ │ ├── simple-module-examples.sch
│ │ │ └── simple-syntax-case.sch
│ │ ├── struct-macros.sch
│ │ ├── struct-proc.sch
│ │ ├── struct-proc0.mal
│ │ ├── struct.sch
│ │ ├── thread.sch
│ │ ├── wcm.sch
│ │ ├── wcm0.mal
│ │ └── windows.sch
│ ├── R6RS/
│ │ ├── benchmarking.sch
│ │ ├── err5rs/
│ │ │ ├── load.sls
│ │ │ ├── records/
│ │ │ │ ├── syntactic/
│ │ │ │ │ └── original.sls
│ │ │ │ └── syntactic.sls
│ │ │ └── records.sls
│ │ ├── explicit-renaming.sls
│ │ ├── larceny/
│ │ │ ├── benchmarking.sls
│ │ │ ├── compile-stale.body.scm
│ │ │ ├── compile-stale.sld
│ │ │ ├── compiler.sld
│ │ │ ├── deprecated.sls
│ │ │ ├── load.sls
│ │ │ ├── parse-options.body.scm
│ │ │ ├── parse-options.sld
│ │ │ ├── r7r6.sld
│ │ │ ├── r7rs/
│ │ │ │ ├── macros.body.scm
│ │ │ │ ├── macros.sld
│ │ │ │ ├── primitives/
│ │ │ │ │ ├── lowlevel.sld
│ │ │ │ │ └── patches.sld
│ │ │ │ ├── primitives.sld
│ │ │ │ ├── promises.body.scm
│ │ │ │ ├── promises.sld
│ │ │ │ └── test.sld
│ │ │ ├── records.sls
│ │ │ ├── shivers-syntax.sls
│ │ │ └── text.sld
│ │ ├── r5rs.sls
│ │ ├── r6rs-compat-larceny.sch
│ │ ├── r6rs-expander.sch
│ │ ├── r6rs-runtime.sch
│ │ ├── r6rs-standard-libraries.sch
│ │ ├── r6rsmode.sch
│ │ ├── readme.txt
│ │ ├── rnrs/
│ │ │ ├── arithmetic.sls
│ │ │ ├── bytevectors.sls
│ │ │ ├── conditions.sls
│ │ │ ├── control.sls
│ │ │ ├── enums.sls
│ │ │ ├── eval.sls
│ │ │ ├── exceptions.sls
│ │ │ ├── files.sls
│ │ │ ├── hashtables.sls
│ │ │ ├── io.sls
│ │ │ ├── lists.sls
│ │ │ ├── load.sls
│ │ │ ├── mutable-pairs.sls
│ │ │ ├── mutable-strings.sls
│ │ │ ├── programs.sls
│ │ │ ├── r5rs.sls
│ │ │ ├── records/
│ │ │ │ ├── syntactic/
│ │ │ │ │ └── original.sls
│ │ │ │ └── syntactic.sls
│ │ │ ├── records.sls
│ │ │ ├── sorting.sls
│ │ │ ├── syntax-case.sls
│ │ │ └── unicode.sls
│ │ └── rnrs.sls
│ ├── R7RS/
│ │ ├── r7rs-cond-expander.sch
│ │ ├── r7rs-includer.sch
│ │ ├── r7rsmode.sch
│ │ └── scheme/
│ │ ├── base.body.scm
│ │ ├── base.sld
│ │ ├── box.sld
│ │ ├── case-lambda.sld
│ │ ├── char.body.scm
│ │ ├── char.sld
│ │ ├── charset.sld
│ │ ├── comparator.sld
│ │ ├── complex.sld
│ │ ├── cxr.sld
│ │ ├── ephemeron.sld
│ │ ├── eval.sld
│ │ ├── file.sld
│ │ ├── generator.sld
│ │ ├── hash-table.sld
│ │ ├── ideque.sld
│ │ ├── ilist.sld
│ │ ├── inexact.sld
│ │ ├── lazy.sld
│ │ ├── list-queue.sld
│ │ ├── list.sld
│ │ ├── load.sld
│ │ ├── lseq.sld
│ │ ├── process-context.body.scm
│ │ ├── process-context.sld
│ │ ├── r5rs.sld
│ │ ├── read.sld
│ │ ├── repl.body.scm
│ │ ├── repl.sld
│ │ ├── rlist.sld
│ │ ├── set.sld
│ │ ├── sort.sld
│ │ ├── stream.sld
│ │ ├── text.sld
│ │ ├── time.body.scm
│ │ ├── time.decls.scm
│ │ ├── time.sld
│ │ ├── vector.sld
│ │ └── write.sld
│ ├── README
│ ├── SRFI/
│ │ ├── README
│ │ ├── in-progress/
│ │ │ ├── README
│ │ │ ├── spans-search-test.sps
│ │ │ ├── spans-test.sps
│ │ │ ├── spans.body1.scm
│ │ │ ├── spans.body1a.scm
│ │ │ ├── spans.body1b.scm
│ │ │ ├── spans.body1c.scm
│ │ │ ├── spans.body1d.scm
│ │ │ ├── spans.body2.scm
│ │ │ ├── spans.sld
│ │ │ ├── srfi-2.sch
│ │ │ ├── srfi-34-test.sch
│ │ │ ├── srfi-34.sch
│ │ │ └── srfi-41.sch
│ │ ├── scheme-r5rs.c
│ │ ├── srfi/
│ │ │ ├── %3a1.sls
│ │ │ ├── %3a101.sls
│ │ │ ├── %3a11.sls
│ │ │ ├── %3a13.sls
│ │ │ ├── %3a14.sls
│ │ │ ├── %3a16.sls
│ │ │ ├── %3a17.sls
│ │ │ ├── %3a19.sls
│ │ │ ├── %3a2.sls
│ │ │ ├── %3a23.sls
│ │ │ ├── %3a25.sls
│ │ │ ├── %3a26.sls
│ │ │ ├── %3a27.sls
│ │ │ ├── %3a28.sls
│ │ │ ├── %3a29.sls
│ │ │ ├── %3a30.sls
│ │ │ ├── %3a31.sls
│ │ │ ├── %3a34.sls
│ │ │ ├── %3a37.sls
│ │ │ ├── %3a38.sls
│ │ │ ├── %3a39.sls
│ │ │ ├── %3a41.sls
│ │ │ ├── %3a42.sls
│ │ │ ├── %3a43.sls
│ │ │ ├── %3a45.sls
│ │ │ ├── %3a48.sls
│ │ │ ├── %3a5.sls
│ │ │ ├── %3a51.sls
│ │ │ ├── %3a54.sls
│ │ │ ├── %3a55.sls
│ │ │ ├── %3a59.sls
│ │ │ ├── %3a6.sls
│ │ │ ├── %3a60.sls
│ │ │ ├── %3a61.sls
│ │ │ ├── %3a62.sls
│ │ │ ├── %3a63.sls
│ │ │ ├── %3a64.sls
│ │ │ ├── %3a66.sls
│ │ │ ├── %3a67.sls
│ │ │ ├── %3a69.sls
│ │ │ ├── %3a71.sls
│ │ │ ├── %3a74.sls
│ │ │ ├── %3a78.sls
│ │ │ ├── %3a8.sls
│ │ │ ├── %3a86.sls.deprecated
│ │ │ ├── %3a87.sls
│ │ │ ├── %3a9.sls
│ │ │ ├── %3a95.sls
│ │ │ ├── %3a98.sls
│ │ │ ├── %3a99.sls
│ │ │ ├── 0.sld
│ │ │ ├── 1.sld
│ │ │ ├── 101.sld
│ │ │ ├── 11.sld
│ │ │ ├── 111.sld
│ │ │ ├── 112.sld
│ │ │ ├── 113.body.scm
│ │ │ ├── 113.sld
│ │ │ ├── 114.advanced.scm
│ │ │ ├── 114.basics.scm
│ │ │ ├── 114.constructors.scm
│ │ │ ├── 114.default.scm
│ │ │ ├── 114.sld
│ │ │ ├── 115.body.scm
│ │ │ ├── 115.boundary.scm
│ │ │ ├── 115.sld
│ │ │ ├── 116/
│ │ │ │ ├── comparators.body.scm
│ │ │ │ ├── comparators.sld
│ │ │ │ ├── ilists.body1.scm
│ │ │ │ ├── ilists.body2.scm
│ │ │ │ └── ilists.sld
│ │ │ ├── 116.sld
│ │ │ ├── 117.body.scm
│ │ │ ├── 117.sld
│ │ │ ├── 121.body.scm
│ │ │ ├── 121.sld
│ │ │ ├── 122.body.scm
│ │ │ ├── 122.sld
│ │ │ ├── 123.body.scm
│ │ │ ├── 123.sld
│ │ │ ├── 124.body.scm
│ │ │ ├── 124.sld
│ │ │ ├── 125.body.scm
│ │ │ ├── 125.sld
│ │ │ ├── 126.body.scm
│ │ │ ├── 126.sld
│ │ │ ├── 127.body.scm
│ │ │ ├── 127.sld
│ │ │ ├── 128/
│ │ │ │ ├── kernel.body.scm
│ │ │ │ ├── kernel.sld
│ │ │ │ ├── reference.body1.scm
│ │ │ │ ├── reference.body2.scm
│ │ │ │ └── reference.sld
│ │ │ ├── 128.body1.scm
│ │ │ ├── 128.body2.scm
│ │ │ ├── 128.sld
│ │ │ ├── 129.sld
│ │ │ ├── 13.sld
│ │ │ ├── 130.body.scm
│ │ │ ├── 130.sld
│ │ │ ├── 131.sld
│ │ │ ├── 132/
│ │ │ │ ├── delndups.scm
│ │ │ │ ├── lmsort.scm
│ │ │ │ ├── merge.scm
│ │ │ │ ├── select.scm
│ │ │ │ ├── sort.scm
│ │ │ │ ├── sortfaster.scm
│ │ │ │ ├── sortp.scm
│ │ │ │ ├── vector-util.scm
│ │ │ │ ├── vhsort.scm
│ │ │ │ ├── visort.scm
│ │ │ │ ├── vmsort.scm
│ │ │ │ ├── vqsort2.scm
│ │ │ │ └── vqsort3.scm
│ │ │ ├── 132.sld
│ │ │ ├── 133.body.scm
│ │ │ ├── 133.sld
│ │ │ ├── 134.body.scm
│ │ │ ├── 134.sld
│ │ │ ├── 135/
│ │ │ │ ├── kernel0.body.scm
│ │ │ │ ├── kernel0.sld
│ │ │ │ ├── kernel16.body.scm
│ │ │ │ ├── kernel16.sld
│ │ │ │ ├── kernel8.body.scm
│ │ │ │ ├── kernel8.sld
│ │ │ │ └── texts.sld
│ │ │ ├── 135.body.scm
│ │ │ ├── 135.sld
│ │ │ ├── 136.body.scm
│ │ │ ├── 136.sld
│ │ │ ├── 137.body.scm
│ │ │ ├── 137.sld
│ │ │ ├── 138.body.scm
│ │ │ ├── 138.sld
│ │ │ ├── 14/
│ │ │ │ ├── bmp.sld
│ │ │ │ ├── char-sets.body.scm
│ │ │ │ ├── char-sets.sld
│ │ │ │ ├── latin-1.sld
│ │ │ │ └── unicode.sld
│ │ │ ├── 14.sld
│ │ │ ├── 141.body.scm
│ │ │ ├── 141.sld
│ │ │ ├── 142.sld
│ │ │ ├── 143.sld
│ │ │ ├── 144.body.scm
│ │ │ ├── 144.body0.scm
│ │ │ ├── 144.constants.scm
│ │ │ ├── 144.ffi.scm
│ │ │ ├── 144.r6rs.scm
│ │ │ ├── 144.sld
│ │ │ ├── 144.special.scm
│ │ │ ├── 145.sld
│ │ │ ├── 146/
│ │ │ │ ├── rbtree.body.scm
│ │ │ │ └── rbtree.sld
│ │ │ ├── 146.body.scm
│ │ │ ├── 146.sld
│ │ │ ├── 147.body.scm
│ │ │ ├── 147.sld
│ │ │ ├── 151.body.scm
│ │ │ ├── 151.sld
│ │ │ ├── 152.body.scm
│ │ │ ├── 152.sld
│ │ │ ├── 16.sld
│ │ │ ├── 17.sld
│ │ │ ├── 19.sld
│ │ │ ├── 2.sld
│ │ │ ├── 23.sld
│ │ │ ├── 25.sld
│ │ │ ├── 26.sld
│ │ │ ├── 27.sld
│ │ │ ├── 28.sld
│ │ │ ├── 29.sld
│ │ │ ├── 30.sld
│ │ │ ├── 31.sld
│ │ │ ├── 34.sld
│ │ │ ├── 37.body.scm
│ │ │ ├── 37.sld
│ │ │ ├── 38.sld
│ │ │ ├── 39.sld
│ │ │ ├── 41.sld
│ │ │ ├── 42.sld
│ │ │ ├── 43.sld
│ │ │ ├── 45.sld
│ │ │ ├── 48.sld
│ │ │ ├── 5.sld
│ │ │ ├── 51.sld
│ │ │ ├── 54.sld
│ │ │ ├── 55.sld
│ │ │ ├── 59.sld
│ │ │ ├── 6.sld
│ │ │ ├── 60.sld
│ │ │ ├── 61.sld
│ │ │ ├── 62.sld
│ │ │ ├── 63.sld
│ │ │ ├── 64.body.scm
│ │ │ ├── 64.sld
│ │ │ ├── 66.sld
│ │ │ ├── 67.sld
│ │ │ ├── 69.sld
│ │ │ ├── 71.sld
│ │ │ ├── 74.sld
│ │ │ ├── 78.sld
│ │ │ ├── 8.sld
│ │ │ ├── 87.sld
│ │ │ ├── 9.sld
│ │ │ ├── 95.sld
│ │ │ ├── 98.sld
│ │ │ ├── 99.sld
│ │ │ ├── srfi38grammar.sch
│ │ │ └── srfi38tokens.sch
│ │ ├── srfi-0.sch
│ │ ├── srfi-1.sch
│ │ ├── srfi-11.sch
│ │ ├── srfi-13.sch
│ │ ├── srfi-14.sch
│ │ ├── srfi-16.sch
│ │ ├── srfi-17.sch
│ │ ├── srfi-19.sch
│ │ ├── srfi-2.sch
│ │ ├── srfi-22.sch
│ │ ├── srfi-23.sch
│ │ ├── srfi-25.sch
│ │ ├── srfi-26.sch
│ │ ├── srfi-27.sch
│ │ ├── srfi-28.sch
│ │ ├── srfi-29.sch
│ │ ├── srfi-30.sch
│ │ ├── srfi-31.sch
│ │ ├── srfi-37.sch
│ │ ├── srfi-38.sch
│ │ ├── srfi-39.sch
│ │ ├── srfi-41.sls
│ │ ├── srfi-42.sch
│ │ ├── srfi-43.sch
│ │ ├── srfi-45.sch
│ │ ├── srfi-48.sch
│ │ ├── srfi-5.sch
│ │ ├── srfi-51.sch
│ │ ├── srfi-54.sch
│ │ ├── srfi-56.sch
│ │ ├── srfi-59.sch
│ │ ├── srfi-6.sch
│ │ ├── srfi-60.sch
│ │ ├── srfi-61.sch
│ │ ├── srfi-62.sch
│ │ ├── srfi-63.sch
│ │ ├── srfi-64.sch
│ │ ├── srfi-66.sch
│ │ ├── srfi-67.sch
│ │ ├── srfi-69.sch
│ │ ├── srfi-7.sch
│ │ ├── srfi-71.sch
│ │ ├── srfi-74.sch
│ │ ├── srfi-78.sch
│ │ ├── srfi-8.sch
│ │ ├── srfi-86.sch
│ │ ├── srfi-87.sch
│ │ ├── srfi-9.sch
│ │ ├── srfi-95.sch
│ │ ├── srfi-96.sch
│ │ ├── srfi-98.sch
│ │ └── test/
│ │ ├── 122test.pgm
│ │ ├── README
│ │ ├── gauche-testsuite.sch
│ │ ├── load-all-tests.sch
│ │ ├── run-r6-tests
│ │ ├── run-r7-tests
│ │ ├── srfi-0-test.sch
│ │ ├── srfi-0-test.sps7
│ │ ├── srfi-1-test.sch
│ │ ├── srfi-1-test.sps
│ │ ├── srfi-1-test.sps7
│ │ ├── srfi-101-test.body.scm
│ │ ├── srfi-101-test.sps
│ │ ├── srfi-101-test.sps7
│ │ ├── srfi-11-test.sch
│ │ ├── srfi-11-test.sps
│ │ ├── srfi-11-test.sps7
│ │ ├── srfi-111-test.sps7
│ │ ├── srfi-112-test.sps7
│ │ ├── srfi-113-test.sps7
│ │ ├── srfi-115-test.sps7
│ │ ├── srfi-116-test.sps7
│ │ ├── srfi-117-test.sps7
│ │ ├── srfi-121-test.sps7
│ │ ├── srfi-122-test.sps7
│ │ ├── srfi-123-test.sps7
│ │ ├── srfi-124-test.sps7
│ │ ├── srfi-125-test.sps7
│ │ ├── srfi-126-test.body.scm
│ │ ├── srfi-126-test.sps7
│ │ ├── srfi-127-test.sps7
│ │ ├── srfi-128-benchmark.sps
│ │ ├── srfi-128-test.sps7
│ │ ├── srfi-129-test.sps7
│ │ ├── srfi-13-test.sch
│ │ ├── srfi-13-test.sps
│ │ ├── srfi-13-test.sps7
│ │ ├── srfi-130-test.sps7
│ │ ├── srfi-132-test.sps7
│ │ ├── srfi-133-test.sps7
│ │ ├── srfi-134-test.body.scm
│ │ ├── srfi-134-test.sps7
│ │ ├── srfi-135-search-test.sps7
│ │ ├── srfi-135-test.sps7
│ │ ├── srfi-136-test.sps7
│ │ ├── srfi-137-test.sps7
│ │ ├── srfi-14-test.sch
│ │ ├── srfi-14-test.sps
│ │ ├── srfi-14-test.sps7
│ │ ├── srfi-141-test.sps7
│ │ ├── srfi-143-test.sps7
│ │ ├── srfi-144-test.scm
│ │ ├── srfi-145-test.sps7
│ │ ├── srfi-146-test.sps7
│ │ ├── srfi-147-test.sps7
│ │ ├── srfi-148-test.sps7
│ │ ├── srfi-151-test.sps7
│ │ ├── srfi-152-test.sps7
│ │ ├── srfi-16-test.sch
│ │ ├── srfi-16-test.sps
│ │ ├── srfi-16-test.sps7
│ │ ├── srfi-17-test.sch
│ │ ├── srfi-17-test.sps
│ │ ├── srfi-17-test.sps7
│ │ ├── srfi-19-test.sch
│ │ ├── srfi-19-test.sps
│ │ ├── srfi-19-test.sps7
│ │ ├── srfi-2-test.sch
│ │ ├── srfi-2-test.sps
│ │ ├── srfi-2-test.sps7
│ │ ├── srfi-22-helper1.sch
│ │ ├── srfi-22-helper2.sch
│ │ ├── srfi-22-test
│ │ ├── srfi-23-test.sch
│ │ ├── srfi-23-test.sps
│ │ ├── srfi-23-test.sps7
│ │ ├── srfi-25-test.sch
│ │ ├── srfi-25-test.sps
│ │ ├── srfi-25-test.sps7
│ │ ├── srfi-26-test.sch
│ │ ├── srfi-26-test.sps
│ │ ├── srfi-26-test.sps7
│ │ ├── srfi-27-test.sch
│ │ ├── srfi-27-test.sps
│ │ ├── srfi-27-test.sps7
│ │ ├── srfi-28-test.sch
│ │ ├── srfi-28-test.sps
│ │ ├── srfi-28-test.sps7
│ │ ├── srfi-29-test.sch
│ │ ├── srfi-29-test.sps
│ │ ├── srfi-29-test.sps7
│ │ ├── srfi-30-test.sch
│ │ ├── srfi-30-test.sps7
│ │ ├── srfi-31-test.sch
│ │ ├── srfi-31-test.sps
│ │ ├── srfi-31-test.sps7
│ │ ├── srfi-34-test.sps7
│ │ ├── srfi-37-test.sch
│ │ ├── srfi-37-test.sps7
│ │ ├── srfi-38-test.sch
│ │ ├── srfi-38-test.sps
│ │ ├── srfi-38-test.sps7
│ │ ├── srfi-39-test.sch
│ │ ├── srfi-39-test.sps
│ │ ├── srfi-39-test.sps7
│ │ ├── srfi-41-test.sps
│ │ ├── srfi-41-test.sps7
│ │ ├── srfi-42-test.sch
│ │ ├── srfi-42-test.sps
│ │ ├── srfi-42-test.sps7
│ │ ├── srfi-43-test.sch
│ │ ├── srfi-43-test.sps
│ │ ├── srfi-43-test.sps7
│ │ ├── srfi-45-test.sch
│ │ ├── srfi-45-test.sps
│ │ ├── srfi-45-test.sps7
│ │ ├── srfi-48-test.sch
│ │ ├── srfi-48-test.sps
│ │ ├── srfi-48-test.sps7
│ │ ├── srfi-5-test.sch
│ │ ├── srfi-5-test.sps
│ │ ├── srfi-5-test.sps7
│ │ ├── srfi-51-test.sch
│ │ ├── srfi-51-test.sps
│ │ ├── srfi-51-test.sps7
│ │ ├── srfi-54-test.sch
│ │ ├── srfi-54-test.sps
│ │ ├── srfi-54-test.sps7
│ │ ├── srfi-55-test.sps7
│ │ ├── srfi-59-test.sps
│ │ ├── srfi-59-test.sps7
│ │ ├── srfi-6-test.sch
│ │ ├── srfi-6-test.sps
│ │ ├── srfi-6-test.sps7
│ │ ├── srfi-60-test.sch
│ │ ├── srfi-60-test.sps
│ │ ├── srfi-60-test.sps7
│ │ ├── srfi-61-test.sch
│ │ ├── srfi-61-test.sps
│ │ ├── srfi-61-test.sps7
│ │ ├── srfi-63-test.sch
│ │ ├── srfi-63-test.sps
│ │ ├── srfi-63-test.sps7
│ │ ├── srfi-64-test.sch
│ │ ├── srfi-64-test.sps
│ │ ├── srfi-64-test.sps7
│ │ ├── srfi-66-test.sch
│ │ ├── srfi-66-test.sps
│ │ ├── srfi-66-test.sps7
│ │ ├── srfi-67-test.sch
│ │ ├── srfi-67-test.sps
│ │ ├── srfi-67-test.sps7
│ │ ├── srfi-69-test.sch
│ │ ├── srfi-69-test.sps
│ │ ├── srfi-69-test.sps7
│ │ ├── srfi-7-helper1.sch
│ │ ├── srfi-7-helper2.sch
│ │ ├── srfi-7-helper3.sch
│ │ ├── srfi-7-test.sch
│ │ ├── srfi-71-test.sch
│ │ ├── srfi-71-test.sps
│ │ ├── srfi-71-test.sps7
│ │ ├── srfi-74-test.sch
│ │ ├── srfi-74-test.sps
│ │ ├── srfi-74-test.sps7
│ │ ├── srfi-78-test.sch
│ │ ├── srfi-78-test.sps
│ │ ├── srfi-78-test.sps7
│ │ ├── srfi-8-test.sch
│ │ ├── srfi-8-test.sps
│ │ ├── srfi-8-test.sps7
│ │ ├── srfi-86-test.sch
│ │ ├── srfi-86-test.sps
│ │ ├── srfi-86-test.sps7
│ │ ├── srfi-87-test.sch
│ │ ├── srfi-87-test.sps
│ │ ├── srfi-87-test.sps7
│ │ ├── srfi-9-test.sch
│ │ ├── srfi-9-test.sps
│ │ ├── srfi-9-test.sps7
│ │ ├── srfi-95-test.sch
│ │ ├── srfi-95-test.sps
│ │ ├── srfi-95-test.sps7
│ │ ├── srfi-98-test.sch
│ │ ├── srfi-98-test.sps
│ │ ├── srfi-98-test.sps7
│ │ ├── srfi-99-test.sps7
│ │ └── test-group.scm
│ ├── Standard/
│ │ ├── README
│ │ ├── applyhook.sch
│ │ ├── apropos.sch
│ │ ├── array-util.sch
│ │ ├── array.sch
│ │ ├── assert.sch
│ │ ├── autoload.sch
│ │ ├── barrier-sync.sch
│ │ ├── box.sch
│ │ ├── combinatory.sch
│ │ ├── comment.sch
│ │ ├── common-syntax.sch
│ │ ├── control.sch
│ │ ├── coroutine.sch
│ │ ├── debugger.sch
│ │ ├── define-record.sch
│ │ ├── define-values.sch
│ │ ├── defmacro.sch
│ │ ├── docextract.sch
│ │ ├── dotimes.sch
│ │ ├── exec-comment.sch
│ │ ├── file-system.sch
│ │ ├── file-utils.sch
│ │ ├── fluid.sch
│ │ ├── foreign-cenums.sch
│ │ ├── foreign-cstructs.sch
│ │ ├── foreign-ctools.sch
│ │ ├── foreign-stdlib.sch
│ │ ├── foreign-sugar.sch
│ │ ├── format.sch
│ │ ├── fortune.sch
│ │ ├── fortune.txt
│ │ ├── fqueue.sch
│ │ ├── gdk.sch
│ │ ├── generator.sch
│ │ ├── glib.sch
│ │ ├── glob.sch
│ │ ├── gtk-2.4.sch
│ │ ├── gtk-enums.sch
│ │ ├── gtk-helper-syntax.sch
│ │ ├── gtk.sch
│ │ ├── in-progress/
│ │ │ ├── bitvector.sch
│ │ │ ├── bitvector.txt
│ │ │ ├── chat.sch
│ │ │ ├── chez-engine.sch
│ │ │ ├── deepcopy.sch
│ │ │ ├── eng.sch
│ │ │ ├── engine.sch
│ │ │ ├── huff.sch
│ │ │ ├── local.sch
│ │ │ ├── m3records.sch
│ │ │ ├── md4.sch
│ │ │ ├── nmap.sch
│ │ │ ├── number-theory.sch
│ │ │ ├── pickle.sch
│ │ │ ├── print-table.sch
│ │ │ ├── record.sch
│ │ │ ├── s48bitvector.sch
│ │ │ ├── text.sch
│ │ │ ├── toposort.sch
│ │ │ ├── units.sch
│ │ │ └── unix-directory.sch
│ │ ├── infix-expr.sch
│ │ ├── io.sch
│ │ ├── list-set.sch
│ │ ├── list.sch
│ │ ├── match-syntax.sch
│ │ ├── match.sch
│ │ ├── md5.sch
│ │ ├── monitor.sch
│ │ ├── mutex.sch
│ │ ├── nasm-disasm.sch
│ │ ├── nonblocking-console.sch
│ │ ├── number.sch
│ │ ├── poll.sch
│ │ ├── pretty.sch
│ │ ├── queue.sch
│ │ ├── random.sch
│ │ ├── readline.sch
│ │ ├── record.sch
│ │ ├── regexp.sch
│ │ ├── sharp-dot.sch
│ │ ├── shivers-syntax.sch
│ │ ├── slib/
│ │ │ └── larceny.init
│ │ ├── socket.sch
│ │ ├── stats.sch
│ │ ├── std-autoloads.sch
│ │ ├── string.sch
│ │ ├── symbol.sch
│ │ ├── tasking-with-io.sch
│ │ ├── tasking.sch
│ │ ├── test/
│ │ │ ├── applyhook.sch
│ │ │ ├── box.sch
│ │ │ ├── brackets.sch
│ │ │ ├── combinatory.sch
│ │ │ ├── control.sch
│ │ │ ├── coroutine.sch
│ │ │ ├── defmacro.sch
│ │ │ ├── format.sch
│ │ │ ├── fqueue.sch
│ │ │ ├── generator.sch
│ │ │ ├── glob.sch
│ │ │ ├── io.sch
│ │ │ ├── list-set.sch
│ │ │ ├── list.sch
│ │ │ ├── match.sch
│ │ │ ├── md5.sch
│ │ │ ├── number.sch
│ │ │ ├── queue.sch
│ │ │ ├── string.sch
│ │ │ ├── symbol.sch
│ │ │ ├── tasking.sch
│ │ │ ├── unify.sch
│ │ │ ├── unix.sch
│ │ │ └── word.sch
│ │ ├── time.sch
│ │ ├── trie.sch
│ │ ├── unify.sch
│ │ ├── unix-descriptor.sch
│ │ ├── unix.sch
│ │ ├── uuencode.sch
│ │ └── word.sch
│ ├── TeachPacks/
│ │ ├── Demos/
│ │ │ ├── ball.sch
│ │ │ ├── bouncing-ball.sch
│ │ │ ├── repl.sch
│ │ │ ├── rocket.sch
│ │ │ └── satellite.sch
│ │ ├── IDE/
│ │ │ └── repl.sch
│ │ ├── Support/
│ │ │ ├── dotnet-defs.sch
│ │ │ ├── image-dotnet.sch
│ │ │ ├── misc.sch
│ │ │ └── world-dotnet.sch
│ │ ├── image.sch
│ │ └── world.sch
│ └── VanTonderMacros/
│ ├── compat-larceny.scm
│ ├── examples.scm
│ ├── expander.scm
│ ├── readme.txt
│ ├── sample-balloons.scm
│ ├── sample-libs-and-program.scm
│ ├── sample-party.scm
│ ├── sample-program.scm
│ ├── sample-stack.scm
│ └── standard-libraries.scm
├── scheme-script
├── setup.sch
├── src/
│ ├── Asm/
│ │ ├── CSharp/
│ │ │ ├── asm-switches.sch
│ │ │ ├── dumpheap-extra.sch
│ │ │ ├── pass5p2-instructions.sch
│ │ │ ├── pass5p2.sch
│ │ │ └── switches.sch
│ │ ├── Fence/
│ │ │ ├── arm-disassembler.sch
│ │ │ ├── arm-optimizer.sch
│ │ │ ├── asm-switches.sch
│ │ │ ├── pass5p2-arm.sch
│ │ │ ├── pass5p2-ppc.sch
│ │ │ ├── pass5p2.sch
│ │ │ └── peepopt.sch
│ │ ├── IAssassin/
│ │ │ ├── asm-switches.sch
│ │ │ ├── pass5p2-sassy.sch
│ │ │ ├── peepopt.sch
│ │ │ ├── sassy-instr.sch
│ │ │ ├── sassy-invoke.sch
│ │ │ └── sassy-machine.sch
│ │ ├── IL/
│ │ │ ├── asm-switches.sch
│ │ │ ├── config.sch
│ │ │ ├── dumpheap-extra.sch
│ │ │ ├── dumpheap-il.sch
│ │ │ ├── il-corememory.sch
│ │ │ ├── il-gen.sch
│ │ │ ├── il-jdot-aliases.sch
│ │ │ ├── il-load-coremem.sch
│ │ │ ├── il-rtif.sch
│ │ │ ├── il-sourcefile.sch
│ │ │ ├── il-src2string.sch
│ │ │ ├── il.imp.sch
│ │ │ ├── il.imp2.sch
│ │ │ ├── pass5p2-instructions.sch
│ │ │ ├── pass5p2-listify.sch
│ │ │ ├── pass5p2-ops.sch
│ │ │ ├── pass5p2.sch
│ │ │ ├── peepopt.sch
│ │ │ ├── util-structs.sch
│ │ │ └── util.sch
│ │ ├── IL-LCG/
│ │ │ ├── dotnet-ffi-lcg.sch
│ │ │ ├── pass5p2.sch
│ │ │ ├── peepopt.sch
│ │ │ └── scratch.sch
│ │ ├── MacScheme/
│ │ │ └── pass5p2.sch
│ │ ├── Nasm/
│ │ │ ├── Experiments/
│ │ │ │ ├── benchmark.c
│ │ │ │ ├── benchmark.scm
│ │ │ │ ├── ccall.scm
│ │ │ │ ├── linker.scm
│ │ │ │ ├── loader.c
│ │ │ │ ├── tailcall.scm
│ │ │ │ └── winloader.c
│ │ │ ├── NASM/
│ │ │ │ ├── assemble.c
│ │ │ │ ├── insns.h
│ │ │ │ ├── insns.pl
│ │ │ │ ├── insnsa.c
│ │ │ │ ├── insnsd.c
│ │ │ │ ├── insnsi.h
│ │ │ │ ├── insnsn.c
│ │ │ │ └── nasm.h
│ │ │ ├── README
│ │ │ ├── dumpheap-overrides.sch
│ │ │ ├── dumpheap-unix.sch
│ │ │ ├── dumpheap-win32.sch
│ │ │ ├── i386asm.sch
│ │ │ ├── pass5p2-nasm.sch
│ │ │ └── peepopt.sch
│ │ ├── PowerPC/
│ │ │ └── pass5p2.sch
│ │ ├── Shared/
│ │ │ ├── asmutil.sch
│ │ │ ├── asmutil32-test.sch
│ │ │ ├── asmutil32.sch
│ │ │ ├── asmutil32be.sch
│ │ │ ├── asmutil32el.sch
│ │ │ ├── dumpheap.sch
│ │ │ ├── external-assembler.sch
│ │ │ ├── link-lop.sch
│ │ │ ├── logior-extra.sch
│ │ │ ├── makefasl.sch
│ │ │ └── pass5p1.sch
│ │ ├── Sparc/
│ │ │ ├── gen-msi.sch
│ │ │ ├── pass5p2.sch
│ │ │ ├── peepopt.sch
│ │ │ ├── scaffold.sch
│ │ │ ├── sparcasm-test.sch
│ │ │ ├── sparcasm.sch
│ │ │ ├── sparcasm2.sch
│ │ │ ├── sparcdis.sch
│ │ │ ├── sparcprim-part1.sch
│ │ │ ├── sparcprim-part2.sch
│ │ │ ├── sparcprim-part3a.sch
│ │ │ ├── sparcprim-part3b.sch
│ │ │ ├── sparcprim-part4.sch
│ │ │ ├── sparcutil.sch
│ │ │ └── switches.sch
│ │ └── Standard-C/
│ │ ├── asm-switches.sch
│ │ ├── dumpheap-overrides.sch
│ │ ├── dumpheap-unix.sch
│ │ ├── dumpheap-win32.sch
│ │ ├── md5.sch
│ │ ├── pass5p2.sch
│ │ ├── peepopt.sch
│ │ └── petit-init-proc.sch
│ ├── Build/
│ │ ├── CL/
│ │ │ ├── README
│ │ │ ├── Scripts/
│ │ │ │ ├── AssembleHeap2.bat
│ │ │ │ ├── CompileHeap.bat
│ │ │ │ ├── CompileRuntime2.bat
│ │ │ │ ├── README
│ │ │ │ └── which.bat
│ │ │ ├── VS8/
│ │ │ │ └── Larceny/
│ │ │ │ ├── Bundle/
│ │ │ │ │ ├── Bundle.vcproj
│ │ │ │ │ ├── bundle-common.ss
│ │ │ │ │ ├── bundleplt.ss
│ │ │ │ │ ├── bundletar.ss
│ │ │ │ │ └── bundlezip.ss
│ │ │ │ ├── Configure/
│ │ │ │ │ ├── Configure.ss
│ │ │ │ │ └── Configure.vcproj
│ │ │ │ ├── Heap/
│ │ │ │ │ ├── Heap.vcproj
│ │ │ │ │ └── Rebuild.ss
│ │ │ │ ├── Larceny.sln
│ │ │ │ ├── Msi/
│ │ │ │ │ └── WindowsInstall.vdproj
│ │ │ │ └── Preprocess/
│ │ │ │ └── Preprocess.vcproj
│ │ │ ├── VSNET/
│ │ │ │ └── Larceny/
│ │ │ │ ├── Bundle/
│ │ │ │ │ ├── Bundle.vcproj
│ │ │ │ │ ├── bundleplt.ss
│ │ │ │ │ ├── bundletar.ss
│ │ │ │ │ └── bundlezip.ss
│ │ │ │ ├── Configure/
│ │ │ │ │ ├── Configure.ss
│ │ │ │ │ └── Configure.vcproj
│ │ │ │ ├── Heap/
│ │ │ │ │ ├── Heap.vcproj
│ │ │ │ │ └── Rebuild.ss
│ │ │ │ ├── Larceny.sln
│ │ │ │ ├── Msi/
│ │ │ │ │ └── WindowsInstall.vdproj
│ │ │ │ └── Preprocess/
│ │ │ │ └── Preprocess.vcproj
│ │ │ ├── files.ss
│ │ │ ├── mzscheme-runner.ss
│ │ │ └── testfile.txt
│ │ ├── Misc/
│ │ │ ├── compfasl.sch
│ │ │ ├── convert-text.sch
│ │ │ ├── fold-includes.sch
│ │ │ ├── heap-info.sch
│ │ │ ├── sim.sch
│ │ │ ├── stcov-qq.sch
│ │ │ ├── stcov.sch
│ │ │ ├── tcov.sch
│ │ │ ├── timeslice.sch
│ │ │ └── undefined.sch
│ │ ├── Scripts/
│ │ │ ├── CommonLarceny.mm
│ │ │ ├── CommonLarceny.ver
│ │ │ ├── Larceny.mmh
│ │ │ ├── larceny.bat
│ │ │ ├── larceny.sh
│ │ │ └── scheme-script
│ │ ├── arm-el-hardfp-larceny-heap.sch
│ │ ├── arm-el-hardfp-twobit-heap.sch
│ │ ├── build-entry-defns.sch
│ │ ├── cleanup.sch
│ │ ├── compile-standard-libraries.sch
│ │ ├── compile-tools.sch
│ │ ├── config.sch
│ │ ├── csharp-config.sch
│ │ ├── dotnet-larceny-lcg-application.sch
│ │ ├── dotnet-larceny-lcg.sch
│ │ ├── dotnet-larceny.sch
│ │ ├── dotnet-seal-twobit.sch
│ │ ├── dotnet-twobit-lcg.sch
│ │ ├── dotnet.sch
│ │ ├── expander.sch
│ │ ├── gasmask.sh
│ │ ├── heap-shake.sch
│ │ ├── iasn-larceny-heap.sch
│ │ ├── iasn-twobit-heap.sch
│ │ ├── macros.gdb
│ │ ├── make.sch
│ │ ├── nbuild-defns.sch
│ │ ├── nbuild-files.sch
│ │ ├── nbuild-param.sch
│ │ ├── nbuild.sch
│ │ ├── petit-larceny-heap.sch
│ │ ├── petit-r5rs-heap.sch
│ │ ├── petit-twobit-heap.sch
│ │ ├── petit-unix-defns-globals.sch
│ │ ├── petit-unix-defns.sch
│ │ ├── r5rs-heap.sch
│ │ ├── readme.txt
│ │ ├── seal-twobit.sch
│ │ ├── sparc-larceny-heap.sch
│ │ ├── sparc-twobit-heap.sch
│ │ ├── sysdep-unix.sch
│ │ └── sysdep-win32.sch
│ ├── Compat/
│ │ ├── Chez/
│ │ │ ├── Makefile
│ │ │ ├── bitpattern.c
│ │ │ ├── bytevec.ss
│ │ │ ├── compat.sch
│ │ │ ├── logops.ss
│ │ │ ├── misc2bytevector.ss
│ │ │ ├── mtime.c
│ │ │ └── values.ss
│ │ ├── Gambit-C/
│ │ │ ├── Makefile
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── format.sch
│ │ │ └── gsi-ffs.scm
│ │ ├── Larceny/
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── tobytevector-be.sch
│ │ │ └── tobytevector-el.sch
│ │ ├── MIT/
│ │ │ └── mit-patches.sch
│ │ ├── MzScheme/
│ │ │ ├── bytevec-el.ss
│ │ │ ├── bytevec.ss
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── logops.ss
│ │ │ ├── misc2bytevector-el.ss
│ │ │ └── misc2bytevector.ss
│ │ ├── PLT-R5RS/
│ │ │ ├── README
│ │ │ ├── bytevec-el.ss
│ │ │ ├── bytevec.ss
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── logops.ss
│ │ │ ├── misc2bytevector-el.ss
│ │ │ └── misc2bytevector.ss
│ │ ├── Petite/
│ │ │ ├── Makefile
│ │ │ ├── bitpattern.c
│ │ │ ├── bytevec-el.ss
│ │ │ ├── bytevec.ss
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── logops.ss
│ │ │ ├── misc2bytevector-el.ss
│ │ │ ├── misc2bytevector.ss
│ │ │ ├── mtime.c
│ │ │ └── values.ss
│ │ └── README
│ ├── Compiler/
│ │ ├── common.imp.sch
│ │ ├── copy.sch
│ │ ├── driver-common.sch
│ │ ├── driver-larceny.sch
│ │ ├── driver-twobit.sch
│ │ ├── expand.sch
│ │ ├── fence.imp.sch
│ │ ├── fence.imp2.sch
│ │ ├── hash.sch
│ │ ├── hashtable.sch
│ │ ├── hashtree.sch
│ │ ├── help-topics.txt
│ │ ├── help.sch
│ │ ├── iasn.imp.sch
│ │ ├── iasn.imp2.sch
│ │ ├── lowlevel.sch
│ │ ├── pass0.sch
│ │ ├── pass1.aux.sch
│ │ ├── pass1.sch
│ │ ├── pass2.aux.sch
│ │ ├── pass2if.sch
│ │ ├── pass2p1.sch
│ │ ├── pass2p2.sch
│ │ ├── pass3.sch
│ │ ├── pass3anormal.sch
│ │ ├── pass3anormal2.sch
│ │ ├── pass3callgraph.sch
│ │ ├── pass3commoning.aux.sch
│ │ ├── pass3commoning.sch
│ │ ├── pass3folding.sch
│ │ ├── pass3inlining.sch
│ │ ├── pass3rep.aux.sch
│ │ ├── pass3rep.sch
│ │ ├── pass4.aux.sch
│ │ ├── pass4let.sch
│ │ ├── pass4p1.sch
│ │ ├── pass4p2.sch
│ │ ├── pass4p3.sch
│ │ ├── pass4special.sch
│ │ ├── prefs.sch
│ │ ├── printlap.sch
│ │ ├── sets.sch
│ │ ├── sparc.imp.sch
│ │ ├── sparc.imp2.sch
│ │ ├── standard-C.imp.sch
│ │ ├── standard-C.imp2.sch
│ │ ├── switches.sch
│ │ ├── syntaxenv.sch
│ │ ├── syntaxrules.sch
│ │ ├── syntaxrules2.sch
│ │ └── usual.sch
│ ├── Lib/
│ │ ├── Arch/
│ │ │ ├── Fence/
│ │ │ │ ├── primops.sch
│ │ │ │ └── toplevel-target.sch
│ │ │ ├── IAssassin/
│ │ │ │ ├── loadable.sch
│ │ │ │ ├── primops.sch
│ │ │ │ └── toplevel-target.sch
│ │ │ ├── IL/
│ │ │ │ ├── loadable.sch
│ │ │ │ ├── primops.sch
│ │ │ │ └── toplevel-target.sch
│ │ │ ├── Sparc/
│ │ │ │ ├── primops.sch
│ │ │ │ └── toplevel-target.sch
│ │ │ └── Standard-C/
│ │ │ ├── loadable.sch
│ │ │ ├── primops.sch
│ │ │ └── toplevel-target.sch
│ │ ├── Common/
│ │ │ ├── SimpleMacros/
│ │ │ │ ├── README.txt
│ │ │ │ ├── simple-macros-tests.scm
│ │ │ │ ├── simple-macros.scm
│ │ │ │ ├── simple-module-examples.scm
│ │ │ │ └── simple-syntax-case.scm
│ │ │ ├── arith.mal
│ │ │ ├── belle.sch
│ │ │ ├── bignums-be.sch
│ │ │ ├── bignums-el.sch
│ │ │ ├── bignums.sch
│ │ │ ├── bitwise.sch
│ │ │ ├── bytevector.sch
│ │ │ ├── bytevectorio.sch
│ │ │ ├── circular.sch
│ │ │ ├── command-line.sch
│ │ │ ├── condition.sch
│ │ │ ├── conio.sch
│ │ │ ├── contag.sch
│ │ │ ├── control.sch
│ │ │ ├── customio.sch
│ │ │ ├── dump.sch
│ │ │ ├── ehandler.sch
│ │ │ ├── enum.sch
│ │ │ ├── env.sch
│ │ │ ├── errmsg.sch
│ │ │ ├── error.sch
│ │ │ ├── error0.sch
│ │ │ ├── eval.sch
│ │ │ ├── exit.sch
│ │ │ ├── fileio.sch
│ │ │ ├── fl.sch
│ │ │ ├── flonums-be.sch
│ │ │ ├── flonums-el.sch
│ │ │ ├── flonums.sch
│ │ │ ├── format.sch
│ │ │ ├── fx.sch
│ │ │ ├── gcctl.sch
│ │ │ ├── go.sch
│ │ │ ├── hash.sch
│ │ │ ├── hashtable.sch
│ │ │ ├── ioboot.sch
│ │ │ ├── iosys.sch
│ │ │ ├── javadot-symbol.sch
│ │ │ ├── javadot-syntax.sch
│ │ │ ├── larceny.pg
│ │ │ ├── larcenyTokens.sch
│ │ │ ├── list.sch
│ │ │ ├── load.sch
│ │ │ ├── makeLexer.sch
│ │ │ ├── malcode.mal
│ │ │ ├── mcode.sch
│ │ │ ├── memstats.sch
│ │ │ ├── num2str.sch
│ │ │ ├── number.sch
│ │ │ ├── oblist.sch
│ │ │ ├── portio.sch
│ │ │ ├── preds.sch
│ │ │ ├── print-shared.sch
│ │ │ ├── print.sch
│ │ │ ├── procinfo.sch
│ │ │ ├── profile.sch
│ │ │ ├── raise.sch
│ │ │ ├── ratnums.sch
│ │ │ ├── reader-dfa.sch
│ │ │ ├── reader.sch
│ │ │ ├── record.sch
│ │ │ ├── rectnums.sch
│ │ │ ├── require.sch
│ │ │ ├── secret.sch
│ │ │ ├── sort.sch
│ │ │ ├── stdio.sch
│ │ │ ├── str2num.sch
│ │ │ ├── string.sch
│ │ │ ├── stringio.sch
│ │ │ ├── struct.sch
│ │ │ ├── sys-macos.sch
│ │ │ ├── sys-unix.sch
│ │ │ ├── sys-win32.sch
│ │ │ ├── syscall-id.sch
│ │ │ ├── syshooks.sch
│ │ │ ├── sysparam.sch
│ │ │ ├── system-interface.sch
│ │ │ ├── text.sch
│ │ │ ├── text2.sch
│ │ │ ├── time.sch
│ │ │ ├── timer.sch
│ │ │ ├── toplevel.sch
│ │ │ ├── transio.sch
│ │ │ ├── typetags.sch
│ │ │ ├── unicode0.sch
│ │ │ ├── unicode1.sch
│ │ │ ├── unicode2.sch
│ │ │ ├── unicode3.sch
│ │ │ ├── unicode4.sch
│ │ │ ├── utf16.sch
│ │ │ └── vector.sch
│ │ ├── Interpreter/
│ │ │ ├── interp-prim.sch
│ │ │ ├── interp.sch
│ │ │ ├── macro-expand.sch
│ │ │ └── switches.sch
│ │ ├── Repl/
│ │ │ ├── main.sch
│ │ │ └── reploop.sch
│ │ ├── Sassy/
│ │ │ ├── ACKNOWLEDGEMENTS
│ │ │ ├── COPYING
│ │ │ ├── NEWS
│ │ │ ├── README
│ │ │ ├── TODO
│ │ │ ├── TODO-ideas
│ │ │ ├── api.scm
│ │ │ ├── changes/
│ │ │ │ ├── ChangeLog-0.2
│ │ │ │ ├── ChangeLog-0.2.1
│ │ │ │ ├── ChangeLog-old
│ │ │ │ └── README
│ │ │ ├── demo/
│ │ │ │ └── boot.sassy
│ │ │ ├── doc/
│ │ │ │ ├── sassy.hdir
│ │ │ │ ├── sassy.tex
│ │ │ │ └── tex2page.tex
│ │ │ ├── elf.scm
│ │ │ ├── extras.scm
│ │ │ ├── flat-bin.scm
│ │ │ ├── inits/
│ │ │ │ ├── csi-2.2-libffi.scm
│ │ │ │ ├── gosh-0.8.5.scm
│ │ │ │ ├── guile-1.7.91.scm
│ │ │ │ ├── larceny-0.97.scm
│ │ │ │ ├── mzscheme-299.400.scm
│ │ │ │ ├── mzscheme-301.scm
│ │ │ │ ├── mzscheme-4.1.5.scm
│ │ │ │ ├── petit-0.92.scm
│ │ │ │ ├── scheme48-1.3.scm
│ │ │ │ └── scm-5e1.scm
│ │ │ ├── intern.scm
│ │ │ ├── macros.scm
│ │ │ ├── main.scm
│ │ │ ├── numbers.scm
│ │ │ ├── opcodes.scm
│ │ │ ├── operands.scm
│ │ │ ├── other/
│ │ │ │ ├── srfi-56-pieces.scm
│ │ │ │ └── srfi-60-pieces.scm
│ │ │ ├── parse.scm
│ │ │ ├── push-stacks.scm
│ │ │ ├── sassy-48.scm
│ │ │ ├── sassy-chicken.scm
│ │ │ ├── sassy.el
│ │ │ ├── sassy.html
│ │ │ ├── sassy.scm
│ │ │ ├── sassy.setup
│ │ │ ├── tests/
│ │ │ │ ├── aa
│ │ │ │ ├── aa.asm
│ │ │ │ ├── aa.scm
│ │ │ │ ├── all
│ │ │ │ ├── all.asm
│ │ │ │ ├── alu
│ │ │ │ ├── alu.asm
│ │ │ │ ├── alu.scm
│ │ │ │ ├── alu16
│ │ │ │ ├── alu16.asm
│ │ │ │ ├── brt
│ │ │ │ ├── brt.scm
│ │ │ │ ├── bt
│ │ │ │ ├── bt.asm
│ │ │ │ ├── bt.scm
│ │ │ │ ├── bt16
│ │ │ │ ├── bt16.asm
│ │ │ │ ├── bye
│ │ │ │ ├── bye.scm
│ │ │ │ ├── cell
│ │ │ │ ├── cell.scm
│ │ │ │ ├── cmovcc
│ │ │ │ ├── cmovcc.asm
│ │ │ │ ├── cmovcc.scm
│ │ │ │ ├── cmpx
│ │ │ │ ├── cmpx.asm
│ │ │ │ ├── cmpx.scm
│ │ │ │ ├── cmpx16
│ │ │ │ ├── cmpx16.asm
│ │ │ │ ├── count
│ │ │ │ ├── count.scm
│ │ │ │ ├── decinc
│ │ │ │ ├── decinc.asm
│ │ │ │ ├── decinc.scm
│ │ │ │ ├── decinc16
│ │ │ │ ├── decinc16.asm
│ │ │ │ ├── doub-shift
│ │ │ │ ├── doub-shift.asm
│ │ │ │ ├── doub-shift.scm
│ │ │ │ ├── doub-shift16
│ │ │ │ ├── doub-shift16.asm
│ │ │ │ ├── eip.scm
│ │ │ │ ├── fac5
│ │ │ │ ├── fac5.scm
│ │ │ │ ├── fp0
│ │ │ │ ├── fp0.asm
│ │ │ │ ├── fp0.scm
│ │ │ │ ├── fp1
│ │ │ │ ├── fp1.asm
│ │ │ │ ├── fp1.scm
│ │ │ │ ├── fp2
│ │ │ │ ├── fp2.asm
│ │ │ │ ├── fp2.scm
│ │ │ │ ├── fp3
│ │ │ │ ├── fp3.asm
│ │ │ │ ├── fp3.scm
│ │ │ │ ├── generate-nasm.scm
│ │ │ │ ├── generate-prim.scm
│ │ │ │ ├── hello
│ │ │ │ ├── hello.scm
│ │ │ │ ├── include.scm
│ │ │ │ ├── jcc
│ │ │ │ ├── jcc.asm
│ │ │ │ ├── jcc.scm
│ │ │ │ ├── jcc16
│ │ │ │ ├── jcc16.asm
│ │ │ │ ├── jumps
│ │ │ │ ├── jumps.asm
│ │ │ │ ├── jumps.scm
│ │ │ │ ├── jumps16
│ │ │ │ ├── jumps16.asm
│ │ │ │ ├── libgoodbye.scm
│ │ │ │ ├── libhello.scm
│ │ │ │ ├── load
│ │ │ │ ├── load.asm
│ │ │ │ ├── load.scm
│ │ │ │ ├── load16
│ │ │ │ ├── load16.asm
│ │ │ │ ├── local-data-static
│ │ │ │ ├── localdata1.scm
│ │ │ │ ├── localdata2.scm
│ │ │ │ ├── localdata3.scm
│ │ │ │ ├── localdata4
│ │ │ │ ├── localdata4.scm
│ │ │ │ ├── mem-ref
│ │ │ │ ├── mem-ref.asm
│ │ │ │ ├── mem-ref.scm
│ │ │ │ ├── mem-ref16
│ │ │ │ ├── mem-ref16.asm
│ │ │ │ ├── misc1
│ │ │ │ ├── misc1.asm
│ │ │ │ ├── misc1.scm
│ │ │ │ ├── misc116
│ │ │ │ ├── misc116.asm
│ │ │ │ ├── misc2
│ │ │ │ ├── misc2.asm
│ │ │ │ ├── misc2.scm
│ │ │ │ ├── misc216
│ │ │ │ ├── misc216.asm
│ │ │ │ ├── misc3
│ │ │ │ ├── misc3.asm
│ │ │ │ ├── misc3.scm
│ │ │ │ ├── mmx
│ │ │ │ ├── mmx.asm
│ │ │ │ ├── mmx.scm
│ │ │ │ ├── movx
│ │ │ │ ├── movx.asm
│ │ │ │ ├── movx.scm
│ │ │ │ ├── movx16
│ │ │ │ ├── movx16.asm
│ │ │ │ ├── non
│ │ │ │ ├── non.asm
│ │ │ │ ├── non.scm
│ │ │ │ ├── non16
│ │ │ │ ├── non16.asm
│ │ │ │ ├── plier
│ │ │ │ ├── plier.asm
│ │ │ │ ├── plier.scm
│ │ │ │ ├── plier16
│ │ │ │ ├── plier16.asm
│ │ │ │ ├── prefix
│ │ │ │ ├── prefix.asm
│ │ │ │ ├── prefix.scm
│ │ │ │ ├── prefix16
│ │ │ │ ├── prefix16.asm
│ │ │ │ ├── prims/
│ │ │ │ │ ├── alt1
│ │ │ │ │ ├── alt1.scm
│ │ │ │ │ ├── alt2
│ │ │ │ │ ├── alt2.scm
│ │ │ │ │ ├── alt3
│ │ │ │ │ ├── alt3.scm
│ │ │ │ │ ├── alt4
│ │ │ │ │ ├── alt4.scm
│ │ │ │ │ ├── begin1
│ │ │ │ │ ├── begin1.scm
│ │ │ │ │ ├── begin2
│ │ │ │ │ ├── begin2.scm
│ │ │ │ │ ├── begin3
│ │ │ │ │ ├── begin3.scm
│ │ │ │ │ ├── begin4
│ │ │ │ │ ├── begin4.scm
│ │ │ │ │ ├── begin5
│ │ │ │ │ ├── begin5.scm
│ │ │ │ │ ├── esc1
│ │ │ │ │ ├── esc1.scm
│ │ │ │ │ ├── esc2
│ │ │ │ │ ├── esc2.scm
│ │ │ │ │ ├── esc3
│ │ │ │ │ ├── esc3.scm
│ │ │ │ │ ├── esc4
│ │ │ │ │ ├── esc4.scm
│ │ │ │ │ ├── esc5
│ │ │ │ │ ├── esc5.scm
│ │ │ │ │ ├── esc6
│ │ │ │ │ ├── esc6.scm
│ │ │ │ │ ├── esc7
│ │ │ │ │ ├── esc7.scm
│ │ │ │ │ ├── exp-k1
│ │ │ │ │ ├── exp-k1.scm
│ │ │ │ │ ├── exp-k2
│ │ │ │ │ ├── exp-k2.scm
│ │ │ │ │ ├── exp-k3
│ │ │ │ │ ├── exp-k3.scm
│ │ │ │ │ ├── exp-k4
│ │ │ │ │ ├── exp-k4.scm
│ │ │ │ │ ├── if1
│ │ │ │ │ ├── if1.scm
│ │ │ │ │ ├── if2
│ │ │ │ │ ├── if2.scm
│ │ │ │ │ ├── if3
│ │ │ │ │ ├── if3.scm
│ │ │ │ │ ├── if4
│ │ │ │ │ ├── if4.scm
│ │ │ │ │ ├── inv1
│ │ │ │ │ ├── inv1.scm
│ │ │ │ │ ├── inv2
│ │ │ │ │ ├── inv2.scm
│ │ │ │ │ ├── inv3
│ │ │ │ │ ├── inv3.scm
│ │ │ │ │ ├── inv4
│ │ │ │ │ ├── inv4.scm
│ │ │ │ │ ├── inv5
│ │ │ │ │ ├── inv5.scm
│ │ │ │ │ ├── inv6
│ │ │ │ │ ├── inv6.scm
│ │ │ │ │ ├── iter1
│ │ │ │ │ ├── iter1.scm
│ │ │ │ │ ├── iter2
│ │ │ │ │ ├── iter2.scm
│ │ │ │ │ ├── iter3
│ │ │ │ │ ├── iter3.scm
│ │ │ │ │ ├── iter4
│ │ │ │ │ ├── iter4.scm
│ │ │ │ │ ├── iter5
│ │ │ │ │ ├── iter5.scm
│ │ │ │ │ ├── iter6
│ │ │ │ │ ├── iter6.scm
│ │ │ │ │ ├── label1
│ │ │ │ │ ├── label1.scm
│ │ │ │ │ ├── label2
│ │ │ │ │ ├── label2.scm
│ │ │ │ │ ├── label3
│ │ │ │ │ ├── label3.scm
│ │ │ │ │ ├── label4
│ │ │ │ │ ├── label4.scm
│ │ │ │ │ ├── leap-mark1
│ │ │ │ │ ├── leap-mark1.scm
│ │ │ │ │ ├── leap-mark2
│ │ │ │ │ ├── leap-mark2.scm
│ │ │ │ │ ├── leap-mark3
│ │ │ │ │ ├── leap-mark3.scm
│ │ │ │ │ ├── locals1
│ │ │ │ │ ├── locals1.scm
│ │ │ │ │ ├── locals2
│ │ │ │ │ ├── locals2.scm
│ │ │ │ │ ├── locals3
│ │ │ │ │ ├── locals3.scm
│ │ │ │ │ ├── locals4
│ │ │ │ │ ├── locals4.scm
│ │ │ │ │ ├── locals5
│ │ │ │ │ ├── locals5.scm
│ │ │ │ │ ├── locals6
│ │ │ │ │ ├── locals6.scm
│ │ │ │ │ ├── locals7
│ │ │ │ │ ├── locals7.scm
│ │ │ │ │ ├── locals8
│ │ │ │ │ ├── locals8.scm
│ │ │ │ │ ├── seq1
│ │ │ │ │ ├── seq1.scm
│ │ │ │ │ ├── seq2
│ │ │ │ │ ├── seq2.scm
│ │ │ │ │ ├── seq3
│ │ │ │ │ ├── seq3.scm
│ │ │ │ │ ├── while1
│ │ │ │ │ ├── while1.scm
│ │ │ │ │ ├── while2
│ │ │ │ │ ├── while2.scm
│ │ │ │ │ ├── while3
│ │ │ │ │ ├── while3.scm
│ │ │ │ │ ├── with-lose1
│ │ │ │ │ ├── with-lose1.scm
│ │ │ │ │ ├── with-lose2
│ │ │ │ │ ├── with-lose2.scm
│ │ │ │ │ ├── with-lose3
│ │ │ │ │ ├── with-lose3.scm
│ │ │ │ │ ├── with-win-lose1
│ │ │ │ │ ├── with-win-lose1.scm
│ │ │ │ │ ├── with-win-lose2
│ │ │ │ │ ├── with-win-lose2.scm
│ │ │ │ │ ├── with-win-lose3
│ │ │ │ │ ├── with-win-lose3.scm
│ │ │ │ │ ├── with-win-lose4
│ │ │ │ │ ├── with-win-lose4.scm
│ │ │ │ │ ├── with-win-lose5
│ │ │ │ │ ├── with-win-lose5.scm
│ │ │ │ │ ├── with-win1
│ │ │ │ │ ├── with-win1.scm
│ │ │ │ │ ├── with-win2
│ │ │ │ │ ├── with-win2.scm
│ │ │ │ │ ├── with-win3
│ │ │ │ │ ├── with-win3.scm
│ │ │ │ │ ├── with-win4
│ │ │ │ │ ├── with-win4.scm
│ │ │ │ │ ├── with-win5
│ │ │ │ │ └── with-win5.scm
│ │ │ │ ├── prims16/
│ │ │ │ │ ├── 16alt1
│ │ │ │ │ ├── 16alt1.scm
│ │ │ │ │ ├── 16alt2
│ │ │ │ │ ├── 16alt2.scm
│ │ │ │ │ ├── 16alt3
│ │ │ │ │ ├── 16alt3.scm
│ │ │ │ │ ├── 16alt4
│ │ │ │ │ ├── 16alt4.scm
│ │ │ │ │ ├── 16begin1
│ │ │ │ │ ├── 16begin1.scm
│ │ │ │ │ ├── 16begin2
│ │ │ │ │ ├── 16begin2.scm
│ │ │ │ │ ├── 16begin3
│ │ │ │ │ ├── 16begin3.scm
│ │ │ │ │ ├── 16begin4
│ │ │ │ │ ├── 16begin4.scm
│ │ │ │ │ ├── 16begin5
│ │ │ │ │ ├── 16begin5.scm
│ │ │ │ │ ├── 16esc1
│ │ │ │ │ ├── 16esc1.scm
│ │ │ │ │ ├── 16esc2
│ │ │ │ │ ├── 16esc2.scm
│ │ │ │ │ ├── 16esc3
│ │ │ │ │ ├── 16esc3.scm
│ │ │ │ │ ├── 16esc4
│ │ │ │ │ ├── 16esc4.scm
│ │ │ │ │ ├── 16esc5
│ │ │ │ │ ├── 16esc5.scm
│ │ │ │ │ ├── 16esc6
│ │ │ │ │ ├── 16esc6.scm
│ │ │ │ │ ├── 16esc7
│ │ │ │ │ ├── 16esc7.scm
│ │ │ │ │ ├── 16exp-k1
│ │ │ │ │ ├── 16exp-k1.scm
│ │ │ │ │ ├── 16exp-k2
│ │ │ │ │ ├── 16exp-k2.scm
│ │ │ │ │ ├── 16exp-k3
│ │ │ │ │ ├── 16exp-k3.scm
│ │ │ │ │ ├── 16exp-k4
│ │ │ │ │ ├── 16exp-k4.scm
│ │ │ │ │ ├── 16if1
│ │ │ │ │ ├── 16if1.scm
│ │ │ │ │ ├── 16if2
│ │ │ │ │ ├── 16if2.scm
│ │ │ │ │ ├── 16if3
│ │ │ │ │ ├── 16if3.scm
│ │ │ │ │ ├── 16if4
│ │ │ │ │ ├── 16if4.scm
│ │ │ │ │ ├── 16inv1
│ │ │ │ │ ├── 16inv1.scm
│ │ │ │ │ ├── 16inv2
│ │ │ │ │ ├── 16inv2.scm
│ │ │ │ │ ├── 16inv3
│ │ │ │ │ ├── 16inv3.scm
│ │ │ │ │ ├── 16inv4
│ │ │ │ │ ├── 16inv4.scm
│ │ │ │ │ ├── 16inv5
│ │ │ │ │ ├── 16inv5.scm
│ │ │ │ │ ├── 16inv6
│ │ │ │ │ ├── 16inv6.scm
│ │ │ │ │ ├── 16iter1
│ │ │ │ │ ├── 16iter1.scm
│ │ │ │ │ ├── 16iter2
│ │ │ │ │ ├── 16iter2.scm
│ │ │ │ │ ├── 16iter3
│ │ │ │ │ ├── 16iter3.scm
│ │ │ │ │ ├── 16iter4
│ │ │ │ │ ├── 16iter4.scm
│ │ │ │ │ ├── 16iter5
│ │ │ │ │ ├── 16iter5.scm
│ │ │ │ │ ├── 16iter6
│ │ │ │ │ ├── 16iter6.scm
│ │ │ │ │ ├── 16label1
│ │ │ │ │ ├── 16label1.scm
│ │ │ │ │ ├── 16label2
│ │ │ │ │ ├── 16label2.scm
│ │ │ │ │ ├── 16label3
│ │ │ │ │ ├── 16label3.scm
│ │ │ │ │ ├── 16label4
│ │ │ │ │ ├── 16label4.scm
│ │ │ │ │ ├── 16leap-mark1
│ │ │ │ │ ├── 16leap-mark1.scm
│ │ │ │ │ ├── 16leap-mark2
│ │ │ │ │ ├── 16leap-mark2.scm
│ │ │ │ │ ├── 16leap-mark3
│ │ │ │ │ ├── 16leap-mark3.scm
│ │ │ │ │ ├── 16locals1
│ │ │ │ │ ├── 16locals1.scm
│ │ │ │ │ ├── 16locals2
│ │ │ │ │ ├── 16locals2.scm
│ │ │ │ │ ├── 16locals3
│ │ │ │ │ ├── 16locals3.scm
│ │ │ │ │ ├── 16locals4
│ │ │ │ │ ├── 16locals4.scm
│ │ │ │ │ ├── 16locals5
│ │ │ │ │ ├── 16locals5.scm
│ │ │ │ │ ├── 16locals6
│ │ │ │ │ ├── 16locals6.scm
│ │ │ │ │ ├── 16locals7
│ │ │ │ │ ├── 16locals7.scm
│ │ │ │ │ ├── 16locals8
│ │ │ │ │ ├── 16locals8.scm
│ │ │ │ │ ├── 16seq1
│ │ │ │ │ ├── 16seq1.scm
│ │ │ │ │ ├── 16seq2
│ │ │ │ │ ├── 16seq2.scm
│ │ │ │ │ ├── 16seq3
│ │ │ │ │ ├── 16seq3.scm
│ │ │ │ │ ├── 16while1
│ │ │ │ │ ├── 16while1.scm
│ │ │ │ │ ├── 16while2
│ │ │ │ │ ├── 16while2.scm
│ │ │ │ │ ├── 16while3
│ │ │ │ │ ├── 16while3.scm
│ │ │ │ │ ├── 16with-lose1
│ │ │ │ │ ├── 16with-lose1.scm
│ │ │ │ │ ├── 16with-lose2
│ │ │ │ │ ├── 16with-lose2.scm
│ │ │ │ │ ├── 16with-lose3
│ │ │ │ │ ├── 16with-lose3.scm
│ │ │ │ │ ├── 16with-win-lose1
│ │ │ │ │ ├── 16with-win-lose1.scm
│ │ │ │ │ ├── 16with-win-lose2
│ │ │ │ │ ├── 16with-win-lose2.scm
│ │ │ │ │ ├── 16with-win-lose3
│ │ │ │ │ ├── 16with-win-lose3.scm
│ │ │ │ │ ├── 16with-win-lose4
│ │ │ │ │ ├── 16with-win-lose4.scm
│ │ │ │ │ ├── 16with-win-lose5
│ │ │ │ │ ├── 16with-win-lose5.scm
│ │ │ │ │ ├── 16with-win1
│ │ │ │ │ ├── 16with-win1.scm
│ │ │ │ │ ├── 16with-win2
│ │ │ │ │ ├── 16with-win2.scm
│ │ │ │ │ ├── 16with-win3
│ │ │ │ │ ├── 16with-win3.scm
│ │ │ │ │ ├── 16with-win4
│ │ │ │ │ ├── 16with-win4.scm
│ │ │ │ │ ├── 16with-win5
│ │ │ │ │ └── 16with-win5.scm
│ │ │ │ ├── quick-elf.scm
│ │ │ │ ├── r-rm
│ │ │ │ ├── r-rm.asm
│ │ │ │ ├── r-rm.scm
│ │ │ │ ├── r-rm16
│ │ │ │ ├── r-rm16.asm
│ │ │ │ ├── regenerate.scm
│ │ │ │ ├── ret
│ │ │ │ ├── ret.asm
│ │ │ │ ├── ret.scm
│ │ │ │ ├── ret16
│ │ │ │ ├── ret16.asm
│ │ │ │ ├── rm
│ │ │ │ ├── rm.asm
│ │ │ │ ├── rm.scm
│ │ │ │ ├── rm16
│ │ │ │ ├── rm16.asm
│ │ │ │ ├── rm2
│ │ │ │ ├── rm2.asm
│ │ │ │ ├── rm2.scm
│ │ │ │ ├── rm216
│ │ │ │ ├── rm216.asm
│ │ │ │ ├── run-tests.scm
│ │ │ │ ├── sect.scm
│ │ │ │ ├── seg
│ │ │ │ ├── seg.asm
│ │ │ │ ├── seg.scm
│ │ │ │ ├── seg16
│ │ │ │ ├── seg16.asm
│ │ │ │ ├── setcc
│ │ │ │ ├── setcc.asm
│ │ │ │ ├── setcc.scm
│ │ │ │ ├── setcc16
│ │ │ │ ├── setcc16.asm
│ │ │ │ ├── shift
│ │ │ │ ├── shift.asm
│ │ │ │ ├── shift.scm
│ │ │ │ ├── shift16
│ │ │ │ ├── shift16.asm
│ │ │ │ ├── sse1
│ │ │ │ ├── sse1.asm
│ │ │ │ ├── sse1.scm
│ │ │ │ ├── sse2
│ │ │ │ ├── sse2.asm
│ │ │ │ ├── sse2.scm
│ │ │ │ ├── sse3
│ │ │ │ ├── sse3.asm
│ │ │ │ ├── sse3.scm
│ │ │ │ ├── sysexit
│ │ │ │ ├── sysexit.scm
│ │ │ │ └── sysexit2.scm
│ │ │ ├── text-block.scm
│ │ │ ├── text.scm
│ │ │ └── units.scm
│ │ └── makefile.sch
│ └── Rts/
│ ├── DotNet/
│ │ ├── AssemblyInfo.cs
│ │ ├── Call.cs
│ │ ├── ClassicOps.cs
│ │ ├── ClassicOpsSpecial.cs
│ │ ├── CodeAddress.cs
│ │ ├── ContinuationISH.cs
│ │ ├── DynLoad.cs
│ │ ├── Exn.cs
│ │ ├── FFI.cs
│ │ ├── Factory.cs
│ │ ├── Instructions.cs
│ │ ├── Load.cs
│ │ ├── Macros.h
│ │ ├── Makefile
│ │ ├── MapOps.cs
│ │ ├── MapOpsSpecial.cs
│ │ ├── Number.cs
│ │ ├── Ops.cs
│ │ ├── Ops.h
│ │ ├── OpsSpecial.cs
│ │ ├── Ops_Procedure.inc
│ │ ├── Ops_SByteVL.inc
│ │ ├── Ops_SChar.inc
│ │ ├── Ops_SFixnum.inc
│ │ ├── Ops_SImmediate.inc
│ │ ├── Ops_SObject.inc
│ │ ├── Ops_SPair.inc
│ │ ├── Ops_STagged.inc
│ │ ├── Ops_SVL.inc
│ │ ├── Perf.cs
│ │ ├── README
│ │ ├── Reg.cs
│ │ ├── Scheme.csproj
│ │ ├── Scheme.csproj8
│ │ ├── SchemeObject.cs.cpp
│ │ ├── Syscall-enum.cs
│ │ └── Syscall.cs
│ ├── Fence/
│ │ ├── arm-millicode.sx
│ │ ├── fence-config.c
│ │ ├── fence-driver.c
│ │ ├── fence-millicode.c
│ │ └── fence-syscall2.c
│ ├── IAssassin/
│ │ ├── config.c
│ │ ├── i386-driver.c
│ │ ├── millicode.c
│ │ └── syscall2.c
│ ├── Nasm/
│ │ ├── config.c
│ │ └── i386-driver.c
│ ├── Shared/
│ │ ├── arithmetic.mac
│ │ ├── i386-millicode.asm
│ │ └── multiply.c
│ ├── Sparc/
│ │ ├── asmmacro.h
│ │ ├── barrier.s
│ │ ├── bdw-cglue.c
│ │ ├── bdw-generic.s
│ │ ├── bdw-memory.s
│ │ ├── cache.c
│ │ ├── cache0.s
│ │ ├── cglue.c
│ │ ├── config.c
│ │ ├── generic.s
│ │ ├── glue.s
│ │ ├── mcode.s
│ │ ├── memory.s
│ │ ├── signals.c
│ │ └── syscall2.c
│ ├── Standard-C/
│ │ ├── config.c
│ │ ├── millicode.c
│ │ └── syscall2.c
│ ├── Sys/
│ │ ├── alloc.c
│ │ ├── argv.c
│ │ ├── assert.h
│ │ ├── barrier.c
│ │ ├── barrier.h
│ │ ├── bdw-collector.c
│ │ ├── bdw-ffi.c
│ │ ├── bdw-gc.c
│ │ ├── bdw-heapio.c
│ │ ├── bdw-larceny.c
│ │ ├── bdw-stats.c
│ │ ├── bdw.h
│ │ ├── callback.c
│ │ ├── cheney-check.c
│ │ ├── cheney-np.c
│ │ ├── cheney-split.c
│ │ ├── cheney.c
│ │ ├── cheney.h
│ │ ├── extbmp.c
│ │ ├── extbmp_t.h
│ │ ├── ffi.c
│ │ ├── gc.c
│ │ ├── gc.h
│ │ ├── gc_mmu_log.c
│ │ ├── gc_mmu_log.h
│ │ ├── gc_t.c
│ │ ├── gc_t.h
│ │ ├── gcdebug.c
│ │ ├── gclib.h
│ │ ├── gset_t.h
│ │ ├── heapio.c
│ │ ├── heapio.h
│ │ ├── larceny.c
│ │ ├── larceny.h
│ │ ├── ldebug.c
│ │ ├── locset.c
│ │ ├── locset_t.h
│ │ ├── los.c
│ │ ├── los_t.h
│ │ ├── malloc.c
│ │ ├── memmgr.c
│ │ ├── memmgr.h
│ │ ├── memmgr_flt.c
│ │ ├── memmgr_flt.h
│ │ ├── memmgr_internal.h
│ │ ├── memmgr_vfy.c
│ │ ├── memmgr_vfy.h
│ │ ├── msgc-core.c
│ │ ├── msgc-core.h
│ │ ├── np-sc-heap.c
│ │ ├── nursery.c
│ │ ├── old-heap.c
│ │ ├── old_heap_t.c
│ │ ├── old_heap_t.h
│ │ ├── osdep-generic.c
│ │ ├── osdep-macos.c
│ │ ├── osdep-unix.c
│ │ ├── osdep-win32.c
│ │ ├── osdep.h
│ │ ├── primitive.c
│ │ ├── region_group.c
│ │ ├── region_group_t.h
│ │ ├── remset-np.c
│ │ ├── remset.c
│ │ ├── remset_np_t.h
│ │ ├── remset_t.h
│ │ ├── sc-heap.c
│ │ ├── semispace.c
│ │ ├── semispace_t.h
│ │ ├── seqbuf.c
│ │ ├── seqbuf_t.h
│ │ ├── signals.c
│ │ ├── signals.h
│ │ ├── smircy.c
│ │ ├── smircy.h
│ │ ├── smircy_checking.c
│ │ ├── smircy_checking.h
│ │ ├── smircy_internal.h
│ │ ├── sro.c
│ │ ├── stack.c
│ │ ├── stack.h
│ │ ├── static-heap.c
│ │ ├── static_heap_t.h
│ │ ├── stats.c
│ │ ├── stats.h
│ │ ├── summ_matrix.c
│ │ ├── summ_matrix_t.h
│ │ ├── summary.c
│ │ ├── summary_t.h
│ │ ├── syscall.c
│ │ ├── unix.c
│ │ ├── uremset_array.c
│ │ ├── uremset_array_t.h
│ │ ├── uremset_debug.c
│ │ ├── uremset_debug_t.h
│ │ ├── uremset_extbmp.c
│ │ ├── uremset_extbmp_t.h
│ │ ├── uremset_t.c
│ │ ├── uremset_t.h
│ │ ├── util.c
│ │ ├── version.c
│ │ ├── young_heap_t.c
│ │ └── young_heap_t.h
│ ├── Util/
│ │ ├── ffi-dummy.c
│ │ └── hsplit.c
│ ├── except.cfg
│ ├── features.sch
│ ├── fence-arm-regs.cfg
│ ├── fence-arm-regs0.cfg
│ ├── globals-fence.cfg
│ ├── globals-nasm.cfg
│ ├── globals.cfg
│ ├── iasn-regs.cfg
│ ├── layouts.cfg
│ ├── make-templates.sch
│ ├── memstats.cfg
│ ├── mprocs.cfg
│ └── sparc-regs.cfg
├── startup.sch
├── test/
│ ├── Benchmarking/
│ │ ├── CrossPlatform/
│ │ │ ├── README
│ │ │ ├── analyse-results.scm
│ │ │ ├── bench
│ │ │ ├── evaluate
│ │ │ ├── generate-html-from-all-results.scm
│ │ │ ├── num-iters/
│ │ │ │ ├── num-iters-1.scm
│ │ │ │ ├── num-iters-int.scm
│ │ │ │ ├── num-iters.scm
│ │ │ │ └── one-iter.scm
│ │ │ ├── optimize-gcc-options.scm
│ │ │ ├── prefix/
│ │ │ │ ├── prefix-bigloo-int.scm
│ │ │ │ ├── prefix-bigloo.scm
│ │ │ │ ├── prefix-chez.scm
│ │ │ │ ├── prefix-chicken.scm
│ │ │ │ ├── prefix-gambit-int.scm
│ │ │ │ ├── prefix-gambit-sp.scm
│ │ │ │ ├── prefix-gambit.scm
│ │ │ │ ├── prefix-henchman.scm
│ │ │ │ ├── prefix-ikarus.scm
│ │ │ │ ├── prefix-kawa.scm
│ │ │ │ ├── prefix-larceny.scm
│ │ │ │ ├── prefix-mit-int.scm
│ │ │ │ ├── prefix-mit.scm
│ │ │ │ ├── prefix-mzscheme.scm
│ │ │ │ ├── prefix-petit.scm
│ │ │ │ ├── prefix-petite-chez.scm
│ │ │ │ └── prefix-scheme48.scm
│ │ │ ├── readme.original
│ │ │ ├── src/
│ │ │ │ ├── ack.awk
│ │ │ │ ├── ack.c
│ │ │ │ ├── ack.scm
│ │ │ │ ├── array1.awk
│ │ │ │ ├── array1.c
│ │ │ │ ├── array1.scm
│ │ │ │ ├── bib
│ │ │ │ ├── boyer.scm
│ │ │ │ ├── browse.scm
│ │ │ │ ├── cat.awk
│ │ │ │ ├── cat.c
│ │ │ │ ├── cat.scm
│ │ │ │ ├── compiler.scm
│ │ │ │ ├── conform.scm
│ │ │ │ ├── cpstak.scm
│ │ │ │ ├── cpstak.sml
│ │ │ │ ├── crash.scm
│ │ │ │ ├── ctak.scm
│ │ │ │ ├── ctak.sml
│ │ │ │ ├── dderiv.scm
│ │ │ │ ├── deriv.scm
│ │ │ │ ├── destruc.scm
│ │ │ │ ├── diviter.c
│ │ │ │ ├── diviter.java
│ │ │ │ ├── diviter.scm
│ │ │ │ ├── diviter.sml
│ │ │ │ ├── divrec.c
│ │ │ │ ├── divrec.java
│ │ │ │ ├── divrec.scm
│ │ │ │ ├── divrec.sml
│ │ │ │ ├── dynamic.scm
│ │ │ │ ├── earley.scm
│ │ │ │ ├── fail.scm
│ │ │ │ ├── fft.c
│ │ │ │ ├── fft.scm
│ │ │ │ ├── fib.c
│ │ │ │ ├── fib.java
│ │ │ │ ├── fib.scm
│ │ │ │ ├── fib.sml
│ │ │ │ ├── fibc.scm
│ │ │ │ ├── fibfp.c
│ │ │ │ ├── fibfp.java
│ │ │ │ ├── fibfp.scm
│ │ │ │ ├── fibfp.sml
│ │ │ │ ├── fpsum.scm
│ │ │ │ ├── gcbench.c
│ │ │ │ ├── gcbench.java
│ │ │ │ ├── gcbench.scm
│ │ │ │ ├── gcbench.sml
│ │ │ │ ├── gcold.scm
│ │ │ │ ├── graphs.scm
│ │ │ │ ├── lattice.scm
│ │ │ │ ├── matrix.scm
│ │ │ │ ├── maze.scm
│ │ │ │ ├── mazefun.scm
│ │ │ │ ├── mbrot.c
│ │ │ │ ├── mbrot.scm
│ │ │ │ ├── nbody.scm
│ │ │ │ ├── nboyer.sch
│ │ │ │ ├── nboyer.scm
│ │ │ │ ├── nqueens.scm
│ │ │ │ ├── ntakl.c
│ │ │ │ ├── ntakl.java
│ │ │ │ ├── ntakl.scm
│ │ │ │ ├── ntakl.sml
│ │ │ │ ├── nucleic.c
│ │ │ │ ├── nucleic.scm
│ │ │ │ ├── num-iters-int.scm
│ │ │ │ ├── num-iters.java
│ │ │ │ ├── num-iters.scm
│ │ │ │ ├── num-iters.sml
│ │ │ │ ├── one-iter.scm
│ │ │ │ ├── paraffins.scm
│ │ │ │ ├── parsing.scm
│ │ │ │ ├── perm9.c
│ │ │ │ ├── perm9.java
│ │ │ │ ├── perm9.scm
│ │ │ │ ├── perm9.sml
│ │ │ │ ├── peval.scm
│ │ │ │ ├── pi.scm
│ │ │ │ ├── pnpoly.c
│ │ │ │ ├── pnpoly.scm
│ │ │ │ ├── primes.scm
│ │ │ │ ├── puzzle.c
│ │ │ │ ├── puzzle.scm
│ │ │ │ ├── puzzle.sml
│ │ │ │ ├── quicksort.scm
│ │ │ │ ├── ray.scm
│ │ │ │ ├── rn100
│ │ │ │ ├── sboyer.scm
│ │ │ │ ├── scheme.scm
│ │ │ │ ├── simplex.scm
│ │ │ │ ├── slatex.scm
│ │ │ │ ├── slatex.sty
│ │ │ │ ├── smlboyer.scm
│ │ │ │ ├── smlboyer.sml
│ │ │ │ ├── string.awk
│ │ │ │ ├── string.c
│ │ │ │ ├── string.scm
│ │ │ │ ├── succeed.scm
│ │ │ │ ├── sum.c
│ │ │ │ ├── sum.java
│ │ │ │ ├── sum.scm
│ │ │ │ ├── sum.sml
│ │ │ │ ├── sum1.awk
│ │ │ │ ├── sum1.c
│ │ │ │ ├── sum1.scm
│ │ │ │ ├── sumfp.c
│ │ │ │ ├── sumfp.java
│ │ │ │ ├── sumfp.scm
│ │ │ │ ├── sumfp.sml
│ │ │ │ ├── sumloop.awk
│ │ │ │ ├── sumloop.c
│ │ │ │ ├── sumloop.scm
│ │ │ │ ├── tail.awk
│ │ │ │ ├── tail.c
│ │ │ │ ├── tail.scm
│ │ │ │ ├── tak.c
│ │ │ │ ├── tak.java
│ │ │ │ ├── tak.scm
│ │ │ │ ├── tak.sml
│ │ │ │ ├── takl.c
│ │ │ │ ├── takl.java
│ │ │ │ ├── takl.scm
│ │ │ │ ├── takl.sml
│ │ │ │ ├── temp.java
│ │ │ │ ├── test.sch
│ │ │ │ ├── test.scm
│ │ │ │ ├── test.tex
│ │ │ │ ├── tfib.c
│ │ │ │ ├── tfib.java
│ │ │ │ ├── tfib.scm
│ │ │ │ ├── trav1.scm
│ │ │ │ ├── trav2.scm
│ │ │ │ ├── triangl.c
│ │ │ │ ├── triangl.scm
│ │ │ │ ├── wc.awk
│ │ │ │ ├── wc.c
│ │ │ │ └── wc.scm
│ │ │ ├── suffix/
│ │ │ │ ├── suffix-bigloo-int.scm
│ │ │ │ ├── suffix-bigloo.scm
│ │ │ │ ├── suffix-chez.scm
│ │ │ │ ├── suffix-chicken.scm
│ │ │ │ ├── suffix-gambit-int.scm
│ │ │ │ ├── suffix-gambit-sp.scm
│ │ │ │ ├── suffix-gambit.scm
│ │ │ │ ├── suffix-henchman.scm
│ │ │ │ ├── suffix-ikarus.scm
│ │ │ │ ├── suffix-kawa.scm
│ │ │ │ ├── suffix-larceny.scm
│ │ │ │ ├── suffix-mit-int.scm
│ │ │ │ ├── suffix-mit.scm
│ │ │ │ ├── suffix-mzscheme.scm
│ │ │ │ ├── suffix-petit.scm
│ │ │ │ ├── suffix-petite-chez.scm
│ │ │ │ └── suffix-scheme48.scm
│ │ │ ├── summarize
│ │ │ ├── summarize.sch
│ │ │ ├── summarize2.sch
│ │ │ ├── table
│ │ │ └── todo.update
│ │ ├── GC/
│ │ │ ├── GCBench.java
│ │ │ ├── PermNKL.java
│ │ │ ├── Pueue4.java
│ │ │ ├── Queue3.java
│ │ │ ├── compile-files.sch
│ │ │ ├── dumb.sch
│ │ │ ├── dummy.sch
│ │ │ ├── dynamic-input-large.sch
│ │ │ ├── dynamic-input-small.sch
│ │ │ ├── dynamic.sch
│ │ │ ├── earley.sch
│ │ │ ├── gcbench.sch
│ │ │ ├── gcbenchJ.sch
│ │ │ ├── gcold.sch
│ │ │ ├── graphs.sch
│ │ │ ├── lattice.sch
│ │ │ ├── nboyer.sch
│ │ │ ├── nucleic2.sch
│ │ │ ├── paraffins.sch
│ │ │ ├── perm.sch
│ │ │ ├── permJ.sch
│ │ │ ├── pueue4.sch
│ │ │ ├── queue3.sch
│ │ │ ├── sboyer.sch
│ │ │ ├── softscheme.sch
│ │ │ ├── twobit-input-long.sch
│ │ │ ├── twobit-input-short.sch
│ │ │ ├── twobit-smaller.sch
│ │ │ └── twobit.sch
│ │ ├── R6RS/
│ │ │ ├── README
│ │ │ ├── bench
│ │ │ ├── inputs/
│ │ │ │ ├── NormalizationTest.txt
│ │ │ │ ├── ack.input
│ │ │ │ ├── array1.input
│ │ │ │ ├── bib
│ │ │ │ ├── bib16
│ │ │ │ ├── bibfreq.input
│ │ │ │ ├── bibfreq2.input
│ │ │ │ ├── browse.input
│ │ │ │ ├── bv2string.input
│ │ │ │ ├── cat.input
│ │ │ │ ├── cat2.input
│ │ │ │ ├── cat3.input
│ │ │ │ ├── compiler.input
│ │ │ │ ├── conform.input
│ │ │ │ ├── cpstak.input
│ │ │ │ ├── ctak.input
│ │ │ │ ├── dderiv.input
│ │ │ │ ├── deriv.input
│ │ │ │ ├── destruc.input
│ │ │ │ ├── diviter.input
│ │ │ │ ├── divrec.input
│ │ │ │ ├── dynamic.data
│ │ │ │ ├── dynamic.input
│ │ │ │ ├── earley.input
│ │ │ │ ├── equal.input
│ │ │ │ ├── fft.input
│ │ │ │ ├── fib.input
│ │ │ │ ├── fibc.input
│ │ │ │ ├── fibfp.input
│ │ │ │ ├── gcbench.input
│ │ │ │ ├── graphs.input
│ │ │ │ ├── hashtable0.input
│ │ │ │ ├── lattice.input
│ │ │ │ ├── listsort.input
│ │ │ │ ├── matrix.input
│ │ │ │ ├── maze.input
│ │ │ │ ├── mazefun.input
│ │ │ │ ├── mbrot.input
│ │ │ │ ├── mbrotZ.input
│ │ │ │ ├── mperm.input
│ │ │ │ ├── nboyer.input
│ │ │ │ ├── normalization.input
│ │ │ │ ├── nqueens.input
│ │ │ │ ├── ntakl.input
│ │ │ │ ├── nucleic.input
│ │ │ │ ├── paraffins.input
│ │ │ │ ├── parsing.data
│ │ │ │ ├── parsing.input
│ │ │ │ ├── parsing16.data
│ │ │ │ ├── peval.input
│ │ │ │ ├── pi.input
│ │ │ │ ├── pnpoly.input
│ │ │ │ ├── primes.input
│ │ │ │ ├── primes2.input
│ │ │ │ ├── puzzle.input
│ │ │ │ ├── quicksort.input
│ │ │ │ ├── ray.input
│ │ │ │ ├── read0.input
│ │ │ │ ├── read1.input
│ │ │ │ ├── read2.input
│ │ │ │ ├── read3.input
│ │ │ │ ├── sboyer.input
│ │ │ │ ├── scheme.input
│ │ │ │ ├── simplex.input
│ │ │ │ ├── slatex-data/
│ │ │ │ │ ├── slatex.sty
│ │ │ │ │ └── test.tex
│ │ │ │ ├── slatex.input
│ │ │ │ ├── string.input
│ │ │ │ ├── sum.input
│ │ │ │ ├── sum1.data
│ │ │ │ ├── sum1.input
│ │ │ │ ├── sumfp.input
│ │ │ │ ├── tail.input
│ │ │ │ ├── tak.input
│ │ │ │ ├── takl.input
│ │ │ │ ├── triangl.input
│ │ │ │ ├── vecsort.input
│ │ │ │ └── wc.input
│ │ │ └── src/
│ │ │ ├── ack.sch
│ │ │ ├── array1.sch
│ │ │ ├── bibfreq.sch
│ │ │ ├── bibfreq2.sch
│ │ │ ├── browse.sch
│ │ │ ├── bv2string.sch
│ │ │ ├── cat.sch
│ │ │ ├── cat2.sch
│ │ │ ├── cat3.sch
│ │ │ ├── common.sch
│ │ │ ├── compiler.sch
│ │ │ ├── conform.sch
│ │ │ ├── cpstak.sch
│ │ │ ├── ctak.sch
│ │ │ ├── dderiv.sch
│ │ │ ├── deriv.sch
│ │ │ ├── destruc.sch
│ │ │ ├── diviter.sch
│ │ │ ├── divrec.sch
│ │ │ ├── dynamic.sch
│ │ │ ├── earley.sch
│ │ │ ├── equal.sch
│ │ │ ├── fft.sch
│ │ │ ├── fib.sch
│ │ │ ├── fibc.sch
│ │ │ ├── fibfp.sch
│ │ │ ├── gcbench.sch
│ │ │ ├── graphs.sch
│ │ │ ├── hashtable0.sch
│ │ │ ├── lattice.sch
│ │ │ ├── listsort.sch
│ │ │ ├── matrix.sch
│ │ │ ├── maze.sch
│ │ │ ├── mazefun.sch
│ │ │ ├── mbrot.sch
│ │ │ ├── mbrotZ.sch
│ │ │ ├── mperm.sch
│ │ │ ├── nboyer.sch
│ │ │ ├── normalization.sch
│ │ │ ├── nqueens.sch
│ │ │ ├── ntakl.sch
│ │ │ ├── nucleic.sch
│ │ │ ├── paraffins.sch
│ │ │ ├── parsing.sch
│ │ │ ├── peval.sch
│ │ │ ├── pi.sch
│ │ │ ├── pnpoly.sch
│ │ │ ├── primes.sch
│ │ │ ├── primes2.sch
│ │ │ ├── puzzle.sch
│ │ │ ├── quicksort.sch
│ │ │ ├── ray.sch
│ │ │ ├── read0.sch
│ │ │ ├── read1.sch
│ │ │ ├── read2.sch
│ │ │ ├── read3.sch
│ │ │ ├── sboyer.sch
│ │ │ ├── scheme.sch
│ │ │ ├── simplex.sch
│ │ │ ├── slatex.sch
│ │ │ ├── string.sch
│ │ │ ├── sum.sch
│ │ │ ├── sum1.sch
│ │ │ ├── sumfp.sch
│ │ │ ├── tail.sch
│ │ │ ├── tak.sch
│ │ │ ├── takl.sch
│ │ │ ├── triangl.sch
│ │ │ ├── vecsort.sch
│ │ │ └── wc.sch
│ │ ├── R7RS/
│ │ │ ├── README
│ │ │ ├── bench
│ │ │ ├── inputs/
│ │ │ │ ├── 29833-0.txt
│ │ │ │ ├── 7142.txt
│ │ │ │ ├── ack.input
│ │ │ │ ├── array1.input
│ │ │ │ ├── bib
│ │ │ │ ├── bibfreq.input
│ │ │ │ ├── bibfreq2.input
│ │ │ │ ├── browse.input
│ │ │ │ ├── bv2string.input
│ │ │ │ ├── cat.input
│ │ │ │ ├── charset.input
│ │ │ │ ├── chudnovsky.input
│ │ │ │ ├── compiler.input
│ │ │ │ ├── conform.input
│ │ │ │ ├── cpstak.input
│ │ │ │ ├── ctak.input
│ │ │ │ ├── dderiv.input
│ │ │ │ ├── deriv.input
│ │ │ │ ├── destruc.input
│ │ │ │ ├── diviter.input
│ │ │ │ ├── divrec.input
│ │ │ │ ├── dynamic.data
│ │ │ │ ├── dynamic.input
│ │ │ │ ├── earley.input
│ │ │ │ ├── equal.input
│ │ │ │ ├── fft.input
│ │ │ │ ├── fib.input
│ │ │ │ ├── fibc.input
│ │ │ │ ├── fibfp.input
│ │ │ │ ├── gcbench.input
│ │ │ │ ├── generator.input
│ │ │ │ ├── graphs.input
│ │ │ │ ├── hashtable0.input
│ │ │ │ ├── ilist.input
│ │ │ │ ├── lattice.input
│ │ │ │ ├── list.input
│ │ │ │ ├── listsort.input
│ │ │ │ ├── lseq.input
│ │ │ │ ├── matrix.input
│ │ │ │ ├── maze.input
│ │ │ │ ├── mazefun.input
│ │ │ │ ├── mbrot.input
│ │ │ │ ├── mbrotZ.input
│ │ │ │ ├── mperm.input
│ │ │ │ ├── nboyer.input
│ │ │ │ ├── nqueens.input
│ │ │ │ ├── ntakl.input
│ │ │ │ ├── nucleic.input
│ │ │ │ ├── paraffins.input
│ │ │ │ ├── parsing.data
│ │ │ │ ├── parsing.input
│ │ │ │ ├── peval.input
│ │ │ │ ├── pi.input
│ │ │ │ ├── pnpoly.input
│ │ │ │ ├── primes.input
│ │ │ │ ├── puzzle.input
│ │ │ │ ├── quicksort.input
│ │ │ │ ├── ray.input
│ │ │ │ ├── read0.input
│ │ │ │ ├── read1.input
│ │ │ │ ├── rlist.input
│ │ │ │ ├── sboyer.input
│ │ │ │ ├── scheme.input
│ │ │ │ ├── set.input
│ │ │ │ ├── simplex.input
│ │ │ │ ├── slatex-data/
│ │ │ │ │ ├── slatex.sty
│ │ │ │ │ └── test.tex
│ │ │ │ ├── slatex.input
│ │ │ │ ├── stream.input
│ │ │ │ ├── string.input
│ │ │ │ ├── sum.input
│ │ │ │ ├── sum1.data
│ │ │ │ ├── sum1.input
│ │ │ │ ├── sumfp.input
│ │ │ │ ├── tail.input
│ │ │ │ ├── tak.input
│ │ │ │ ├── takl.input
│ │ │ │ ├── text.input
│ │ │ │ ├── triangl.input
│ │ │ │ ├── vecsort.input
│ │ │ │ ├── vector.input
│ │ │ │ └── wc.input
│ │ │ ├── src/
│ │ │ │ ├── ack.scm
│ │ │ │ ├── array1.scm
│ │ │ │ ├── bibfreq.scm
│ │ │ │ ├── bibfreq2.scm
│ │ │ │ ├── browse.scm
│ │ │ │ ├── bv2string.scm
│ │ │ │ ├── cat.scm
│ │ │ │ ├── charset.scm
│ │ │ │ ├── chudnovsky.scm
│ │ │ │ ├── common.scm
│ │ │ │ ├── compiler.scm
│ │ │ │ ├── conform.scm
│ │ │ │ ├── cpstak.scm
│ │ │ │ ├── ctak.scm
│ │ │ │ ├── dderiv.scm
│ │ │ │ ├── deriv.scm
│ │ │ │ ├── destruc.scm
│ │ │ │ ├── diviter.scm
│ │ │ │ ├── divrec.scm
│ │ │ │ ├── dynamic.scm
│ │ │ │ ├── earley.scm
│ │ │ │ ├── equal.scm
│ │ │ │ ├── fft.scm
│ │ │ │ ├── fib.scm
│ │ │ │ ├── fibc.scm
│ │ │ │ ├── fibfp.scm
│ │ │ │ ├── gcbench.scm
│ │ │ │ ├── generator.scm
│ │ │ │ ├── graphs.scm
│ │ │ │ ├── hashtable0.scm
│ │ │ │ ├── ilist.scm
│ │ │ │ ├── lattice.scm
│ │ │ │ ├── list.scm
│ │ │ │ ├── listsort.scm
│ │ │ │ ├── lseq.scm
│ │ │ │ ├── matrix.scm
│ │ │ │ ├── maze.scm
│ │ │ │ ├── mazefun.scm
│ │ │ │ ├── mbrot.scm
│ │ │ │ ├── mbrotZ.scm
│ │ │ │ ├── mperm.scm
│ │ │ │ ├── nboyer.scm
│ │ │ │ ├── nqueens.scm
│ │ │ │ ├── ntakl.scm
│ │ │ │ ├── nucleic.scm
│ │ │ │ ├── paraffins.scm
│ │ │ │ ├── parsing.scm
│ │ │ │ ├── peval.scm
│ │ │ │ ├── pi.scm
│ │ │ │ ├── pnpoly.scm
│ │ │ │ ├── primes.scm
│ │ │ │ ├── puzzle.scm
│ │ │ │ ├── quicksort.scm
│ │ │ │ ├── ray.scm
│ │ │ │ ├── read0.scm
│ │ │ │ ├── read1.scm
│ │ │ │ ├── rlist.scm
│ │ │ │ ├── sboyer.scm
│ │ │ │ ├── scheme.scm
│ │ │ │ ├── set.scm
│ │ │ │ ├── simplex.scm
│ │ │ │ ├── slatex.scm
│ │ │ │ ├── stream.scm
│ │ │ │ ├── string.scm
│ │ │ │ ├── sum.scm
│ │ │ │ ├── sum1.scm
│ │ │ │ ├── sumfp.scm
│ │ │ │ ├── tail.scm
│ │ │ │ ├── tak.scm
│ │ │ │ ├── takl.scm
│ │ │ │ ├── text.scm
│ │ │ │ ├── triangl.scm
│ │ │ │ ├── vecsort.scm
│ │ │ │ ├── vector.scm
│ │ │ │ └── wc.scm
│ │ │ ├── summarize.sch
│ │ │ └── summarize2.sch
│ │ └── reading.sch
│ ├── Boot/
│ │ ├── README
│ │ └── fib.sch
│ ├── Compiler/
│ │ ├── README
│ │ ├── p2tests.sch
│ │ ├── p4tests.sch
│ │ ├── primtests.sch
│ │ └── run-tests.sch
│ ├── FFI/
│ │ ├── Makefile
│ │ ├── README
│ │ ├── ffi-test-ff.c
│ │ ├── ffi-test.sch
│ │ ├── ffi-tests.sch
│ │ ├── std-ffi-test-ff.c
│ │ ├── std-ffi-test.def
│ │ └── std-ffi-test.sch
│ ├── GC/
│ │ ├── Makefile
│ │ ├── README
│ │ ├── dummy.sch
│ │ ├── dynamic.sch
│ │ ├── gcbench0.sch
│ │ ├── gcbench1.sch
│ │ ├── gcbench2.sch
│ │ ├── grow.sch
│ │ ├── lattice.sch
│ │ ├── nbody.sch
│ │ ├── nboyer.sch
│ │ ├── nucleic2.sch
│ │ ├── nvboyer.sch
│ │ ├── permsort.sch
│ │ ├── process-log.sch
│ │ ├── sboyer.sch
│ │ └── support.sch
│ ├── Jaffer/
│ │ ├── README
│ │ └── r4rstest.scm
│ ├── Lib/
│ │ ├── NormalizationTest.txt
│ │ ├── README
│ │ ├── bool.sch
│ │ ├── bytevector.sch
│ │ ├── char.sch
│ │ ├── complex.sch
│ │ ├── condition.sch
│ │ ├── ctak.sch
│ │ ├── dynamic-wind.sch
│ │ ├── enum.sch
│ │ ├── env.sch
│ │ ├── except.sch
│ │ ├── fact.sch
│ │ ├── fib.sch
│ │ ├── fixnums.sch
│ │ ├── hashtable.sch
│ │ ├── io.sch
│ │ ├── load-all-tests.sch
│ │ ├── normalization.sch
│ │ ├── number.sch
│ │ ├── pred.sch
│ │ ├── print.sch
│ │ ├── record.sch
│ │ ├── regression.sch
│ │ ├── string.sch
│ │ ├── test.sch
│ │ └── wcm.sch
│ ├── Misc/
│ │ ├── README
│ │ ├── env-tests.sch
│ │ └── nucleic2.sch
│ ├── R6RS/
│ │ ├── cmdline.sch
│ │ ├── cmdline.script
│ │ ├── cpoint.sch
│ │ ├── cpointR6.sch
│ │ ├── earley.input
│ │ ├── earley.sch
│ │ ├── exceptions.sch
│ │ ├── fib.input
│ │ ├── fib.sch
│ │ ├── grabbag.sch
│ │ ├── grabbag.script
│ │ ├── hello.sch
│ │ ├── nboyer.input
│ │ ├── nboyer.sch
│ │ ├── nothing.sch
│ │ ├── nothingBig.sch
│ │ ├── regression.sch
│ │ ├── run-benchmark.sch
│ │ ├── testall
│ │ └── testall.bat
│ ├── R7RS/
│ │ ├── Lib/
│ │ │ ├── README
│ │ │ ├── README2
│ │ │ ├── testall
│ │ │ ├── testall-chibi
│ │ │ ├── testall-chicken
│ │ │ ├── testall-foment
│ │ │ ├── testall-gauche
│ │ │ ├── testall-kawa
│ │ │ ├── testall-sagittarius
│ │ │ ├── testr6rs-chibi
│ │ │ ├── testr6rs-larceny
│ │ │ ├── testr6rs-sagittarius
│ │ │ └── tests/
│ │ │ ├── r6rs/
│ │ │ │ ├── README.txt
│ │ │ │ ├── arithmetic/
│ │ │ │ │ └── fixnums.sld
│ │ │ │ ├── base.sld
│ │ │ │ ├── bytevectors.sld
│ │ │ │ ├── control.sld
│ │ │ │ ├── enums.sld
│ │ │ │ ├── eval.sld
│ │ │ │ ├── exceptions.sld
│ │ │ │ ├── hashtables.sld
│ │ │ │ ├── io/
│ │ │ │ │ └── simple.sld
│ │ │ │ ├── lists.sld
│ │ │ │ ├── mutable-pairs.sld
│ │ │ │ ├── mutable-strings.sld
│ │ │ │ ├── programs.sld
│ │ │ │ ├── r5rs.sld
│ │ │ │ ├── run/
│ │ │ │ │ ├── arithmetic/
│ │ │ │ │ │ └── fixnums.sps
│ │ │ │ │ ├── base.sps
│ │ │ │ │ ├── bytevectors.sps
│ │ │ │ │ ├── control.sps
│ │ │ │ │ ├── enums.sps
│ │ │ │ │ ├── eval.sps
│ │ │ │ │ ├── exceptions.sps
│ │ │ │ │ ├── hashtables.sps
│ │ │ │ │ ├── io/
│ │ │ │ │ │ └── simple.sps
│ │ │ │ │ ├── lists.sps
│ │ │ │ │ ├── mutable-pairs.sps
│ │ │ │ │ ├── mutable-strings.sps
│ │ │ │ │ ├── programs.sps
│ │ │ │ │ ├── r5rs.sps
│ │ │ │ │ ├── sorting.sps
│ │ │ │ │ └── unicode.sps
│ │ │ │ ├── sorting.sld
│ │ │ │ └── unicode.sld
│ │ │ └── scheme/
│ │ │ ├── base-test1.scm
│ │ │ ├── base-test2.scm
│ │ │ ├── base-test3.scm
│ │ │ ├── base-test4.scm
│ │ │ ├── base.body-closed.scm
│ │ │ ├── base.sld
│ │ │ ├── box.sld
│ │ │ ├── case-lambda.sld
│ │ │ ├── char.body-alt.scm
│ │ │ ├── char.body.scm
│ │ │ ├── char.sld
│ │ │ ├── charset.sld
│ │ │ ├── comparator.sld
│ │ │ ├── complex.body.scm
│ │ │ ├── complex.sld
│ │ │ ├── cxr.sld
│ │ │ ├── ephemeron.sld
│ │ │ ├── eval.body.scm
│ │ │ ├── eval.sld
│ │ │ ├── file.sld
│ │ │ ├── flonum.sld
│ │ │ ├── generator.sld
│ │ │ ├── hash-table.sld
│ │ │ ├── ideque.sld
│ │ │ ├── ilist.sld
│ │ │ ├── inexact.sld
│ │ │ ├── lazy.sld
│ │ │ ├── list-queue.sld
│ │ │ ├── list.sld
│ │ │ ├── load-test1.scm
│ │ │ ├── load-test2.scm
│ │ │ ├── load-test3.scm
│ │ │ ├── load.sld
│ │ │ ├── lseq.sld
│ │ │ ├── process-context.sld
│ │ │ ├── read.sld
│ │ │ ├── repl-test2.scm
│ │ │ ├── repl.sld
│ │ │ ├── rlist.sld
│ │ │ ├── run/
│ │ │ │ ├── base.sps
│ │ │ │ ├── box.sps
│ │ │ │ ├── case-lambda.sps
│ │ │ │ ├── char.sps
│ │ │ │ ├── charset.sps
│ │ │ │ ├── comparator.sps
│ │ │ │ ├── complex.sps
│ │ │ │ ├── cxr.sps
│ │ │ │ ├── ephemeron.sps
│ │ │ │ ├── eval.sps
│ │ │ │ ├── file.sps
│ │ │ │ ├── flonum.sps
│ │ │ │ ├── generator.sps
│ │ │ │ ├── hash-table.sps
│ │ │ │ ├── ideque.sps
│ │ │ │ ├── ilist.sps
│ │ │ │ ├── inexact.sps
│ │ │ │ ├── lazy.sps
│ │ │ │ ├── list-queue.sps
│ │ │ │ ├── list.sps
│ │ │ │ ├── load.sps
│ │ │ │ ├── lseq.sps
│ │ │ │ ├── process-context.sps
│ │ │ │ ├── read.sps
│ │ │ │ ├── repl.sps
│ │ │ │ ├── rlist.sps
│ │ │ │ ├── set.sps
│ │ │ │ ├── sort.sps
│ │ │ │ ├── stream.sps
│ │ │ │ ├── text.sps
│ │ │ │ ├── time.sps
│ │ │ │ ├── vector.sps
│ │ │ │ └── write.sps
│ │ │ ├── set.sld
│ │ │ ├── sort.sld
│ │ │ ├── stream.sld
│ │ │ ├── test.sld
│ │ │ ├── text.sld
│ │ │ ├── time.sld
│ │ │ ├── vector.sld
│ │ │ └── write.sld
│ │ ├── Numbers/
│ │ │ └── clisp-number-tests.sps
│ │ ├── conflicts.scm
│ │ └── srfi.scm
│ ├── README
│ ├── Scripts/
│ │ ├── autobuild-conservative
│ │ ├── autobuild-precise
│ │ ├── backup-xml-files.sh
│ │ ├── benchmark-only
│ │ ├── build-only
│ │ ├── checkout-common-larceny
│ │ ├── checkout-git
│ │ ├── checkout-git-cdash
│ │ ├── checkout-svn
│ │ ├── checkout-svn-cdash
│ │ ├── checkout-svn-dart
│ │ ├── clone-only
│ │ ├── delete-builds-from-16th-to-24th.sh
│ │ ├── delete-builds-from-16th-to-31st.sh
│ │ ├── delete-builds-from-25th-to-31st.sh
│ │ ├── delete-builds-from-2nd-to-14th.sh
│ │ ├── delete-builds-from-2nd-to-8th.sh
│ │ ├── delete-builds-from-9th-to-14th.sh
│ │ ├── gcbench-cdash
│ │ ├── nightly-build
│ │ ├── package-bin-release.sh
│ │ ├── test-only
│ │ └── test2-only
│ ├── Sparc/
│ │ ├── README
│ │ └── prim-error.sch
│ ├── Stress/
│ │ ├── README
│ │ ├── bench
│ │ ├── results.Larceny
│ │ ├── src/
│ │ │ ├── boyer.scm
│ │ │ ├── browse.scm
│ │ │ ├── conform.scm
│ │ │ ├── cpstak.scm
│ │ │ ├── crash.scm
│ │ │ ├── ctak.scm
│ │ │ ├── dderiv.scm
│ │ │ ├── deriv.scm
│ │ │ ├── destruc.scm
│ │ │ ├── diviter.scm
│ │ │ ├── divrec.scm
│ │ │ ├── dynamic.scm
│ │ │ ├── earley.scm
│ │ │ ├── fail.scm
│ │ │ ├── fft.c
│ │ │ ├── fft.scm
│ │ │ ├── fib.c
│ │ │ ├── fib.scm
│ │ │ ├── fibc.scm
│ │ │ ├── fibfp.c
│ │ │ ├── fibfp.scm
│ │ │ ├── fpsum.scm
│ │ │ ├── graphs.scm
│ │ │ ├── lattice.scm
│ │ │ ├── matrix.scm
│ │ │ ├── maze.scm
│ │ │ ├── mazefun.scm
│ │ │ ├── mbrot.c
│ │ │ ├── mbrot.scm
│ │ │ ├── nbody.scm
│ │ │ ├── nboyer.scm
│ │ │ ├── nqueens.scm
│ │ │ ├── nucleic.c
│ │ │ ├── nucleic.scm
│ │ │ ├── num-iters-int.scm
│ │ │ ├── num-iters.scm
│ │ │ ├── one-iter.scm
│ │ │ ├── perm9.scm
│ │ │ ├── peval.scm
│ │ │ ├── pnpoly.c
│ │ │ ├── pnpoly.scm
│ │ │ ├── prefix-chez.scm
│ │ │ ├── prefix-larceny.scm
│ │ │ ├── primes.scm
│ │ │ ├── puzzle.scm
│ │ │ ├── quicksort.scm
│ │ │ ├── ray.scm
│ │ │ ├── scheme.scm
│ │ │ ├── simplex.scm
│ │ │ ├── slatex.scm
│ │ │ ├── slatex.sty
│ │ │ ├── smlboyer.scm
│ │ │ ├── succeed.scm
│ │ │ ├── suffix-larceny.scm
│ │ │ ├── sum.c
│ │ │ ├── sum.scm
│ │ │ ├── sumfp.c
│ │ │ ├── sumfp.scm
│ │ │ ├── tak.c
│ │ │ ├── tak.scm
│ │ │ ├── takl.scm
│ │ │ ├── test.tex
│ │ │ ├── trav1.scm
│ │ │ ├── trav2.scm
│ │ │ └── triangl.scm
│ │ ├── summarize
│ │ ├── summarize.sch
│ │ ├── switches.scm
│ │ └── sys/
│ │ └── larceny/
│ │ └── crash.scm
│ ├── run-benchmark.sch
│ └── run-gc-tests.sch
└── tools/
├── LexGen/
│ ├── accessible.sch
│ ├── lexgen.c.sch
│ ├── lexgen.java.sch
│ ├── lexgen.scheme.sch
│ ├── loadlexgen.sch
│ ├── regexp.sch
│ └── select.sch
├── ParseGen/
│ ├── README
│ ├── follow.sch
│ ├── loadparsegen.sch
│ ├── parsegen.c.sch
│ ├── parsegen.java.sch
│ ├── parsegen.pascal.sch
│ ├── parsegen.sch
│ ├── parsegen.scheme.sch
│ ├── parsegen0.pg
│ ├── parsegen0.sch
│ ├── sets.sch
│ └── sets2.sch
├── R6RS/
│ ├── README
│ ├── download-snow
│ ├── make-snow
│ ├── r6rs/
│ │ ├── arithmetic/
│ │ │ ├── fixnums.body.scm
│ │ │ └── fixnums.sld
│ │ ├── base.body.scm
│ │ ├── base.sld
│ │ ├── bytevectors.body.scm
│ │ ├── bytevectors.sld
│ │ ├── control.sld
│ │ ├── enums.body.scm
│ │ ├── enums.sld
│ │ ├── eval.sld
│ │ ├── exceptions.sld
│ │ ├── files.sld
│ │ ├── hashtables.atop69.scm
│ │ ├── hashtables.body69.scm
│ │ ├── hashtables.sld
│ │ ├── io/
│ │ │ └── simple.sld
│ │ ├── lists.body.scm
│ │ ├── lists.sld
│ │ ├── mutable-pairs.sld
│ │ ├── mutable-strings.sld
│ │ ├── programs.sld
│ │ ├── r5rs.sld
│ │ ├── sorting.body.scm
│ │ ├── sorting.sld
│ │ ├── unicode-reference/
│ │ │ ├── unicode0.body.scm
│ │ │ ├── unicode0.sld
│ │ │ ├── unicode1.body.scm
│ │ │ ├── unicode1.sld
│ │ │ ├── unicode2.body.scm
│ │ │ ├── unicode2.sld
│ │ │ ├── unicode3.body.scm
│ │ │ ├── unicode3.sld
│ │ │ ├── unicode4.body.scm
│ │ │ └── unicode4.sld
│ │ └── unicode.sld
│ ├── r6rsDoc.html
│ └── upload-snow
├── R7RS/
│ ├── in-progress/
│ │ └── hash/
│ │ ├── bimaps.body.scm
│ │ └── bimaps.sld
│ ├── make-snow
│ └── upload-snow
└── Unicode/
└── r6rs-unicode/
├── README
├── check-normalization.scm
├── check-wordbreaking.scm
├── local/
│ ├── unicode.sls
│ ├── unicode0.sls
│ ├── unicode1.sls
│ ├── unicode2.sls
│ ├── unicode3.sls
│ └── unicode4.sls
├── parseUCD.sch
├── strategy.sch
└── unicode-tests.sch
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
*.sch linguist-language=Scheme
================================================
FILE: .gitignore
================================================
*~
*.fasl
*.slfasl
*.o
*.obj
*.lap
*.lop
include/asmdefs.h
include/cdefs.h
include/config.ah
include/config.h
include/except.ah
include/except.ch
include/globals.ah
include/globals.ch
include/layouts.ah
include/layouts.ch
include/mprocs.ah
include/mprocs.ch
include/regs.ah
include/regs.ch
larceny.bin
larceny.heap
twobit.heap
sasstrap.heap
arm.heap
lib/R6RS/r6rs-standard-libraries.exp
src/Lib/Common/ecodes.sch
src/Lib/Common/globals.sch
src/Lib/Common/layouts.sch
src/Lib/Common/regs.sch
src/Rts/Makefile
src/Rts/Shared/arithmetic.c
src/Rts/c-table.c
src/Rts/larceny.bin
src/Rts/nasm-table.asm
src/Rts/fence-table.sx
tablesLarceny
dfaLarceny.sch
parserLarceny.sch
test/Benchmarking/R6RS/results.*
test/Benchmarking/R6RS/Results
test/Benchmarking/R6RS/outputs
test/Benchmarking/R7RS/results.*
test/Benchmarking/R7RS/Results
test/Benchmarking/R7RS/outputs
test/Jaffer/tmp*
test/R7RS/Lib/temp.scm
test/R7RS/Lib/testresults*
lib/SRFI/test/*.log
================================================
FILE: COPYRIGHT
================================================
Copyright 1991, 1994, 1998 William D Clinger
Copyright 1998 Lars T Hansen
Copyright 1984 - 1993 Lightship Software, Incorporated
Permission to copy this software, in whole or in part, to use this
software for any lawful purpose, and to redistribute this software
is granted subject to the following restriction: Any publication
or redistribution of this software, whether on its own or
incorporated into other software, must bear the above copyright
notices and the following legend:
The Twobit compiler and the Larceny runtime system were
developed by William Clinger and Lars Hansen with the
assistance of Lightship Software and the College of Computer
Science of Northeastern University. This acknowledges that
Clinger et al remain the sole copyright holders to Twobit
and Larceny and that no rights pursuant to that status are
waived or conveyed.
Twobit and Larceny are provided as is. The user specifically
acknowledges that Northeastern University, William Clinger, Lars
Hansen, and Lightship Software have not made any representations
or warranty with regard to performance of Twobit and Larceny,
their merchantability, or fitness for a particular purpose. Users
further acknowledge that they have had the opportunity to inspect
Twobit and Larceny and will hold harmless Northeastern University,
William Clinger, Lars Hansen, and Lightship Software from any cost,
liability, or expense arising from, or in any way related to the
use of this software.
Bug reports, comments, and suggestions can be sent to the authors
of Twobit and Larceny at larceny@ccs.neu.edu.
----------------------------------------------------------------
The implementors of Larceny include:
William D Clinger
Lars T Hansen
Lightship Software, Incorporated
Felix S Klock II
Jesse Tov
Files that contain Twobit and/or Larceny source code and are
copyrighted by these people are governed by Larceny's main
permission notice above.
----------------------------------------------------------------
In addition to Twobit and Larceny's main copyright and permission
notices above, the following copyright and permission notices
pertain to software that is part of Twobit and/or Larceny or
may be distributed together with Twobit and Larceny.
In source distributions of Larceny, the following copyright and
permission notices also appear within the copyrighted code. We
reproduce them here for reference, and to ensure that they are
distributed with binary distributions of Larceny.
We emphasize that all copyrighted software used in Twobit and
Larceny is used by the kind permission of the copyright holders.
----------------------------------------------------------------
lib/Base/pp.sch and lib/Standard/pretty.sch include the following:
; Copyright (c) 1991, Marc Feeley.
;
; Permission to copy this software, in whole or in part, to use this
; software for any lawful purpose, and to redistribute this software
; is hereby granted.
----------------------------------------------------------------
lib/Base/shivers-syntax.sch includes the following:
;;; Copyright (c) 1993-1999 Richard Kelsey and Jonathan Rees
;;; Copyright (c) 1994-1999 by Olin Shivers and Brian D. Carlstrom.
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; 1. Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; 2. Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; 3. The name of the authors may not be used to endorse or promote products
;;; derived from this software without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
;;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
;;; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
;;; IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
;;; INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
;;; NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
;;; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------
lib/MzScheme/class.sch,
lib/MzScheme/generic.sch, and
lib/MzScheme/instance.sch
include the following:
;;; Copyright (c) 1992 Xerox Corporation. All Rights Reserved.
;;;
;;; Use, reproduction, and preparation of derivative works are permitted. Any
;;; copy of this software or of any derivative work must include the above
;;; copyright notice of Xerox Corporation, this paragraph and the one after it.
;;; Any distribution of this software or derivative works must comply with all
;;; applicable United States export control laws.
;;; This software is made available AS IS, and XEROX CORPORATION DISCLAIMS ALL
;;; WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND
;;; NOTWITHSTANDING ANY OTHER PROVISION CONTAINED HEREIN, ANY LIABILITY FOR
;;; DAMAGES RESULTING FROM THE SOFTWARE OR ITS USE IS EXPRESSLY DISCLAIMED,
;;; WHETHER ARISING IN CONTRACT, TORT (INCLUDING NEGLIGENCE) OR STRICT
;;; LIABILITY, EVEN IF XEROX CORPORATION IS ADVISED OF THE POSSIBILITY OF SUCH
;;; DAMAGES.
----------------------------------------------------------------
lib/MzScheme/compress.sch,
lib/MzScheme/identifier,
lib/MzScheme/simple-macros/simple-macros.sch, and
src/Lib/Common/SimpleMacros/simple-macros.scm
include the following:
Simple Hygienic Macros and Simple Modules:
Copyright (c) 2005 Andr van Tonder
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the ``Software''),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
----------------------------------------------------------------
lib/MzScheme/simple-macros/simple-syntax-case.sch includes the
following:
;; Copyright (c) 1993-2004 Richard Kelsey and Jonathan Rees
;; All rights reserved.
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions
;; are met:
;; 1. Redistributions of source code must retain the above copyright
;; notice, this list of conditions and the following disclaimer.
;; 2. Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in the
;; documentation and/or other materials provided with the distribution.
;; 3. The name of the authors may not be used to endorse or promote products
;; derived from this software without specific prior written permission.
;;
;; THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
;; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
;; IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
;; INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
;; NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
;; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------
In lib/R6RS, most files include the following:
;;; Copyright (c) 2006 Andre van Tonder
;;;
;;; Copyright statement at http://srfi.schemers.org/srfi-process.html
----------------------------------------------------------------
lib/R6RS/r6rs-standard-libraries.sch and src/Compiler/usual.sch
include the following:
; Copyright (C) Richard Kelsey, Michael Sperber (2002). All Rights Reserved.
;
; Permission is hereby granted, free of charge, to any
; person obtaining a copy of this software and associated
; documentation files (the "Software"), to deal in the
; Software without restriction, including without
; limitation the rights to use, copy, modify, merge,
; publish, distribute, sublicense, and/or sell copies of
; the Software, and to permit persons to whom the Software
; is furnished to do so, subject to the following conditions:
;
; The above copyright notice and this permission notice
; shall be included in all copies or substantial portions
; of the Software.
----------------------------------------------------------------
In lib/SRFI, most files include a variation of the standard SRFI
copyright notice. Regardless of the specific wording of copyright
notices that may appear in that directory, all authors of the
source code in that directory have agreed to the permission notice
that is part of the standard SRFI copyright statement, which is
found in http://srfi.schemers.org/srfi-process.html:
Copyright (C) AUTHOR (YEAR). All Rights Reserved.
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject
to the following conditions:
The above copyright notice and this permission notice shall
be included in all copies or substantial portions of the
Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
----------------------------------------------------------------
lib/SRFI/test/srfi-13-test.sch, which is not used by Twobit or
Larceny but is distributed with Larceny for the convenience of
our users, includes both of the following:
;;;; Copyright (C) 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; the Free Software Foundation; either version 2, or (at your option)
;;;; any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this software; see the file COPYING. If not, write to
;;;; the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
;;;; Boston, MA 02111-1307 USA
;; Copyright (c) 2000-2003 Shiro Kawai, All rights reserved.
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions
;; are met:
;;
;; 1. Redistributions of source code must retain the above copyright
;; notice, this list of conditions and the following disclaimer.
;;
;; 2. Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in the
;; documentation and/or other materials provided with the distribution.
;;
;; 3. Neither the name of the authors nor the names of its contributors
;; may be used to endorse or promote products derived from this
;; software without specific prior written permission.
;;
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------
lib/Standard/array.sch, which is not used by Twobit or Larceny
but is distributed with Larceny for the convenience of our users,
includes the following:
; Copyright (C) 1993 Alan Bawden
;
; Permission to copy this software, to redistribute it, and to use it
; for any purpose is granted, subject to the following restrictions and
; understandings.
;
; 1. Any copy made of this software must include this copyright notice
; in full.
;
; 2. Users of this software agree to make their best efforts (a) to
; return to me any improvements or extensions that they make, so that
; these may be included in future releases; and (b) to inform me of
; noteworthy uses of this software.
;
; 3. I have made no warrantee or representation that the operation of
; this software will be error-free, and I am under no obligation to
; provide any services, by way of maintenance, update, or otherwise.
;
; 4. In conjunction with products arising from the use of this material,
; there shall be no use of my name in any advertising, promotional, or
; sales literature without prior written consent in each case.
----------------------------------------------------------------
lib/Standard/md5.sch and src/Asm/Standard-C/md5.sch
include the following:
;;; Copyright (c) 2002, Jens Axel Sgaard
;;;
;;; Permission to copy this software, in whole or in part, to use this
;;; software for any lawful purpose, and to redistribute this software
;;; is hereby granted.
----------------------------------------------------------------
lib/Standard/unify.sch, which is not used by Twobit or Larceny
but is distributed with Larceny for the convenience of our users,
includes the following:
; Copyright 1999 Lars T Hansen
;
; Permission to use this code for any purpose whatsoever is hereby
; granted, provided that the above copyright notice and this legend
; are preserved in any work using this code.
----------------------------------------------------------------
src/Lib/Common/raise.sch includes the following:
; Copyright (C) Richard Kelsey, Michael Sperber (2002). All Rights Reserved.
;
; Permission is hereby granted, free of charge, to any
; person obtaining a copy of this software and associated
; documentation files (the "Software"), to deal in the
; Software without restriction, including without
; limitation the rights to use, copy, modify, merge,
; publish, distribute, sublicense, and/or sell copies of
; the Software, and to permit persons to whom the Software
; is furnished to do so, subject to the following conditions:
;
; The above copyright notice and this permission notice
; shall be included in all copies or substantial portions
; of the Software.
----------------------------------------------------------------
src/Lib/Common/ratnums.sch and src/Lib/Common/rectnums.sch
include the following:
; Copyright 1992 Rmy Evard.
;
; Permission to copy this software, in whole or in part, to use this
; software for any lawful purpose, and to redistribute this software
; is granted.
----------------------------------------------------------------
src/Lib/Common/unicode4.sch includes the following:
; Copyright (c) 2006 Michael Sperber
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; 1. Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; 2. Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in the
; documentation and/or other materials provided with the distribution.
; 3. The name of the authors may not be used to endorse or promote products
; derived from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
; IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
; INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
; NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------
The files in the src/Lib/Sassy directory are used only by the
IAssassin variety of native Larceny, which runs on Intel x86
architectures. Most of the files in that directory are
copyrighted by Jonathan Kraut and used by IAssassin varieties
of Larceny under the GNU LESSER GENERAL PUBLIC LICENSE; a typical
copyright notice reads as follows:
; Copyright (C) 2005 Jonathan Kraut
; This library is free software; you can redistribute it and/or
; modify it under the terms of the GNU Lesser General Public
; License as published by the Free Software Foundation; either
; version 2.1 of the License, or (at your option) any later version.
; This library is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
; Lesser General Public License for more details.
; You should have received a copy of the GNU Lesser General Public
; License along with this library; if not, write to the Free Software
; Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
A copy of the LGPL license is contained within src/Lib/Sassy,
and our obligations under section 6d of that license are met by
offering the source code for Larceny on the same web page that
offers a binary distribution of IAssassin Larceny. For the
specific copyright notices on files that are contained within
the src/Lib/Sassy directory, please view the files in that
directory or obtain those files from Sassy's main web site:
http://home.earthlink.net/~krautj/sassy/sassy.html
----------------------------------------------------------------
src/Lib/Sassy/other/srfi-56-pieces.scm includes the following:
;;; Copyright (c) 2004-2005 by Alex Shinn. All rights reserved.
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation files
;;; (the "Software"), to deal in the Software without restriction,
;;; including without limitation the rights to use, copy, modify, merge,
;;; publish, distribute, sublicense, and/or sell copies of the Software,
;;; and to permit persons to whom the Software is furnished to do so,
;;; subject to the following conditions:
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
;;; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
;;; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
;;; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
;;; SOFTWARE.
----------------------------------------------------------------
src/Lib/Sassy/other/srfi-60-pieces.scm includes the following:
;;; Copyright (C) 1991, 1993, 2001, 2003, 2005 Aubrey Jaffer
;
;Permission to copy this software, to modify it, to redistribute it,
;to distribute modified versions, and to use it for any purpose is
;granted, subject to the following restrictions and understandings.
;
;1. Any copy made of this software must include this copyright notice
;in full.
;
;2. I have made no warranty or representation that the operation of
;this software will be error-free, and I am under no obligation to
;provide any services, by way of maintenance, update, or otherwise.
;
;3. In conjunction with products arising from the use of this
;material, there shall be no use of my name in any advertising,
;promotional, or sales literature without prior written consent in
;each case.
----------------------------------------------------------------
The test directory contains programs that are not part of Twobit
or Larceny but are distributed in source form with the Larceny
source code for the convenience of programmers who need to test
or to benchmark Larceny. All of those programs are distributed
by permission of the copyright holders; for specific copyright
notices, please consult the files themselves.
----------------------------------------------------------------
================================================
FILE: README-COMMON-LARCENY.txt
================================================
SYSTEM REQUIREMENTS
Currently, this software is distributed for
- Windows on Intel x86 machines, Microsoft .NET Framework 2.0
You can make Common Larceny work on other platforms (e.g. Mac OS X
with the Mono Framework 1.1) but we do not yet provide support for
those systems.
WHAT YOU NEED
To run the interpreter, you will first need to set the LARCENY_ROOT
environment variable explicitly to the Larceny's distribution's path
before running Common Larceny. Otherwise, everything else should
work "out of the box".
To compile files, the development tools (e.g. ilasm) must be in your
search path. Also, for now you must have Twobit.fasl and Twobit.exe
in the current directory when you start the compiler.
To run with auto-compilation of loaded files, for now you must have
Larceny.fasl and Larceny.exe in the current directory when you start
the runtime. Note that the compiler itself has not been optimized,
and so there is a noticeable delay when loading source in this mode.
QUICK START
CommonLarceny (Win32):
- If you want to run with auto-compilation of Scheme source loaded
with the load procedure, run
> CommonLarceny Larceny.fasl
- If you want to use the compiler under the interpreter, run
> CommonLarceny Twobit.fasl
- If you're content to use only the interpreter, run
> CommonLarceny
Do not run Twobit.exe; it is not a standalone application.
Do not run Larceny.exe; it is not a standalone application.
COMPILING SCHEME SOURCE WITH LARCENY
- (compile-file <SOURCE> [<TARGET>])
(compile-file "source.sch")
compiles "source.sch", leaving the compiled code in "source.fasl"
(compile-file "source.sch" "target.fasl")
compiles "source.sch", leaving the compiled code in "target.fasl"
- (load "target.fasl")
loads the compiled code in "target.fasl"
FURTHER READING
For more information, including detailed instructions on how to build
Common Larceny, please see the Common Larceny User Manual under
doc/CommonLarceny.
For a list of bugs that are known to persist in this release, see
doc/KNOWN-BUGS.
================================================
FILE: README-FIRST.txt
================================================
SYSTEM REQUIREMENTS
Currently, this software is distributed for:
- Windows on Intel x86 machines (native IA32 backend)
- Linux on Intel x86 machines (native IA32 and C backends)
- Linux on little-endian ARMv7 machines (native ARM-32 backend)
- Mac OS X (>= 10.4) on Intel x86 machines (native IA32 backend)
The current version of Larceny always runs in 32-bit mode, but the
native IA32 variety of Larceny is known to work on x86-64 hardware
provided the necessary 32-bit libraries are installed (see below).
A binary distribution of Larceny will occupy about 40 megabytes
of disk when unpacked. A source distribution of Larceny will
expand to almost 200 megabytes as it is built.
"Petit Larceny" is used throughout Larceny's documentation to
refer to all varieties other than Common Larceny and the native
backends for IA32 and ARMv7 [1]. (If you intend to use Common
Larceny, see the Common Larceny user's manual [2].)
WHAT YOU NEED
Native (IA32, ARM): everything should work out of the box. If not,
you may need to install some 32-bit libraries or (on Windows) allow
Larceny to opt out of DEP. See doc/HOWTO-INSTALL.
Petit Larceny (Linux, Mac OS X): ensure that the GNU C Compiler (gcc)
is in your execution path. (If you are building from source, see
doc/HOWTO-BUILD.)
Mac OS X: Use Apple's Developer Tools, http://developer.apple.com/
Petit Larceny only: After gcc is in your execution path,
you should install the R7RS runtime and standard libraries
by performing step 4 of the process described in doc/HOWTO-BUILD.
QUICK START
Linux and MacOS X:
- Run
% ./larceny
Win32:
- Run
> larceny
EXECUTION MODES
R5RS traditional read/eval/print loop (the default)
R6RS see doc/HOWTO-R6RS
R7RS see doc/HOWTO-R7RS
Scheme script see doc/HOWTO-SCRIPT
The precompiled distributions of native Larceny should work
out of the box in all four modes, but the R6RS, R7RS, and
Scheme script modes will not work in Petit Larceny until
you have performed step 4 of the process described in
doc/HOWTO-BUILD.
COMPILING SCHEME SOURCE WITH LARCENY
Native versions of Larceny compile all definitions and most
expressions to machine code as they are typed or loaded.
Programs will load faster if precompiled; in Petit Larceny,
the precompiled programs will also run much faster.
To precompile files that contain R5RS Scheme code:
- (compile-file <SOURCE> [<TARGET>])
(compile-file "source.sch")
compiles "source.sch", leaving the compiled code in "source.fasl"
(compile-file "source.sch" "target.fasl")
compiles "source.sch", leaving the compiled code in "target.fasl"
- (load "target.fasl")
loads the compiled code in "target.fasl"
To precompile R7RS/R6RS libraries, programs, and Scheme scripts,
use the compile-larceny and compile-stale scripts that are in
Larceny's root directory.
Please see the Larceny User Manual [3] for details.
FURTHER READING
If you want to install Larceny for other users on your system, see
doc/HOWTO-INSTALL. To build your own Larceny, take a look at
doc/HOWTO-BUILD. To build Common Larceny, see the Common Larceny
documentation in doc/CommonLarceny/user-manual.txt.
Most importantly, see the Larceny user manual in doc/UserManual.
The most recent version of the user manual is autobuilt daily
and is online at http://www.cesura17.net/~larcenists/Nightly/doc/
NOTES
[1] You may be able to make Petit Larceny work on other platforms
(e.g. MacOSX/PowerPC or Linux/PowerPC with the C backend) but we do
not support those systems.
[2] http://larceny.ccs.neu.edu/doc/CommonLarceny/user-manual.html
[3] http://larceny.ccs.neu.edu/doc/
================================================
FILE: README.md
================================================
Larceny is a simple and efficient implementation of the Scheme
programming language. It supports the R7RS Red Edition, R6RS,
R5RS, and IEEE/ANSI standards for Scheme on several platforms.
## Main Larceny Web Site
To download released versions of Larceny, see Larceny's official
web site at http://www.larcenists.org/ .
## Bug/Ticket Submissions
If you're here to report a bug, please do so. And we thank you.
## Developer Resources
If you're a developer or user interested in Larceny's nightly
builds, please see Larceny's
[wiki pages](https://github.com/larcenists/larceny/wiki).
## Building Larceny from Source
If you cloned this repository, be sure to read README-FIRST.txt.
More documentation is also available in doc/, such as these files
and directories:
* doc/HOWTO-BUILD
* doc/HOWTO-INSTALL
* doc/UserManual/
* doc/LarcenyNotes/
among many others.
================================================
FILE: compile-larceny
================================================
#!/usr/bin/env scheme-script
#!r7rs
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Usage:
;;;
;;; compile-larceny [options...] [pathname]
;;;
;;; Compiles the R7RS top-level program contained within the
;;; file named by pathname. If no pathname is given, but one
;;; or more directories are specified by -I or -A options,
;;; attempts to compile any R7RS or R6RS libraries found in
;;; those directories.
;;;
;;; Options:
;;;
;;; -o outfile
;;; Specifies the name of the executable file to be
;;; generated. If this option is omitted, and the
;;; pathname is of the form pgm.scm or pgm.sps, then
;;; the executable file will be named pgm. If the
;;; pathname is of some other form, and no outfile
;;; is specified via this option, then the executable
;;; file will be named a.out.
;;;
;;; -I directory
;;; -A directory
;;; These options specify a directory to be searched
;;; when locating libraries imported by the program.
;;; The -I option specifies a directory to be searched
;;; before searching directories that contain standard
;;; libraries, while the -A option specifies a directory
;;; to be searched after.
;;;
;;; -D feature
;;; Declares a feature to be recognized by cond-expand
;;; when the program is compiled.
;;;
;;; The -I, -A, and -D options may be used more than once.
;;;
;;; When compiling a program, all libraries imported by the
;;; program, whether directly or indirectly, are assumed to
;;; have already been compiled, or don't need to be compiled,
;;; or are contained within the program file itself.
;;;
;;; If no program or output file is specified, then an attempt
;;; will be made to compile all libraries found within directories
;;; specified by -I or -A options, proceeding from left to right.
;;; That compilation process will respect import dependencies
;;; between libraries located within one of those directories
;;; and any of its subdirectories, but will not respect import
;;; dependencies between libraries located within two different
;;; directories specified by the -I or -A options. If a library
;;; found within the first directory specified imports a library
;;; located within the second directory specified, the compiled
;;; forms of those libraries will not be consistent, and any
;;; programs that import both of them will not run.
;;;
;;; See SRFI 138: http://srfi.schemers.org/srfi-138
;;;
;;; KNOWN BUGS:
;;;
;;; doesn't yet look at the COMPILE_R7RS environment variable.
;;; doesn't handle colon-separated directory lists
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(import (scheme base)
(scheme cxr)
(scheme process-context)
(scheme write)
(scheme list)
(srfi 138)
(larceny compiler)
(larceny parse-options))
(define (usage-message)
(let ((q (current-error-port)))
(for-each
(lambda (s) (display s q) (newline q))
'("Usage: compile-larceny [ OPTION ... ] [ PGM ]"
" compiles PGM as specified by SRFI 138"
"Options:"
" -o outfile"
" -I directory"
" -A directory"
" -D feature")))
(exit 1))
;;; cmds will resemble
;;; ("larceny" "compile-larceny" "-I" "dir1" ... "pgm.scm")
(define cmds (command-line))
;;; Returns 6 values:
;;; the name of the program to be compiled, or #f
;;; the name of the executable file to be generated, or #f
;;; the list of -D features, from left to right
;;; the list of -I directories, from left to right
;;; the list of -A directories, from left to right
;;; the list of all -I and -A directories, from left to right
(define (parse-commands)
(call-with-values
(lambda ()
(larceny:parse-options (cddr cmds)
'((seq "-o" _)
(seq "-D" _)
(seq (or "-I" "-A") _))))
(lambda (pgms opts-o opts-D opts-IA)
(cond ((or (> (length pgms) 1)
(> (length opts-o) 1))
(usage-message)
(values #f #f '() '() '() '()))
(else
(values (if (null? pgms) #f (car pgms))
(if (null? opts-o) #f (cadr (car opts-o)))
(map cadr opts-D)
(map cadr
(filter (lambda (x) (string=? (car x) "-I"))
opts-IA))
(map cadr
(filter (lambda (x) (string=? (car x) "-A"))
opts-IA))
(map cadr opts-IA)))))))
(define (process-commands)
(call-with-values
parse-commands
(lambda (pgm outfile features dirs1 dirs2 alldirs)
(cond (pgm
(compile-r7rs pgm outfile dirs1 dirs2 features))
(outfile
(usage-message))
((null? alldirs)
(usage-message))
(else
(display "Compiling libraries...\n"
(current-error-port))
(guard (exn (#t (report-error-and-exit exn)))
(for-each (lambda (dir)
(parameterize
((current-require-path
(append dirs1
(current-require-path)
dirs2))
(larceny:current-declared-features
(append (larceny:current-declared-features)
features))
(current-directory dir))
(compile-stale-libraries)))
alldirs)))))))
(define (report-error-and-exit exn)
(report-error exn)
(exit 1))
(define (report-error exn)
(display "ERROR: " (current-error-port))
(if (error-object? exn)
(begin (display (error-object-message exn)
(current-error-port))
(newline (current-error-port))
(for-each (lambda (x)
(write x (current-error-port))
(newline (current-error-port)))
(error-object-irritants exn)))
(display "abandoning compilation\n"
(current-error-port))))
(process-commands)
================================================
FILE: compile-stale
================================================
#!/usr/bin/env scheme-script
#!r7rs
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Compiles all .sld and .sls files that lie within the directory
;;; (and its subdirectories) from which this Scheme script is invoked.
;;;
;;; Compiling a large number of interdependent source files by
;;; hand is inconvenient because files must be compiled in an
;;; order consistent with their import dependencies: Every
;;; compiled library must be compiled before any compiled
;;; files that import the library.
;;;
;;; If the files compiled by this script define libraries
;;; that are imported by compiled files that lie outside the
;;; directory from which this Scheme script is invoked, then
;;; those compiled files will become stale, which means those
;;; compiled files should be removed or replaced by freshly
;;; compiled files.
;;;
;;; Larceny refuses to execute compiled code from a stale
;;; file, because the compiled code in stale files may be
;;; dangerously inconsistent with the compiled code of
;;; libraries on which the stale file depends.
;;;
;;; KNOWN BUGS:
;;;
;;; doesn't handle colon-separated directory lists
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(import (scheme base)
(scheme cxr)
(scheme file)
(scheme process-context)
(scheme list)
(larceny compiler)
(larceny parse-options))
(define cmds (command-line))
(call-with-values
(lambda ()
(larceny:parse-options (cddr cmds)
'((seq "-I" _)
(seq "-A" _)
(seq "-D" _))))
(lambda (files opts-I opts-A opts-D)
(let ((dirs-I (map cadr opts-I))
(dirs-A (map cadr opts-A))
(features (map cadr opts-D)))
(parameterize ((current-require-path
(append dirs-I (current-require-path) dirs-A))
(larceny:current-declared-features
(append (larceny:current-declared-features)
features)))
(if (every file-exists? files)
(apply compile-stale files)
(error "compile-stale: can't find some of these files"
files))))))
================================================
FILE: doc/.gitignore
================================================
LarcenyNotes/larceny-notes.xml
UserManual/user-manual.fo
UserManual/user-manual.xml
builddate.html
buildlog.html
larceny-notes-alt.html
larceny-notes.html
sourceindex.html
user-manual-alt.html
user-manual.chunked/
user-manual.html
user-manual.pdf
================================================
FILE: doc/CommonLarceny/image-teachpack.html
================================================
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<meta name="generator" content="AsciiDoc 8.0.0" />
<style type="text/css">
/* Debug borders */
p, li, dt, dd, div, pre, h1, h2, h3, h4, h5, h6 {
/*
border: 1px solid red;
*/
}
body {
margin: 1em 5% 1em 5%;
}
a {
color: blue;
text-decoration: underline;
}
a:visited {
color: fuchsia;
}
em {
font-style: italic;
}
strong {
font-weight: bold;
}
tt {
color: navy;
}
h1, h2, h3, h4, h5, h6 {
color: #527bbd;
font-family: sans-serif;
margin-top: 1.2em;
margin-bottom: 0.5em;
line-height: 1.3;
}
h1 {
border-bottom: 2px solid silver;
}
h2 {
border-bottom: 2px solid silver;
padding-top: 0.5em;
}
div.sectionbody {
font-family: serif;
margin-left: 0;
}
hr {
border: 1px solid silver;
}
p {
margin-top: 0.5em;
margin-bottom: 0.5em;
}
pre {
padding: 0;
margin: 0;
}
span#author {
color: #527bbd;
font-family: sans-serif;
font-weight: bold;
font-size: 1.2em;
}
span#email {
}
span#revision {
font-family: sans-serif;
}
div#footer {
font-family: sans-serif;
font-size: small;
border-top: 2px solid silver;
padding-top: 0.5em;
margin-top: 4.0em;
}
div#footer-text {
float: left;
padding-bottom: 0.5em;
}
div#footer-badges {
float: right;
padding-bottom: 0.5em;
}
div#preamble,
div.tableblock, div.imageblock, div.exampleblock, div.verseblock,
div.quoteblock, div.literalblock, div.listingblock, div.sidebarblock,
div.admonitionblock {
margin-right: 10%;
margin-top: 1.5em;
margin-bottom: 1.5em;
}
div.admonitionblock {
margin-top: 2.5em;
margin-bottom: 2.5em;
}
div.content { /* Block element content. */
padding: 0;
}
/* Block element titles. */
div.title, caption.title {
font-family: sans-serif;
font-weight: bold;
text-align: left;
margin-top: 1.0em;
margin-bottom: 0.5em;
}
div.title + * {
margin-top: 0;
}
td div.title:first-child {
margin-top: 0.0em;
}
div.content div.title:first-child {
margin-top: 0.0em;
}
div.content + div.title {
margin-top: 0.0em;
}
div.sidebarblock > div.content {
background: #ffffee;
border: 1px solid silver;
padding: 0.5em;
}
div.listingblock {
margin-right: 0%;
}
div.listingblock > div.content {
border: 1px solid silver;
background: #f4f4f4;
padding: 0.5em;
}
div.quoteblock > div.content {
padding-left: 2.0em;
}
div.attribution {
text-align: right;
}
div.verseblock + div.attribution {
text-align: left;
}
div.admonitionblock .icon {
vertical-align: top;
font-size: 1.1em;
font-weight: bold;
text-decoration: underline;
color: #527bbd;
padding-right: 0.5em;
}
div.admonitionblock td.content {
padding-left: 0.5em;
border-left: 2px solid silver;
}
div.exampleblock > div.content {
border-left: 2px solid silver;
padding: 0.5em;
}
div.verseblock div.content {
white-space: pre;
}
div.imageblock div.content { padding-left: 0; }
div.imageblock img { border: 1px solid silver; }
span.image img { border-style: none; }
dl {
margin-top: 0.8em;
margin-bottom: 0.8em;
}
dt {
margin-top: 0.5em;
margin-bottom: 0;
font-style: italic;
}
dd > *:first-child {
margin-top: 0;
}
ul, ol {
list-style-position: outside;
}
ol.olist2 {
list-style-type: lower-alpha;
}
div.tableblock > table {
border: 3px solid #527bbd;
}
thead {
font-family: sans-serif;
font-weight: bold;
}
tfoot {
font-weight: bold;
}
div.hlist {
margin-top: 0.8em;
margin-bottom: 0.8em;
}
td.hlist1 {
vertical-align: top;
font-style: italic;
padding-right: 0.8em;
}
td.hlist2 {
vertical-align: top;
}
@media print {
div#footer-badges { display: none; }
}
/* Workarounds for IE6's broken and incomplete CSS2. */
div.sidebar-content {
background: #ffffee;
border: 1px solid silver;
padding: 0.5em;
}
div.sidebar-title, div.image-title {
font-family: sans-serif;
font-weight: bold;
margin-top: 0.0em;
margin-bottom: 0.5em;
}
div.listingblock div.content {
border: 1px solid silver;
background: #f4f4f4;
padding: 0.5em;
}
div.quoteblock-content {
padding-left: 2.0em;
}
div.exampleblock-content {
border-left: 2px solid silver;
padding-left: 0.5em;
}
</style>
<title>Common Larceny Image Teachpack</title>
</head>
<body>
<div id="header">
<h1>Common Larceny Image Teachpack</h1>
</div>
<div id="preamble">
<div class="sectionbody">
<p>This teachpack provides primitives for constructing and manipulating images.
Vector shapes are created as outlines or solid shapes. Bitmaps can be created
from files or from lists of colors. Additional primitives
allow for the composition of images. This teachpacks is based on the PLT image
teachpack and provides the same methods as well as some new ones. Much of this
documentation is borrowed from PLT.</p>
</div>
</div>
<h2>Implementation</h2>
<div class="sectionbody">
<p>The image teachpack is designed so that it can be implemented on different
systems. For example, the provided implementation runs, in conjunction with
CommonLarceny, on the Microsoft .NET 2.0 Framework. Another implementation
for a different scheme system or GUI framework could be developed, if one
so desired.</p>
</div>
<h2>Use</h2>
<div class="sectionbody">
<p>To use the functions provided by the image teachpack, use Common
Larceny's require facility: <tt>(require "TeachPacks/image")</tt>.</p>
<h3>Background Knowledge</h3>
<p>Before diving into the list of functions provided by the teachpack, it is
important to understand some of the teachpack's data definitions.</p>
<p><strong>Mode</strong> is one of the following two symbols or strings:</p>
<div class="literalblock">
<div class="content">
<pre><tt>-- 'solid
-- 'outline
-- "solid"
-- "outline"</tt></pre>
</div></div>
<p>'solid is used for creating solid basic shapes; 'outline is used for creating
outlines of basic shapes. Strings are used in an analogous manner.</p>
<p>A <strong>CS</strong> is a color structure: <tt>(make-color N N N)</tt> where <tt>N</tt> is between 0 and 255.</p>
<p>A <strong>Color</strong> is one of:</p>
<div class="literalblock">
<div class="content">
<pre><tt>-- a color symbol, e.g., 'blue
-- a color string, e.g., "blue"
-- a CS, e.g., (make-color 0 0 255), which also denotes blue.</tt></pre>
</div></div>
<p>Color arguments are used to paint the shapes or their outlines. See below for
more information about colors. Additionally, the following predicate precisely
specifies what a valid image color is:</p>
<div class="literalblock">
<div class="content">
<pre><tt>image-color? : anything -> boolean`</tt></pre>
</div></div>
<p>The image teachpack provides the following functions, which are also provided
by the PLT image teachpack.</p>
<h3>Vector Shapes</h3>
<p><tt>rectangle : Int Int Mode Color -> Image</tt></p>
<p>Creates a rectangle using the given width, height, mode, and color</p>
<p><tt>circle : Int Mode Color -> Image</tt></p>
<p>Creates a circle using the given radius, mode, and color</p>
<p><tt>ellipse : Int Int Mode Color -> Image</tt></p>
<p>Creates an ellipse using the given width, height, and color</p>
<p><tt>triangle : Int Mode Color -> Image</tt></p>
<p>Creates an upward pointing equilateral triangle using the given edge size
and color</p>
<p><tt>star : Int[>=2] Int[>=1] Int[>=1] Mode Color -> Image</tt></p>
<p>Creates a multi-pointed star; the first number specifies the number of
points, the second specifies the radius where the points begin and the third
specifies the radius where they end.</p>
<p><tt>line : Int Int Color -> Image</tt></p>
<p>Creates an image with a colored line from (0,0) to the point with the
given coordinates</p>
<p><tt>add-line : Image Int Int Int Int Color -> Image</tt></p>
<p>Adds a line to an existing image, drawn between the two given points</p>
<p><tt>text : String Size Color -> Image</tt></p>
<p>Creates an image of the text in the given string, with the point size,
and color specified by the last two arguments</p>
<h3>Image Properties</h3>
<p>Images have many properties. To understand how functions manipulate and create
images, we need to understand one of these properties immediately: <strong>pinholes</strong>.
Each image, including primitive shapes, come with a pinhole. Usually the
pinhole is in the center of the shape except for those created from line and
text, which have pinholes at the top left. When in doubt you can always find
out where the pinhole is and even place it somewhere else:</p>
<p><tt>pinhole-x : Image -> Int</tt></p>
<p>Determines the x coordinate of the pinhole, measuring from the left of
the image</p>
<p><tt>pinhole-y : Image -> Int</tt></p>
<p>Determines the y coordinate of the pinhole, measuring down from the top
of the image</p>
<p><tt>put-pinhole : Image Int Int -> Image</tt></p>
<p>Puts the pinhole in the location specified by the arguments, counting
from the left and down from the top, respectively.</p>
<p><tt>move-pinhole : Image Int Int -> Image</tt></p>
<p>Moves the pinhole down and to the right (by the specified amounts) of
its current location. Use negative numbers to move it up or to the left.</p>
<h3>Composite Images</h3>
<p>The next group of functions build images from images:</p>
<p><tt>overlay : Image Image Image … -> Image</tt></p>
<p>Adds the pixels of the second Image onto the first image. The operation
lines up the images via their pinholes.</p>
<p><tt>overlay/xy : Image Int Int Image -> Image</tt></p>
<p>Adds the pixels of the second image onto the first image. Instead of
lining up on the pinhole, the second image's pinhole is lined up with an
offset from the first image's pinhole. The two coordinates specify how far
down and to the right the offset should be. The pinhole of the resulting
image is the same place as the pinhole in the first image.</p>
<p><tt>image-inside? : Image Image -> Boolean</tt></p>
<p>Determines whether the pixels of the second image appear in the first.</p>
<p><tt>find-image : Image Image -> Posn</tt></p>
<p>Determines where the pixels of the second image appear in the first, with
respect to the pinhole of the first image.</p>
<p>Two more properties of images are useful for image manipulations: their
width and height. The two functions for extracting these properties are:</p>
<p><tt>image-width : Image -> Int</tt></p>
<p>Obtains an Image's width in pixels</p>
<p><tt>image-height : Image -> Int</tt></p>
<p>Obtains an image's height in pixels</p>
<h3>Bitmap Images</h3>
<p>Bitmap images can be constructed from existing files or from lists of colors.</p>
<p>A <strong>List-of-color</strong> is one of:</p>
<div class="literalblock">
<div class="content">
<pre><tt>-- empty
-- (cons Color List-of-color)</tt></pre>
</div></div>
<p>A List-of-color represents a sequence of colors. It is possible to extract an
image's colors and pixels and to create images from a list of colors.</p>
<p><tt>image->color-list : Image -> List-of-color</tt>
Converts an image to a list of colors</p>
<p>color-list->image : List-of-color Nat Nat Nat Nat -> Image</p>
<p>Converts a list of colors to an image with the given width and height,
and pinhole coordinates (the pinhole coordinates are with respect to the
top-left of the image).</p>
<p>Additionally, images can be created from existing files.</p>
<p><tt>image-from-file : string -> Image</tt></p>
<p>Constructs a bitmap image from the given file path</p>
<h3>Image Manipulation</h3>
<p>The shrink functions trim an image by eliminating extraneous pixels.</p>
<p><tt>shrink-tl : Image Int Int -> Image </tt></p>
<p>Shrinks the image, starting from the top-left corner. The two numbers
indicate how many pixels to save. The pinhole of the resulting image is
in the middle of the image.</p>
<p><tt>shrink-tr : Image Int Int -> Image</tt></p>
<p>Shrinks the image, starting from the top-right corner. The two numbers
indicate how many pixels to save. The pinhole of the resulting image is in
the middle of the image.</p>
<p><tt>shrink-bl : Image Int Int -> Image</tt></p>
<p>Shrinks the image, starting from the bottom-left corner. The two numbers
indicate how many pixels to save. The pinhole of the resulting image is in
the middle of the image.</p>
<p><tt>shrink-br : Image Int Int -> Image</tt></p>
<p>Shrinks the image, starting from the bottom-right corner. The two numbers
indicate how many pixels to save. The pinhole of the resulting image is
in the middle of the image.</p>
<p><tt>shrink : Image Int Int Int Int -> Image</tt></p>
<p>Shrinks an image around its pinhole. The numbers are the pixels to save to
left, above, to the right, and below the pinhole, respectively. The pixel
directly on the pinhole is always saved.</p>
<h3>Transparency and Alpha Information</h3>
<p>The following functions extract the consitiuent colors from an image and
combine colors into an image, but the functions provide alpha-channel
information as well. Alpha channels are a measure of transparency; 0
indicates fully opaque and 255 indicates fully transparent.</p>
<p><tt>image->alpha-color-list : image -> list-of-alpha-color</tt></p>
<p>Converts an image to a list of alpha colors</p>
<p><tt>alpha-color-list->image : list-of-alpha-color int int int int -> image</tt></p>
<p>Converts a list of alpha colors to an image with the given width and
height, and pinhole coordinates (the pinhole coordinates are with respect to
the top-left of the image).</p>
<p><tt>make-alpha-color : int int int int -> color</tt></p>
<p>Constructs an alpha color</p>
<p><tt>alpha-color? : anything -> boolean</tt></p>
<p>Determines if its input is a color</p>
<p><tt>alpha-color-alpha : color -> int</tt></p>
<p>Extracts the alpha value of a color</p>
<p><tt>alpha-color-red : color -> int</tt></p>
<p>Extract the red component of a color</p>
<p><tt>alpha-color-green : color -> int</tt></p>
<p>Extracts the green component of a color</p>
<p><tt>alpha-color-blue : color -> int</tt></p>
<p>Extract the blue component of a color</p>
</div>
<div id="footer">
<div id="footer-text">
Last updated 14-Dec-2006 17:57:27 EDT
</div>
</div>
</body>
</html>
================================================
FILE: doc/CommonLarceny/image-teachpack.txt
================================================
= Common Larceny Image Teachpack
This teachpack provides primitives for constructing and manipulating images.
Vector shapes are created as outlines or solid shapes. Bitmaps can be created
from files or from lists of colors. Additional primitives
allow for the composition of images. This teachpacks is based on the PLT image
teachpack and provides the same methods as well as some new ones. Much of this
documentation is borrowed from PLT.
== Implementation
The image teachpack is designed so that it can be implemented on different
systems. For example, the provided implementation runs, in conjunction with
CommonLarceny, on the Microsoft .NET 2.0 Framework. Another implementation
for a different scheme system or GUI framework could be developed, if one
so desired.
== Use
To use the functions provided by the image teachpack, use Common
Larceny's require facility: `(require "TeachPacks/image")`.
=== Background Knowledge
Before diving into the list of functions provided by the teachpack, it is
important to understand some of the teachpack's data definitions.
*Mode* is one of the following two symbols or strings:
-- 'solid
-- 'outline
-- "solid"
-- "outline"
'solid is used for creating solid basic shapes; 'outline is used for creating
outlines of basic shapes. Strings are used in an analogous manner.
A *CS* is a color structure: `(make-color N N N)` where `N` is between 0 and 255.
A *Color* is one of:
-- a color symbol, e.g., 'blue
-- a color string, e.g., "blue"
-- a CS, e.g., (make-color 0 0 255), which also denotes blue.
Color arguments are used to paint the shapes or their outlines. See below for
more information about colors. Additionally, the following predicate precisely
specifies what a valid image color is:
image-color? : anything -> boolean`
The image teachpack provides the following functions, which are also provided
by the PLT image teachpack.
=== Vector Shapes
`rectangle : Int Int Mode Color -> Image`
Creates a rectangle using the given width, height, mode, and color
`circle : Int Mode Color -> Image`
Creates a circle using the given radius, mode, and color
`ellipse : Int Int Mode Color -> Image`
Creates an ellipse using the given width, height, and color
`triangle : Int Mode Color -> Image`
Creates an upward pointing equilateral triangle using the given edge size
and color
`star : Int[>=2] Int[>=1] Int[>=1] Mode Color -> Image`
Creates a multi-pointed star; the first number specifies the number of
points, the second specifies the radius where the points begin and the third
specifies the radius where they end.
`line : Int Int Color -> Image`
Creates an image with a colored line from (0,0) to the point with the
given coordinates
`add-line : Image Int Int Int Int Color -> Image`
Adds a line to an existing image, drawn between the two given points
`text : String Size Color -> Image`
Creates an image of the text in the given string, with the point size,
and color specified by the last two arguments
=== Image Properties
Images have many properties. To understand how functions manipulate and create
images, we need to understand one of these properties immediately: *pinholes*.
Each image, including primitive shapes, come with a pinhole. Usually the
pinhole is in the center of the shape except for those created from line and
text, which have pinholes at the top left. When in doubt you can always find
out where the pinhole is and even place it somewhere else:
`pinhole-x : Image -> Int`
Determines the x coordinate of the pinhole, measuring from the left of
the image
`pinhole-y : Image -> Int`
Determines the y coordinate of the pinhole, measuring down from the top
of the image
`put-pinhole : Image Int Int -> Image`
Puts the pinhole in the location specified by the arguments, counting
from the left and down from the top, respectively.
`move-pinhole : Image Int Int -> Image`
Moves the pinhole down and to the right (by the specified amounts) of
its current location. Use negative numbers to move it up or to the left.
=== Composite Images
The next group of functions build images from images:
`overlay : Image Image Image ... -> Image`
Adds the pixels of the second Image onto the first image. The operation
lines up the images via their pinholes.
`overlay/xy : Image Int Int Image -> Image`
Adds the pixels of the second image onto the first image. Instead of
lining up on the pinhole, the second image's pinhole is lined up with an
offset from the first image's pinhole. The two coordinates specify how far
down and to the right the offset should be. The pinhole of the resulting
image is the same place as the pinhole in the first image.
`image-inside? : Image Image -> Boolean`
Determines whether the pixels of the second image appear in the first.
`find-image : Image Image -> Posn`
Determines where the pixels of the second image appear in the first, with
respect to the pinhole of the first image.
Two more properties of images are useful for image manipulations: their
width and height. The two functions for extracting these properties are:
`image-width : Image -> Int`
Obtains an Image's width in pixels
`image-height : Image -> Int`
Obtains an image's height in pixels
=== Bitmap Images
Bitmap images can be constructed from existing files or from lists of colors.
A *List-of-color* is one of:
-- empty
-- (cons Color List-of-color)
A List-of-color represents a sequence of colors. It is possible to extract an
image's colors and pixels and to create images from a list of colors.
`image->color-list : Image -> List-of-color`
Converts an image to a list of colors
color-list->image : List-of-color Nat Nat Nat Nat -> Image
Converts a list of colors to an image with the given width and height,
and pinhole coordinates (the pinhole coordinates are with respect to the
top-left of the image).
Additionally, images can be created from existing files.
`image-from-file : string -> Image`
Constructs a bitmap image from the given file path
=== Image Manipulation
The shrink functions trim an image by eliminating extraneous pixels.
`shrink-tl : Image Int Int -> Image `
Shrinks the image, starting from the top-left corner. The two numbers
indicate how many pixels to save. The pinhole of the resulting image is
in the middle of the image.
`shrink-tr : Image Int Int -> Image`
Shrinks the image, starting from the top-right corner. The two numbers
indicate how many pixels to save. The pinhole of the resulting image is in
the middle of the image.
`shrink-bl : Image Int Int -> Image`
Shrinks the image, starting from the bottom-left corner. The two numbers
indicate how many pixels to save. The pinhole of the resulting image is in
the middle of the image.
`shrink-br : Image Int Int -> Image`
Shrinks the image, starting from the bottom-right corner. The two numbers
indicate how many pixels to save. The pinhole of the resulting image is
in the middle of the image.
`shrink : Image Int Int Int Int -> Image`
Shrinks an image around its pinhole. The numbers are the pixels to save to
left, above, to the right, and below the pinhole, respectively. The pixel
directly on the pinhole is always saved.
=== Transparency and Alpha Information
The following functions extract the consitiuent colors from an image and
combine colors into an image, but the functions provide alpha-channel
information as well. Alpha channels are a measure of transparency; 0
indicates fully opaque and 255 indicates fully transparent.
`image->alpha-color-list : image -> list-of-alpha-color`
Converts an image to a list of alpha colors
`alpha-color-list->image : list-of-alpha-color int int int int -> image`
Converts a list of alpha colors to an image with the given width and
height, and pinhole coordinates (the pinhole coordinates are with respect to
the top-left of the image).
`make-alpha-color : int int int int -> color`
Constructs an alpha color
`alpha-color? : anything -> boolean`
Determines if its input is a color
`alpha-color-alpha : color -> int`
Extracts the alpha value of a color
`alpha-color-red : color -> int`
Extract the red component of a color
`alpha-color-green : color -> int`
Extracts the green component of a color
`alpha-color-blue : color -> int`
Extract the blue component of a color
================================================
FILE: doc/CommonLarceny/user-manual.txt
================================================
= Common Larceny User Manual
The most recent revision of this manual can always be found at
http://larceny.ccs.neu.edu/doc/CommonLarceny/user-manual.html[].
== Background
=== What Is Common Larceny?
Common Larceny is a variant of Larceny, a simple and efficient run-time system
for Scheme. It is built to run on the ECMA Common Language Infrastructure
(CLI). In Common Larceny, Scheme code is compiled to Common Intermediate
Language, and is then assembled into bytecode for execution by native
just-in-time (JIT) compilers.
When used in conjunction with Microsoft's .NET Framework, which includes an
implementation of the CLI, the Common Language Runtime, Common Larceny provides
an interface to the .NET Framework class library, allowing developers to take
full advantage of dozens of predefined classes designed to facilitate
application development.
/////////////////////////////////////
This section needs to be filled in
=== Why Was Common Larceny Developed?
???
/////////////////////////////////////
=== Who Developed Common Larceny?
Common Larceny was initially developed between 2002 and 2004 by Ryan Culpepper,
Joe Marshall, Dale Vaillancourt, and others under the direction of Will Clinger
and Matthias Felleisen at Northeastern University. Felix Klock, Jesse Tov, and
Chris Burns have contributed to the latest development of Common Larceny.
== Obtaining Common Larceny
The easiest way to start using Common Larceny is to download a binary
distribution bundle. Each bundle contains a Common Larceny executable file,
and the libraries required by the executable. If you'd like to build from
source, you can do that, too. However, first you must ensure that your system
meets certain requirements.
=== System Requirements
Currently, this software is distributed for Windows on Intel x86 machines,
Microsoft .NET Framework 2.0.
Common Larceny 'may' work on other platforms (e.g. Mac OS X
with the Mono Framework 1.1) but we do not yet provide support for
those systems.
==== Common Language Infrastructure
Common Larceny requires the
http://www.ecma-international.org/publications/standards/Ecma-335.htm[
Common Language Infrastructure]. It is known to work with the
http://www.microsoft.com/net/[Microsoft .NET Framework] implementation.
In the past, some releases of Common Larceny have worked with
http://www.mono-project.com/downloads/[Mono] also, but we have
not tested the current release with Mono.
It is also conceivable that Common Larceny might work with
http://www.dotgnu.org/pnet.html[DotGNU Portable.NET] or
http://msdn.microsoft.com/net/sscli/[Microsoft Shared Source CLI (Rotor)],
but it hasn't been tried.
When using the Microsoft .NET Framework implementation of the CLI, you only
need the .NET redistributable package, but the .NET SDK contains a much richer
set of utilities and documentation.
==== Environment Variables
Common Larceny requires you to have the environment variable `LARCENY_ROOT`
defined as the root directory of your larceny distribution, e.g. `C:\Larceny\`.
For more information on managing environment variables in Windows XP, see
http://support.microsoft.com/kb/310519[Microsoft Knowledge Base Article
310519].
=== Binary Distribution
Choose one of these binary distribution bundles:
* http://www.ccs.neu.edu/home/will/Larceny/CommonLarceny/LarcenySDK.zip[
Larceny SDK (Zip bundle)]
* http://www.ccs.neu.edu/home/will/Larceny/CommonLarceny/LarcenySDK.tgz[
Larceny SDK (Gzipped TAR file)]
The `CommonLarceny.exe` executable is a console program. When it is started,
it will print a number of diagnostic lines and then enter a `read-eval-print`
loop.
_Note:_ The distributed bundles also include the `Larceny.exe`
executable. This is not a standalone application so no attempt should be
made to run the file on its own.
=== Source Distribution
If you would like to build Common Larceny from source, download the source
distribution
(http://www.ccs.neu.edu/home/will/Larceny/LarcenyReleases/\
larceny-0.93-src.tar.gz[Gzipped TAR File]). Once you have downloaded the
source distribution, the instructions below should enable you to build
Common Larceny yourself.
== Building from Source
=== Setup
To build Common Larceny from source, you will need a working version
of regular Larceny. (You might be able to use Petite Chez or MzScheme
instead, but they have not been tested recently and are not recommended.)
You will also need to have a couple of executable programs available in your
path. You may need to edit `src\Rts\DotNet\makefile` to use appropriate programs
on your system.
* You will need a working version of `make` or `nmake`.
* You will need the Intermediate Language Assembler (ILAsm). Usually,
`ilasm.exe` is located under
`\Windows\Microsoft.NET\Framework\v?.?.?\ilasm.exe`.
* You will need some version of a C preprocessor. Visual Studio comes with
`cl.exe`, the Microsoft C/C++ Compiler, which has a command-line
switch that enables it to preprocess files. Alternatively, you can use
`cpp`. See options for `larceny-setup` below.
Once you have ensured the above requirements are met, start your host Scheme
system, and change to the root of the Larceny distribution, if necessary. The
`current-directory` procedure should do the trick. Then, load the
configuration file for Common Larceny: `(load "src/Build/dotnet.sch")`
Next, you need to inform the build tool of the specifics of the host
environment. Invoke `larceny-setup` with three or four arguments:
> (larceny-setup <host-scheme> <os> <endianness> <codegen-options>)
where:
- `<host-scheme>` is a string corresponding to your Scheme system; it
must match one of the subdirectories of Compat, eg `"Petite"`,
`"MzScheme"`, `"Larceny"`
- `<os>` is a symbol, one of `'win32`, `'unix`, `'macosx`
- `<endianness>` is a symbol, one of `'little`, `'big`
- `<codegen-options>` is an optional combination of the following symbols:
* `$$'mono$$` - to build Larceny using the 'Mono' implementation of the
CLI,
* `$$'rotor$$` - to build Larceny using the 'Rotor' implementation of the
CLI,
* `$$'debug$$` - to build a debugged version of the runtime-system, and
* `$$'use-cl$$` - to use the 'Miscrosoft C/C++ Compiler', cl.exe, to
preprocess certain files needed to build the runtime-system. Without
this flag, `cpp` will be used.
For example, to build under Larceny on a Windows machine, using Microsoft's
C/C++ Compiler, you would use:
> (larceny-setup "Larceny" 'win32 'little 'use-cl)
After setting up the environment for building Larceny, evaluate the following:
> (build-config-files)
> (load-compiler)
The first procedure builds the config files (`Rts\\*.cfg`), and the second
loads the Twobit compiler. You can't load the compiler until after you have
run `larceny-setup` and `build-config-files`.
=== The .NET Heap
The next step involves building the .NET heap. After loading the compiler in
the previous step, simply evaluate:
> (make-dotnet-heap)
This procedure loads the Scheme files needed to build the .NET heap and
compiles and assembles their contained code to MSIL code in three stages. First
it compiles Scheme code to MacScheme code (`.lap` files), then assembles the
MacScheme code into s-expressions representing MSIL code, (`.lop` files), and
finally dumps these s-expressions as raw MSIL code (`.code-il` files).
Evaluating `make-dotnet-heap` produces a file in the root of the Larceny
distribution, `dotnet.heap.exe`. This is the executable file that you will run
to load Common Larceny. In bundled distributions, we rename this to
`CommonLarceny.exe`.
=== The Runtime System
Lastly, you will need to build the runtime system:
> (build-runtime-system)
This procedure will create `Scheme.dll` in the `src\Rts\DotNet` directory. The
`Scheme.dll` library contains the classes that make up the Common Larceny
runtime. Copy `Scheme.dll` into the root directory of the Larceny Distribution.
You should now have a working copy of Common Larceny in your `LARCENY_ROOT`
directory. Rename `dotnet.heap.exe` to `CommonLarceny.exe` (not necessary but
suggested) and run it to enter the interactive `read-eval-print` loop.
[[X1]]
=== CompileOnLoad
Running the `CommonLarceny.exe` executable alone loads Common Larceny as an
interpreted Scheme system. It is also possible to load Common Larceny so that
it compiles Scheme code upon load. This creates slightly longer load times,
but can improve execution times by quite a bit.
To build the fast-loading (`.fasl`) and `.exe` files used to invoke the
CompileOnLoad version of Common Larceny, first build the heap and the
runtime-system as described above. Then run:
> (build-larceny)
This will create new files in the root of your Common Larceny distribution,
namely `Larceny.exe` and `Larceny.fasl`. These files are required to run the
CompileOnLoad version of Common Larceny.
To use the CompileOnLoad version of Common Larceny, invoke the runtime with:
CommonLarceny Larceny.fasl.
=== Compiling the R6RS and ERR5RS Runtime Libraries
If you want to use Common Larceny to run R6RS or ERR5RS programs,
then you will need to compile the R6RS runtime system and the R6RS
standard libraries.
To do so, first remove any and all `.fasl` and `.slfasl` files from
the `lib/R6RS` directory and its subdirectories. Then:
CommonLarceny Larceny.fasl
> (require 'r6rsmode)
> (larceny:compile-r6rs-runtime)
This will take a very long time, and will print numerous messages
to the screen about files not found.
== Using Common Larceny
Common Larceny can be run in any of three modes:
* r5rs -- default read/eval/print loop for R5RS programs
* err5rs -- read/eval/print loop for debugging R6RS programs
* r6rs -- batch-mode execution of R6RS programs
=== R5RS Mode
To run Common Larceny in its default R5RS mode, just run the
`CommonLarceny.exe` like this:
CommonLarceny
To compile files as they are loaded, add `Larceny.fasl` to the
command line, like this:
CommonLarceny Larceny.fasl
=== ERR5RS Mode
To run Common Larceny in ERR5RS mode, add the `--err5rs`
command-line option, like this:
CommonLarceny Larceny.fasl --err5rs
=== R6RS Mode
To run R6RS programs in Common Larceny, you will need to specify
the `--r6rs` and `--program` command-line options, and may also
need to use the `--path` option.
Suppose, for example, that you want to run an R6RS program named
`myprogram.sps` that may use some of the standard R6RS libraries,
some of the ERR5RS/R6RS libraries provided by Common Larceny, and
some of the ERR5RS/R6RS SRFI libraries provided by Common Larceny,
but does not define or use any other libraries. Then you can run
the program like this:
CommonLarceny Larceny.fasl --r6rs --program myprogram.sps
If the program defines its own libraries, or uses libraries other
than those provided by Common Larceny, then you will need to tell
Common Larceny where those libraries reside by using the `--path`
command-line option or the `LARCENY_LIBPATH` environment variable,
both of which are documented in the Larceny User Manual, which is
online at http://larceny.ccs.neu.edu/doc/
=== Compiling Code to Run within Common Larceny
The same compiler that is used to compile files as they are loaded
can also be used to compile files ahead of time, which makes them
load faster.
Compiling a file with Common Larceny is now done the same way as
in native Larceny. See the Larceny User Manual, which is online
at http://larceny.ccs.neu.edu/doc/
Suppose, for example, that you want to compile two files that
contain R5RS code, `even.sch` and `odd.sch`. You can compile
them as follows:
CommonLarceny Larceny.fasl
> (compile-file "even.sch")
> (compile-file "odd.sch")
> (exit)
After the files have been compiled, you can load them into
a new session of Common Larceny by listing the names of the
compiled files on the command line, like this:
CommonLarceny Larceny.fasl even.fasl odd.fasl
You can also use the `load` procedure to load the compiled files
into a session of Common Larceny that is already running:
CommonLarceny Larceny.fasl
> (load "even.fasl")
> (load "odd.fasl")
Once compiled, a compiled file cannot be moved because its
absolute path name is wired into the compiled file. This
restriction may be removed in some future version of Common
Larceny.
================================================
FILE: doc/CommonLarceny/world-teachpack.html
================================================
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<meta name="generator" content="AsciiDoc 8.0.0" />
<style type="text/css">
/* Debug borders */
p, li, dt, dd, div, pre, h1, h2, h3, h4, h5, h6 {
/*
border: 1px solid red;
*/
}
body {
margin: 1em 5% 1em 5%;
}
a {
color: blue;
text-decoration: underline;
}
a:visited {
color: fuchsia;
}
em {
font-style: italic;
}
strong {
font-weight: bold;
}
tt {
color: navy;
}
h1, h2, h3, h4, h5, h6 {
color: #527bbd;
font-family: sans-serif;
margin-top: 1.2em;
margin-bottom: 0.5em;
line-height: 1.3;
}
h1 {
border-bottom: 2px solid silver;
}
h2 {
border-bottom: 2px solid silver;
padding-top: 0.5em;
}
div.sectionbody {
font-family: serif;
margin-left: 0;
}
hr {
border: 1px solid silver;
}
p {
margin-top: 0.5em;
margin-bottom: 0.5em;
}
pre {
padding: 0;
margin: 0;
}
span#author {
color: #527bbd;
font-family: sans-serif;
font-weight: bold;
font-size: 1.2em;
}
span#email {
}
span#revision {
font-family: sans-serif;
}
div#footer {
font-family: sans-serif;
font-size: small;
border-top: 2px solid silver;
padding-top: 0.5em;
margin-top: 4.0em;
}
div#footer-text {
float: left;
padding-bottom: 0.5em;
}
div#footer-badges {
float: right;
padding-bottom: 0.5em;
}
div#preamble,
div.tableblock, div.imageblock, div.exampleblock, div.verseblock,
div.quoteblock, div.literalblock, div.listingblock, div.sidebarblock,
div.admonitionblock {
margin-right: 10%;
margin-top: 1.5em;
margin-bottom: 1.5em;
}
div.admonitionblock {
margin-top: 2.5em;
margin-bottom: 2.5em;
}
div.content { /* Block element content. */
padding: 0;
}
/* Block element titles. */
div.title, caption.title {
font-family: sans-serif;
font-weight: bold;
text-align: left;
margin-top: 1.0em;
margin-bottom: 0.5em;
}
div.title + * {
margin-top: 0;
}
td div.title:first-child {
margin-top: 0.0em;
}
div.content div.title:first-child {
margin-top: 0.0em;
}
div.content + div.title {
margin-top: 0.0em;
}
div.sidebarblock > div.content {
background: #ffffee;
border: 1px solid silver;
padding: 0.5em;
}
div.listingblock {
margin-right: 0%;
}
div.listingblock > div.content {
border: 1px solid silver;
background: #f4f4f4;
padding: 0.5em;
}
div.quoteblock > div.content {
padding-left: 2.0em;
}
div.attribution {
text-align: right;
}
div.verseblock + div.attribution {
text-align: left;
}
div.admonitionblock .icon {
vertical-align: top;
font-size: 1.1em;
font-weight: bold;
text-decoration: underline;
color: #527bbd;
padding-right: 0.5em;
}
div.admonitionblock td.content {
padding-left: 0.5em;
border-left: 2px solid silver;
}
div.exampleblock > div.content {
border-left: 2px solid silver;
padding: 0.5em;
}
div.verseblock div.content {
white-space: pre;
}
div.imageblock div.content { padding-left: 0; }
div.imageblock img { border: 1px solid silver; }
span.image img { border-style: none; }
dl {
margin-top: 0.8em;
margin-bottom: 0.8em;
}
dt {
margin-top: 0.5em;
margin-bottom: 0;
font-style: italic;
}
dd > *:first-child {
margin-top: 0;
}
ul, ol {
list-style-position: outside;
}
ol.olist2 {
list-style-type: lower-alpha;
}
div.tableblock > table {
border: 3px solid #527bbd;
}
thead {
font-family: sans-serif;
font-weight: bold;
}
tfoot {
font-weight: bold;
}
div.hlist {
margin-top: 0.8em;
margin-bottom: 0.8em;
}
td.hlist1 {
vertical-align: top;
font-style: italic;
padding-right: 0.8em;
}
td.hlist2 {
vertical-align: top;
}
@media print {
div#footer-badges { display: none; }
}
/* Workarounds for IE6's broken and incomplete CSS2. */
div.sidebar-content {
background: #ffffee;
border: 1px solid silver;
padding: 0.5em;
}
div.sidebar-title, div.image-title {
font-family: sans-serif;
font-weight: bold;
margin-top: 0.0em;
margin-bottom: 0.5em;
}
div.listingblock div.content {
border: 1px solid silver;
background: #f4f4f4;
padding: 0.5em;
}
div.quoteblock-content {
padding-left: 2.0em;
}
div.exampleblock-content {
border-left: 2px solid silver;
padding-left: 0.5em;
}
</style>
<title>Common Larceny World Teachpack</title>
</head>
<body>
<div id="header">
<h1>Common Larceny World Teachpack</h1>
</div>
<div id="preamble">
<div class="sectionbody">
<p>The world teachpack provides two kinds of functions. Those of the first kind
allow students to simulate a small world of animated drawings and games. Those
of the second kind provide functionality for creating scenes, or composite
images with their pinholes in their upper-left hand corner.</p>
<p>This teachpack is based on the PLT world teachpack and provides the same methods
as well as some new ones. Much of this documentation is borrowed from PLT.</p>
</div>
</div>
<h2>Implementation</h2>
<div class="sectionbody">
<p>The world teachpack is designed so that it can be implemented on different
systems. For example, the provided implementation runs, in conjunction with
CommonLarceny, on the Microsoft .NET 2.0 Framework. Another implementation
for a different scheme system or GUI framework could be developed, if one
so desired.</p>
</div>
<h2>Use</h2>
<div class="sectionbody">
<p>To use the functions provided by the world teachpack, use Common
Larceny's require facility: <tt>(require "TeachPacks/world")</tt>.</p>
<h3>Background Knowledge</h3>
<p>The following functions are provided by the world teachpack. For information on
programming the world, please visit
<a href="http://www.ccs.neu.edu/home/matthias/HtDP/Worldv300/">http://www.ccs.neu.edu/home/matthias/HtDP/Worldv300/</a> for a tutorial
by Matthias Felleisen.</p>
<h3>World Functions</h3>
<p><tt>big-bang : Number Number Number World -> true</tt></p>
<p><tt>(big-bang width height n w)</tt> creates and shows a <tt>width</tt> x <tt>height</tt> canvas,
starts the clock, makes it tick every <tt>n</tt> seconds, and makes <tt>w</tt> the first world.
This function should always be evaluated last, because it actually creates the
world. Therefore, the following functions should be evaluted first, to
handle tick, keyboard, and mouse events in the world.</p>
<p><tt>on-tick-event : (World -> World) -> true</tt></p>
<p><tt>(on-tick-event tock)</tt> means that DrScheme must call <tt>tock</tt> on the current world
every time the clock ticks; it uses the result as the next world</p>
<p><tt>on-key-event : (World KeyEvent -> World) -> true</tt></p>
<p><tt>(on-key-event change)</tt> means that DrScheme must call <tt>change</tt> on the current
world and a (representation of the) keyevent for every keystroke the
programmer (user of the computer) makes; it uses the result as the next
world</p>
<p>A <strong>KeyEvent</strong> is one of:</p>
<div class="literalblock">
<div class="content">
<pre><tt>-- Char (char?)
-- Symbol (symbol?)</tt></pre>
</div></div>
<p>When the Keyevent is a char, the programmer (user of the computer) has hit an
alphanumeric key. Symbols such as <tt>'left</tt>, <tt>'right</tt>, <tt>'up</tt>, <tt>'down</tt>, <tt>'release</tt>
denote arrow keys or the events of releasing a key on the keypad.</p>
<p><tt>on-mouse-event : (World Number Number MouseEvent -> World) -> true</tt></p>
<p><tt>(on-mouse-event clack)</tt> means that DrScheme must call <tt>clack</tt> on the current
world, the current <tt>x</tt> and <tt>y</tt> coordinates of the mouse, and and a
(representation of the) mouse event for every action of the mouse the
programmer (user of the computer) makes; it uses the result as the next world</p>
<p>A <strong>MouseEvent</strong> is one of:</p>
<div class="literalblock">
<div class="content">
<pre><tt>-- 'button-down
-- 'button-up
-- 'drag
-- 'move
-- 'enter
-- 'leave</tt></pre>
</div></div>
<p>The symbols denote the appropriate action with the mouse and (any of) its
button(s).</p>
<p><tt>on-redraw : (World -> Scene) -> true</tt></p>
<p><tt>(on-redraw world->scene)</tt> means that DrScheme calls <tt>world->scene</tt> whenever the
canvas must be redrawn (usually after a tick/keyboard/mouse event has occurred);
the function consumes the current world and produces a scene, which is then
displayed in the teachpack's canvas</p>
<p><tt>end-of-time : String or Symbol -> World</tt></p>
<p>When DrScheme evaluates <tt>(end-of-time)</tt>, it stops the clock and displays the
given string or symbol; no further tick events, key events, or redraw events
take place until the world is created again.</p>
<h3>Scene Functions</h3>
<p>The rest are functions for creating scenes:</p>
<p><tt>nw:rectangle : Number Number Mode Color -> Image</tt></p>
<p><tt>(nw:rectangle width height mode color)</tt> creates a <tt>width</tt> x <tt>height</tt> rectangle,
solid or outlined, with its anchor in the NW corner</p>
<p><tt>empty-scene : Number Number -> Scene</tt></p>
<p><tt>(empty-scene width height)</tt> creates a <tt>width</tt> x <tt>height</tt> "scene" (frame with
origin in NW)</p>
<p><tt>place-image : Image Number Number Scence -> Scene</tt></p>
<p><tt>(place-image image x y scene)</tt> places <tt>image</tt> at <tt>(x,y)</tt> into scene; <tt>(x,y)</tt>
are computer graphics coordinates (origin in the upper left hand corner)</p>
<p><tt>add-line : Scene Number Number Number Number Color -> Scene</tt></p>
<p><tt>(add-line scene x0 y0 x1 y1 c)</tt> places a line of color <tt>c</tt> from <tt>(x0,y0)</tt> to
<tt>(x1,y1)</tt> into <tt>scene</tt>; <tt>(x,y)</tt> are computer graphics coordinates; in contrast
to the image teachpack's <tt>add-line</tt> function, this one cuts off those portions
of the line that go beyond the boundaries of the given scene.</p>
<p><tt>run-movie : (Listof Image) -> true</tt></p>
<p><tt>(run-movie loi)</tt> shows the list of images in loi, time-delayed</p>
<p>Finally, the teachpack provides all the functions that image teachpack provides
except <tt>add-line</tt>, which has a slightly different functionality.</p>
</div>
<h2>Examples</h2>
<div class="sectionbody">
<p>The files in <tt>lib/TeachPacks/Demos</tt> show how to
create worlds and simple animations. They are derived from Matthias's demo
(see above).</p>
</div>
<div id="footer">
<div id="footer-text">
Last updated 14-Dec-2006 17:57:23 EDT
</div>
</div>
</body>
</html>
================================================
FILE: doc/CommonLarceny/world-teachpack.txt
================================================
= Common Larceny World Teachpack
The world teachpack provides two kinds of functions. Those of the first kind
allow students to simulate a small world of animated drawings and games. Those
of the second kind provide functionality for creating scenes, or composite
images with their pinholes in their upper-left hand corner.
This teachpack is based on the PLT world teachpack and provides the same methods
as well as some new ones. Much of this documentation is borrowed from PLT.
== Implementation
The world teachpack is designed so that it can be implemented on different
systems. For example, the provided implementation runs, in conjunction with
CommonLarceny, on the Microsoft .NET 2.0 Framework. Another implementation
for a different scheme system or GUI framework could be developed, if one
so desired.
== Use
To use the functions provided by the world teachpack, use Common
Larceny's require facility: `(require "TeachPacks/world")`.
=== Background Knowledge
The following functions are provided by the world teachpack. For information on
programming the world, please visit
http://www.ccs.neu.edu/home/matthias/HtDP/Worldv300/[] for a tutorial
by Matthias Felleisen.
=== World Functions
`big-bang : Number Number Number World -> true`
`(big-bang width height n w)` creates and shows a `width` x `height` canvas,
starts the clock, makes it tick every `n` seconds, and makes `w` the first world.
This function should always be evaluated last, because it actually creates the
world. Therefore, the following functions should be evaluted first, to
handle tick, keyboard, and mouse events in the world.
`on-tick-event : (World -> World) -> true`
`(on-tick-event tock)` means that DrScheme must call `tock` on the current world
every time the clock ticks; it uses the result as the next world
`on-key-event : (World KeyEvent -> World) -> true`
`(on-key-event change)` means that DrScheme must call `change` on the current
world and a (representation of the) keyevent for every keystroke the
programmer (user of the computer) makes; it uses the result as the next
world
A *KeyEvent* is one of:
-- Char (char?)
-- Symbol (symbol?)
When the Keyevent is a char, the programmer (user of the computer) has hit an
alphanumeric key. Symbols such as `'left`, `'right`, `'up`, `'down`, `'release`
denote arrow keys or the events of releasing a key on the keypad.
`on-mouse-event : (World Number Number MouseEvent -> World) -> true`
`(on-mouse-event clack)` means that DrScheme must call `clack` on the current
world, the current `x` and `y` coordinates of the mouse, and and a
(representation of the) mouse event for every action of the mouse the
programmer (user of the computer) makes; it uses the result as the next world
A *MouseEvent* is one of:
-- 'button-down
-- 'button-up
-- 'drag
-- 'move
-- 'enter
-- 'leave
The symbols denote the appropriate action with the mouse and (any of) its
button(s).
`on-redraw : (World -> Scene) -> true`
`(on-redraw world->scene)` means that DrScheme calls `world->scene` whenever the
canvas must be redrawn (usually after a tick/keyboard/mouse event has occurred);
the function consumes the current world and produces a scene, which is then
displayed in the teachpack's canvas
`end-of-time : String or Symbol -> World`
When DrScheme evaluates `(end-of-time)`, it stops the clock and displays the
given string or symbol; no further tick events, key events, or redraw events
take place until the world is created again.
=== Scene Functions
The rest are functions for creating scenes:
`nw:rectangle : Number Number Mode Color -> Image`
`(nw:rectangle width height mode color)` creates a `width` x `height` rectangle,
solid or outlined, with its anchor in the NW corner
`empty-scene : Number Number -> Scene`
`(empty-scene width height)` creates a `width` x `height` "scene" (frame with
origin in NW)
`place-image : Image Number Number Scence -> Scene`
`(place-image image x y scene)` places `image` at `(x,y)` into scene; `(x,y)`
are computer graphics coordinates (origin in the upper left hand corner)
`add-line : Scene Number Number Number Number Color -> Scene`
`(add-line scene x0 y0 x1 y1 c)` places a line of color `c` from `(x0,y0)` to
`(x1,y1)` into `scene`; `(x,y)` are computer graphics coordinates; in contrast
to the image teachpack's `add-line` function, this one cuts off those portions
of the line that go beyond the boundaries of the given scene.
`run-movie : (Listof Image) -> true`
`(run-movie loi)` shows the list of images in loi, time-delayed
Finally, the teachpack provides all the functions that image teachpack provides
except `add-line`, which has a slightly different functionality.
== Examples
The files in `lib/TeachPacks/Demos` how to create worlds and simple
animations. They are derived from Matthias's demo (see above).
================================================
FILE: doc/DevManual/auxlib.txt
================================================
Auxiliary Library
~~~~~~~~~~~~~~~~~
[WARNING]
================================================================
Most of the information in this section is obsolete or
obsolescent. Larceny's libraries have been reorganized
several times since this chapter was written, and will
undergo even more rapid reorganization during Larceny's
transition to ERR5RS/R6RS libraries.
================================================================
Larceny's library is split into two parts: the basis library and the
auxiliary library. The basis library is the library in the basis heap
image ("larceny.heap"), which is produced by the development
environment; this library consists of all standard procedures and
macros and a number of Larceny-specific extensions. The auxiliary
library consists of files in the Auxlib subdirectory and contains many
generally useful Scheme procedures.
The library is split because it reduces the turnaround time for a
system build, a limiting factor during the development of Larceny. The
auxiliary library is incorporated into the heap image by compiling it,
loading it, and then dumping the heap.
==== List procedures
aremq!
aremv!
aremove!
filter
find
least
greatest
mappend
make-list
reduce
reduce-right
fold-left
fold-right
iota
list-head
==== String Procedures
substring-match
substring-match-ci
->string
string-insert!
==== Vector Procedures
vector-copy
==== I/O Procedures
pretty-print
pretty-line-length
read-line
read-substring
write-substring
file-modification-time
file-newer?
absolute-pathname?
relative-pathname?
make-pathname
==== Load
load-noisily [filename]
load-quietly [filename]
load
*load-print-filename*
*load-prefer-requested*
*load-path*
*load-extensions*
================================================
FILE: doc/DevManual/bdw.txt
================================================
Using the Boehm-Demers-Weiser conservative GC
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
INSERT INTRODUCTORY TEXT HERE (bdw.txt).
////////////////////////////////////
==== Contents
[1. Introduction][1]
[2. Installation][2]
[3. Configuration and build][3]
[4. Use][4]
[5. Performance measurements][5]
////////////////////////////////////
==== Introduction
Larceny can be configured to use the Boehm-Demers-Weiser conservative garbage collector (in the following called "the collector"). The collector is covered by the following copyright notice:
_
Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved.
Copyright (c) 1996-1998 by Silicon Graphics. All rights reserved.
THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
Permission is hereby granted to use or copy this program for any purpose, provided the above notices are retained on all copies. Permission to modify the code and to distribute modified code is granted, provided the above notices are retained, and a notice that the code was modified is included with the above copyright notice.
_
==== Installation
I have tested version 4.14 of the collector with Larceny. Integration is straightforward, although you must build a separate version of larceny (called bdwlarceny) that uses the collector - you can't build a Grand Unified executable that lets you select the conservative collector with a command line switch.
The collector is not part of the Larceny distribution file - you must get it and install it separately.
Download the collector from Hans Boehm's web site at [ http://www.hpl.hp.com/personal/Hans_Boehm/gc/][6], and give it a name; I usually call it something like bdw-gc-4.14.tar.gz. Whatever you call it, you should have a .tar.gz file, and you should place it in the directory $LARCENY (cf. the [setup instructions][7]). Edit the file $LARCENY/Makefile so that the value of the variable BDW_DIST corresponds to the name of the archive that holds the collector.
When in $LARCENY, type
make bdw_unpack
and the archive will be unpacked and moved to the correct location, which is the directory $LARCENY/Rts/bdw-gc.
==== Configuration and build
===== Setup
The file Rts/bdw-gc/Makefile as distributed by Boehm defines the C compiler to be 'cc'. You may want to change this to be the compiler you use to compile Larceny, which, on SunOS systems, will most certainly not be the standard 'cc'. I've been using gcc without problems.
In the definition of CFLAGS near the top of the Makefile:
* You may want to change -O to -O3 (or higher).
* Yoy may want to add -g to aid in debugging.
* You must remove -DNO_EXECUTE_PERMISSION.
* -DALL_INTERIOR_POINTERS is no longer required and may be removed.
===== Installing hooks
(This is optional, but recommended.)
The collector does not itself provide a mechanism whereby user code can be called at the beginning and end of garbage collections, so I've created one. It requires some trivial code modification.
Add the line
#include "../Sys/bdw.h"
to the file Rts/bdw-gc/alloc.c, following the other include files. This header file redefines two macros used by the collector, STOP_WORLD and START_WORLD, and makes them call the procedures bdw_before_gc and bdw_after_gc, respectively. (Those are defined in Rts/Sys/bdw-collector.c.)
Performing this step is recommended because it enables performance measurements, detection of in-line allocation, and clearing of the unused portion of the stack before each collection. Even so, not all GC time is accounted for, in particular any time spent in lazy sweeping is not recorded.
===== Build
The collector will now be built when you build bdwlarceny: go to $LARCENY and type
make bdwlarceny
===== Using newer versions of the collector
It is probable that any newer version of the collector can be subsitituted for version 4.14. If you do use a newer version, check the collector's config.h file to make sure that the symbol ALIGN_DOUBLE is defined for the SPARC architecture (on line 477 in version 4.14).
==== Use
_You may not run Scheme code that has been compiled with in-line allocation._ In its default configuration, and if the hooks have been installed [as explained above][8], the run-time system will detect such attempts (after the fact, but in a reliable manner), and abort the program. While it would be possible for the system to recover from such attempts, the performance of the resulting programs would most likely be very poor, and I'm not going to bother.
It is in your best interest to use split heaps, as explained in the manual ([Reorganizing a heap image][9]), but this is not required.
==== Performance measurements and statistics
Larceny's interface to the collector is not yet full-fledged; many run-time statistics are not gathered because the collector does not provide the necessary hooks. In an effort to make it possible to learn at least something about performance, the [previously mentioned hooks][8] have been provided.
The collector uses lazy sweeping, so the time measurements you get are at best a lower bound on GC time, and probably not an accurate statistic. It's better than nothing. It is also reasonably straightforward to account for the time spent in lazy sweeping, but outside the scope of this release.
* * *
_$Id: bdw.html 1480 2000-09-12 21:23:07Z lth $_
[larceny@ccs.neu.edu][10]
[1]: #intro
[2]: #install
[3]: #config
[4]: #use
[5]: #measuring
[6]: http://www.hpl.hp.com/personal/Hans_Boehm/gc/
[7]: compiling.html
[8]: #hooks
[9]: starting.html#reorg
[10]: mailto:larceny@ccs.neu.edu
================================================
FILE: doc/DevManual/bytevectors.txt
================================================
Bytevectors
~~~~~~~~~~~
A _bytevector_ is a data structure that stores bytes -- exact
8-bit unsigned integers. Bytevectors are useful in constructing
system interfaces and other low-level programming. In Larceny,
many bytevector-like structures -- strings, bignums, and even
bytevectors themselves -- are implemented in terms of a
lower-level _bytevector-like_ data type. The operations on
generic bytevector-like structures are particularly fast but
useful largely in code that manipulates Larceny's data
representations.
The R6RS <<BytevectorsLibrary, bytevectors library>> now
provides a large set of procedures that, in Larceny, are
defined using the procedures described below.
proc:make-bytevector[kind="Integrable procedure",args="length",result="bytevector"]
proctempl:make-bytevector[kind="Integrable procedure",args="length fill",result="bytevector"]
Returns a bytevector of the desired length.
If no second argument is given, then the bytevector has not
been initialized and most likely contains garbage.
_Operations on bytevector structures_
proctempl:bytevector?[args="obj",result="boolean"]
proctempl:bytevector-length[args="bytevector",result="integer"]
proctempl:bytevector-ref[args="bytevector offset",result="byte"]
proctempl:bytevector-set![args="bytevector offset byte",result="unspecified"]
proctempl:bytevector-equal?[args="bytevector1 bytevector2",result="boolean"]
proctempl:bytevector-fill![args="bytevector byte",result="unspecified"]
proctempl:bytevector-copy[args="bytevector",result="bytevector"]
These procedures do what you expect. All procedures are integrable, except bytevector-equal? and bytevector-copy.
_Operations on bytevector-like structures_
proctempl:bytevector-like?[args="obj",result="boolean"]
proctempl:bytevector-like-length[args="bytevector",result="integer"]
proctempl:bytevector-like-ref[args="bytevector offset",result="byte"]
proctempl:bytevector-like-set![args="bytevector offset byte",result="unspecified"]
proctempl:bytevector-like-equal?[args="bytevector1 bytevector2",result="boolean"]
proctempl:bytevector-like-copy[args="bytevector",result="bytevector"]
A bytevector-like structure is a low-level representation on which data that are indexable like bytevectors are built, e.g., bytevectors, strings, bignums, and flonums.
There is no way of constructing a "generic" bytevector-like structure; use the constructors for the data mapped onto bytevector-like structures instead, like make-string or make-bytevector.
The bytevector-like operations operate on all bytevector-like structures. All the procedures are integrable, except bytevector-like-equal? and bytevector-like-copy.
================================================
FILE: doc/DevManual/compiling.txt
================================================
Compiling and Installing Larceny
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
INSERT INTRODUCTORY TEXT HERE (compiling.txt).
[WARNING]
================================================================
This text is absurdly out of date. You're better off reading
link:HOWTO-BUILD[].
================================================================
///////////////////////////////////
==== Contents
[1. Source distribution format][1]
[2. Requirements][2]
[3. Installation][3]
[4. Creating the heap images][4]
///////////////////////////////////
==== Source distribution format
Larceny is distributed as a gzipped tar file that contains the sources
for the compiler, the run-time system, and the Scheme libraries, and
everything needed to build the system (short of a host Scheme
implementation and the conservative garbage collector, if you'll be
using that). The name of the archive is larceny-_X.Y_-src.tar.gz,
where _Z.Y_ is the version number.
In the distribution directory you will also find archives of
precompiled binaries and heap images for Larceny; the archives are
named larceny-_X.Y_-sunos_Z_-bin.tar.gz where _Z_ is 4 or 5.
==== Requirements
A host Scheme system is needed to compile the Larceny Scheme
sources. Any version of Larceny is suitable, as is Chez Scheme version
5. (Chez Scheme version 4 has worked in the past, also.) See Step 5
below for details.
==== Installation
===== Step 1: Unpack
Unpack the source archive as discussed in the [Introduction][5].
===== Step 2: Configure
Edit the file _Rts/Makefile_ to reflect your environment and
experimental needs. Normally, there's nothing you need to do here. If
you do need to do something, then the comments in the makefile will
guide you.
Some older Sparc machines have strange instruction cache behavior that must be dealt with specially by editing the Makefile. Click [here][6] for more information about this.
If you are planning on building the system with the
Boehm-Demers-Weiser conservative garbage collector, then you should
read [this][7] for more information about other setup steps you need
to perform.
===== Step 3: Create the bootstrap setup
Before anything else can be done, the build directories must be
configured. That is done by executing the command
make setup
That command will edit the "build" script, set up some symbolic links
in the source tree, and compile some C programs used by the
development system.
===== Step 4: Compiling the system
To create the Larceny executable, execute the command
make larceny.bin
or, if you are compiling the system with the conservative collector,
make bdwlarceny.bin
You are now the proud owner of a Larceny executable, called either
larceny.bin or bdwlarceny.bin.
===== Step 5: Building the heap image
The heap image is built using a Scheme-based compiler, so you need a
working Scheme system. Normally, you can use a previously built
version of Larceny as your development environment. If for some reason
you can't use a previously built version of Larceny, you can use
another Scheme system.
We have built Larceny with Chez Scheme, MacScheme, and Gambit-C; a
compatibility library for Chez Scheme is included in the
distribution. If you have neither of these host systems, contact us,
as setting up a new host system can be a little hairy.
The system you are using as the host system needs to be configured in
to the _build_ script: set the BUILD_HOST variable at the top to a
string that identifies your system (see comments in the file).
Now execute the command
build
When the Scheme prompt appears, create the heap image by evaluating
the expression
(make-sparc-heap)
All Scheme source files will now be compiled and then dumped in a heap
image with the name sparc.heap.
More information about how to use the development system for more
interesting things, including how to compile the compiler, is
available [here][8].
To find out how to run Larceny, click [here][9].
==== Creating the heap images
First compile the development system as detailed [here][10].
Some Scheme scripts are supplied in the Util subdirectory that are
helpful in (re)creating the heap images distributed with Larceny:
larceny.heap, twobit.heap, and r5rs.heap. These files are called
std-heap.sch, twobit-heap.sch, and r5rs-heap.sch. They may _only_ be
loaded into a process that was started with the command line
larceny.bin -stopcopy sparc.heap
where `sparc.heap` is a heap that was created as in step 3 above.
(The -stopcopy switch is needed because the generational collector
does not yet do heap dumping.)
To build a heap image, start larceny.bin as outlined above and load
the desired script ("Util/std-heap.sch", "Util/twobit-heap.sch", or
"Util/r5rs-heap.sch") into the interpreter. The script will load the
necessary files, dump a heap image, and then run larceny on the image
to reorganize it (splitting code and data, as it were). Once you've
built a heap, you should not use the same running process to build
another, and it is most useful to quit and restart.
* * *
_$Id: compiling.html 434 1998-12-21 21:23:26Z will $_
[larceny@ccs.neu.edu][11]
[1]: #distribution
[2]: #requirements
[3]: #installation
[4]: #heaps
[5]: intro.html
[6]: sparc-cache.html
[7]: bdw.html
[8]: developing.html
[9]: starting.html
[10]: developing.html#larceny
[11]: mailto:larceny@ccs.neu.edu
================================================
FILE: doc/DevManual/concept.txt
================================================
Concept Index
~~~~~~~~~~~~~
///////////////////////////////////////////////////////////////////////
We should be able to create the contents of this automatically, right?
///////////////////////////////////////////////////////////////////////
This is an alphabetical listing of concepts. It needs to be improved; on the other hand, if you know the general topic you're interested in, then go directly to the page for that topic using the topic index in the [User's Manual][1].
[Bootstrapping Larceny][2]
[Command line format overview][3]
[Compiling files][4]
[Compiler switches][5]
[Creating the heap images][6]
[Developers' command line options][7]
[Developing under Chez Scheme][8]
[Developing under Larceny][9]
[Development system overview][10]
[Development system startup][11] [File name conventions][12]
[GC policy options (precise GC)][13]
[GC policy options (conservative gc)][14]
[General command line options][15]
[Heap allocation options (precise GC)][16]
[Installing Larceny][17]
["Make" facility][18]
[Reorganizing a heap image][19]
[Requirements for compilation][20]
[Running Larceny (precise GC)][21]
[Running Larceny (conservative GC)][22]
[Source distribution format][23]
[Startup file][24]
procedure information
top-level environments
* * *
_$Id: concept.html 392 1998-12-19 16:22:30Z lth $_
[larceny@ccs.neu.edu][25]
[1]: manual.html#contents
[2]: developing.html#bootstrap
[3]: starting.html#summary:general
[4]: developing.html#compiling
[5]: developing.html#switches
[6]: compiling.html#heaps
[7]: starting.html#developer
[8]: developing.html#chez
[9]: developing.html#larceny
[10]: developing.html#overview
[11]: developing.html#starting
[12]: developing.html#naming
[13]: starting.html#policy:precise
[14]: starting.html#policy:conservative
[15]: starting.html#general
[16]: starting.html#heap:precise
[17]: compiling.html#installation
[18]: developing.html#make
[19]: starting.html#reorg
[20]: compiling.html#requirements
[21]: starting.html#summary:precise
[22]: starting.html#summary:conservative
[23]: compiling.html#distribution
[24]: starting.html#startup-file
[25]: mailto:larceny@ccs.neu.edu
================================================
FILE: doc/DevManual/control.txt
================================================
Control Features
~~~~~~~~~~~~~~~~
For more information about the countdown timer and timer interrupts, see
link:LarcenyNotes/note1-timer.html[the note on timer interrupts].
proc:add-exit-procedure![args="thunk",result="unspecified"]
add-exit-procedure! adds _thunk_ to the list of procedures that are
run when the Scheme process terminates (either by a call to <<ProcExit,exit>>
or when end-of-file is detected at the interactive prompt). The
procedures are run in the opposite order of that in which they were
added.
proc:add-init-procedure![args="thunk",result="unspecified"]
add-init-procedure! adds _thunk_ to the list of procedures that are
run when the Scheme process is restarted from a dumped heap image. The
procedures are run in the order in which they were added.
proc:call-without-interrupts[args="thunk",result="object"]
Call _thunk_, disabling timer interrupts in its dynamic extent. Returns the value(s) returned by the call to _thunk_.
proc:decode-error[args="error",optarg="port",result="unspecified"]
Prints a human-readable form of _error_ on the _port_, or on the current output port if _port_ is not supplied.
The _error_ is a list as obtained by the error handler, as in the following example where the error handler prints the error and then resets the system:
(error-handler
(lambda error
(decode-error error)
(reset)))
proc:disable-interrupts[args="none",result="ticks-remaining or #f"]
Disables timer interrupts and returns the number of ticks remaining on the clock before the next interrupt, or #f if interrupts were already disabled.
proc:enable-interrupts[args="timer-value",result="unspecified"]
Enables timer interrupts and sets the countdown timer to _timer-value_, which must be a positive fixnum.
proc:error[args="arg ...",result="unspecified"]
The error procedure applies the currently installed error handler (see <<error-handler>>) to _arg ..._.
anchor:error-handler[]
indexterm:[error-handler]
_Parameter error-handler_
The value of the error-handler parameter is a procedure of one or more arguments. The first argument is a key that indicates where the error occurred. If the key is an exact integer, then the error occurred in a primitive or system subroutine, and the integer is the system error code; additional arguments are arguments to the primitive that failed. If the key is the empty list, then it should be ignored. Otherwise, it is part of an error message signalled with 'error' (which calls the installed error handler).
The default error handler prints an appropriate error message and then calls reset.
proc:eval[args="datum",optarg="environment",result="value ..."]
Eval conforms to the specification in the R5RS but additionally allows a <<environ,first-class environment>> to be used in place of the environment-specifier. If no environment or environment-specifier is used, the current interaction environment is used.
Eval just calls the current value of the <<evaluator>> parameter on its arguments.
anchor:evaluator[]
indexterm:[evaluator]
_Parameter evaluator_
The value of this parameter is a procedure of one or two arguments: an expression to be evaluated and optionally an environment. The eval procedure calls the value of evaluator.
proc:ProcExit[var="exit"]
proctempl:exit[args="none",result="never returns"]
proctempl:exit[args="value",result="never returns"]
exit runs any exit procedures installed by <<add-exit-procedure!>> and then terminates the Scheme process. The optional argument is the exit status to return to the parent process. The default exit status is 0.
anchor:keyboard-interrupt-handler[]
indexterm:[keyboard-interrupt-handler]
_Parameter keyboard-interrupt-handler_
This parameter takes a value that is a procedure of no arguments. The procedure is called whenever a keyboard interrupt is received by the system. In the current system, a keyboard interrupt can be received in a critical section; the keyboard interrupt handler is called with the interrupt enable state unchanged.
If the keyboard interrupt handler returns, the interrupted computation will continue execution.
anchor:load-evaluator[]
indexterm:[load-evaluator]
_Parameter load-evaluator_
The value of the parameter load-evaluator is a procedure of two arguments. The procedure is called to evaluate an expression loaded from a source file.
proc:quit[args="none",result="unspecified"]
Quit calls the currently installed quit handler (see <<quit-handler>>).
anchor:quit-handler[]
indexterm:[quit-handler]
_Parameter quit-handler_
The value of this parameter is a procedure of no parameters. The initial value of quit-handler is exit, though the <<repl,read-eval-print loop>> sets up its own quit handler.
proc:reset[args="none",result="unspecified"]
Reset calls the currently installed reset handler (see <<reset-handler>>).
anchor:reset-handler[]
indexterm:[reset-handler]
_Parameter reset-handler_
The value of the reset-handler parameter is a procedure of an arbitrary number of arguments. The default reset handler terminates the program; the read-eval-print loop installs a new handler that instead returns control to the read-eval-print loop.
anchor:standard-timeslice[]
indexterm:[standard-timeslice]
_Parameter standard-timeslice_
The value of this parameter is a positive fixnum that will be used to reinitialize the countdown timer on expiration.
Using the value returned from standard-timeslice rather than some arbitrary integer value allows you to write programs that manipulate the interrupt enable flag without hard-coding timer values into your program. The value returned is normally very large, ensuring minimal interrupt overhead to the program. However, tasking systems will want to change the timeslice value to ensure reasonable task switching behavior; the "best" setting depends on the system on which Larceny is running and can presumably be computed by the tasking system, if desired.
For what it's worth, a setting of 50000 gives OK interrupt behavior on a Sparc-10 system, about 10 interrupts per second. This of course depends on the actual code running.
anchor:timer-interrupt-handler[]
indexterm:[timer-interrupt-handler]
_Parameter timer-interrupt-handler_
The value of this parameter is a procedure of no arguments. The procedure is called with interrupts disabled when a timer interrupt is received and the interrupt enable state is "enabled".
proc:typetag[args="object",result="fixnum"]
Returns the typetag of _object_ if _object_ is boxed, and signals an error if it is not boxed.
Typetags are documented link:LarcenyNotes/note2-repr.html[elsewhere].
proc:typetag-set![args="object typetag",result="unspecified"]
Sets the typetag of _object_ to _typetag_, if _object_ is boxed, and signals an error if it is not boxed.
Typetags are documented [elsewhere][10].
* * *
_$Id: control.html 1470 2000-09-12 02:46:47Z lth $_
[larceny@ccs.neu.edu][11]
[9]: #proc:reset-handler
[11]: mailto:larceny@ccs.neu.edu
================================================
FILE: doc/DevManual/developing.txt
================================================
Using The Development System
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[WARNING]
================================================================
This section is woefully out of date.
================================================================
///////////////////////////////////////////////////////////////////////
== Contents
[1. Overview][1]
[2. Starting the development system][2] [3. File name conventions][3]
[4. Compiling][4]
[5. Compiler switches][5] (wiki name: DevelopingSwitches )
[6. The "make" facility][6]
[7. Developing under Chez Scheme][7]
[8. Developing under Larceny][8]
[9. Bootstrapping][9]
///////////////////////////////////////////////////////////////////////
==== Overview
The development system is a Scheme application that runs inside a
Scheme host system. Currently, the host Scheme system can be either
Chez Scheme (we use version 5) or Larceny.
The development system contains the Twobit compiler and the selected
target assembler (currently only a SPARC assembler is operational). A
Scheme-based "make" utility is also available.
For the novice, the most important command in the development
environment is
(help)
which is a simple, interactive help system for the developer.
==== Starting the development system
You start the development system with the command build on the Unix command line, after [configuring and compiling][10] the support code. build accepts several command line switches, as shown below; you can also type build -help. If you start it without options, it will use Larceny as the host system, and will load the SPARC assembler.
-a argument ... or -arguments argument ... Pass the arguments on the command line to the host Scheme system. This switch must be the last switch on the build command line.
-c or -chez Use Chez Scheme as the host system.
-h or -help Print a command summary.
-i or -interpreted Load the Scheme source files for the development environment, even if compiled versions that are newer exist.
-l or -larceny Use the installed version of Larceny as the host system (the shell script "larceny" in your path).
-lb or -larceny.bin Use larceny.bin as the host system (the file "larceny.bin" in the directory in which build was configured).
-sparc Load the SPARC assembler.
-v Display the names of all development system files loaded, as they are loaded.
==== File name conventions
The following table lists the file name extensions that by convention are used by the development environment. While it is often possible for you to use other extensions, the development environment may not always do what you expect; for example, if you compile "foo.sch" you get "foo.fasl", but if you compile "foo.s", you will end up with "foo.s.fasl".
**.sch** or **.scm**: Scheme source files. **.lap**: Compiled files in tokenized form ("Lisp Assembly Program"). **.mal**: MacScheme assembly language source. **.lop**: Compiled and assembled files in tokenized form ("Lisp Object Program"). **.fasl**: Compiled and assembled files in directly-loadable form ("Fastload"). **.heap**: Larceny heap images.
==== Compiling
===== Rebuilding the heap image
The command
(make-sparc-heap)
recompiles any changed files in the Lib, Repl, and Eval subdirectories, and rebuilds "sparc.heap" from the resulting object files. You need to rebuild the heap every time you change any files in these subdirectories, since loading them into the interactive system will not have any effect on their use in the procedures compiled into the heap.
===== Rebuilding the development environment
You can compile the various pieces of the development environments with the commands listed below. These commands, as well as file lists for each and the rules used in compilation, are defined in the file Lib/makefile.sch (see the next section for more about the Make utility). Common to all of these commands is that if you pass an extra argument (anything will do), then instead of doing the rebuild, the command will just print out what it would have done had you asked for a build.
(make-auxlib) Rebuilds all the files in the Auxlib subdirectory. These include a pretty printer, sorting procedures, and utility procedures that are not in the basic heap image.
(make-compat) Rebuilds the Larceny compatibility package.
(make-compiler) Rebuilds all the files in the Compiler subdirectory, and some files in Asm/Common.
(make-development-environment) Rebuilds the compiler, the Sparc assembler, the Larceny compatibility package, and the Auxlib directory, and in addition creates Lib/makefile.fasl.
(make-sparcasm) Rebuilds the Sparc assembler files and any common assembler files not built by make-compiler.
===== Single-file compiling
(compile-file _source-file-name_)
(compile-file _source-file-name_ _target-file-name_) Compile-file compiles a Scheme source file directly to a fastload-format target file. If _target-file-name_ is not specified, the output file will be the name of the source file with extension **.fasl**.
(compile313 _source-file-name_)
(compile313 _source-file-name_ _target-file-name_) Compiles a Scheme source file to LAP format.
(assemble313 _source-file-name_)
(assemble313 _source-file-name_ _target-file-name_) Compiles a LAP or MAL format source file to LOP format.
(make-fasl _source-file-name_)
(make-fasl _source-file-name_ _target-file-name_) Translates a LOP format source file to a fastload format file.
===== Disassembly
(disassemble-file _source-file-name_)
(disassemble-file _source-file-name_ _target-file-name_) Disassembles a LOP format file. The disassembly is printed to the current output port, or, if a target file name is given, to the target file.
[[DevelopingSwitches]]
==== Compiler switches
The command
(compiler-switches)
lists all the compiler switches. See the online help for more information about how to set and reset switches.
The command
(compiler-switches _flag_)
sets groups of compiler switches according to the value of the symbol _flag_. The flags are slow, standard, fast-safe, fast-unsafe, and factory-settings. See the online help for more information about the flags and their effects.
If you are willing to compromise safety a little, you should turn off catch-undefined-globals. Normally, compiled code checks every global access to see whether the value fetched was the special value #!undefined, triggering an error if it was. This check adds a test to every read from a global variable.
If you use (compiler-switches 'fast-unsafe), most type checking in the compiled code will then be disabled. Type checking will still be performed by library procedures, however. The truly needy may feel free to recompile the heap image with safety turned off. Be warned that Larceny does not currently catch SIGSEGV or SIGBUS, so any wrong step on your part will likely crash the system.
==== The "make" facility
UTSL (specifically, Util/make.sch).
==== Developing under Chez Scheme
A facility is available in the Chez Scheme based development environment that makes starting the environment much faster. When in the development environment, the command
(chez-compile-files)
will compile most of the Scheme files used by the development environment into Chez Scheme object modules (.so type) in their respective directories. The next time you enter the development environment, the object files will be loaded in preference of the Scheme files. However, if a Scheme file has been modified since its object file was created, the Scheme file is loaded instead.
==== Developing under Larceny
If you're using the installed Larceny for development, you can cut down the time it takes to load the compiler by precompiling the development environment to .fasl files. When in the development environment, execute
(make-development-environment)
to compile all the pertinent files. Then run build to run Larceny with the compiled development environment. As for the Chez Scheme environment, if a Scheme file is modified after it has been compiled, the source file will be loaded rather than the compiled file.
==== Bootstrapping
Here's how I do it.
* Build the basic heap image with Chez Scheme.
* Either build the compiler files with Chez Scheme, or load the development environment into Larceny's interpreter, and build the compiler files.
* Load the compiler development environment into Larceny, and rebuild everything.
Also see the file Testsuite/Scripts/autobuild-precise.
* * *
_$Id: developing.html 1116 1999-11-02 16:38:38Z lth $_
[larceny@ccs.neu.edu][11]
[1]: #overview
[2]: #starting
[3]: #naming
[4]: #compiling
[5]: #switches
[6]: #make
[7]: #chez
[8]: #larceny
[9]: #bootstrap
[10]: compiling.html
[11]: mailto:larceny@ccs.neu.edu
================================================
FILE: doc/DevManual/environ.txt
================================================
anchor:environ[]
Environments
~~~~~~~~~~~~
Environments are a deprecated feature of Larceny.
(During Larceny's conversion to R6RS, all programs
that use environments are likely to break.
If the documentation that follows were not needed
by the Larceny developers themselves, it would have
been removed from this user manual.)
Larceny's top-level environments are implemented using
first-class environment data structures. Environments can
be created and manipulated by user code and are occasionally
useful to isolate computations or provide restricted namespaces.
proc:make-environment[args="name",result="env"]
Make-environment creates a new environment with the given _name,_ a string.
proc:environment?[args="obj",result="bool"]
Returns #T iff _obj_ is an environment.
proc:environment-name[args="env",result="name"]
Returns the _name_ that was given to _make-environment._
proc:environment-get-cell[args="env id",result="cell"]
Returns the cell for the variable _id_ in environment _env._ Signals an error if _id_ denotes a macro in _env._
proc:environment-variables[args="env",result="variables"]
Returns a list of the names of variables that are bound in _env_.
proc:environment-variable?[args="env id",result="bool"]
Returns #T if _id_ is a variable in _env._
proc:environment-get[args="env id",result="obj"]
Returns the value of _id_ in _env._ Signals an error if _id_ does not denote a variable with a defined value in _env._
proc:environment-set![args="env id obj"]
Stores _obj_ in the location denoted by _id_ in the environment represented by _env_. If _id_ denotes a macro in _env_ then the macro definition is removed.
// FIXME below needs review on many points
proc:environment-macros[args="env",result="macros"]
Returns a list of the names of macros defined in _env._
// FIXME check result type
proc:environment-macro?[args="env id",result="macro"]
Returns #T if _id_ is a macro in _env._
proc:environment-get-macro[args="env id",result="macro"]
Returns the macro associated with _id_ in _env._ Signals an error if _id_ does not denote a macro in _env._
proc:environment-set-macro![args="env id macro"]
Changes the macro associated with _id_ in _env_ to be _macro_. If _id_ denotes a variable in _env_ then the variable is removed.
proc:environment-copy[args="env",optarg="name",result="env"]
Returns a copy of the environment _env,_ giving the new environment the name _name_ if it is specified. The new environment has the same macros and variables as _env,_ but the variables are all bound to new locations.
proc:environment-syntax-environment[args="env",result="syntaxenv"]
Returns the syntactic environment of _env._ Generally this is of no use unless you're working with the Twobit internals.
anchor:interaction-environment[]
indexterm:[interaction-environment]
_Parameter interaction-environment_
The value of this parameter is the current interaction environment, which is used to look up global variables and syntax definitions in the read-eval-print loop as well as in eval and load when those procedures are called without arguments.
// FIXME: does null environment really take a version?
proc:null-environment[args="version",result="env"]
proc:scheme-report-environment[args="version",result="env"]
These are specified as for the R5RS, and _version_ may be 4 or 5.
NOTE: Based in part on _Extracting heuristic information from
environments_, authored by Will Clinger and sent to rrrs-authors on 09
May 1996.
================================================
FILE: doc/DevManual/ephemeral.txt
================================================
Ephemeral functionality
~~~~~~~~~~~~~~~~~~~~~~~
[WARNING]
================================================================
Some of the information in this section is obsolete or
obsolescent. Larceny's libraries have been reorganized
several times since this chapter was written, and will
undergo even more rapid reorganization during Larceny's
transition to ERR5RS/R6RS libraries.
================================================================
[WARNING]
================================================================
This chapter is a pseudo user manual for experimental and/or
ephemeral functionality in Larceny. Experimental functionality is
functionality that might eventually be incorporated in the standard
distribution in some form or another, because it's a feature we
want. Ephemeral functionality is functionality that may be useful
in the current implementation of Larceny, but may be radically
redesigned or removed altogether in the future.
================================================================
==== Ephemeral functionality
(None supported in this release.)
==== Experimental functionality
===== Generalized procedures
Larceny has an experimental implementation of MIT Scheme style "apply
hooks", which are generalized procedures. To use this facility, you
must assemble Experimental/applyhook0.mal to a fasl file and load it;
you must also load Experimental/applyhook.sch.
An apply hook is a procedure that contains another procedure and a
data object; in particular, if x is bound to an apply hook, then
(procedure? x) => #t.
When the apply hook is called, the procedure stored in the hook is
called with the arguments of the apply hook. That procedure can
inspect or change the procedure or the data stored in the hook using
the procedures below.
(make-apply-hook procedure object) => apply-hook
(apply-hook? object) => boolean
(apply-hook-procedure apply-hook) => procedure
(set-apply-hook-procedure! apply-hook procedure) => unspecified
(apply-hook-extra apply-hook) => object
(set-apply-hook-extra! apply-hook val) => unspecified
================================================
FILE: doc/DevManual/lowlevel.txt
================================================
Low-level Functionality
~~~~~~~~~~~~~~~~~~~~~~~
proc:current-continuation-structure[args="none"]
Returns a transparent representation of the current continuation: a
vector representing the innermost continuation frame. A field in the
frame points to the parent frame, and so on.
proc:make-trampoline[args="procedure"]
Returns an environment-less procedure that takes any number of
arguments and tail-calls _procedure_ with those arguments.
It is not possible to create a procedure with a shorter procedure
structure than that of a trampoline. That fact may be relied on: a
trampoline can be patched into any other procedure.
// FIXME which is the canon, lowlevel.txt or ffi.txt ?
proctempl:peek-bytes[args="address buffer k"]
Read _k_ bytes from memory starting at address _address_ and placing
them in the bytevector _buffer_ starting at index 0.
// FIXME which is the canon, lowlevel.txt or ffi.txt ?
proctempl:poke-bytes[args="address buffer k"]
Write _k_ bytes from bytevector _buffer_ starting at index 0 to memory
starting at address _address_.
proc:syscall[args="code obj1 ..."]
Make a call on the Larceny run-time system function identified by
_code_ with arguments obj1 .... Returns what is returned by the system
function.
================================================
FILE: doc/DevManual/memstats.txt
================================================
# Data Returned by Memstats
The vector returned from memstats has the content as shown below, ordered by increasing index. Note that this vector is _not_ laid out in the same way as the data produced by [stats-dump-on][1].
**THIS IS NO LONGER CORRECT. SEE Lib/Common/memstats.sch FOR THE LIST OF ACCESSOR FUNCTIONS TO MANIPULATE THE STRUCTURE RETURNED FROM MEMSTATS. THE DOCUMENTATION WILL BE UPDATED AT SOME POINT.**
................................................................................................................
0. Number of words allocated (accumulated)
1. Number of words reclaimed (accumulated)
2. Number of words copied (accumulated)
3. Milliseconds spent in garbage collection (accumulated, including promotion). See also entry 28.
4. Words live (current)
5. Generation last collected (current)
6. Type of last collection: 0=collection, 1=promotion (current)
7. Generation information: a vector of vectors, one subvector for each generation, containing the following:
7.0. Number of garbage collections in generation (accumulated)
7.1. Number of promotions into generation (accumulated)
7.2. Time spent in the generation's garbage collector for collections _and_ promotions (accumulated)
7.3. Words live in the generation (current)
7.4. Flag: this is a non-predictive 'young' generation (0 or 1)
7.5. Flag: this is a non-predictive 'old' generation (0 or 1)
7.6. If a non-predictive generation, the value 'j'
7.7. If a non-predictive generation, the value 'k'
7.8. Words allocated to the generation (current). Note that this is the sum of the allocations for both semispaces, if there are semispaces. Therefore, allocation can exceed target size.
7.9. The generation's target size, in words (current). Note that this is _per semispace_.
7.10. Time spent promoting into the generation (accumulated).
8. Remembered-set information: a vector of vectors, one subvector for each remembered set, containing the following:
8.0. Words allocated to remembered set node pool (current)
8.1. Words used in remembered set node pool (current)
8.2. Words allocated to remembered set hash table (current)
8.3. Words used in remembered set hash table (current)
8.4. Number of objects recorded in hash table (accumulated)
8.5. Number of objects removed from hash table (accumulated)
8.6. Number of old-generation objects scanned from remembered set (accumulated)
8.7. Number of words of old-generation objects scanned from remembered set (accumulated)
8.8. Number of transactions recorded in the remembered set's sequential store buffer (SSB)
9. Number of stack frames flushed (accumulated)
10. Number of words of stack flushed (accumulated)
11. Number of stacks created (accumulated)
12. Number of stack frames restored (accumulated)
13. Number of words allocated to heaps (current)
14. Number of words allocated to remembered-sets (current)
15. Number of words allocated to RTS "other" (current)
16. Simulated write barrier: number of array assignments (accumulated)
17. Simulated write barrier: number of array assignments filtered because the LHS is young or already remembered (accumulated)
18. Simulated write barrier: number of array assignments filtered because the RHS is a non-pointer (accumulated)
19. Simulated write barrier: number of array assignments filtered because a cross-generation pointer was not created
20. Simulated write barrier: number of array assignments that resulted in the LHS being added to a remembered set
21. Elapsed time since startup.
22. System CPU time since startup.
23. User CPU time since startup.
24. Number of page faults that did not incur a physical read ("minor") (accumulated)
25. Number of page faults that did inclur a physical read ("major") (accumulated)
26. Remembered-set statistics for the extra remembered set for the non-predictive collector, or #f
27. Number of words of maximum heap occupancy so far during the run.
28. Milliseconds spent in promotion.
................................................................................................................
* * *
_$Id: memstats.html 1365 2000-02-29 20:55:29Z lth $_
[larceny@ccs.neu.edu][2]
[1]: syscontrol.html#proc:stats-dump-on
[2]: mailto:larceny@ccs.neu.edu
================================================
FILE: doc/DevManual/nasm-representations.txt
================================================
Representations and register assignments for i386
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2002-11-06
[WARNING]
================================================================
WARNING!! Not presently maintained, look in i386-machine.ah for
up-to-date information.
================================================================
EAX is used as a temp for generated code, and to pass SECOND on calls
to millicode. It is never a root for garbage collection, so SECOND
must be flushed to memory by millicode.
SECOND eax
RESULT ebx
REG1 ecx
REG2 edx
REG3 edi
REG4 esi
CONT ebp
GLOBALS esp
There is a particular reason GLOBALS is mapped to esp. The first slot
of globals is empty. Thus, to call millicode one can always execute a
CALL instruction, the return address will be pushed into the first
element of GLOBALS. Millicode must pop the value to adjust GLOBALS
and save the address.
This trick allows CONT to grow and meet the heap pointer without any
buffer between them, and makes millicode calls compact.
This assumes that the operating system's interrupt handlers do not
push values onto the user stack; if they do, we must have plenty of
space available at the beginning of GLOBALS or must not use esp at
all.
;;;
;;; Note that since a CALL is used, there must be room on the processor
;;; stack for one word of return address. The trick we use is for
;;; ESP to point to GLOBALS, not CONT, so GLOBALS is not right on entry
;;; to stubs here until the return value has been popped. On the other hand,
;;; we don't have to worry about space between the heap and the stack.
;;; The jump vector contains addresses of millicode procedures; a call
;;; to a millicode procedure is an indirect call:
;;; CALL [GLOBALS+M_...]
Todo list.
- globals needs a dummy element at the beginning
- the .ah files should be generated in the correct format by the
config scripts, this is a matter of changing syntax only
- more millicode procs should be implemented (look at globals.ah)
- need to work out how millicode is going to work -- it's in C
and probably assumes Petit Larceny calling conventions. If we
are to keep it in C then some integration of the Petit Larceny
engine with the native code must be accomplished! If not, we
need to rewrite the millicode to fit native conventions, but
this seems painful at this time.
If a C function calls a Scheme procedure it meets code that does this:
save C state
switch to Scheme mode
push a continuation on the Scheme stack that switches back
to C mode and returns
continue executing
If a Scheme function calls a C procedure it meets code that does this:
save Scheme state
switch to C mode
push a continuation on the C stack that switches back to
Scheme mode and returns
continue executing
Millicode is probably messier still, or should they all be considered
cross-language calls? Then calling millicode will cost more!
Probably not necessary; when millicode calls Scheme it longjumps out,
throwing away the C continuation; only the Scheme continuation
remains, and it is properly constructed. (It is a C frame that will
return to Scheme, ... maybe?? What if it was Scheme code compiled to
C that performed the original call?)
;; The code with globals assigned to esp and cont to ebp is
;; slightly slower on fib(35) than with the assignments reversed.
;; No doubt this is CPU specific.
;; Also it seems that the CPU prefers to work with data in eax and
;; ebx: introducing some peephole optimization so that it worked on
;; data in ecx slowed evenodd down quite a bit. Peephole
;; optimizations that have not paid off are REG_OP2IMM_zerop and
;; REG_OP2IMM_SETREG_subtract, both programs were slower than the
;; equivalent sequence of more primitive ops.
================================================
FILE: doc/DevManual/procidx.txt
================================================
Index of Library Procedures
~~~~~~~~~~~~~~~~~~~~~~~~~~~
///////////////////////////////////////////////////////////////////////
We should be able to create the contents of this automatically, right?
///////////////////////////////////////////////////////////////////////
This index lists the procedures that are documented in this Manual. Procedures that are described in the Revised Reports or in the IEEE Standard but not listed here may be assumed to behave according to their specifications in the standards documents. A discrepancy between defined and implemented behavior constitutes a bug, [which you should report][1].
[bignum?][5]
[bytevector?][9]
[bytevector-copy][10]
[bytevector-equal?][11]
[bytevector-fill!][12]
[bytevector-length][13]
[bytevector-like?][14]
[bytevector-like-copy][15]
[bytevector-like-equal?][16]
[bytevector-like-length][17]
[bytevector-like-ref][18]
[bytevector-like-set!][19]
[bytevector-ref][20]
[bytevector-set!][21]
[compnum?][26]
[flonum?][65]
[fx--][73]
[<">fx<][76]
[<=">fx<=][77]
[">fx>][78]
[=">fx>=][79]
[make-procedure][114]
[oblist][123]
[parameterize][127]
[procedure-length][138]
[procedure-ref][140]
[procedure-set!][141]
[ratnum?][148]
[rectnum?][159]
[sort][178]
[sort!][178]
[vector-like?][207]
[vector-like-length][208]
[vector-like-ref][209]
[vector-like-set][210]
* * *
_$Id: procidx.html 1526 2000-09-22 21:27:03Z lth $_
[larceny@ccs.neu.edu][1]
[1]: mailto:larceny@ccs.neu.edu
[2]: control.html#proc:add-exit-procedure!
[3]: control.html#proc:add-init-procedure!
[4]: pairs_lists.html#proc:append!
[5]: numbers.html#proc:bignum-p
[6]: debugging.html#proc:break
[7]: debugging.html#proc:break-entry
[8]: debugging.html#proc:break-handler
[9]: bytevectors.html#proc:bytevector-p
[10]: bytevectors.html#proc:bytevector-copy
[11]: bytevectors.html#proc:bytevector-equal-p
[12]: bytevectors.html#proc:bytevector-fill!
[13]: bytevectors.html#proc:bytevector-length
[14]: bytevectors.html#proc:bytevector-like-p
[15]: bytevectors.html#proc:bytevector-like-copy
[16]: bytevectors.html#proc:bytevector-like-equal-p
[17]: bytevectors.html#proc:bytevector-like-length
[18]: bytevectors.html#proc:bytevector-like-ref
[19]: bytevectors.html#proc:bytevector-like-set!
[20]: bytevectors.html#proc:bytevector-ref
[21]: bytevectors.html#proc:bytevector-set!
[22]: control.html#proc:call-without-interrupts
[23]: io.html#proc:close-open-files
[24]: syscontrol.html#proc:collect
[25]: os.html#proc:command-line-arguments
[26]: numbers.html#proc:compnum-p
[27]: io.html#proc:console-input-port
[28]: io.html#proc:console-input-port-factory
[29]: io.html#proc:console-output-port
[30]: io.html#proc:console-output-port-factory
[31]: lowlevel.html#proc:current-continuation-structure
[32]: io.html#proc:current-input-port
[33]: io.html#proc:current-output-port
[34]: control.html#proc:decode-error
[35]: io.html#proc:delete-file
[36]: control.html#proc:disable-interrupts
[37]: syscontrol.html#proc:display-memstats
[38]: os.html#proc:dump-heap
[39]: os.html#proc:dump-interactive-heap
[40]: control.html#proc:enable-interrupts
[41]: environ.html#proc:environment-p
[42]: environ.html#proc:environment-copy
[43]: environ.html#proc:environment-get
[44]: environ.html#proc:environment-get-cell
[45]: environ.html#proc:environment-get-macro
[46]: environ.html#proc:environment-macro-p
[47]: environ.html#proc:environment-macros
[48]: environ.html#proc:environment-name
[49]: environ.html#proc:environment-set!
[50]: environ.html#proc:environment-set-macro!
[51]: environ.html#proc:environment-syntax-environment
[52]: environ.html#proc:environment-variable?
[53]: environ.html#proc:environment-variables
[54]: io.html#proc:eof-object
[55]: hashtable.html#proc:equal-hash
[56]: control.html#proc:error
[57]: control.html#proc:error-handler
[58]: control.html#proc:eval
[59]: control.html#proc:evaluator
[60]: pairs_lists.html#proc:every-p
[61]: control.html#proc:exit
[62]: io.html#proc:file-exists-p
[63]: io.html#proc:file-modification-time
[64]: fixnums.html#proc:fixnum-p
[65]: numbers.html#proc:flonum-p
[66]: io.html#proc:flush-output-port
[67]: ffi.html#proc:foreign-file
[68]: ffi.html#proc:foreign-procedure
[69]: ffi.html#proc:foreign-null-pointer
[70]: ffi.html#proc:foreign-null-pointer-p
[71]: fixnums.html#proc:fx+
[72]: fixnums.html#proc:fx-
[73]: fixnums.html#proc:fx--
[74]: fixnums.html#proc:fx*
[75]: fixnums.html#proc:fx=
[76]: fixnums.html#proc:fx<
[77]: fixnums.html#proc:fx<=
[78]: fixnums.html#proc:fx>
[79]: fixnums.html#proc:fx>=
[80]: fixnums.html#proc:fxnegative-p
[81]: fixnums.html#proc:fxpositive-p
[82]: fixnums.html#proc:fxzero-p
[83]: syscontrol.html#proc:gc-counter
[84]: syscontrol.html#proc:gcctl
[85]: symbols.html#proc:gensym
[86]: os.html#proc:getenv
[87]: io.html#proc:get-output-string
[88]: proplist.html#proc:getprop
[89]: hashtable.html#proc:hashtable-contains-p
[90]: hashtable.html#proc:hashtable-clear!
[91]: hashtable.html#proc:hashtable-copy
[92]: hashtable.html#proc:hashtable-fetch
[93]: hashtable.html#proc:hashtable-for-each
[94]: hashtable.html#proc:hashtable-get
[95]: hashtable.html#proc:hashtable-map
[96]: hashtable.html#proc:hashtable-put!
[97]: hashtable.html#proc:hashtable-remove!
[98]: hashtable.html#proc:hashtable-size
[99]: repl.html#proc:herald
[100]: control.html#proc:keyboard-interrupt-handler
[101]: environ.html#proc:interaction-environment
[102]: pairs_lists.html#proc:last-pair
[103]: pairs_lists.html#proc:list-copy
[104]: control.html#proc:load-evaluator
[105]: fixnums.html#proc:logand
[106]: fixnums.html#proc:logior
[107]: fixnums.html#proc:lognot
[108]: fixnums.html#proc:logxor
[109]: fixnums.html#proc:lsh
[110]: bytevectors.html#proc:make-bytevector
[111]: environ.html#proc:make-environment
[112]: hashtable.html#proc:make-hashtable
[113]: parameters.html#proc:make-parameter
[114]: procedures.html#proc:make-procedure
[115]: records.html#proc:make-record-type
[116]: structures.html#proc:make-structure
[117]: lowlevel.html#proc:make-trampoline
[118]: syscontrol.html#proc:memstats
[119]: fixnums.html#proc:most-positive-fixnum
[120]: fixnums.html#proc:most-negative-fixnum
[121]: environ.html#proc:null-environment
[122]: hashtable.html#proc:object-hash
[123]: symbols.html#proc:oblist
[124]: symbols.html#proc:oblist-set!
[125]: io.html#proc:open-input-string
[126]: io.html#proc:open-output-string
[127]: parameters.html#syntax:parameterize
[128]: ffi.html#proc:peek-bytes
[129]: ffi.html#proc:poke-bytes
[130]: io.html#proc:port-p
[131]: io.html#proc:port-name
[132]: io.html#proc:port-position
[133]: procedures.html#proc:procedure-arity
[134]: procedures.html#proc:procedure-copy
[135]: procedures.html#proc:procedure-documentation-string
[136]: procedures.html#proc:procedure-environment
[137]: procedures.html#proc:procedure-expression
[138]: procedures.html#proc:procedure-length
[139]: procedures.html#proc:procedure-name
[140]: procedures.html#proc:procedure-ref
[141]: procedures.html#proc:procedure-set!
[142]: procedures.html#proc:procedure-source-file
[143]: procedures.html#proc:procedure-source-position
[144]: proplist.html#proc:putprop
[145]: control.html#proc:quit
[146]: control.html#proc:quit-handler
[147]: numbers.html#proc:random
[148]: numbers.html#proc:ratnum-p
[149]: records.html#proc:record-p
[150]: records.html#proc:record-accessor
[151]: records.html#proc:record-constructor
[152]: records.html#proc:record-predicate
[153]: records.html#proc:record-type-descriptor
[154]: records.html#proc:record-type-extends?
[155]: records.html#proc:record-type-field-names
[156]: records.html#proc:record-type-name
[157]: records.html#proc:record-type-parent
[158]: records.html#proc:record-updater
[159]: numbers.html#proc:rectnum-p
[160]: pairs_lists.html#proc:remove
[161]: pairs_lists.html#proc:remove!
[162]: proplist.html#proc:remprop
[163]: io.html#proc:rename-file
[164]: repl.html#proc:repl-level
[165]: repl.html#proc:repl-printer
[166]: repl.html#proc:repl-evaluator
[167]: repl.html#proc:repl-prompt
[168]: control.html#proc:reset
[169]: control.html#proc:reset-handler
[170]: io.html#proc:reset-output-string
[171]: pairs_lists.html#proc:reverse!
[172]: fixnums.html#proc:rsha
[173]: fixnums.html#proc:rshl
[174]: syscontrol.html#proc:run-benchmark
[175]: syscontrol.html#proc:run-with-stats
[176]: environ.html#proc:scheme-report-environment
[177]: pairs_lists.html#proc:some-p
[178]: sorting.html#proc:sort
[179]: srfi.html#proc:srfi0-add-key!
[180]: srfi.html#proc:srfi0-keys
[181]: syscontrol.html#proc:sro
[182]: control.html#proc:standard-timeslice
[183]: syscontrol.html#proc:stats-dump-off
[184]: syscontrol.html#proc:stats-dump-on
[185]: strings.html#proc:string-downcase
[186]: strings.html#proc:string-downcase!
[187]: hashtable.html#proc:string-hash
[188]: strings.html#proc:string-upcase
[189]: strings.html#proc:string-upcase!
[190]: structures.html#proc:structure-p
[191]: structures.html#proc:structure-comparator
[192]: structures.html#proc:structure-printer
[193]: strings.html#proc:substring-fill!
[194]: os.html#proc:system
[195]: hashtable.html#proc:symbol-hash
[196]: lowlevel.html#proc:syscall
[197]: syscontrol.html#proc:system-features
[198]: debugging.html#proc:trace
[199]: debugging.html#proc:trace-entry
[200]: debugging.html#proc:trace-exit
[201]: control.html#proc:timer-interrupt-handler
[202]: control.html#proc:typetag
[203]: control.html#proc:typetag-set!
[204]: debugging.html#proc:unbreak
[205]: debugging.html#proc:untrace
[206]: vectors.html#proc:vector-copy
[207]: vectors.html#proc:vector-like-p
[208]: vectors.html#proc:vector-like-length
[209]: vectors.html#proc:vector-like-ref
[210]: vectors.html#proc:vector-like-set!
[211]: io.html#proc:with-input-from-port
[212]: io.html#proc:with-output-to-port
================================================
FILE: doc/DevManual/repl.txt
================================================
anchor:repl[]
The Read-Eval-Print Loop ("REPL")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
anchor:repl-level[]
indexterm:[repl-level]
_Parameter repl-level_
The value of this parameter is a nonnegative exact integer that is the
current nesting level of read-eval-print loops.
anchor:repl-evaluator[]
indexterm:[repl-evaluator]
_Parameter repl-evaluator_
The value of repl-evaluator is a procedure of two arguments, an
expression and an environment. The procedure should evaluate the
expression in the environment and return the result(s).
anchor:repl-printer[]
indexterm:[repl-printer]
_Parameter repl-printer_
The value of repl-printer is a procedure of two arguments, a value to
print and a port.
If the value to print is not #!unspecified, the procedure should print
it on the current output port. The default printer is write in
r5rs.heap and pretty-print in larceny.heap and twobit.heap.
anchor:repl-prompt[]
indexterm:[repl-prompt]
_Parameter repl-prompt_
The value of repl-prompt is a procedure that takes two arguments, a
level and an output port, and that prints a prompt corresponding to
that level on the port.
anchor:herald[]
indexterm:[herald]
_Parameter herald_
The value of herald is a string or #f. If a string, the
read-eval-print loop prints the string when Larceny first starts up.
* * *
[IMPORTANT]
================================================================================
FIXME:
existence of repl
repl behavior in general, notably
- its control of current input and output and how you can't interactively
change current input and output.
- its control of the error handler, reset handler, quit handler, and
sundry interrupt handlers
================================================================================
================================================
FILE: doc/DevManual/starting.txt
================================================
Running Larceny
~~~~~~~~~~~~~~~
WARNING: Some of this section is wildly out of date. But other parts are unchanged. Beware.
////////////////////////////////////////////////
==== Contents
1. [Summary (Overall behavior)][1]
2. [Quick summary (precise GC)][2]
3. [Quick summary (conservative GC)][3]
4. [Command line format overview][4]
5. [Heap allocation options (precise GC)][5]
6. [GC policy options (precise GC)][6]
7. [GC policy options (conservative gc)][7]
8. [General options][8]
9. [Developers' options][9]
10. [Startup file][10]
11. [Reorganizing a heap image][11]
////////////////////////////////////////////////
==== Summary (Overall behavior)
Larceny can be started in two distinct ways. Those users who use
Larceny only for Scheme programming will usually install it as
described in <<TheIntroduction>> and will run it via the standard
shell script by typing larceny at the shell prompt.
Those users who change Twobit and Larceny, on the other hand, will
also run the shell script -- and also the twobit script -- but will
sometimes need to run a newly-compiled program or newly-built heap
without installing it first. In that case, the binary 'larceny.bin'
will be run directly, as described below.
The command line options in this section apply to both the shell
scripts and the binary program. However, a heap file name may not be
supplied to the shell scripts, and the option -small (described in
<<TheIntroduction>>) is not accepted by the binary program or by
the twobit script.
==== Summary (precise gc)
Larceny is most easily run from the command line with the following
command:
larceny.bin _heap-filename_
That command will run Larceny with the default configuration. (You can
also omit the _heap-filename_, which then defaults to the file
sparc.heap in the current directory.) The default configuration is:
* Writeable static area for the heap image
* Three collected areas:
* Nursery (youngest generation): 1Mbyte single space
* Ephemeral generation: 2Mbyte, fixed size, two-space copy-collected
* Dynamic generation: 3Mbyte, expandable, two-space copy-collected, no size limit, load factor 3.0
* Separate large object subspace in each collected area
* Remembered set: 16K hash table entries; 16K sequential store buffer (SSB) slots
* Breakpoints are enabled
* Single stepping is disabled
* Printing of startup statistics is disabled
* Printing of nonessential messages is enabled
==== Summary (conservative GC)
Larceny with the conservative collector is run from the command line
with the following command:
bdwlarceny.bin _heap-filename_
That command will run Larceny with the default configuration. (You can
also omit the _heap-filename_, which then defaults to the file
larceny.heap in the current directory.) The default configuration is:
* Non-generational, non-incremental collection
* Breakpoints are disabled
* Single stepping is disabled
* Printing of startup statistics is disabled
* Printing of nonessential messages is enabled
_Note:_ It is beneficial to run the conservative collector with a
_split heap image_, that is, a heap image where the code vectors and
the other data are separated. Using such a heap image reduces the risk
of accidental storage retention, although it is at the present time
unclear whether the practical benefits are measurable (in Larceny, at
least). The heap image created by the development system is not split,
but you can create such a heap image with Larceny. Click [here][11] to
learn more.
==== Command line format overview
Larceny accepts a number of command line options to control its
configuration and behavior. The summary of the command line format is
as follows:
larceny.bin [ _option_ ... ] [ _heap-filename_ ] [ -args _argument_ ... ]
where each _option_ is described in this document; see the
[contents][13] for a topic listing. If the switch -args is present,
then the arguments following that switch are made available to Scheme
code running in Larceny as a vector of strings; see the description of
the [command-line-arguments][14] procedure.
_Option arguments_: where an argument _size_ is indicated, a
nonnegative integer is expected, optionally followed immediately by
the letter "K" (Kilo) or "M" (Mega); e.g. a size of 512K means 524288
8-bit bytes. Where an argument _n_ is indicated, a nonnegative integer
is expected.
==== Heap allocation options (precise GC)
-gen Select the generational garbage collector with the default number of collected areas (3). An area is akin to a generation except that some areas (notably, the non-predictive dynamic area) have multiple generations.
-areas _n_ Select the generational garbage collector with _n_ collected areas, where _n_ specifies the number of non-static heap areas the system will use. Implies use of a generational collector. The default for _n_ is 3 and the minimum is 2.
-np Select the generational garbage collector with the non-predictive dynamic area. This option can be combined with -areas to select a specific number of areas.
-stopcopy Select the stop-and-copy garbage collector with one collected area.
-nostatic Disable the static area (which is on by default in all configurations).
-size _size_
-size_k_ _size_ Specify the size of the data areas, in bytes. If the form -size_k_ is used, then the size for area _k_ is set, all others remain unchanged. Areas are numbered from 1, where area 1 is the youngest. If the more general form is used, then the value specified affects all areas that have not had their size specified individually.
The dynamic area will grow to accomodate the live data; see -load and -max.
-steps _n_
-stepsize _size_
Select the generational garbage collector and the non-predictive dynamic area, and also set the initial number of steps or the initial step size.
-stats Print a summary of memory allocation statistics at startup time.
==== GC policy options (precise GC)
-max _size_ Specify the desired maximum heap size for the dynamic area. This is a very strong suggestion to the collector for that area that it should never allow the size of the area to grow to more than _size_ bytes. In each case when the collector cannot obey this, it prints a message to this effect and temporarily exceeds the limit with the minimal amount it thinks works.
In practice this appears to work very well.
-load _n_ Specify the inverse load factor (ratio of heap storage to live storage) for the dynamic area. This is a decimal number; the default is 3.0.
-rhash _size_ Specify the size of the remembered-set hash table, in the number of elements the table will have. The size given must be a power of 2. The default is 16K. _Bug warning: this is ignored in 1.0a1. See BUGS._
-ssb _size_ Specify the size of the write barrier's Sequential Store Buffer (SSB), as the number of elements the SSB will have. The default is 16K. _Bug warning: this is ignored in 1.0a1. See BUGS._
==== GC policy options (conservative GC)
-incremental Enable the conservative collector's incremental, generational mode. **This switch is currently disabled**. I've had no luck whatever using incremental collection under SunOS; this probably has to do with the costly VM write protection under SunOS coupled with the very high frequency of writes.
link:LarcenyNotes/note11-bdw.html[Here] are some musings on the issue.
==== General options
-help Print a summary of the legal command line options.
-quiet Suppress nonessential messages.
-annoy-user
-annoy-user-greatly Print annoying messages at major points in the program (garbage collections in older generations, for example). The form -annoy-user-greatly causes the garbage collectors to print messages about promotions and policy decisions also. Try it; you'll hate it.
==== Developers' options
-break _[Development]_ Enable manually-placed breakpoints.
-step _[Development]_ Enable debugging of code compiled with MAL single-stepping enabled.
==== Startup/configuration file
The default read-eval-print loop looks for a startup/configuration
file when Larceny is started. The file, if found, will be assumed to
contain either Scheme source code or compiled fasl-format code, and
will be loaded before control is passed to the repl. If the file is
found but the load fails, a warning will be printed but the
read-eval-print loop will still be run.
The file .larceny will be taken to be the startup file; Larceny looks
first in the current directory and then in the user's home directory.
==== Reorganizing a heap image
You can create a split heap image by invoking the following command:
larceny.bin -reorganize-and-dump filename
where filename is the name of an existing heap file. Larceny will read
the heap file, reorganize it into two pieces, one containing code and
one other data, and then dump a new heap file filename.split
containing the split heap. Larceny then exits. The new heap file can
be used as an argument to larceny in future runs.
* * *
$Id: starting.html 434 1998-12-21 21:23:26Z will $
[larceny@ccs.neu.edu][16]
[1]: #summary:overall
[2]: #summary:precise
[3]: #summary:conservative
[4]: #summary:general
[5]: #heap:precise
[6]: #policy:precise
[7]: #policy:conservative
[8]: #general
[9]: #developer
[10]: #startup-file
[11]: #reorg
[12]: intro.html
[13]: #contents
[14]: manual#proc:command-line-arguments
[16]: mailto:larceny@ccs.neu.edu
================================================
FILE: doc/DevManual/structures.txt
================================================
Structures
~~~~~~~~~~
Larceny now provides
http://scheme-punks.org/wiki/index.php?title=Main_Page[ERR5RS-compatible]
records, which programmers should use instead of structures.
[WARNING]
================================================================
Structures are _strongly_ deprecated, because they are now unsafe.
Larceny's improved support for records involved the addition of
a new global invariant that operations on structures must preserve.
Programmers who use the structures API described below cannot be
trusted to preserve that invariant (and we're not even going to
tell you what it is, because we change it more often than we can
update this manual).
Structures remain in Larceny only for use by Larceny developers,
who use them to implement records. In future versions of
Larceny, the structures API described below will disappear.
================================================================
_Structures_ are vector-like objects for which none of the standard
Scheme type predicates test true. They are therefore suitable
implementation vehicles for new and experimental data types.
There are no structure-length, structure-ref, or structure-set!
procedures. Instead, use the vector-like-length, vector-like-ref, and
vector-like-set procedures.
proc:make-structure[args="length",result="structure"]
Returns a structure of the specified _length_.
proc:structure?[args="object",result="boolean"]
Returns #t if _object_ is a structure, and #f otherwise.
anchor:structure-comparator[]
indexterm:[structure-comparator]
_Parameter structure-comparator_
The value of this parameter is a procedure of two arguments: the
structures to be compared. The default behavior is to compare the
structures element-by-element using equal? and return #t if they agree
at all fields.
The structure comparator may be called by equal? to compare two
structures for equality.
anchor:structure-printer[]
indexterm:[structure-printer]
_Parameter structure-printer_
The value of this parameter is a procedure of three arguments: a
structure, an output port, and a boolean which is #t if the printer
must quote its output, as for write.
A typical use of structure-printer is to retrieve the current
structure printer procedure and install a new procedure that checks
its argument to see if it's a structure of a particular type; if it
is, then a custom printer is invoked, otherwise the old printer is
invoked. For example:
(define (install-structure-printer mystruct? printer)
(let ((old (structure-printer)))
(structure-printer (lambda (obj port quote?)
(if (mystruct? obj)
(printer obj port quote?)
(old obj port quote?))))))
================================================
FILE: doc/HOWTO-BUILD
================================================
Building Larceny
WHAT YOU NEED
Most users of Larceny will never need to build Larceny from source,
and can ignore this documentation.
If you want to recompile the Scheme sources entirely from source, you
will need the source code plus a Scheme system that can host Larceny's
build process. At this time, that means you need to start with a
binary distribution of Larceny [1]. See README-FIRST.txt for more
details.
If you want to build Larceny or Petit Larceny entirely from source,
you will also need a C compiler (such as gcc). For x86-32 targets,
you will also need the NASM assembler [2] and the necessary 32-bit
library packages [3].
To build Common Larceny, see the Common Larceny documentation in
doc/CommonLarceny/user-manual.txt.
WHAT TO DO
Building Larceny has four major steps:
1. Set up the Larceny development environment.
Run your host Scheme (a prebuilt version of Larceny [1]), and change
to the root directory of the Larceny tree.
> (load "setup.sch")
> (setup 'scheme: ${SCHEME} 'host: ${HOST} [ 'sassy | 'common ]
'string-rep: ${STREP})
The call to setup (above) has several options that let you
declare which implementation of Scheme you want to use for
the build process (SCHEME) and which OS you are using as
both the host and target of the build (HOST):
SCHEME ::= 'larceny | 'mzscheme | 'petite | 'chez
HOST ::= 'macosx | 'macosx-el | 'linux86 | 'win32 | 'linux-arm-el
STRING-REP ::= 'flat4 | 'flat1
The HOST option macosx-el is for Intel-based Macintosh computers.
The HOST option macosx is for PowerPC-based Macintosh computers.
The HOST option linux-arm-el is for most ARM-based Linux systems.
The optional 'sassy flag will build native Larceny (x86-32) on
Linux, Windows, or MacOS X. The 'sassy flag is necessary if
you want to use dynamic loading on Win32, and is strongly
recommended for that operating system. There are several
other optional flags that change the compiler's behavior [4].
The STRING-REP option determines the representation used
for strings. The flat4 representation uses 4 bytes per
character, is the default on all versions of Larceny, and
is the only representation that can be used when building
Petit Larceny or Common Larceny. The flat1 representation
of strings uses 1 byte per character, which limits it to
strings of Latin-1 characters. Native Larceny for x86-32
can be built to use either the flat4 or flat1 representations;
be sure to perform a full build when switching from one
representation to the other. At present, native Larceny
on ARM can only be built with the flat4 representation.
Some useful examples which are known to work:
To build native Larceny:
> (setup 'scheme: 'larceny 'host: 'win32 'sassy 'always-source)
> (setup 'scheme: 'larceny 'host: 'linux86 'sassy)
> (setup 'scheme: 'larceny 'host: 'linux86 'sassy 'string-rep: 'flat1)
> (setup 'scheme: 'larceny 'host: 'macosx-el 'sassy)
To build native Larceny for little-endian ARMv7 running Linux
an explicit target: will be required [5]:
> (setup 'scheme: 'larceny
'host: 'linux-arm-el
'target: 'linux-arm-el-hardfp 'native)
To build native Larceny for ARMv7 target platforms that reserve
the ARM platform register, specify 'linux-arm-el-hardfp0 instead
of 'linux-arm-el-hardfp.
To build Petit Larceny:
> (setup 'scheme: 'larceny 'host: 'linux86 'always-source)
2. Build Larceny components
After the development environment is setup, you should compile the core
system:
> (build-config-files) ; [6]
> (load-compiler)
> (build-heap)
> (build-runtime)
> (build-executable)
You will now have a working Larceny interpreter and minimal heap image.
To build a complete Larceny user system, including the Twobit compiler:
> (build-larceny-files)
You may want the Twobit compiler development environment; on
Petit, you must build it separately:
> (build-twobit)
After all that, it's time to exit from your host Scheme:
> (exit)
For Windows, you'll need to mark the larceny.bin.exe as incompatible
with NX:
editbin.exe /NXCOMPAT:NO larceny.bin.exe
Larceny will not run under Windows with DEP set to AlwaysOn, but
Larceny will run with DEP set to OptOut, OptIn, or AlwaysOff.
3. Create heap images
Step 2 above creates a bootstrap heap (petit.heap, arm.heap, or
sasstrap.heap). To create the user and development heap images, exit
the host Scheme back to your command shell. Then perform one of the
following three sets of commands (omitting those for twobit unless
you want the Twobit compiler development environment):
On IAssassin Larceny (Intel) [7]:
% "./larceny.bin" -stopcopy -- src/Build/iasn-larceny-heap.fasl
> (exit)
% "./larceny.bin" -stopcopy -- src/Build/iasn-twobit-heap.fasl
> (exit)
On Native Larceny (ARM):
% ./larceny.bin -stopcopy -- src/Build/arm-el-hardfp-larceny-heap.fasl
> (exit)
% ./larceny.bin -stopcopy -- src/Build/arm-el-hardfp-twobit-heap.fasl
> (exit)
On Petit Larceny:
% ./petit-larceny.bin -stopcopy -- src/Build/petit-larceny-heap.sch
> (exit)
% ./twobit.bin -stopcopy -- src/Build/petit-twobit-heap.sch
> (exit)
Then, if you want the Twobit compiler development environment:
On *NIX:
% cp larceny twobit
On Windows:
> copy larceny.bat twobit.bat
On Windows machines, you will probably need to tell DEP to allow
larceny.bin to opt-out.
You can now run "./larceny" (and maybe "./twobit") in its default
-r5rs mode, but the -r7rs and -r6rs modes won't work until you
do step 4.
4. Compile the R7RS/R6RS/SRFI standard libraries.
Run Larceny in its default -r5rs mode, and compile the
R7RS/R6RS/SRFI standard libraries as follows.
% ./larceny
Larceny v0.98 "Funny in the Head" (...)
> (require 'r7rsmode)
> (larceny:compile-r7rs-runtime)
> (exit)
Larceny should now run correctly in all modes. If you want
to use Larceny to run Scheme scripts on a Unix system, then
you should make sure that the Larceny root directory is in
your execution path, ahead of any other directories that
may contain a file named scheme-script.
----------------------------------------------------------------
NOTES
[1] For the build process, you need a prebuilt version of Larceny
itself. In the past, several other implementations of Scheme
could be used for the build process, but they don't work any more.
[2] http://www.nasm.us/
For Windows and Ubuntu Linux, we use NASM version 2. For MacOS X,
we use NASM version 0.98.40, which is installed with the Apple
Developer command line tools.
For the 'sassy backend on 'win32, Microsoft's development tools
(including NMAKE) and NASM must both be in your search path.
[3] On Linux machines, you may need to do the following:
sudo apt-get install lib32z1
sudo apt-get install libc6-i386
sudo apt-get install libc6-dev-i386
On MacOS X machines, you may need to install the Apple Developer
command line tools.
On Windows, the Microsoft Visual Studio Community 2013 download
contains everything you need (and a lot more than you need). We
use the "VS2013 x86 Native Tools Command Prompt".
[4] Larceny requires CPU support for floating point instructions.
Several sub-ABIs exist for floating point on the ARM architecture.
The two APIs are known as "soft" (hardware instructions are generated but
the calling convention is as for software floating point; gcc calls
this "softfp") and "hard" (hardware instructions are generated and the
calling convention uses FPU registers). Larceny needs to know the ABI
when it compiles C code, and the target name therefore contains either
"softfp" or "hardfp". Generally the operating system sets the ABI and
all programs on the system use it; check your local documentation.
[5] Some other potentially useful flags, given optionally at the end of
the call to setup:
'code-cov
This enables loading of the instrumented files generated by the
stcov tool when loading the compiler. Use this to test code
coverage of the compiler testsuite
'rebuild-code-cov
This causes the stcov files to be regenerated before loading.
This implies 'code-cov.
'always-source
Don't load compiled fasl files when loading the development
environment under Larceny. This is useful under Petit Larceny
if the executable gets out of sync with the fasl files.
'nasm
Build a Petit Larceny which targets the NASM assembler (IA32)
rather than Standard C. This option is deprecated in favor of
the Sassy backend; indeed, we suspect that it no longer builds
correctly now that we have added the string-rep: parameter to
setup.
[6] This is only strictly necessary the first time and when the options
given to setup have changed, but it should be safe to do every time.
[7] The quotation marks around "./larceny.bin" are a uniform syntax that
works on both Microsoft Windows and UNIX-like shells. The reason is
left as an exercise for the reader.
================================================
FILE: doc/HOWTO-ERR5RS
================================================
ABOUT ERR5RS
ERR5RS is an expeditious revision of the R5RS to fill part
of the gap that lies between the R5RS and R6RS [1,2,3].
ERR5RS extends the R5RS by adding
* R6RS-compatible library and import syntax
* dynamic loading of libraries
* dynamic importing of libraries
* repl-friendly semantics for top-level programs
* a subset of R6RS lexical syntax
* R6RS-compatible records, but with superior APIs
The most important thing to know about ERR5RS is that it is
a supplement to the R6RS, not a replacement. ERR5RS makes
the most important innovations of the R6RS available for use
in read/eval-print loops and R5RS-style dynamic programs,
which are outside the scope of the R6RS.
The second most important thing to know about ERR5RS is that
it is being designed with portability in mind. Its statement
of requirements and goals mentions several different aspects
of portability:
* portability/reuse between R5RS and ERR5RS (backward compatibility)
* portability/reuse between different implementations of ERR5RS
* portability/reuse between ERR5RS and R6RS programs
* ease of understanding
* ease of implementation
ERR5RS libraries are portable because the mapping between
library names and files is not left up to implementations,
but is specified by the extended semantics of loading and
importing.
Portability of ERR5RS libraries and programs also depends
upon the availability and quality of ERR5RS-compatible
implementations. Larceny v0.95 was the first implementation
of ERR5RS, and Larceny's users have a great opportunity to
influence the continuing evolution and acceptance of ERR5RS.
COMPILING THE ERR5RS/R6RS RUNTIME
If you are using Petit Larceny, you must pre-compile the
ERR5RS/R6RS runtime and standard libraries before you can
use Larceny's ERR5RS mode. Follow the instructions for
step 4 of the process described in HOWTO-BUILD.
If you are using a binary distribution of native Larceny,
the ERR5RS/R6RS runtime and standard libraries should work
out of the box. If you touch or modify any of the source
files in lib/R6RS, however, then your next attempt to run
Larceny in ERR5RS or R6RS mode is likely to generate a
warning about "loading source in favor of stale fasl file".
This message may be followed by a long series of error
messages about syntactic keywords used as a variable,
ending with the kind of error you'd expect to see when a
large R6RS program is fed to a Scheme compiler that was
expecting to see R5RS-compatible code. To fix the
problem, repeat step 4 of HOWTO-BUILD.
ERR5RS MODE
To interact with Larceny's ERR5RS read/eval/print loop,
specify the -err5rs option on Larceny's command line:
% larceny -err5rs
Larceny v0.96 "Fluoridation" (...)
ERR5RS mode (no libraries have been imported)
Since no libraries have been imported, the only forms you
can evaluate are constant literals, variable references
(but no variables have been imported!), procedure calls
(but no procedure values are accessible!), library
definitions, and import forms. The first thing you'll
want to do is to import some of the pre-loaded libraries,
such as:
> (import (rnrs base) (rnrs lists) (rnrs io simple))
Once you have imported (rnrs base) or a composite library
that includes it, you can evaluate definitions and use
all other syntax and variables you have imported:
> (define two^7 (expt 2 (+ 3 4)))
> two^7
128
LIBRARY PATH
As an extension to ERR5RS, Larceny automatically loads
libraries when they are first imported, provided Larceny
can find the libraries in its library search path. The
library search path defaults to a path that contains
the predefined libraries listed below, but one additional
directory can be added to the library search path using
Larceny's --path command-line option.
Autoloaded libraries must be defined in files that follow
Larceny's standard naming conventions for ERR5RS/R6RS
library files. These naming conventions are described
in Larceny's user manual (see doc/user-manual.*).
DYNAMIC LOADING
To load top-level programs or unadorned R5RS-style code
from a file, you must first import a suitable load procedure:
> (import (err5rs load))
Loading a library does not automatically import it:
> (load "lib/R6RS/benchmarking.sch")
> (time (vector-for-each + (make-vector 1000000 0)))
Error: Undefined global variable "time".
Entering debugger; type "?" for help.
debug> q
To use the variables and syntax that are exported by an
explicitly loaded library, you must import that library
explicitly:
> (import (larceny benchmarking))
> (time (vector-for-each + (make-vector 1000000 0)))
Words allocated: 3095752
Words reclaimed: 0
Elapsed time...: 111 ms (User: 104 ms; System: 8 ms)
Elapsed GC time: 4 ms (CPU: 4 in 8 collections.)
Before you import a library or load a top-level program,
you must first load any nonstandard libraries it imports
unless those libraries will be found using Larceny's
library search path.
You do not have to import those libraries into the ERR5RS
top level, however, unless you want to use the variables
and syntax exported by those libraries in the expressions
and definitions you evaluate at the top level.
PREDEFINED LIBRARIES
For your convenience, Larceny pre-loads or autoloads all
of the standard R6RS libraries and several other libraries
besides, so you can import from those libraries without
having to load them yourself. For a list of predefined
libraries, see Larceny's user manual [4].
ACCESS TO LARCENY PROCEDURES
Larceny supports an extension to the ERR5RS that allows an
import form to import any R5RS procedure from Larceny's
R5RS-conforming top-level environment. For examples of its
use, see lib/R6RS/larceny/benchmarking.sls.
PRECOMPILING ERR5RS/R6RS FILES
Larceny v0.96 allows separate compilation of ERR5RS/R6RS
libraries, top-level programs, and Scheme scripts. The
compile-stale script will compile all .sls files that
reside within the directory from which it is invoked.
That is awkward to do manually, since a file should not
be compiled until all of the libraries that it imports
have been compiled.
For more information on separate compilation of ERR5RS
libraries and programs, see Larceny's user manual [4].
--------
[1] http://scheme-punks.org/wiki/index.php?title=ERR5RS:Charter
[2] http://www.schemers.org/Documents/Standards/R5RS/
[3] http://www.r6rs.org/
[4] http://larceny.ccs.neu.edu/doc/user-manual.html
or doc/user-manual*.html
================================================
FILE: doc/HOWTO-FENCE
================================================
2 August 2012 / lth@acm.org
5 May 2015 / WillClinger (updated status)
Overview.
This file contains some information about the Fence platform for
Larceny, and for native ports built on Fence. The Fence is a
"platform-independent platform".
The Fence assembler is machine independent and takes a high-level
intermediate code (MacScheme assembly instructions with many primitive
operations) and translates it to a low-level intermediate code. The
low-level intermediate code is called the Cant; it is at the level of
a real CPU. The Cant assembler, in turn, is machine-dependent and
translates Cant to machine code for a specific target machine.
The Fence assembler supports many optimizations in a portable way and
generates good code. In particular, it open-codes many primitives,
translates the rest to millicode calls, and performs many useful
peephole optimizations. All this code will work with any platform
built on Fence/Cant without further work required.
A simple Cant implementation (minimally about 500 lines of Scheme code
and 200 lines of assembler in the millicode layer, see the last
section of this document) will provide decent performance. An
optimizing Cant implementation will provide good performance, at least
on systems that are not completely register-starved.
The Cant instruction set is defined at the end of
Asm/Fence/pass5p2.sch. Some assumptions and simplifications are
documented at the head of that file.
At the time of writing one Cant implementation is operational, for the
32-bit ARM instruction set on the ARMv7-A CPU.
Quick start for developers.
The build procedure is standard; see HOWTO-BUILD for the details. I
use the following command for setting up the build system, there is at
present no "softfp" target but one is easy to create.
> (setup 'target: 'linux-arm-el-hardfp 'native)
Status, 5 May 2015:
- The little-endian ARM-32 Cant implementation with flat4 strings is
operational.
- Peephole optimizations have been ported from IAssassin. There is an
ARM-specific optimizer for branch elimination and an ARM
disassembler that eases debugging.
- Several different causes of segmentation faults and other fatal errors
have been tracked down and fixed.
- Tests passed
- System can rebuild its heap in both interpreted and compiled mode
(loading from fasl).
- Reloading the development system in larceny.heap from source and
rebuilding the heap works.
- test/Jaffer
- test/Lib
- test/Compiler
- test/R6RS
- test/R7RS (including conflicts.scm, Lib, and Numbers)
- test/Benchmarking/R7RS
- lib/SRFI/test (except tests that need the FFI)
- Tests NOT passed (details down below, after bugs and other items)
- test/GC (no full barrier for regional collector)
- test/FFI (no FFI)
Non-filed bugs and other to-do items:
- BUG (possibly very old, OK to just file the bug):
Looks like the stop-and-copy collector will never collect in
response to a stack overflow, but always expand the heap: passing 0
to collect_if_no_room() means it will always return 0 (no
collection). Passing STACK_ROOM would have been more appropriate.
- Lars has been rebuilding heaps on the ARM device using interpreter.
Will has been rebuilding heaps under Arch Linux ARM using compiler.
- Goal: bitwise identical heap
- fence-millicode.c: mc_alloc_bv: some magic to "align" the bytevector
so that it is better for code. Probably x86-specific but lacking a
proper ifdef and reasonable motivation. There is similar code
lurking in cheney.c (at least) in forward(), also not ifdef'd.
- Need to work around the use of MOVT in order to run on the ARMv6
CPU. The ARM11 implementation is popular (eg Raspberry Pi, many
existing devices) and that uses the ARMv6 architecture.
- Should get Petit Larceny running under ARM Linux.
Bugs.
- Timer issues:
There's a workaround in the Fence millicode for a problem seen on
ARM where disable_interrupts() would return a large negative number
or zero. The underlying bug is not known, but it might be a problem
(discovered late) where a stale enregistered value was used after
the return from a timer trap.
Need to retest this now, when the bug has been fixed.
Larceny bugs to file:
- The test suite in test/Lib fails with an error in the Record tests
if run twice in the same system ("nongenerative record type").
- In src/Lib/Arch/Fence/toplevel-target.sch and primops.sch there are
commented-out definitions of eg fx+, fx-, fx* -- these are disabled
because the R6RS mandated specific exceptions when these operations
overflow or are given non-fixnum arguments. R6RS-compatible (hence
slow) definitions are found in Lib/Common/fx.sch and in
Compiler/common.imp.sch
- There is no primitive support for bitwise-and, etc, used in eg
string->utf8 and utf8->string, but it does not seem that it would be
hard to add fixnum fast cases?
Other optimization items and concerns.
- Performance should be okay when we stay in native code, bad when
we trap to millicode (because the millicode traps to C in almost
all cases, notably for generic arithmetic).
* According to singled-threaded GeekBench, our 3.6 GHz i7-4790
is about 4 times as fast as our 2.0 GHz Exynos 5800 (ARMv7A).
Eyeballing R7RS benchmark results, Will thinks the Fence/ARM
code generator is doing pretty well:
the i7 is roughly 4 to 5 times as fast on tak, fib, sum
the i7 is 10 to 17 times as fast on fibfp, sumfp, fft, nucleic, mbrot
(because the IAssassin millicode is bummed for flonums)
the i7 is 6 to 25 times as fast on cat, tail, wc, read1, slatex
(io-intensive; read1 is the 25x outlier, attributable to the
SSD vs micro SD mismatch)
the i7 is 4 to 10 times as fast on nboyer, sboyer, gcbench, mperm
(gc-intensive, where the i7's 8 MB L3 cache should help)
- Asm/Fence/*.sch
* Search for TODO in all these files to locate opportunities for
performance tweaks (better instruction selection, better
strategies) and some other spots that may need attention.
- Code size remains a concern; ARM-32 is about as bad as Sparc.
- It would be better for both ARM and x86 if the value for UNDEFINED
could be represented in 8 bits. Since the low two bits are 10 we
can't use a shifted constant on ARM, so it has to be a byte constant.
The payoff is smaller code when checking for undefined globals.
Unfortunately it looks like the immediate space does not have room for
that encoding.
It is possible to define undefined to mean imm.misc + (0 << 8)
instead of imm.misc + (3 << 8) as now. Nobody uses the former value.
Measurements shows that that would reduce the ARM heap by 42904 bytes.
Probably worth doing, eventually.
How to port Larceny using Fence/Cant.
TO BE WRITTEN.
------------------------------------------------------------
WHY SHOULD ANYTHING BE NONDETERMINISTIC?
- GC is not time-based. (or wasn't, before).
(Some gc activity is now time-based, and timer interrupts
may be nondeterministic as well. Timer interrupts based
entirely on the software countdown timer produced too much
variation for scheduling tasks in the regional collector;
this was solved by using a rather short countdown interval
while ignoring countdown interrupts that occurred too soon
after the previous scheduling interrupt, as determined by
the operating system's notion of the actual time.)
- Heap addresses as a result of mmap?
(Yes, these are nondeterministic. See below.)
- If icache flush, how? Surely not by the program moving
between cores, we must assume the OS takes care of that.
(If it's an icache flush bug it's something that is "random"
because the program is sometimes moved, sometimes not, and
when it is not we have a bug.) Affinity can be controlled:
http://unix.stackexchange.com/questions/23106/limit-process-to-one-cpu-core
Heap addresses are indeed not stable. Here are four consecutive
invocations with larceny.heap (first expression after start):
> (syscall 36 (cons 1 2))
3055912328
> (syscall 36 (cons 1 2))
3055285640
> (syscall 36 (cons 1 2))
3055338888
> (syscall 36 (cons 1 2))
3055203720
Nondeterministic heap addresses in Windows 7 helped us to find
long-standing latent bugs in alloc.c and memmgr.c; see these
commits from 24 and 26 February 2015:
532461822a157d67c5048daf95df38b5d6faf8df
d90f165d98a7250c1425a4b5309727f19467a36e
------------------------------------------------------------
Test suites that do not pass.
Lars reported the following problem, but several crashers have been
fixed since then:
The GC tests do NOT pass:
- Benchmark runner just hangs, no diagnosis yet.
It could be the missing write barrier or whatever.
It hangs hard, ^C does not kill it (from within *shell*),
though sending a HUP does. It does not use any CPU, very strange.
----------------------------------------
Instruction cache flushing on ARM and elsewhere.
Apparently ARM can use the same flushing method as on Sparc, where we
flush individual addresses / cache lines as we generate code or copy
bytevectors. But the instructions to perform the flushing are
privileged, so a system call is required. On Linux, there is a system
call "clear_cache" to clear a range of addresses in the instruction
cache, but some noise on the web indicates that it is not properly
implemented in libc on all Android platforms. Right now
fence-driver.c makes the system call with inline assembler but this
could be investigated further.
On the ARM, we have to flush both the data cache and then the
instruction cache for the addresses / cache lines occupied by the
copied bytevectors. Previously, we were flushing only the cache
lines occupied by the bytevectors before they were copied. With
a unified or write-through data cache, the old way worked; it
isn't guaranteed to work with a split cache that uses write-back
for the data cache, as is usual for the ARM.
Ticket #724 describes a bug caused by an off-by-one error in the
cache-flushing routine, which has now been fixed.
================================================
FILE: doc/HOWTO-INSTALL
================================================
Installing Larceny
Short version:
Put Larceny's main directory wherever you like, and give it
whatever name you like.
Copy the executable scripts (larceny and scheme-script) wherever
you like, and edit them to set LARCENY_ROOT to the absolute
path of Larceny's main directory. (On Linux systems, you can
just create links to those scripts instead of copying them, and
you don't need to edit them.) You may also want to copy or
create links to the compile-larceny and compile-stale scripts.
If the directory that contains the executable scripts is not
already part of your path, then add it to your path.
If that doesn't work, keep reading.
System requirements:
To build Larceny from source code, see HOWTO-BUILD. Prebuilt
binary distributions of Larceny are available for machines with
ARMv7 or Intel IA32 and compatible (i386 or x86-32) processors
running the following operating systems:
Linux
MacOS X
Windows XP or later
Although Larceny still uses 32-bit pointers, it will run on
64-bit machines provided the necessary 32-bit compatibility
libraries have been installed.
On Linux machines, the 32-bit libraries can be installed by
incanting something like
sudo apt-get install lib32z1
sudo apt-get install libc6-i386
(The second of those should be unnecessary because libc6-i386
should be installed automatically when lib32z1 is installed.)
To build Larceny from source, you would also need to install
libc6-dev-i386.
On Macintoshes with Intel processors, the 32-bit libraries
should already be installed. If they aren't, installing the
Apple Developer command-line tools should fix the problem.
On Windows, the DEP feature must be told to allow Larceny to
opt-out. (See below.)
Long version:
After you download a binary distribution of Larceny or build from
source, there will be several scripts for starting Larceny in the root
of the Larceny tree. These can be run from that location, regardless of
where you keep the tree. If you want to make Larceny available to other
users of your system, however, or if you want to install the executables
in a standard place, this document will tell you how.
Larceny is usually started by a script, which has two functions:
- It sets an environment variable LARCENY_ROOT to the absolute path of
the Larceny tree, which is assumed to be the same as the directory
that the script is in.
- It dispatches on the name of the script, to choose both a Larceny
executable (such as larceny.bin) and a heap image (such as
larceny.heap).
Which scripts you have depends on what platform you are using:
- Windows: Batch files "larceny.bat" and "twobit.bat"
- Linux, Mac OS X: Shell scripts "larceny", "scheme-script",
compile-larceny, and "compile-stale"
Note that "twobit" and "twobit.heap" are no longer distributed
as part of Larceny's binary distributions.
If you would like to move a larceny or twobit script to another
directory but not rename it, it is sufficient to hard-code the
location of Larceny's root directory into the script. For
example, to install Petit Larceny into /usr/local on Linux,
untar the Larceny tree as /usr/local/lib/larceny. Then copy
the scripts "larceny", "scheme-script", "compile-stale", and
"compile-larceny" to /usr/local/bin, editing the first two by
uncommenting the line that sets LARCENY_ROOT, and setting it to
/usr/local/lib/larceny.
If you would like to change something else, such as the name of
a script, editing the script should not be too difficult.
Larceny is one of the few implementations of R6RS Scheme that
provides the scheme-script feature proposed by the R6RS editors,
but other implementations may define their own scheme-script. If
you want Larceny to execute your Scheme scripts, then you should
use the which command to make sure Larceny's scheme-script comes
before any others in your execution path. (By the way, Larceny's
scheme-script feature now executes programs in R7RS mode rather
than R6RS. Because Larceny's implementation of the R7RS acts as
a
gitextract_1uoc4hss/
├── .gitattributes
├── .gitignore
├── COPYRIGHT
├── README-COMMON-LARCENY.txt
├── README-FIRST.txt
├── README.md
├── compile-larceny
├── compile-stale
├── doc/
│ ├── .gitignore
│ ├── CommonLarceny/
│ │ ├── image-teachpack.html
│ │ ├── image-teachpack.txt
│ │ ├── user-manual.txt
│ │ ├── world-teachpack.html
│ │ └── world-teachpack.txt
│ ├── DevManual/
│ │ ├── auxlib.txt
│ │ ├── bdw.txt
│ │ ├── bytevectors.txt
│ │ ├── compiling.txt
│ │ ├── concept.txt
│ │ ├── control.txt
│ │ ├── developing.txt
│ │ ├── environ.txt
│ │ ├── ephemeral.txt
│ │ ├── lowlevel.txt
│ │ ├── memstats.txt
│ │ ├── nasm-representations.txt
│ │ ├── procidx.txt
│ │ ├── repl.txt
│ │ ├── starting.txt
│ │ └── structures.txt
│ ├── HOWTO-BUILD
│ ├── HOWTO-ERR5RS
│ ├── HOWTO-FENCE
│ ├── HOWTO-INSTALL
│ ├── HOWTO-R6RS
│ ├── HOWTO-R7RS
│ ├── HOWTO-SCRIPT
│ ├── HOWTO-SLIB
│ ├── HOWTO-SRFI
│ ├── KNOWN-BUGS
│ ├── LarcenyNotes/
│ │ ├── generic-add.html
│ │ ├── larceny-notes.txt
│ │ ├── note1-timer.html
│ │ ├── note10-primops.html
│ │ ├── note11-bdw.html
│ │ ├── note12-procinfo.html
│ │ ├── note13-malcode.html
│ │ ├── note14-petit.html
│ │ ├── note2-repr.html
│ │ ├── note3-arithmetic.html
│ │ ├── note4-exceptions.html
│ │ ├── note5-heap.html
│ │ ├── note6-sparc.html
│ │ ├── note7-ffi.html
│ │ ├── note8-release.html
│ │ ├── note9-iosys.html
│ │ ├── noteX-gc.html
│ │ ├── noteX-newgc.html
│ │ ├── noteX-petit.html
│ │ ├── noteX-rts.html
│ │ ├── noteX-sc-heap.html
│ │ └── template.html
│ ├── Makefile
│ ├── OldDocs/
│ │ ├── BUGS
│ │ ├── BUGS-FIXED
│ │ ├── BUGS-RETIRED
│ │ ├── HOWTO-BUILD
│ │ ├── HOWTO-CVS
│ │ ├── HOWTO-I386
│ │ ├── HOWTO-MACOSX
│ │ ├── HOWTO-PETIT
│ │ ├── HOWTO-PPC
│ │ ├── HOWTO-SCREEN
│ │ ├── HOWTO-SPARC
│ │ ├── HOWTO-UNIX
│ │ ├── HOWTO-WIN32
│ │ ├── TODO
│ │ ├── TODO-PETIT
│ │ ├── TODO-RAINYDAY
│ │ ├── TODO-RELEASE
│ │ └── USER-REQUESTS
│ ├── UserManual/
│ │ ├── benchmarking.txt
│ │ ├── bytevectors.txt
│ │ ├── compiler.txt
│ │ ├── compiling.txt
│ │ ├── debugging.txt
│ │ ├── draft.txt
│ │ ├── entry.txt
│ │ ├── err5rs.txt
│ │ ├── ffi.txt
│ │ ├── fixnums.txt
│ │ ├── hashtable.txt
│ │ ├── ieee-std.txt
│ │ ├── intro.txt
│ │ ├── io.txt
│ │ ├── lexical.txt
│ │ ├── libraries.txt
│ │ ├── load.txt
│ │ ├── naming.txt
│ │ ├── numbers.txt
│ │ ├── os.txt
│ │ ├── pairs_lists.txt
│ │ ├── parameters.txt
│ │ ├── procedures.txt
│ │ ├── procidx.txt
│ │ ├── proplist.txt
│ │ ├── r6rs.txt
│ │ ├── r7rs.txt
│ │ ├── records.txt
│ │ ├── recprinter.txt
│ │ ├── running.txt
│ │ ├── slib.txt
│ │ ├── sorting.txt
│ │ ├── sparc-cache.txt
│ │ ├── srfi.txt
│ │ ├── starting.txt
│ │ ├── strings.txt
│ │ ├── symbols.txt
│ │ ├── syscontrol.txt
│ │ ├── template.txt
│ │ ├── unprovided.txt
│ │ ├── user-manual.txt
│ │ └── vectors.txt
│ ├── index.html
│ └── larcenydoc.conf
├── examples/
│ └── CommonLarceny/
│ ├── event-handling-demo1.sch
│ ├── event-handling-demo2.sch
│ └── form-graphics.sch
├── include/
│ ├── Nasm/
│ │ └── i386-instr.ah
│ ├── Shared/
│ │ ├── i386-machine.ah
│ │ ├── millicode.h
│ │ ├── petit-config.h
│ │ └── petit-machine.h
│ ├── Standard-C/
│ │ └── petit-instr.h
│ └── Sys/
│ ├── larceny-types.h
│ └── macros.h
├── lib/
│ ├── Base/
│ │ ├── defaults.sch
│ │ ├── dotnet-compile-file.sch
│ │ ├── format.sch
│ │ ├── io.sch
│ │ ├── list.sch
│ │ ├── load.sch
│ │ ├── macros.sch
│ │ ├── misc.sch
│ │ ├── osdep-macos.sch
│ │ ├── osdep-unix.sch
│ │ ├── osdep-win32.sch
│ │ ├── petit-compile-file.sch
│ │ ├── pp.sch
│ │ ├── process-stats.sch
│ │ ├── shivers-syntax.sch
│ │ ├── std-ffi.sch
│ │ ├── string.sch
│ │ ├── unix-functions.sch
│ │ └── vector.sch
│ ├── Broken/
│ │ ├── nonblocking-console.sch
│ │ ├── read-circular.sch
│ │ ├── read-source.sch
│ │ ├── task-test.sch
│ │ ├── task-test2.sch
│ │ ├── transcript.sch
│ │ └── unix-descriptor.sch
│ ├── Debugger/
│ │ ├── call-cc.sch
│ │ ├── countcalls.sch
│ │ ├── debug-info.txt
│ │ ├── debug.sch
│ │ ├── debugging.txt
│ │ ├── inspect-cont.sch
│ │ ├── new-debugger.sch
│ │ ├── profile.sch
│ │ ├── trace.sch
│ │ └── variables.sch
│ ├── Experimental/
│ │ ├── Beginning/
│ │ │ ├── beginning.txt
│ │ │ ├── colors.txt
│ │ │ ├── interpreter.sch
│ │ │ ├── loadall.sch
│ │ │ ├── posn.sch
│ │ │ ├── primops.sch
│ │ │ ├── stepper.sch
│ │ │ ├── syntax.sch
│ │ │ └── tests.sch
│ │ ├── DotNet/
│ │ │ ├── collections.sch
│ │ │ ├── dotnet-ffi-lcg.sch
│ │ │ ├── example.sch
│ │ │ ├── gui-inspection.sch
│ │ │ ├── maybe-read.sch
│ │ │ ├── protoobj.sch
│ │ │ ├── simple-inspection.sch
│ │ │ ├── simple-reflection.sch
│ │ │ ├── stepper-gui.sch
│ │ │ ├── stepper-menus.sch
│ │ │ ├── stepper-overrides.sch
│ │ │ ├── toolsmith-form.sch
│ │ │ ├── toolsmith-shared.sch
│ │ │ └── toolsmith-stepper.sch
│ │ ├── Makefile
│ │ ├── accum-profile.sch
│ │ ├── applyhook.sch
│ │ ├── applyhook0.mal
│ │ ├── apropos.sch
│ │ ├── exception.sch
│ │ ├── finger.sch
│ │ ├── glut.sch
│ │ ├── ia32parser.sch
│ │ ├── iosys.txt
│ │ ├── match.sch
│ │ ├── object-behavior/
│ │ │ ├── compute-object-behavior.sch
│ │ │ ├── hash.sch
│ │ │ ├── hashtable.sch
│ │ │ └── plot-profile.sch
│ │ ├── object-id.sch
│ │ ├── opengl-constants.sch
│ │ ├── opengl-enums.sch
│ │ ├── opengl-functions.sch
│ │ ├── opengl.sch
│ │ ├── poll.sch
│ │ ├── print-circular.sch
│ │ ├── scheme-source.sch
│ │ ├── smtp.sch
│ │ ├── socket-offset.c
│ │ ├── socket-support.c
│ │ ├── socket.sch
│ │ ├── system-stuff.sch
│ │ ├── task-test0.sch
│ │ ├── tasking-extra.sch
│ │ ├── tasking-notes.txt
│ │ ├── tasking-unix.sch
│ │ ├── tasking-with-io.sch
│ │ ├── tasking.sch
│ │ ├── twobit-benchmark.sch
│ │ ├── twobit-pass-times.sch
│ │ ├── twobit-timer.sch
│ │ ├── unix-support.c
│ │ ├── unix.sch
│ │ ├── weak.sch
│ │ ├── webclient/
│ │ │ ├── README
│ │ │ ├── browser.sch
│ │ │ ├── datastore.sch
│ │ │ ├── es-aux.sch
│ │ │ ├── es-cg.sch
│ │ │ ├── es-lexer.sch
│ │ │ ├── es-parser.sch
│ │ │ ├── es-runtime.sch
│ │ │ ├── html-entities.sch
│ │ │ ├── html-format.sch
│ │ │ ├── html-parser-test.sch
│ │ │ ├── html-parser.sch
│ │ │ └── wget.sch
│ │ ├── webserver/
│ │ │ ├── web-fun.sch
│ │ │ ├── web-server.sch
│ │ │ └── web-utils.sch
│ │ ├── winsock-descriptor.sch
│ │ └── winsock.sch
│ ├── Ffi/
│ │ ├── README
│ │ ├── arm-abi.txt
│ │ ├── bdw-memory.sch
│ │ ├── ffi-i386.sch
│ │ ├── ffi-linux-x86.sch
│ │ ├── ffi-load.sch
│ │ ├── ffi-lower.sch
│ │ ├── ffi-macosx.sch
│ │ ├── ffi-sparc.sch
│ │ ├── ffi-sunos4.sch
│ │ ├── ffi-sunos5.sch
│ │ ├── ffi-upper.sch
│ │ ├── ffi-util.sch
│ │ ├── ffi-win32.sch
│ │ ├── i386-abi.txt
│ │ ├── memory.sch
│ │ ├── sparc-abi.txt
│ │ └── tramp.sch
│ ├── MzScheme/
│ │ ├── class.sch
│ │ ├── compress.sch
│ │ ├── cont.sch
│ │ ├── custodian.sch
│ │ ├── dotnet-ffi.sch
│ │ ├── dotnet.sch
│ │ ├── envaux.sch
│ │ ├── excel-demo.sch
│ │ ├── exn.sch
│ │ ├── generic.sch
│ │ ├── gprint.sch
│ │ ├── hash-compat.sch
│ │ ├── identifier.sch
│ │ ├── init.sch
│ │ ├── inspector.sch
│ │ ├── instance.sch
│ │ ├── instance0.mal
│ │ ├── macros.sch
│ │ ├── misc.sch
│ │ ├── namespace.sch
│ │ ├── parameters.sch
│ │ ├── record.sch
│ │ ├── simple-macros/
│ │ │ ├── mzmacros.sch
│ │ │ ├── r5rs.sch
│ │ │ ├── simple-macros-tests.sch
│ │ │ ├── simple-macros.sch
│ │ │ ├── simple-module-examples.sch
│ │ │ └── simple-syntax-case.sch
│ │ ├── struct-macros.sch
│ │ ├── struct-proc.sch
│ │ ├── struct-proc0.mal
│ │ ├── struct.sch
│ │ ├── thread.sch
│ │ ├── wcm.sch
│ │ ├── wcm0.mal
│ │ └── windows.sch
│ ├── R6RS/
│ │ ├── benchmarking.sch
│ │ ├── err5rs/
│ │ │ ├── load.sls
│ │ │ ├── records/
│ │ │ │ ├── syntactic/
│ │ │ │ │ └── original.sls
│ │ │ │ └── syntactic.sls
│ │ │ └── records.sls
│ │ ├── explicit-renaming.sls
│ │ ├── larceny/
│ │ │ ├── benchmarking.sls
│ │ │ ├── compile-stale.body.scm
│ │ │ ├── compile-stale.sld
│ │ │ ├── compiler.sld
│ │ │ ├── deprecated.sls
│ │ │ ├── load.sls
│ │ │ ├── parse-options.body.scm
│ │ │ ├── parse-options.sld
│ │ │ ├── r7r6.sld
│ │ │ ├── r7rs/
│ │ │ │ ├── macros.body.scm
│ │ │ │ ├── macros.sld
│ │ │ │ ├── primitives/
│ │ │ │ │ ├── lowlevel.sld
│ │ │ │ │ └── patches.sld
│ │ │ │ ├── primitives.sld
│ │ │ │ ├── promises.body.scm
│ │ │ │ ├── promises.sld
│ │ │ │ └── test.sld
│ │ │ ├── records.sls
│ │ │ ├── shivers-syntax.sls
│ │ │ └── text.sld
│ │ ├── r5rs.sls
│ │ ├── r6rs-compat-larceny.sch
│ │ ├── r6rs-expander.sch
│ │ ├── r6rs-runtime.sch
│ │ ├── r6rs-standard-libraries.sch
│ │ ├── r6rsmode.sch
│ │ ├── readme.txt
│ │ ├── rnrs/
│ │ │ ├── arithmetic.sls
│ │ │ ├── bytevectors.sls
│ │ │ ├── conditions.sls
│ │ │ ├── control.sls
│ │ │ ├── enums.sls
│ │ │ ├── eval.sls
│ │ │ ├── exceptions.sls
│ │ │ ├── files.sls
│ │ │ ├── hashtables.sls
│ │ │ ├── io.sls
│ │ │ ├── lists.sls
│ │ │ ├── load.sls
│ │ │ ├── mutable-pairs.sls
│ │ │ ├── mutable-strings.sls
│ │ │ ├── programs.sls
│ │ │ ├── r5rs.sls
│ │ │ ├── records/
│ │ │ │ ├── syntactic/
│ │ │ │ │ └── original.sls
│ │ │ │ └── syntactic.sls
│ │ │ ├── records.sls
│ │ │ ├── sorting.sls
│ │ │ ├── syntax-case.sls
│ │ │ └── unicode.sls
│ │ └── rnrs.sls
│ ├── R7RS/
│ │ ├── r7rs-cond-expander.sch
│ │ ├── r7rs-includer.sch
│ │ ├── r7rsmode.sch
│ │ └── scheme/
│ │ ├── base.body.scm
│ │ ├── base.sld
│ │ ├── box.sld
│ │ ├── case-lambda.sld
│ │ ├── char.body.scm
│ │ ├── char.sld
│ │ ├── charset.sld
│ │ ├── comparator.sld
│ │ ├── complex.sld
│ │ ├── cxr.sld
│ │ ├── ephemeron.sld
│ │ ├── eval.sld
│ │ ├── file.sld
│ │ ├── generator.sld
│ │ ├── hash-table.sld
│ │ ├── ideque.sld
│ │ ├── ilist.sld
│ │ ├── inexact.sld
│ │ ├── lazy.sld
│ │ ├── list-queue.sld
│ │ ├── list.sld
│ │ ├── load.sld
│ │ ├── lseq.sld
│ │ ├── process-context.body.scm
│ │ ├── process-context.sld
│ │ ├── r5rs.sld
│ │ ├── read.sld
│ │ ├── repl.body.scm
│ │ ├── repl.sld
│ │ ├── rlist.sld
│ │ ├── set.sld
│ │ ├── sort.sld
│ │ ├── stream.sld
│ │ ├── text.sld
│ │ ├── time.body.scm
│ │ ├── time.decls.scm
│ │ ├── time.sld
│ │ ├── vector.sld
│ │ └── write.sld
│ ├── README
│ ├── SRFI/
│ │ ├── README
│ │ ├── in-progress/
│ │ │ ├── README
│ │ │ ├── spans-search-test.sps
│ │ │ ├── spans-test.sps
│ │ │ ├── spans.body1.scm
│ │ │ ├── spans.body1a.scm
│ │ │ ├── spans.body1b.scm
│ │ │ ├── spans.body1c.scm
│ │ │ ├── spans.body1d.scm
│ │ │ ├── spans.body2.scm
│ │ │ ├── spans.sld
│ │ │ ├── srfi-2.sch
│ │ │ ├── srfi-34-test.sch
│ │ │ ├── srfi-34.sch
│ │ │ └── srfi-41.sch
│ │ ├── scheme-r5rs.c
│ │ ├── srfi/
│ │ │ ├── %3a1.sls
│ │ │ ├── %3a101.sls
│ │ │ ├── %3a11.sls
│ │ │ ├── %3a13.sls
│ │ │ ├── %3a14.sls
│ │ │ ├── %3a16.sls
│ │ │ ├── %3a17.sls
│ │ │ ├── %3a19.sls
│ │ │ ├── %3a2.sls
│ │ │ ├── %3a23.sls
│ │ │ ├── %3a25.sls
│ │ │ ├── %3a26.sls
│ │ │ ├── %3a27.sls
│ │ │ ├── %3a28.sls
│ │ │ ├── %3a29.sls
│ │ │ ├── %3a30.sls
│ │ │ ├── %3a31.sls
│ │ │ ├── %3a34.sls
│ │ │ ├── %3a37.sls
│ │ │ ├── %3a38.sls
│ │ │ ├── %3a39.sls
│ │ │ ├── %3a41.sls
│ │ │ ├── %3a42.sls
│ │ │ ├── %3a43.sls
│ │ │ ├── %3a45.sls
│ │ │ ├── %3a48.sls
│ │ │ ├── %3a5.sls
│ │ │ ├── %3a51.sls
│ │ │ ├── %3a54.sls
│ │ │ ├── %3a55.sls
│ │ │ ├── %3a59.sls
│ │ │ ├── %3a6.sls
│ │ │ ├── %3a60.sls
│ │ │ ├── %3a61.sls
│ │ │ ├── %3a62.sls
│ │ │ ├── %3a63.sls
│ │ │ ├── %3a64.sls
│ │ │ ├── %3a66.sls
│ │ │ ├── %3a67.sls
│ │ │ ├── %3a69.sls
│ │ │ ├── %3a71.sls
│ │ │ ├── %3a74.sls
│ │ │ ├── %3a78.sls
│ │ │ ├── %3a8.sls
│ │ │ ├── %3a86.sls.deprecated
│ │ │ ├── %3a87.sls
│ │ │ ├── %3a9.sls
│ │ │ ├── %3a95.sls
│ │ │ ├── %3a98.sls
│ │ │ ├── %3a99.sls
│ │ │ ├── 0.sld
│ │ │ ├── 1.sld
│ │ │ ├── 101.sld
│ │ │ ├── 11.sld
│ │ │ ├── 111.sld
│ │ │ ├── 112.sld
│ │ │ ├── 113.body.scm
│ │ │ ├── 113.sld
│ │ │ ├── 114.advanced.scm
│ │ │ ├── 114.basics.scm
│ │ │ ├── 114.constructors.scm
│ │ │ ├── 114.default.scm
│ │ │ ├── 114.sld
│ │ │ ├── 115.body.scm
│ │ │ ├── 115.boundary.scm
│ │ │ ├── 115.sld
│ │ │ ├── 116/
│ │ │ │ ├── comparators.body.scm
│ │ │ │ ├── comparators.sld
│ │ │ │ ├── ilists.body1.scm
│ │ │ │ ├── ilists.body2.scm
│ │ │ │ └── ilists.sld
│ │ │ ├── 116.sld
│ │ │ ├── 117.body.scm
│ │ │ ├── 117.sld
│ │ │ ├── 121.body.scm
│ │ │ ├── 121.sld
│ │ │ ├── 122.body.scm
│ │ │ ├── 122.sld
│ │ │ ├── 123.body.scm
│ │ │ ├── 123.sld
│ │ │ ├── 124.body.scm
│ │ │ ├── 124.sld
│ │ │ ├── 125.body.scm
│ │ │ ├── 125.sld
│ │ │ ├── 126.body.scm
│ │ │ ├── 126.sld
│ │ │ ├── 127.body.scm
│ │ │ ├── 127.sld
│ │ │ ├── 128/
│ │ │ │ ├── kernel.body.scm
│ │ │ │ ├── kernel.sld
│ │ │ │ ├── reference.body1.scm
│ │ │ │ ├── reference.body2.scm
│ │ │ │ └── reference.sld
│ │ │ ├── 128.body1.scm
│ │ │ ├── 128.body2.scm
│ │ │ ├── 128.sld
│ │ │ ├── 129.sld
│ │ │ ├── 13.sld
│ │ │ ├── 130.body.scm
│ │ │ ├── 130.sld
│ │ │ ├── 131.sld
│ │ │ ├── 132/
│ │ │ │ ├── delndups.scm
│ │ │ │ ├── lmsort.scm
│ │ │ │ ├── merge.scm
│ │ │ │ ├── select.scm
│ │ │ │ ├── sort.scm
│ │ │ │ ├── sortfaster.scm
│ │ │ │ ├── sortp.scm
│ │ │ │ ├── vector-util.scm
│ │ │ │ ├── vhsort.scm
│ │ │ │ ├── visort.scm
│ │ │ │ ├── vmsort.scm
│ │ │ │ ├── vqsort2.scm
│ │ │ │ └── vqsort3.scm
│ │ │ ├── 132.sld
│ │ │ ├── 133.body.scm
│ │ │ ├── 133.sld
│ │ │ ├── 134.body.scm
│ │ │ ├── 134.sld
│ │ │ ├── 135/
│ │ │ │ ├── kernel0.body.scm
│ │ │ │ ├── kernel0.sld
│ │ │ │ ├── kernel16.body.scm
│ │ │ │ ├── kernel16.sld
│ │ │ │ ├── kernel8.body.scm
│ │ │ │ ├── kernel8.sld
│ │ │ │ └── texts.sld
│ │ │ ├── 135.body.scm
│ │ │ ├── 135.sld
│ │ │ ├── 136.body.scm
│ │ │ ├── 136.sld
│ │ │ ├── 137.body.scm
│ │ │ ├── 137.sld
│ │ │ ├── 138.body.scm
│ │ │ ├── 138.sld
│ │ │ ├── 14/
│ │ │ │ ├── bmp.sld
│ │ │ │ ├── char-sets.body.scm
│ │ │ │ ├── char-sets.sld
│ │ │ │ ├── latin-1.sld
│ │ │ │ └── unicode.sld
│ │ │ ├── 14.sld
│ │ │ ├── 141.body.scm
│ │ │ ├── 141.sld
│ │ │ ├── 142.sld
│ │ │ ├── 143.sld
│ │ │ ├── 144.body.scm
│ │ │ ├── 144.body0.scm
│ │ │ ├── 144.constants.scm
│ │ │ ├── 144.ffi.scm
│ │ │ ├── 144.r6rs.scm
│ │ │ ├── 144.sld
│ │ │ ├── 144.special.scm
│ │ │ ├── 145.sld
│ │ │ ├── 146/
│ │ │ │ ├── rbtree.body.scm
│ │ │ │ └── rbtree.sld
│ │ │ ├── 146.body.scm
│ │ │ ├── 146.sld
│ │ │ ├── 147.body.scm
│ │ │ ├── 147.sld
│ │ │ ├── 151.body.scm
│ │ │ ├── 151.sld
│ │ │ ├── 152.body.scm
│ │ │ ├── 152.sld
│ │ │ ├── 16.sld
│ │ │ ├── 17.sld
│ │ │ ├── 19.sld
│ │ │ ├── 2.sld
│ │ │ ├── 23.sld
│ │ │ ├── 25.sld
│ │ │ ├── 26.sld
│ │ │ ├── 27.sld
│ │ │ ├── 28.sld
│ │ │ ├── 29.sld
│ │ │ ├── 30.sld
│ │ │ ├── 31.sld
│ │ │ ├── 34.sld
│ │ │ ├── 37.body.scm
│ │ │ ├── 37.sld
│ │ │ ├── 38.sld
│ │ │ ├── 39.sld
│ │ │ ├── 41.sld
│ │ │ ├── 42.sld
│ │ │ ├── 43.sld
│ │ │ ├── 45.sld
│ │ │ ├── 48.sld
│ │ │ ├── 5.sld
│ │ │ ├── 51.sld
│ │ │ ├── 54.sld
│ │ │ ├── 55.sld
│ │ │ ├── 59.sld
│ │ │ ├── 6.sld
│ │ │ ├── 60.sld
│ │ │ ├── 61.sld
│ │ │ ├── 62.sld
│ │ │ ├── 63.sld
│ │ │ ├── 64.body.scm
│ │ │ ├── 64.sld
│ │ │ ├── 66.sld
│ │ │ ├── 67.sld
│ │ │ ├── 69.sld
│ │ │ ├── 71.sld
│ │ │ ├── 74.sld
│ │ │ ├── 78.sld
│ │ │ ├── 8.sld
│ │ │ ├── 87.sld
│ │ │ ├── 9.sld
│ │ │ ├── 95.sld
│ │ │ ├── 98.sld
│ │ │ ├── 99.sld
│ │ │ ├── srfi38grammar.sch
│ │ │ └── srfi38tokens.sch
│ │ ├── srfi-0.sch
│ │ ├── srfi-1.sch
│ │ ├── srfi-11.sch
│ │ ├── srfi-13.sch
│ │ ├── srfi-14.sch
│ │ ├── srfi-16.sch
│ │ ├── srfi-17.sch
│ │ ├── srfi-19.sch
│ │ ├── srfi-2.sch
│ │ ├── srfi-22.sch
│ │ ├── srfi-23.sch
│ │ ├── srfi-25.sch
│ │ ├── srfi-26.sch
│ │ ├── srfi-27.sch
│ │ ├── srfi-28.sch
│ │ ├── srfi-29.sch
│ │ ├── srfi-30.sch
│ │ ├── srfi-31.sch
│ │ ├── srfi-37.sch
│ │ ├── srfi-38.sch
│ │ ├── srfi-39.sch
│ │ ├── srfi-41.sls
│ │ ├── srfi-42.sch
│ │ ├── srfi-43.sch
│ │ ├── srfi-45.sch
│ │ ├── srfi-48.sch
│ │ ├── srfi-5.sch
│ │ ├── srfi-51.sch
│ │ ├── srfi-54.sch
│ │ ├── srfi-56.sch
│ │ ├── srfi-59.sch
│ │ ├── srfi-6.sch
│ │ ├── srfi-60.sch
│ │ ├── srfi-61.sch
│ │ ├── srfi-62.sch
│ │ ├── srfi-63.sch
│ │ ├── srfi-64.sch
│ │ ├── srfi-66.sch
│ │ ├── srfi-67.sch
│ │ ├── srfi-69.sch
│ │ ├── srfi-7.sch
│ │ ├── srfi-71.sch
│ │ ├── srfi-74.sch
│ │ ├── srfi-78.sch
│ │ ├── srfi-8.sch
│ │ ├── srfi-86.sch
│ │ ├── srfi-87.sch
│ │ ├── srfi-9.sch
│ │ ├── srfi-95.sch
│ │ ├── srfi-96.sch
│ │ ├── srfi-98.sch
│ │ └── test/
│ │ ├── 122test.pgm
│ │ ├── README
│ │ ├── gauche-testsuite.sch
│ │ ├── load-all-tests.sch
│ │ ├── run-r6-tests
│ │ ├── run-r7-tests
│ │ ├── srfi-0-test.sch
│ │ ├── srfi-0-test.sps7
│ │ ├── srfi-1-test.sch
│ │ ├── srfi-1-test.sps
│ │ ├── srfi-1-test.sps7
│ │ ├── srfi-101-test.body.scm
│ │ ├── srfi-101-test.sps
│ │ ├── srfi-101-test.sps7
│ │ ├── srfi-11-test.sch
│ │ ├── srfi-11-test.sps
│ │ ├── srfi-11-test.sps7
│ │ ├── srfi-111-test.sps7
│ │ ├── srfi-112-test.sps7
│ │ ├── srfi-113-test.sps7
│ │ ├── srfi-115-test.sps7
│ │ ├── srfi-116-test.sps7
│ │ ├── srfi-117-test.sps7
│ │ ├── srfi-121-test.sps7
│ │ ├── srfi-122-test.sps7
│ │ ├── srfi-123-test.sps7
│ │ ├── srfi-124-test.sps7
│ │ ├── srfi-125-test.sps7
│ │ ├── srfi-126-test.body.scm
│ │ ├── srfi-126-test.sps7
│ │ ├── srfi-127-test.sps7
│ │ ├── srfi-128-benchmark.sps
│ │ ├── srfi-128-test.sps7
│ │ ├── srfi-129-test.sps7
│ │ ├── srfi-13-test.sch
│ │ ├── srfi-13-test.sps
│ │ ├── srfi-13-test.sps7
│ │ ├── srfi-130-test.sps7
│ │ ├── srfi-132-test.sps7
│ │ ├── srfi-133-test.sps7
│ │ ├── srfi-134-test.body.scm
│ │ ├── srfi-134-test.sps7
│ │ ├── srfi-135-search-test.sps7
│ │ ├── srfi-135-test.sps7
│ │ ├── srfi-136-test.sps7
│ │ ├── srfi-137-test.sps7
│ │ ├── srfi-14-test.sch
│ │ ├── srfi-14-test.sps
│ │ ├── srfi-14-test.sps7
│ │ ├── srfi-141-test.sps7
│ │ ├── srfi-143-test.sps7
│ │ ├── srfi-144-test.scm
│ │ ├── srfi-145-test.sps7
│ │ ├── srfi-146-test.sps7
│ │ ├── srfi-147-test.sps7
│ │ ├── srfi-148-test.sps7
│ │ ├── srfi-151-test.sps7
│ │ ├── srfi-152-test.sps7
│ │ ├── srfi-16-test.sch
│ │ ├── srfi-16-test.sps
│ │ ├── srfi-16-test.sps7
│ │ ├── srfi-17-test.sch
│ │ ├── srfi-17-test.sps
│ │ ├── srfi-17-test.sps7
│ │ ├── srfi-19-test.sch
│ │ ├── srfi-19-test.sps
│ │ ├── srfi-19-test.sps7
│ │ ├── srfi-2-test.sch
│ │ ├── srfi-2-test.sps
│ │ ├── srfi-2-test.sps7
│ │ ├── srfi-22-helper1.sch
│ │ ├── srfi-22-helper2.sch
│ │ ├── srfi-22-test
│ │ ├── srfi-23-test.sch
│ │ ├── srfi-23-test.sps
│ │ ├── srfi-23-test.sps7
│ │ ├── srfi-25-test.sch
│ │ ├── srfi-25-test.sps
│ │ ├── srfi-25-test.sps7
│ │ ├── srfi-26-test.sch
│ │ ├── srfi-26-test.sps
│ │ ├── srfi-26-test.sps7
│ │ ├── srfi-27-test.sch
│ │ ├── srfi-27-test.sps
│ │ ├── srfi-27-test.sps7
│ │ ├── srfi-28-test.sch
│ │ ├── srfi-28-test.sps
│ │ ├── srfi-28-test.sps7
│ │ ├── srfi-29-test.sch
│ │ ├── srfi-29-test.sps
│ │ ├── srfi-29-test.sps7
│ │ ├── srfi-30-test.sch
│ │ ├── srfi-30-test.sps7
│ │ ├── srfi-31-test.sch
│ │ ├── srfi-31-test.sps
│ │ ├── srfi-31-test.sps7
│ │ ├── srfi-34-test.sps7
│ │ ├── srfi-37-test.sch
│ │ ├── srfi-37-test.sps7
│ │ ├── srfi-38-test.sch
│ │ ├── srfi-38-test.sps
│ │ ├── srfi-38-test.sps7
│ │ ├── srfi-39-test.sch
│ │ ├── srfi-39-test.sps
│ │ ├── srfi-39-test.sps7
│ │ ├── srfi-41-test.sps
│ │ ├── srfi-41-test.sps7
│ │ ├── srfi-42-test.sch
│ │ ├── srfi-42-test.sps
│ │ ├── srfi-42-test.sps7
│ │ ├── srfi-43-test.sch
│ │ ├── srfi-43-test.sps
│ │ ├── srfi-43-test.sps7
│ │ ├── srfi-45-test.sch
│ │ ├── srfi-45-test.sps
│ │ ├── srfi-45-test.sps7
│ │ ├── srfi-48-test.sch
│ │ ├── srfi-48-test.sps
│ │ ├── srfi-48-test.sps7
│ │ ├── srfi-5-test.sch
│ │ ├── srfi-5-test.sps
│ │ ├── srfi-5-test.sps7
│ │ ├── srfi-51-test.sch
│ │ ├── srfi-51-test.sps
│ │ ├── srfi-51-test.sps7
│ │ ├── srfi-54-test.sch
│ │ ├── srfi-54-test.sps
│ │ ├── srfi-54-test.sps7
│ │ ├── srfi-55-test.sps7
│ │ ├── srfi-59-test.sps
│ │ ├── srfi-59-test.sps7
│ │ ├── srfi-6-test.sch
│ │ ├── srfi-6-test.sps
│ │ ├── srfi-6-test.sps7
│ │ ├── srfi-60-test.sch
│ │ ├── srfi-60-test.sps
│ │ ├── srfi-60-test.sps7
│ │ ├── srfi-61-test.sch
│ │ ├── srfi-61-test.sps
│ │ ├── srfi-61-test.sps7
│ │ ├── srfi-63-test.sch
│ │ ├── srfi-63-test.sps
│ │ ├── srfi-63-test.sps7
│ │ ├── srfi-64-test.sch
│ │ ├── srfi-64-test.sps
│ │ ├── srfi-64-test.sps7
│ │ ├── srfi-66-test.sch
│ │ ├── srfi-66-test.sps
│ │ ├── srfi-66-test.sps7
│ │ ├── srfi-67-test.sch
│ │ ├── srfi-67-test.sps
│ │ ├── srfi-67-test.sps7
│ │ ├── srfi-69-test.sch
│ │ ├── srfi-69-test.sps
│ │ ├── srfi-69-test.sps7
│ │ ├── srfi-7-helper1.sch
│ │ ├── srfi-7-helper2.sch
│ │ ├── srfi-7-helper3.sch
│ │ ├── srfi-7-test.sch
│ │ ├── srfi-71-test.sch
│ │ ├── srfi-71-test.sps
│ │ ├── srfi-71-test.sps7
│ │ ├── srfi-74-test.sch
│ │ ├── srfi-74-test.sps
│ │ ├── srfi-74-test.sps7
│ │ ├── srfi-78-test.sch
│ │ ├── srfi-78-test.sps
│ │ ├── srfi-78-test.sps7
│ │ ├── srfi-8-test.sch
│ │ ├── srfi-8-test.sps
│ │ ├── srfi-8-test.sps7
│ │ ├── srfi-86-test.sch
│ │ ├── srfi-86-test.sps
│ │ ├── srfi-86-test.sps7
│ │ ├── srfi-87-test.sch
│ │ ├── srfi-87-test.sps
│ │ ├── srfi-87-test.sps7
│ │ ├── srfi-9-test.sch
│ │ ├── srfi-9-test.sps
│ │ ├── srfi-9-test.sps7
│ │ ├── srfi-95-test.sch
│ │ ├── srfi-95-test.sps
│ │ ├── srfi-95-test.sps7
│ │ ├── srfi-98-test.sch
│ │ ├── srfi-98-test.sps
│ │ ├── srfi-98-test.sps7
│ │ ├── srfi-99-test.sps7
│ │ └── test-group.scm
│ ├── Standard/
│ │ ├── README
│ │ ├── applyhook.sch
│ │ ├── apropos.sch
│ │ ├── array-util.sch
│ │ ├── array.sch
│ │ ├── assert.sch
│ │ ├── autoload.sch
│ │ ├── barrier-sync.sch
│ │ ├── box.sch
│ │ ├── combinatory.sch
│ │ ├── comment.sch
│ │ ├── common-syntax.sch
│ │ ├── control.sch
│ │ ├── coroutine.sch
│ │ ├── debugger.sch
│ │ ├── define-record.sch
│ │ ├── define-values.sch
│ │ ├── defmacro.sch
│ │ ├── docextract.sch
│ │ ├── dotimes.sch
│ │ ├── exec-comment.sch
│ │ ├── file-system.sch
│ │ ├── file-utils.sch
│ │ ├── fluid.sch
│ │ ├── foreign-cenums.sch
│ │ ├── foreign-cstructs.sch
│ │ ├── foreign-ctools.sch
│ │ ├── foreign-stdlib.sch
│ │ ├── foreign-sugar.sch
│ │ ├── format.sch
│ │ ├── fortune.sch
│ │ ├── fortune.txt
│ │ ├── fqueue.sch
│ │ ├── gdk.sch
│ │ ├── generator.sch
│ │ ├── glib.sch
│ │ ├── glob.sch
│ │ ├── gtk-2.4.sch
│ │ ├── gtk-enums.sch
│ │ ├── gtk-helper-syntax.sch
│ │ ├── gtk.sch
│ │ ├── in-progress/
│ │ │ ├── bitvector.sch
│ │ │ ├── bitvector.txt
│ │ │ ├── chat.sch
│ │ │ ├── chez-engine.sch
│ │ │ ├── deepcopy.sch
│ │ │ ├── eng.sch
│ │ │ ├── engine.sch
│ │ │ ├── huff.sch
│ │ │ ├── local.sch
│ │ │ ├── m3records.sch
│ │ │ ├── md4.sch
│ │ │ ├── nmap.sch
│ │ │ ├── number-theory.sch
│ │ │ ├── pickle.sch
│ │ │ ├── print-table.sch
│ │ │ ├── record.sch
│ │ │ ├── s48bitvector.sch
│ │ │ ├── text.sch
│ │ │ ├── toposort.sch
│ │ │ ├── units.sch
│ │ │ └── unix-directory.sch
│ │ ├── infix-expr.sch
│ │ ├── io.sch
│ │ ├── list-set.sch
│ │ ├── list.sch
│ │ ├── match-syntax.sch
│ │ ├── match.sch
│ │ ├── md5.sch
│ │ ├── monitor.sch
│ │ ├── mutex.sch
│ │ ├── nasm-disasm.sch
│ │ ├── nonblocking-console.sch
│ │ ├── number.sch
│ │ ├── poll.sch
│ │ ├── pretty.sch
│ │ ├── queue.sch
│ │ ├── random.sch
│ │ ├── readline.sch
│ │ ├── record.sch
│ │ ├── regexp.sch
│ │ ├── sharp-dot.sch
│ │ ├── shivers-syntax.sch
│ │ ├── slib/
│ │ │ └── larceny.init
│ │ ├── socket.sch
│ │ ├── stats.sch
│ │ ├── std-autoloads.sch
│ │ ├── string.sch
│ │ ├── symbol.sch
│ │ ├── tasking-with-io.sch
│ │ ├── tasking.sch
│ │ ├── test/
│ │ │ ├── applyhook.sch
│ │ │ ├── box.sch
│ │ │ ├── brackets.sch
│ │ │ ├── combinatory.sch
│ │ │ ├── control.sch
│ │ │ ├── coroutine.sch
│ │ │ ├── defmacro.sch
│ │ │ ├── format.sch
│ │ │ ├── fqueue.sch
│ │ │ ├── generator.sch
│ │ │ ├── glob.sch
│ │ │ ├── io.sch
│ │ │ ├── list-set.sch
│ │ │ ├── list.sch
│ │ │ ├── match.sch
│ │ │ ├── md5.sch
│ │ │ ├── number.sch
│ │ │ ├── queue.sch
│ │ │ ├── string.sch
│ │ │ ├── symbol.sch
│ │ │ ├── tasking.sch
│ │ │ ├── unify.sch
│ │ │ ├── unix.sch
│ │ │ └── word.sch
│ │ ├── time.sch
│ │ ├── trie.sch
│ │ ├── unify.sch
│ │ ├── unix-descriptor.sch
│ │ ├── unix.sch
│ │ ├── uuencode.sch
│ │ └── word.sch
│ ├── TeachPacks/
│ │ ├── Demos/
│ │ │ ├── ball.sch
│ │ │ ├── bouncing-ball.sch
│ │ │ ├── repl.sch
│ │ │ ├── rocket.sch
│ │ │ └── satellite.sch
│ │ ├── IDE/
│ │ │ └── repl.sch
│ │ ├── Support/
│ │ │ ├── dotnet-defs.sch
│ │ │ ├── image-dotnet.sch
│ │ │ ├── misc.sch
│ │ │ └── world-dotnet.sch
│ │ ├── image.sch
│ │ └── world.sch
│ └── VanTonderMacros/
│ ├── compat-larceny.scm
│ ├── examples.scm
│ ├── expander.scm
│ ├── readme.txt
│ ├── sample-balloons.scm
│ ├── sample-libs-and-program.scm
│ ├── sample-party.scm
│ ├── sample-program.scm
│ ├── sample-stack.scm
│ └── standard-libraries.scm
├── scheme-script
├── setup.sch
├── src/
│ ├── Asm/
│ │ ├── CSharp/
│ │ │ ├── asm-switches.sch
│ │ │ ├── dumpheap-extra.sch
│ │ │ ├── pass5p2-instructions.sch
│ │ │ ├── pass5p2.sch
│ │ │ └── switches.sch
│ │ ├── Fence/
│ │ │ ├── arm-disassembler.sch
│ │ │ ├── arm-optimizer.sch
│ │ │ ├── asm-switches.sch
│ │ │ ├── pass5p2-arm.sch
│ │ │ ├── pass5p2-ppc.sch
│ │ │ ├── pass5p2.sch
│ │ │ └── peepopt.sch
│ │ ├── IAssassin/
│ │ │ ├── asm-switches.sch
│ │ │ ├── pass5p2-sassy.sch
│ │ │ ├── peepopt.sch
│ │ │ ├── sassy-instr.sch
│ │ │ ├── sassy-invoke.sch
│ │ │ └── sassy-machine.sch
│ │ ├── IL/
│ │ │ ├── asm-switches.sch
│ │ │ ├── config.sch
│ │ │ ├── dumpheap-extra.sch
│ │ │ ├── dumpheap-il.sch
│ │ │ ├── il-corememory.sch
│ │ │ ├── il-gen.sch
│ │ │ ├── il-jdot-aliases.sch
│ │ │ ├── il-load-coremem.sch
│ │ │ ├── il-rtif.sch
│ │ │ ├── il-sourcefile.sch
│ │ │ ├── il-src2string.sch
│ │ │ ├── il.imp.sch
│ │ │ ├── il.imp2.sch
│ │ │ ├── pass5p2-instructions.sch
│ │ │ ├── pass5p2-listify.sch
│ │ │ ├── pass5p2-ops.sch
│ │ │ ├── pass5p2.sch
│ │ │ ├── peepopt.sch
│ │ │ ├── util-structs.sch
│ │ │ └── util.sch
│ │ ├── IL-LCG/
│ │ │ ├── dotnet-ffi-lcg.sch
│ │ │ ├── pass5p2.sch
│ │ │ ├── peepopt.sch
│ │ │ └── scratch.sch
│ │ ├── MacScheme/
│ │ │ └── pass5p2.sch
│ │ ├── Nasm/
│ │ │ ├── Experiments/
│ │ │ │ ├── benchmark.c
│ │ │ │ ├── benchmark.scm
│ │ │ │ ├── ccall.scm
│ │ │ │ ├── linker.scm
│ │ │ │ ├── loader.c
│ │ │ │ ├── tailcall.scm
│ │ │ │ └── winloader.c
│ │ │ ├── NASM/
│ │ │ │ ├── assemble.c
│ │ │ │ ├── insns.h
│ │ │ │ ├── insns.pl
│ │ │ │ ├── insnsa.c
│ │ │ │ ├── insnsd.c
│ │ │ │ ├── insnsi.h
│ │ │ │ ├── insnsn.c
│ │ │ │ └── nasm.h
│ │ │ ├── README
│ │ │ ├── dumpheap-overrides.sch
│ │ │ ├── dumpheap-unix.sch
│ │ │ ├── dumpheap-win32.sch
│ │ │ ├── i386asm.sch
│ │ │ ├── pass5p2-nasm.sch
│ │ │ └── peepopt.sch
│ │ ├── PowerPC/
│ │ │ └── pass5p2.sch
│ │ ├── Shared/
│ │ │ ├── asmutil.sch
│ │ │ ├── asmutil32-test.sch
│ │ │ ├── asmutil32.sch
│ │ │ ├── asmutil32be.sch
│ │ │ ├── asmutil32el.sch
│ │ │ ├── dumpheap.sch
│ │ │ ├── external-assembler.sch
│ │ │ ├── link-lop.sch
│ │ │ ├── logior-extra.sch
│ │ │ ├── makefasl.sch
│ │ │ └── pass5p1.sch
│ │ ├── Sparc/
│ │ │ ├── gen-msi.sch
│ │ │ ├── pass5p2.sch
│ │ │ ├── peepopt.sch
│ │ │ ├── scaffold.sch
│ │ │ ├── sparcasm-test.sch
│ │ │ ├── sparcasm.sch
│ │ │ ├── sparcasm2.sch
│ │ │ ├── sparcdis.sch
│ │ │ ├── sparcprim-part1.sch
│ │ │ ├── sparcprim-part2.sch
│ │ │ ├── sparcprim-part3a.sch
│ │ │ ├── sparcprim-part3b.sch
│ │ │ ├── sparcprim-part4.sch
│ │ │ ├── sparcutil.sch
│ │ │ └── switches.sch
│ │ └── Standard-C/
│ │ ├── asm-switches.sch
│ │ ├── dumpheap-overrides.sch
│ │ ├── dumpheap-unix.sch
│ │ ├── dumpheap-win32.sch
│ │ ├── md5.sch
│ │ ├── pass5p2.sch
│ │ ├── peepopt.sch
│ │ └── petit-init-proc.sch
│ ├── Build/
│ │ ├── CL/
│ │ │ ├── README
│ │ │ ├── Scripts/
│ │ │ │ ├── AssembleHeap2.bat
│ │ │ │ ├── CompileHeap.bat
│ │ │ │ ├── CompileRuntime2.bat
│ │ │ │ ├── README
│ │ │ │ └── which.bat
│ │ │ ├── VS8/
│ │ │ │ └── Larceny/
│ │ │ │ ├── Bundle/
│ │ │ │ │ ├── Bundle.vcproj
│ │ │ │ │ ├── bundle-common.ss
│ │ │ │ │ ├── bundleplt.ss
│ │ │ │ │ ├── bundletar.ss
│ │ │ │ │ └── bundlezip.ss
│ │ │ │ ├── Configure/
│ │ │ │ │ ├── Configure.ss
│ │ │ │ │ └── Configure.vcproj
│ │ │ │ ├── Heap/
│ │ │ │ │ ├── Heap.vcproj
│ │ │ │ │ └── Rebuild.ss
│ │ │ │ ├── Larceny.sln
│ │ │ │ ├── Msi/
│ │ │ │ │ └── WindowsInstall.vdproj
│ │ │ │ └── Preprocess/
│ │ │ │ └── Preprocess.vcproj
│ │ │ ├── VSNET/
│ │ │ │ └── Larceny/
│ │ │ │ ├── Bundle/
│ │ │ │ │ ├── Bundle.vcproj
│ │ │ │ │ ├── bundleplt.ss
│ │ │ │ │ ├── bundletar.ss
│ │ │ │ │ └── bundlezip.ss
│ │ │ │ ├── Configure/
│ │ │ │ │ ├── Configure.ss
│ │ │ │ │ └── Configure.vcproj
│ │ │ │ ├── Heap/
│ │ │ │ │ ├── Heap.vcproj
│ │ │ │ │ └── Rebuild.ss
│ │ │ │ ├── Larceny.sln
│ │ │ │ ├── Msi/
│ │ │ │ │ └── WindowsInstall.vdproj
│ │ │ │ └── Preprocess/
│ │ │ │ └── Preprocess.vcproj
│ │ │ ├── files.ss
│ │ │ ├── mzscheme-runner.ss
│ │ │ └── testfile.txt
│ │ ├── Misc/
│ │ │ ├── compfasl.sch
│ │ │ ├── convert-text.sch
│ │ │ ├── fold-includes.sch
│ │ │ ├── heap-info.sch
│ │ │ ├── sim.sch
│ │ │ ├── stcov-qq.sch
│ │ │ ├── stcov.sch
│ │ │ ├── tcov.sch
│ │ │ ├── timeslice.sch
│ │ │ └── undefined.sch
│ │ ├── Scripts/
│ │ │ ├── CommonLarceny.mm
│ │ │ ├── CommonLarceny.ver
│ │ │ ├── Larceny.mmh
│ │ │ ├── larceny.bat
│ │ │ ├── larceny.sh
│ │ │ └── scheme-script
│ │ ├── arm-el-hardfp-larceny-heap.sch
│ │ ├── arm-el-hardfp-twobit-heap.sch
│ │ ├── build-entry-defns.sch
│ │ ├── cleanup.sch
│ │ ├── compile-standard-libraries.sch
│ │ ├── compile-tools.sch
│ │ ├── config.sch
│ │ ├── csharp-config.sch
│ │ ├── dotnet-larceny-lcg-application.sch
│ │ ├── dotnet-larceny-lcg.sch
│ │ ├── dotnet-larceny.sch
│ │ ├── dotnet-seal-twobit.sch
│ │ ├── dotnet-twobit-lcg.sch
│ │ ├── dotnet.sch
│ │ ├── expander.sch
│ │ ├── gasmask.sh
│ │ ├── heap-shake.sch
│ │ ├── iasn-larceny-heap.sch
│ │ ├── iasn-twobit-heap.sch
│ │ ├── macros.gdb
│ │ ├── make.sch
│ │ ├── nbuild-defns.sch
│ │ ├── nbuild-files.sch
│ │ ├── nbuild-param.sch
│ │ ├── nbuild.sch
│ │ ├── petit-larceny-heap.sch
│ │ ├── petit-r5rs-heap.sch
│ │ ├── petit-twobit-heap.sch
│ │ ├── petit-unix-defns-globals.sch
│ │ ├── petit-unix-defns.sch
│ │ ├── r5rs-heap.sch
│ │ ├── readme.txt
│ │ ├── seal-twobit.sch
│ │ ├── sparc-larceny-heap.sch
│ │ ├── sparc-twobit-heap.sch
│ │ ├── sysdep-unix.sch
│ │ └── sysdep-win32.sch
│ ├── Compat/
│ │ ├── Chez/
│ │ │ ├── Makefile
│ │ │ ├── bitpattern.c
│ │ │ ├── bytevec.ss
│ │ │ ├── compat.sch
│ │ │ ├── logops.ss
│ │ │ ├── misc2bytevector.ss
│ │ │ ├── mtime.c
│ │ │ └── values.ss
│ │ ├── Gambit-C/
│ │ │ ├── Makefile
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── format.sch
│ │ │ └── gsi-ffs.scm
│ │ ├── Larceny/
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── tobytevector-be.sch
│ │ │ └── tobytevector-el.sch
│ │ ├── MIT/
│ │ │ └── mit-patches.sch
│ │ ├── MzScheme/
│ │ │ ├── bytevec-el.ss
│ │ │ ├── bytevec.ss
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── logops.ss
│ │ │ ├── misc2bytevector-el.ss
│ │ │ └── misc2bytevector.ss
│ │ ├── PLT-R5RS/
│ │ │ ├── README
│ │ │ ├── bytevec-el.ss
│ │ │ ├── bytevec.ss
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── logops.ss
│ │ │ ├── misc2bytevector-el.ss
│ │ │ └── misc2bytevector.ss
│ │ ├── Petite/
│ │ │ ├── Makefile
│ │ │ ├── bitpattern.c
│ │ │ ├── bytevec-el.ss
│ │ │ ├── bytevec.ss
│ │ │ ├── compat.sch
│ │ │ ├── compat2.sch
│ │ │ ├── logops.ss
│ │ │ ├── misc2bytevector-el.ss
│ │ │ ├── misc2bytevector.ss
│ │ │ ├── mtime.c
│ │ │ └── values.ss
│ │ └── README
│ ├── Compiler/
│ │ ├── common.imp.sch
│ │ ├── copy.sch
│ │ ├── driver-common.sch
│ │ ├── driver-larceny.sch
│ │ ├── driver-twobit.sch
│ │ ├── expand.sch
│ │ ├── fence.imp.sch
│ │ ├── fence.imp2.sch
│ │ ├── hash.sch
│ │ ├── hashtable.sch
│ │ ├── hashtree.sch
│ │ ├── help-topics.txt
│ │ ├── help.sch
│ │ ├── iasn.imp.sch
│ │ ├── iasn.imp2.sch
│ │ ├── lowlevel.sch
│ │ ├── pass0.sch
│ │ ├── pass1.aux.sch
│ │ ├── pass1.sch
│ │ ├── pass2.aux.sch
│ │ ├── pass2if.sch
│ │ ├── pass2p1.sch
│ │ ├── pass2p2.sch
│ │ ├── pass3.sch
│ │ ├── pass3anormal.sch
│ │ ├── pass3anormal2.sch
│ │ ├── pass3callgraph.sch
│ │ ├── pass3commoning.aux.sch
│ │ ├── pass3commoning.sch
│ │ ├── pass3folding.sch
│ │ ├── pass3inlining.sch
│ │ ├── pass3rep.aux.sch
│ │ ├── pass3rep.sch
│ │ ├── pass4.aux.sch
│ │ ├── pass4let.sch
│ │ ├── pass4p1.sch
│ │ ├── pass4p2.sch
│ │ ├── pass4p3.sch
│ │ ├── pass4special.sch
│ │ ├── prefs.sch
│ │ ├── printlap.sch
│ │ ├── sets.sch
│ │ ├── sparc.imp.sch
│ │ ├── sparc.imp2.sch
│ │ ├── standard-C.imp.sch
│ │ ├── standard-C.imp2.sch
│ │ ├── switches.sch
│ │ ├── syntaxenv.sch
│ │ ├── syntaxrules.sch
│ │ ├── syntaxrules2.sch
│ │ └── usual.sch
│ ├── Lib/
│ │ ├── Arch/
│ │ │ ├── Fence/
│ │ │ │ ├── primops.sch
│ │ │ │ └── toplevel-target.sch
│ │ │ ├── IAssassin/
│ │ │ │ ├── loadable.sch
│ │ │ │ ├── primops.sch
│ │ │ │ └── toplevel-target.sch
│ │ │ ├── IL/
│ │ │ │ ├── loadable.sch
│ │ │ │ ├── primops.sch
│ │ │ │ └── toplevel-target.sch
│ │ │ ├── Sparc/
│ │ │ │ ├── primops.sch
│ │ │ │ └── toplevel-target.sch
│ │ │ └── Standard-C/
│ │ │ ├── loadable.sch
│ │ │ ├── primops.sch
│ │ │ └── toplevel-target.sch
│ │ ├── Common/
│ │ │ ├── SimpleMacros/
│ │ │ │ ├── README.txt
│ │ │ │ ├── simple-macros-tests.scm
│ │ │ │ ├── simple-macros.scm
│ │ │ │ ├── simple-module-examples.scm
│ │ │ │ └── simple-syntax-case.scm
│ │ │ ├── arith.mal
│ │ │ ├── belle.sch
│ │ │ ├── bignums-be.sch
│ │ │ ├── bignums-el.sch
│ │ │ ├── bignums.sch
│ │ │ ├── bitwise.sch
│ │ │ ├── bytevector.sch
│ │ │ ├── bytevectorio.sch
│ │ │ ├── circular.sch
│ │ │ ├── command-line.sch
│ │ │ ├── condition.sch
│ │ │ ├── conio.sch
│ │ │ ├── contag.sch
│ │ │ ├── control.sch
│ │ │ ├── customio.sch
│ │ │ ├── dump.sch
│ │ │ ├── ehandler.sch
│ │ │ ├── enum.sch
│ │ │ ├── env.sch
│ │ │ ├── errmsg.sch
│ │ │ ├── error.sch
│ │ │ ├── error0.sch
│ │ │ ├── eval.sch
│ │ │ ├── exit.sch
│ │ │ ├── fileio.sch
│ │ │ ├── fl.sch
│ │ │ ├── flonums-be.sch
│ │ │ ├── flonums-el.sch
│ │ │ ├── flonums.sch
│ │ │ ├── format.sch
│ │ │ ├── fx.sch
│ │ │ ├── gcctl.sch
│ │ │ ├── go.sch
│ │ │ ├── hash.sch
│ │ │ ├── hashtable.sch
│ │ │ ├── ioboot.sch
│ │ │ ├── iosys.sch
│ │ │ ├── javadot-symbol.sch
│ │ │ ├── javadot-syntax.sch
│ │ │ ├── larceny.pg
│ │ │ ├── larcenyTokens.sch
│ │ │ ├── list.sch
│ │ │ ├── load.sch
│ │ │ ├── makeLexer.sch
│ │ │ ├── malcode.mal
│ │ │ ├── mcode.sch
│ │ │ ├── memstats.sch
│ │ │ ├── num2str.sch
│ │ │ ├── number.sch
│ │ │ ├── oblist.sch
│ │ │ ├── portio.sch
│ │ │ ├── preds.sch
│ │ │ ├── print-shared.sch
│ │ │ ├── print.sch
│ │ │ ├── procinfo.sch
│ │ │ ├── profile.sch
│ │ │ ├── raise.sch
│ │ │ ├── ratnums.sch
│ │ │ ├── reader-dfa.sch
│ │ │ ├── reader.sch
│ │ │ ├── record.sch
│ │ │ ├── rectnums.sch
│ │ │ ├── require.sch
│ │ │ ├── secret.sch
│ │ │ ├── sort.sch
│ │ │ ├── stdio.sch
│ │ │ ├── str2num.sch
│ │ │ ├── string.sch
│ │ │ ├── stringio.sch
│ │ │ ├── struct.sch
│ │ │ ├── sys-macos.sch
│ │ │ ├── sys-unix.sch
│ │ │ ├── sys-win32.sch
│ │ │ ├── syscall-id.sch
│ │ │ ├── syshooks.sch
│ │ │ ├── sysparam.sch
│ │ │ ├── system-interface.sch
│ │ │ ├── text.sch
│ │ │ ├── text2.sch
│ │ │ ├── time.sch
│ │ │ ├── timer.sch
│ │ │ ├── toplevel.sch
│ │ │ ├── transio.sch
│ │ │ ├── typetags.sch
│ │ │ ├── unicode0.sch
│ │ │ ├── unicode1.sch
│ │ │ ├── unicode2.sch
│ │ │ ├── unicode3.sch
│ │ │ ├── unicode4.sch
│ │ │ ├── utf16.sch
│ │ │ └── vector.sch
│ │ ├── Interpreter/
│ │ │ ├── interp-prim.sch
│ │ │ ├── interp.sch
│ │ │ ├── macro-expand.sch
│ │ │ └── switches.sch
│ │ ├── Repl/
│ │ │ ├── main.sch
│ │ │ └── reploop.sch
│ │ ├── Sassy/
│ │ │ ├── ACKNOWLEDGEMENTS
│ │ │ ├── COPYING
│ │ │ ├── NEWS
│ │ │ ├── README
│ │ │ ├── TODO
│ │ │ ├── TODO-ideas
│ │ │ ├── api.scm
│ │ │ ├── changes/
│ │ │ │ ├── ChangeLog-0.2
│ │ │ │ ├── ChangeLog-0.2.1
│ │ │ │ ├── ChangeLog-old
│ │ │ │ └── README
│ │ │ ├── demo/
│ │ │ │ └── boot.sassy
│ │ │ ├── doc/
│ │ │ │ ├── sassy.hdir
│ │ │ │ ├── sassy.tex
│ │ │ │ └── tex2page.tex
│ │ │ ├── elf.scm
│ │ │ ├── extras.scm
│ │ │ ├── flat-bin.scm
│ │ │ ├── inits/
│ │ │ │ ├── csi-2.2-libffi.scm
│ │ │ │ ├── gosh-0.8.5.scm
│ │ │ │ ├── guile-1.7.91.scm
│ │ │ │ ├── larceny-0.97.scm
│ │ │ │ ├── mzscheme-299.400.scm
│ │ │ │ ├── mzscheme-301.scm
│ │ │ │ ├── mzscheme-4.1.5.scm
│ │ │ │ ├── petit-0.92.scm
│ │ │ │ ├── scheme48-1.3.scm
│ │ │ │ └── scm-5e1.scm
│ │ │ ├── intern.scm
│ │ │ ├── macros.scm
│ │ │ ├── main.scm
│ │ │ ├── numbers.scm
│ │ │ ├── opcodes.scm
│ │ │ ├── operands.scm
│ │ │ ├── other/
│ │ │ │ ├── srfi-56-pieces.scm
│ │ │ │ └── srfi-60-pieces.scm
│ │ │ ├── parse.scm
│ │ │ ├── push-stacks.scm
│ │ │ ├── sassy-48.scm
│ │ │ ├── sassy-chicken.scm
│ │ │ ├── sassy.el
│ │ │ ├── sassy.html
│ │ │ ├── sassy.scm
│ │ │ ├── sassy.setup
│ │ │ ├── tests/
│ │ │ │ ├── aa
│ │ │ │ ├── aa.asm
│ │ │ │ ├── aa.scm
│ │ │ │ ├── all
│ │ │ │ ├── all.asm
│ │ │ │ ├── alu
│ │ │ │ ├── alu.asm
│ │ │ │ ├── alu.scm
│ │ │ │ ├── alu16
│ │ │ │ ├── alu16.asm
│ │ │ │ ├── brt
│ │ │ │ ├── brt.scm
│ │ │ │ ├── bt
│ │ │ │ ├── bt.asm
│ │ │ │ ├── bt.scm
│ │ │ │ ├── bt16
│ │ │ │ ├── bt16.asm
│ │ │ │ ├── bye
│ │ │ │ ├── bye.scm
│ │ │ │ ├── cell
│ │ │ │ ├── cell.scm
│ │ │ │ ├── cmovcc
│ │ │ │ ├── cmovcc.asm
│ │ │ │ ├── cmovcc.scm
│ │ │ │ ├── cmpx
│ │ │ │ ├── cmpx.asm
│ │ │ │ ├── cmpx.scm
│ │ │ │ ├── cmpx16
│ │ │ │ ├── cmpx16.asm
│ │ │ │ ├── count
│ │ │ │ ├── count.scm
│ │ │ │ ├── decinc
│ │ │ │ ├── decinc.asm
│ │ │ │ ├── decinc.scm
│ │ │ │ ├── decinc16
│ │ │ │ ├── decinc16.asm
│ │ │ │ ├── doub-shift
│ │ │ │ ├── doub-shift.asm
│ │ │ │ ├── doub-shift.scm
│ │ │ │ ├── doub-shift16
│ │ │ │ ├── doub-shift16.asm
│ │ │ │ ├── eip.scm
│ │ │ │ ├── fac5
│ │ │ │ ├── fac5.scm
│ │ │ │ ├── fp0
│ │ │ │ ├── fp0.asm
│ │ │ │ ├── fp0.scm
│ │ │ │ ├── fp1
│ │ │ │ ├── fp1.asm
│ │ │ │ ├── fp1.scm
│ │ │ │ ├── fp2
│ │ │ │ ├── fp2.asm
│ │ │ │ ├── fp2.scm
│ │ │ │ ├── fp3
│ │ │ │ ├── fp3.asm
│ │ │ │ ├── fp3.scm
│ │ │ │ ├── generate-nasm.scm
│ │ │ │ ├── generate-prim.scm
│ │ │ │ ├── hello
│ │ │ │ ├── hello.scm
│ │ │ │ ├── include.scm
│ │ │ │ ├── jcc
│ │ │ │ ├── jcc.asm
│ │ │ │ ├── jcc.scm
│ │ │ │ ├── jcc16
│ │ │ │ ├── jcc16.asm
│ │ │ │ ├── jumps
│ │ │ │ ├── jumps.asm
│ │ │ │ ├── jumps.scm
│ │ │ │ ├── jumps16
│ │ │ │ ├── jumps16.asm
│ │ │ │ ├── libgoodbye.scm
│ │ │ │ ├── libhello.scm
│ │ │ │ ├── load
│ │ │ │ ├── load.asm
│ │ │ │ ├── load.scm
│ │ │ │ ├── load16
│ │ │ │ ├── load16.asm
│ │ │ │ ├── local-data-static
│ │ │ │ ├── localdata1.scm
│ │ │ │ ├── localdata2.scm
│ │ │ │ ├── localdata3.scm
│ │ │ │ ├── localdata4
│ │ │ │ ├── localdata4.scm
│ │ │ │ ├── mem-ref
│ │ │ │ ├── mem-ref.asm
│ │ │ │ ├── mem-ref.scm
│ │ │ │ ├── mem-ref16
│ │ │ │ ├── mem-ref16.asm
│ │ │ │ ├── misc1
│ │ │ │ ├── misc1.asm
│ │ │ │ ├── misc1.scm
│ │ │ │ ├── misc116
│ │ │ │ ├── misc116.asm
│ │ │ │ ├── misc2
│ │ │ │ ├── misc2.asm
│ │ │ │ ├── misc2.scm
│ │ │ │ ├── misc216
│ │ │ │ ├── misc216.asm
│ │ │ │ ├── misc3
│ │ │ │ ├── misc3.asm
│ │ │ │ ├── misc3.scm
│ │ │ │ ├── mmx
│ │ │ │ ├── mmx.asm
│ │ │ │ ├── mmx.scm
│ │ │ │ ├── movx
│ │ │ │ ├── movx.asm
│ │ │ │ ├── movx.scm
│ │ │ │ ├── movx16
│ │ │ │ ├── movx16.asm
│ │ │ │ ├── non
│ │ │ │ ├── non.asm
│ │ │ │ ├── non.scm
│ │ │ │ ├── non16
│ │ │ │ ├── non16.asm
│ │ │ │ ├── plier
│ │ │ │ ├── plier.asm
│ │ │ │ ├── plier.scm
│ │ │ │ ├── plier16
│ │ │ │ ├── plier16.asm
│ │ │ │ ├── prefix
│ │ │ │ ├── prefix.asm
│ │ │ │ ├── prefix.scm
│ │ │ │ ├── prefix16
│ │ │ │ ├── prefix16.asm
│ │ │ │ ├── prims/
│ │ │ │ │ ├── alt1
│ │ │ │ │ ├── alt1.scm
│ │ │ │ │ ├── alt2
│ │ │ │ │ ├── alt2.scm
│ │ │ │ │ ├── alt3
│ │ │ │ │ ├── alt3.scm
│ │ │ │ │ ├── alt4
│ │ │ │ │ ├── alt4.scm
│ │ │ │ │ ├── begin1
│ │ │ │ │ ├── begin1.scm
│ │ │ │ │ ├── begin2
│ │ │ │ │ ├── begin2.scm
│ │ │ │ │ ├── begin3
│ │ │ │ │ ├── begin3.scm
│ │ │ │ │ ├── begin4
│ │ │ │ │ ├── begin4.scm
│ │ │ │ │ ├── begin5
│ │ │ │ │ ├── begin5.scm
│ │ │ │ │ ├── esc1
│ │ │ │ │ ├── esc1.scm
│ │ │ │ │ ├── esc2
│ │ │ │ │ ├── esc2.scm
│ │ │ │ │ ├── esc3
│ │ │ │ │ ├── esc3.scm
│ │ │ │ │ ├── esc4
│ │ │ │ │ ├── esc4.scm
│ │ │ │ │ ├── esc5
│ │ │ │ │ ├── esc5.scm
│ │ │ │ │ ├── esc6
│ │ │ │ │ ├── esc6.scm
│ │ │ │ │ ├── esc7
│ │ │ │ │ ├── esc7.scm
│ │ │ │ │ ├── exp-k1
│ │ │ │ │ ├── exp-k1.scm
│ │ │ │ │ ├── exp-k2
│ │ │ │ │ ├── exp-k2.scm
│ │ │ │ │ ├── exp-k3
│ │ │ │ │ ├── exp-k3.scm
│ │ │ │ │ ├── exp-k4
│ │ │ │ │ ├── exp-k4.scm
│ │ │ │ │ ├── if1
│ │ │ │ │ ├── if1.scm
│ │ │ │ │ ├── if2
│ │ │ │ │ ├── if2.scm
│ │ │ │ │ ├── if3
│ │ │ │ │ ├── if3.scm
│ │ │ │ │ ├── if4
│ │ │ │ │ ├── if4.scm
│ │ │ │ │ ├── inv1
│ │ │ │ │ ├── inv1.scm
│ │ │ │ │ ├── inv2
│ │ │ │ │ ├── inv2.scm
│ │ │ │ │ ├── inv3
│ │ │ │ │ ├── inv3.scm
│ │ │ │ │ ├── inv4
│ │ │ │ │ ├── inv4.scm
│ │ │ │ │ ├── inv5
│ │ │ │ │ ├── inv5.scm
│ │ │ │ │ ├── inv6
│ │ │ │ │ ├── inv6.scm
│ │ │ │ │ ├── iter1
│ │ │ │ │ ├── iter1.scm
│ │ │ │ │ ├── iter2
│ │ │ │ │ ├── iter2.scm
│ │ │ │ │ ├── iter3
│ │ │ │ │ ├── iter3.scm
│ │ │ │ │ ├── iter4
│ │ │ │ │ ├── iter4.scm
│ │ │ │ │ ├── iter5
│ │ │ │ │ ├── iter5.scm
│ │ │ │ │ ├── iter6
│ │ │ │ │ ├── iter6.scm
│ │ │ │ │ ├── label1
│ │ │ │ │ ├── label1.scm
│ │ │ │ │ ├── label2
│ │ │ │ │ ├── label2.scm
│ │ │ │ │ ├── label3
│ │ │ │ │ ├── label3.scm
│ │ │ │ │ ├── label4
│ │ │ │ │ ├── label4.scm
│ │ │ │ │ ├── leap-mark1
│ │ │ │ │ ├── leap-mark1.scm
│ │ │ │ │ ├── leap-mark2
│ │ │ │ │ ├── leap-mark2.scm
│ │ │ │ │ ├── leap-mark3
│ │ │ │ │ ├── leap-mark3.scm
│ │ │ │ │ ├── locals1
│ │ │ │ │ ├── locals1.scm
│ │ │ │ │ ├── locals2
│ │ │ │ │ ├── locals2.scm
│ │ │ │ │ ├── locals3
│ │ │ │ │ ├── locals3.scm
│ │ │ │ │ ├── locals4
│ │ │ │ │ ├── locals4.scm
│ │ │ │ │ ├── locals5
│ │ │ │ │ ├── locals5.scm
│ │ │ │ │ ├── locals6
│ │ │ │ │ ├── locals6.scm
│ │ │ │ │ ├── locals7
│ │ │ │ │ ├── locals7.scm
│ │ │ │ │ ├── locals8
│ │ │ │ │ ├── locals8.scm
│ │ │ │ │ ├── seq1
│ │ │ │ │ ├── seq1.scm
│ │ │ │ │ ├── seq2
│ │ │ │ │ ├── seq2.scm
│ │ │ │ │ ├── seq3
│ │ │ │ │ ├── seq3.scm
│ │ │ │ │ ├── while1
│ │ │ │ │ ├── while1.scm
│ │ │ │ │ ├── while2
│ │ │ │ │ ├── while2.scm
│ │ │ │ │ ├── while3
│ │ │ │ │ ├── while3.scm
│ │ │ │ │ ├── with-lose1
│ │ │ │ │ ├── with-lose1.scm
│ │ │ │ │ ├── with-lose2
│ │ │ │ │ ├── with-lose2.scm
│ │ │ │ │ ├── with-lose3
│ │ │ │ │ ├── with-lose3.scm
│ │ │ │ │ ├── with-win-lose1
│ │ │ │ │ ├── with-win-lose1.scm
│ │ │ │ │ ├── with-win-lose2
│ │ │ │ │ ├── with-win-lose2.scm
│ │ │ │ │ ├── with-win-lose3
│ │ │ │ │ ├── with-win-lose3.scm
│ │ │ │ │ ├── with-win-lose4
│ │ │ │ │ ├── with-win-lose4.scm
│ │ │ │ │ ├── with-win-lose5
│ │ │ │ │ ├── with-win-lose5.scm
│ │ │ │ │ ├── with-win1
│ │ │ │ │ ├── with-win1.scm
│ │ │ │ │ ├── with-win2
│ │ │ │ │ ├── with-win2.scm
│ │ │ │ │ ├── with-win3
│ │ │ │ │ ├── with-win3.scm
│ │ │ │ │ ├── with-win4
│ │ │ │ │ ├── with-win4.scm
│ │ │ │ │ ├── with-win5
│ │ │ │ │ └── with-win5.scm
│ │ │ │ ├── prims16/
│ │ │ │ │ ├── 16alt1
│ │ │ │ │ ├── 16alt1.scm
│ │ │ │ │ ├── 16alt2
│ │ │ │ │ ├── 16alt2.scm
│ │ │ │ │ ├── 16alt3
│ │ │ │ │ ├── 16alt3.scm
│ │ │ │ │ ├── 16alt4
│ │ │ │ │ ├── 16alt4.scm
│ │ │ │ │ ├── 16begin1
│ │ │ │ │ ├── 16begin1.scm
│ │ │ │ │ ├── 16begin2
│ │ │ │ │ ├── 16begin2.scm
│ │ │ │ │ ├── 16begin3
│ │ │ │ │ ├── 16begin3.scm
│ │ │ │ │ ├── 16begin4
│ │ │ │ │ ├── 16begin4.scm
│ │ │ │ │ ├── 16begin5
│ │ │ │ │ ├── 16begin5.scm
│ │ │ │ │ ├── 16esc1
│ │ │ │ │ ├── 16esc1.scm
│ │ │ │ │ ├── 16esc2
│ │ │ │ │ ├── 16esc2.scm
│ │ │ │ │ ├── 16esc3
│ │ │ │ │ ├── 16esc3.scm
│ │ │ │ │ ├── 16esc4
│ │ │ │ │ ├── 16esc4.scm
│ │ │ │ │ ├── 16esc5
│ │ │ │ │ ├── 16esc5.scm
│ │ │ │ │ ├── 16esc6
│ │ │ │ │ ├── 16esc6.scm
│ │ │ │ │ ├── 16esc7
│ │ │ │ │ ├── 16esc7.scm
│ │ │ │ │ ├── 16exp-k1
│ │ │ │ │ ├── 16exp-k1.scm
│ │ │ │ │ ├── 16exp-k2
│ │ │ │ │ ├── 16exp-k2.scm
│ │ │ │ │ ├── 16exp-k3
│ │ │ │ │ ├── 16exp-k3.scm
│ │ │ │ │ ├── 16exp-k4
│ │ │ │ │ ├── 16exp-k4.scm
│ │ │ │ │ ├── 16if1
│ │ │ │ │ ├── 16if1.scm
│ │ │ │ │ ├── 16if2
│ │ │ │ │ ├── 16if2.scm
│ │ │ │ │ ├── 16if3
│ │ │ │ │ ├── 16if3.scm
│ │ │ │ │ ├── 16if4
│ │ │ │ │ ├── 16if4.scm
│ │ │ │ │ ├── 16inv1
│ │ │ │ │ ├── 16inv1.scm
│ │ │ │ │ ├── 16inv2
│ │ │ │ │ ├── 16inv2.scm
│ │ │ │ │ ├── 16inv3
│ │ │ │ │ ├── 16inv3.scm
│ │ │ │ │ ├── 16inv4
│ │ │ │ │ ├── 16inv4.scm
│ │ │ │ │ ├── 16inv5
│ │ │ │ │ ├── 16inv5.scm
│ │ │ │ │ ├── 16inv6
│ │ │ │ │ ├── 16inv6.scm
│ │ │ │ │ ├── 16iter1
│ │ │ │ │ ├── 16iter1.scm
│ │ │ │ │ ├── 16iter2
│ │ │ │ │ ├── 16iter2.scm
│ │ │ │ │ ├── 16iter3
│ │ │ │ │ ├── 16iter3.scm
│ │ │ │ │ ├── 16iter4
│ │ │ │ │ ├── 16iter4.scm
│ │ │ │ │ ├── 16iter5
│ │ │ │ │ ├── 16iter5.scm
│ │ │ │ │ ├── 16iter6
│ │ │ │ │ ├── 16iter6.scm
│ │ │ │ │ ├── 16label1
│ │ │ │ │ ├── 16label1.scm
│ │ │ │ │ ├── 16label2
│ │ │ │ │ ├── 16label2.scm
│ │ │ │ │ ├── 16label3
│ │ │ │ │ ├── 16label3.scm
│ │ │ │ │ ├── 16label4
│ │ │ │ │ ├── 16label4.scm
│ │ │ │ │ ├── 16leap-mark1
│ │ │ │ │ ├── 16leap-mark1.scm
│ │ │ │ │ ├── 16leap-mark2
│ │ │ │ │ ├── 16leap-mark2.scm
│ │ │ │ │ ├── 16leap-mark3
│ │ │ │ │ ├── 16leap-mark3.scm
│ │ │ │ │ ├── 16locals1
│ │ │ │ │ ├── 16locals1.scm
│ │ │ │ │ ├── 16locals2
│ │ │ │ │ ├── 16locals2.scm
│ │ │ │ │ ├── 16locals3
│ │ │ │ │ ├── 16locals3.scm
│ │ │ │ │ ├── 16locals4
│ │ │ │ │ ├── 16locals4.scm
│ │ │ │ │ ├── 16locals5
│ │ │ │ │ ├── 16locals5.scm
│ │ │ │ │ ├── 16locals6
│ │ │ │ │ ├── 16locals6.scm
│ │ │ │ │ ├── 16locals7
│ │ │ │ │ ├── 16locals7.scm
│ │ │ │ │ ├── 16locals8
│ │ │ │ │ ├── 16locals8.scm
│ │ │ │ │ ├── 16seq1
│ │ │ │ │ ├── 16seq1.scm
│ │ │ │ │ ├── 16seq2
│ │ │ │ │ ├── 16seq2.scm
│ │ │ │ │ ├── 16seq3
│ │ │ │ │ ├── 16seq3.scm
│ │ │ │ │ ├── 16while1
│ │ │ │ │ ├── 16while1.scm
│ │ │ │ │ ├── 16while2
│ │ │ │ │ ├── 16while2.scm
│ │ │ │ │ ├── 16while3
│ │ │ │ │ ├── 16while3.scm
│ │ │ │ │ ├── 16with-lose1
│ │ │ │ │ ├── 16with-lose1.scm
│ │ │ │ │ ├── 16with-lose2
│ │ │ │ │ ├── 16with-lose2.scm
│ │ │ │ │ ├── 16with-lose3
│ │ │ │ │ ├── 16with-lose3.scm
│ │ │ │ │ ├── 16with-win-lose1
│ │ │ │ │ ├── 16with-win-lose1.scm
│ │ │ │ │ ├── 16with-win-lose2
│ │ │ │ │ ├── 16with-win-lose2.scm
│ │ │ │ │ ├── 16with-win-lose3
│ │ │ │ │ ├── 16with-win-lose3.scm
│ │ │ │ │ ├── 16with-win-lose4
│ │ │ │ │ ├── 16with-win-lose4.scm
│ │ │ │ │ ├── 16with-win-lose5
│ │ │ │ │ ├── 16with-win-lose5.scm
│ │ │ │ │ ├── 16with-win1
│ │ │ │ │ ├── 16with-win1.scm
│ │ │ │ │ ├── 16with-win2
│ │ │ │ │ ├── 16with-win2.scm
│ │ │ │ │ ├── 16with-win3
│ │ │ │ │ ├── 16with-win3.scm
│ │ │ │ │ ├── 16with-win4
│ │ │ │ │ ├── 16with-win4.scm
│ │ │ │ │ ├── 16with-win5
│ │ │ │ │ └── 16with-win5.scm
│ │ │ │ ├── quick-elf.scm
│ │ │ │ ├── r-rm
│ │ │ │ ├── r-rm.asm
│ │ │ │ ├── r-rm.scm
│ │ │ │ ├── r-rm16
│ │ │ │ ├── r-rm16.asm
│ │ │ │ ├── regenerate.scm
│ │ │ │ ├── ret
│ │ │ │ ├── ret.asm
│ │ │ │ ├── ret.scm
│ │ │ │ ├── ret16
│ │ │ │ ├── ret16.asm
│ │ │ │ ├── rm
│ │ │ │ ├── rm.asm
│ │ │ │ ├── rm.scm
│ │ │ │ ├── rm16
│ │ │ │ ├── rm16.asm
│ │ │ │ ├── rm2
│ │ │ │ ├── rm2.asm
│ │ │ │ ├── rm2.scm
│ │ │ │ ├── rm216
│ │ │ │ ├── rm216.asm
│ │ │ │ ├── run-tests.scm
│ │ │ │ ├── sect.scm
│ │ │ │ ├── seg
│ │ │ │ ├── seg.asm
│ │ │ │ ├── seg.scm
│ │ │ │ ├── seg16
│ │ │ │ ├── seg16.asm
│ │ │ │ ├── setcc
│ │ │ │ ├── setcc.asm
│ │ │ │ ├── setcc.scm
│ │ │ │ ├── setcc16
│ │ │ │ ├── setcc16.asm
│ │ │ │ ├── shift
│ │ │ │ ├── shift.asm
│ │ │ │ ├── shift.scm
│ │ │ │ ├── shift16
│ │ │ │ ├── shift16.asm
│ │ │ │ ├── sse1
│ │ │ │ ├── sse1.asm
│ │ │ │ ├── sse1.scm
│ │ │ │ ├── sse2
│ │ │ │ ├── sse2.asm
│ │ │ │ ├── sse2.scm
│ │ │ │ ├── sse3
│ │ │ │ ├── sse3.asm
│ │ │ │ ├── sse3.scm
│ │ │ │ ├── sysexit
│ │ │ │ ├── sysexit.scm
│ │ │ │ └── sysexit2.scm
│ │ │ ├── text-block.scm
│ │ │ ├── text.scm
│ │ │ └── units.scm
│ │ └── makefile.sch
│ └── Rts/
│ ├── DotNet/
│ │ ├── AssemblyInfo.cs
│ │ ├── Call.cs
│ │ ├── ClassicOps.cs
│ │ ├── ClassicOpsSpecial.cs
│ │ ├── CodeAddress.cs
│ │ ├── ContinuationISH.cs
│ │ ├── DynLoad.cs
│ │ ├── Exn.cs
│ │ ├── FFI.cs
│ │ ├── Factory.cs
│ │ ├── Instructions.cs
│ │ ├── Load.cs
│ │ ├── Macros.h
│ │ ├── Makefile
│ │ ├── MapOps.cs
│ │ ├── MapOpsSpecial.cs
│ │ ├── Number.cs
│ │ ├── Ops.cs
│ │ ├── Ops.h
│ │ ├── OpsSpecial.cs
│ │ ├── Ops_Procedure.inc
│ │ ├── Ops_SByteVL.inc
│ │ ├── Ops_SChar.inc
│ │ ├── Ops_SFixnum.inc
│ │ ├── Ops_SImmediate.inc
│ │ ├── Ops_SObject.inc
│ │ ├── Ops_SPair.inc
│ │ ├── Ops_STagged.inc
│ │ ├── Ops_SVL.inc
│ │ ├── Perf.cs
│ │ ├── README
│ │ ├── Reg.cs
│ │ ├── Scheme.csproj
│ │ ├── Scheme.csproj8
│ │ ├── SchemeObject.cs.cpp
│ │ ├── Syscall-enum.cs
│ │ └── Syscall.cs
│ ├── Fence/
│ │ ├── arm-millicode.sx
│ │ ├── fence-config.c
│ │ ├── fence-driver.c
│ │ ├── fence-millicode.c
│ │ └── fence-syscall2.c
│ ├── IAssassin/
│ │ ├── config.c
│ │ ├── i386-driver.c
│ │ ├── millicode.c
│ │ └── syscall2.c
│ ├── Nasm/
│ │ ├── config.c
│ │ └── i386-driver.c
│ ├── Shared/
│ │ ├── arithmetic.mac
│ │ ├── i386-millicode.asm
│ │ └── multiply.c
│ ├── Sparc/
│ │ ├── asmmacro.h
│ │ ├── barrier.s
│ │ ├── bdw-cglue.c
│ │ ├── bdw-generic.s
│ │ ├── bdw-memory.s
│ │ ├── cache.c
│ │ ├── cache0.s
│ │ ├── cglue.c
│ │ ├── config.c
│ │ ├── generic.s
│ │ ├── glue.s
│ │ ├── mcode.s
│ │ ├── memory.s
│ │ ├── signals.c
│ │ └── syscall2.c
│ ├── Standard-C/
│ │ ├── config.c
│ │ ├── millicode.c
│ │ └── syscall2.c
│ ├── Sys/
│ │ ├── alloc.c
│ │ ├── argv.c
│ │ ├── assert.h
│ │ ├── barrier.c
│ │ ├── barrier.h
│ │ ├── bdw-collector.c
│ │ ├── bdw-ffi.c
│ │ ├── bdw-gc.c
│ │ ├── bdw-heapio.c
│ │ ├── bdw-larceny.c
│ │ ├── bdw-stats.c
│ │ ├── bdw.h
│ │ ├── callback.c
│ │ ├── cheney-check.c
│ │ ├── cheney-np.c
│ │ ├── cheney-split.c
│ │ ├── cheney.c
│ │ ├── cheney.h
│ │ ├── extbmp.c
│ │ ├── extbmp_t.h
│ │ ├── ffi.c
│ │ ├── gc.c
│ │ ├── gc.h
│ │ ├── gc_mmu_log.c
│ │ ├── gc_mmu_log.h
│ │ ├── gc_t.c
│ │ ├── gc_t.h
│ │ ├── gcdebug.c
│ │ ├── gclib.h
│ │ ├── gset_t.h
│ │ ├── heapio.c
│ │ ├── heapio.h
│ │ ├── larceny.c
│ │ ├── larceny.h
│ │ ├── ldebug.c
│ │ ├── locset.c
│ │ ├── locset_t.h
│ │ ├── los.c
│ │ ├── los_t.h
│ │ ├── malloc.c
│ │ ├── memmgr.c
│ │ ├── memmgr.h
│ │ ├── memmgr_flt.c
│ │ ├── memmgr_flt.h
│ │ ├── memmgr_internal.h
│ │ ├── memmgr_vfy.c
│ │ ├── memmgr_vfy.h
│ │ ├── msgc-core.c
│ │ ├── msgc-core.h
│ │ ├── np-sc-heap.c
│ │ ├── nursery.c
│ │ ├── old-heap.c
│ │ ├── old_heap_t.c
│ │ ├── old_heap_t.h
│ │ ├── osdep-generic.c
│ │ ├── osdep-macos.c
│ │ ├── osdep-unix.c
│ │ ├── osdep-win32.c
│ │ ├── osdep.h
│ │ ├── primitive.c
│ │ ├── region_group.c
│ │ ├── region_group_t.h
│ │ ├── remset-np.c
│ │ ├── remset.c
│ │ ├── remset_np_t.h
│ │ ├── remset_t.h
│ │ ├── sc-heap.c
│ │ ├── semispace.c
│ │ ├── semispace_t.h
│ │ ├── seqbuf.c
│ │ ├── seqbuf_t.h
│ │ ├── signals.c
│ │ ├── signals.h
│ │ ├── smircy.c
│ │ ├── smircy.h
│ │ ├── smircy_checking.c
│ │ ├── smircy_checking.h
│ │ ├── smircy_internal.h
│ │ ├── sro.c
│ │ ├── stack.c
│ │ ├── stack.h
│ │ ├── static-heap.c
│ │ ├── static_heap_t.h
│ │ ├── stats.c
│ │ ├── stats.h
│ │ ├── summ_matrix.c
│ │ ├── summ_matrix_t.h
│ │ ├── summary.c
│ │ ├── summary_t.h
│ │ ├── syscall.c
│ │ ├── unix.c
│ │ ├── uremset_array.c
│ │ ├── uremset_array_t.h
│ │ ├── uremset_debug.c
│ │ ├── uremset_debug_t.h
│ │ ├── uremset_extbmp.c
│ │ ├── uremset_extbmp_t.h
│ │ ├── uremset_t.c
│ │ ├── uremset_t.h
│ │ ├── util.c
│ │ ├── version.c
│ │ ├── young_heap_t.c
│ │ └── young_heap_t.h
│ ├── Util/
│ │ ├── ffi-dummy.c
│ │ └── hsplit.c
│ ├── except.cfg
│ ├── features.sch
│ ├── fence-arm-regs.cfg
│ ├── fence-arm-regs0.cfg
│ ├── globals-fence.cfg
│ ├── globals-nasm.cfg
│ ├── globals.cfg
│ ├── iasn-regs.cfg
│ ├── layouts.cfg
│ ├── make-templates.sch
│ ├── memstats.cfg
│ ├── mprocs.cfg
│ └── sparc-regs.cfg
├── startup.sch
├── test/
│ ├── Benchmarking/
│ │ ├── CrossPlatform/
│ │ │ ├── README
│ │ │ ├── analyse-results.scm
│ │ │ ├── bench
│ │ │ ├── evaluate
│ │ │ ├── generate-html-from-all-results.scm
│ │ │ ├── num-iters/
│ │ │ │ ├── num-iters-1.scm
│ │ │ │ ├── num-iters-int.scm
│ │ │ │ ├── num-iters.scm
│ │ │ │ └── one-iter.scm
│ │ │ ├── optimize-gcc-options.scm
│ │ │ ├── prefix/
│ │ │ │ ├── prefix-bigloo-int.scm
│ │ │ │ ├── prefix-bigloo.scm
│ │ │ │ ├── prefix-chez.scm
│ │ │ │ ├── prefix-chicken.scm
│ │ │ │ ├── prefix-gambit-int.scm
│ │ │ │ ├── prefix-gambit-sp.scm
│ │ │ │ ├── prefix-gambit.scm
│ │ │ │ ├── prefix-henchman.scm
│ │ │ │ ├── prefix-ikarus.scm
│ │ │ │ ├── prefix-kawa.scm
│ │ │ │ ├── prefix-larceny.scm
│ │ │ │ ├── prefix-mit-int.scm
│ │ │ │ ├── prefix-mit.scm
│ │ │ │ ├── prefix-mzscheme.scm
│ │ │ │ ├── prefix-petit.scm
│ │ │ │ ├── prefix-petite-chez.scm
│ │ │ │ └── prefix-scheme48.scm
│ │ │ ├── readme.original
│ │ │ ├── src/
│ │ │ │ ├── ack.awk
│ │ │ │ ├── ack.c
│ │ │ │ ├── ack.scm
│ │ │ │ ├── array1.awk
│ │ │ │ ├── array1.c
│ │ │ │ ├── array1.scm
│ │ │ │ ├── bib
│ │ │ │ ├── boyer.scm
│ │ │ │ ├── browse.scm
│ │ │ │ ├── cat.awk
│ │ │ │ ├── cat.c
│ │ │ │ ├── cat.scm
│ │ │ │ ├── compiler.scm
│ │ │ │ ├── conform.scm
│ │ │ │ ├── cpstak.scm
│ │ │ │ ├── cpstak.sml
│ │ │ │ ├── crash.scm
│ │ │ │ ├── ctak.scm
│ │ │ │ ├── ctak.sml
│ │ │ │ ├── dderiv.scm
│ │ │ │ ├── deriv.scm
│ │ │ │ ├── destruc.scm
│ │ │ │ ├── diviter.c
│ │ │ │ ├── diviter.java
│ │ │ │ ├── diviter.scm
│ │ │ │ ├── diviter.sml
│ │ │ │ ├── divrec.c
│ │ │ │ ├── divrec.java
│ │ │ │ ├── divrec.scm
│ │ │ │ ├── divrec.sml
│ │ │ │ ├── dynamic.scm
│ │ │ │ ├── earley.scm
│ │ │ │ ├── fail.scm
│ │ │ │ ├── fft.c
│ │ │ │ ├── fft.scm
│ │ │ │ ├── fib.c
│ │ │ │ ├── fib.java
│ │ │ │ ├── fib.scm
│ │ │ │ ├── fib.sml
│ │ │ │ ├── fibc.scm
│ │ │ │ ├── fibfp.c
│ │ │ │ ├── fibfp.java
│ │ │ │ ├── fibfp.scm
│ │ │ │ ├── fibfp.sml
│ │ │ │ ├── fpsum.scm
│ │ │ │ ├── gcbench.c
│ │ │ │ ├── gcbench.java
│ │ │ │ ├── gcbench.scm
│ │ │ │ ├── gcbench.sml
│ │ │ │ ├── gcold.scm
│ │ │ │ ├── graphs.scm
│ │ │ │ ├── lattice.scm
│ │ │ │ ├── matrix.scm
│ │ │ │ ├── maze.scm
│ │ │ │ ├── mazefun.scm
│ │ │ │ ├── mbrot.c
│ │ │ │ ├── mbrot.scm
│ │ │ │ ├── nbody.scm
│ │ │ │ ├── nboyer.sch
│ │ │ │ ├── nboyer.scm
│ │ │ │ ├── nqueens.scm
│ │ │ │ ├── ntakl.c
│ │ │ │ ├── ntakl.java
│ │ │ │ ├── ntakl.scm
│ │ │ │ ├── ntakl.sml
│ │ │ │ ├── nucleic.c
│ │ │ │ ├── nucleic.scm
│ │ │ │ ├── num-iters-int.scm
│ │ │ │ ├── num-iters.java
│ │ │ │ ├── num-iters.scm
│ │ │ │ ├── num-iters.sml
│ │ │ │ ├── one-iter.scm
│ │ │ │ ├── paraffins.scm
│ │ │ │ ├── parsing.scm
│ │ │ │ ├── perm9.c
│ │ │ │ ├── perm9.java
│ │ │ │ ├── perm9.scm
│ │ │ │ ├── perm9.sml
│ │ │ │ ├── peval.scm
│ │ │ │ ├── pi.scm
│ │ │ │ ├── pnpoly.c
│ │ │ │ ├── pnpoly.scm
│ │ │ │ ├── primes.scm
│ │ │ │ ├── puzzle.c
│ │ │ │ ├── puzzle.scm
│ │ │ │ ├── puzzle.sml
│ │ │ │ ├── quicksort.scm
│ │ │ │ ├── ray.scm
│ │ │ │ ├── rn100
│ │ │ │ ├── sboyer.scm
│ │ │ │ ├── scheme.scm
│ │ │ │ ├── simplex.scm
│ │ │ │ ├── slatex.scm
│ │ │ │ ├── slatex.sty
│ │ │ │ ├── smlboyer.scm
│ │ │ │ ├── smlboyer.sml
│ │ │ │ ├── string.awk
│ │ │ │ ├── string.c
│ │ │ │ ├── string.scm
│ │ │ │ ├── succeed.scm
│ │ │ │ ├── sum.c
│ │ │ │ ├── sum.java
│ │ │ │ ├── sum.scm
│ │ │ │ ├── sum.sml
│ │ │ │ ├── sum1.awk
│ │ │ │ ├── sum1.c
│ │ │ │ ├── sum1.scm
│ │ │ │ ├── sumfp.c
│ │ │ │ ├── sumfp.java
│ │ │ │ ├── sumfp.scm
│ │ │ │ ├── sumfp.sml
│ │ │ │ ├── sumloop.awk
│ │ │ │ ├── sumloop.c
│ │ │ │ ├── sumloop.scm
│ │ │ │ ├── tail.awk
│ │ │ │ ├── tail.c
│ │ │ │ ├── tail.scm
│ │ │ │ ├── tak.c
│ │ │ │ ├── tak.java
│ │ │ │ ├── tak.scm
│ │ │ │ ├── tak.sml
│ │ │ │ ├── takl.c
│ │ │ │ ├── takl.java
│ │ │ │ ├── takl.scm
│ │ │ │ ├── takl.sml
│ │ │ │ ├── temp.java
│ │ │ │ ├── test.sch
│ │ │ │ ├── test.scm
│ │ │ │ ├── test.tex
│ │ │ │ ├── tfib.c
│ │ │ │ ├── tfib.java
│ │ │ │ ├── tfib.scm
│ │ │ │ ├── trav1.scm
│ │ │ │ ├── trav2.scm
│ │ │ │ ├── triangl.c
│ │ │ │ ├── triangl.scm
│ │ │ │ ├── wc.awk
│ │ │ │ ├── wc.c
│ │ │ │ └── wc.scm
│ │ │ ├── suffix/
│ │ │ │ ├── suffix-bigloo-int.scm
│ │ │ │ ├── suffix-bigloo.scm
│ │ │ │ ├── suffix-chez.scm
│ │ │ │ ├── suffix-chicken.scm
│ │ │ │ ├── suffix-gambit-int.scm
│ │ │ │ ├── suffix-gambit-sp.scm
│ │ │ │ ├── suffix-gambit.scm
│ │ │ │ ├── suffix-henchman.scm
│ │ │ │ ├── suffix-ikarus.scm
│ │ │ │ ├── suffix-kawa.scm
│ │ │ │ ├── suffix-larceny.scm
│ │ │ │ ├── suffix-mit-int.scm
│ │ │ │ ├── suffix-mit.scm
│ │ │ │ ├── suffix-mzscheme.scm
│ │ │ │ ├── suffix-petit.scm
│ │ │ │ ├── suffix-petite-chez.scm
│ │ │ │ └── suffix-scheme48.scm
│ │ │ ├── summarize
│ │ │ ├── summarize.sch
│ │ │ ├── summarize2.sch
│ │ │ ├── table
│ │ │ └── todo.update
│ │ ├── GC/
│ │ │ ├── GCBench.java
│ │ │ ├── PermNKL.java
│ │ │ ├── Pueue4.java
│ │ │ ├── Queue3.java
│ │ │ ├── compile-files.sch
│ │ │ ├── dumb.sch
│ │ │ ├── dummy.sch
│ │ │ ├── dynamic-input-large.sch
│ │ │ ├── dynamic-input-small.sch
│ │ │ ├── dynamic.sch
│ │ │ ├── earley.sch
│ │ │ ├── gcbench.sch
│ │ │ ├── gcbenchJ.sch
│ │ │ ├── gcold.sch
│ │ │ ├── graphs.sch
│ │ │ ├── lattice.sch
│ │ │ ├── nboyer.sch
│ │ │ ├── nucleic2.sch
│ │ │ ├── paraffins.sch
│ │ │ ├── perm.sch
│ │ │ ├── permJ.sch
│ │ │ ├── pueue4.sch
│ │ │ ├── queue3.sch
│ │ │ ├── sboyer.sch
│ │ │ ├── softscheme.sch
│ │ │ ├── twobit-input-long.sch
│ │ │ ├── twobit-input-short.sch
│ │ │ ├── twobit-smaller.sch
│ │ │ └── twobit.sch
│ │ ├── R6RS/
│ │ │ ├── README
│ │ │ ├── bench
│ │ │ ├── inputs/
│ │ │ │ ├── NormalizationTest.txt
│ │ │ │ ├── ack.input
│ │ │ │ ├── array1.input
│ │ │ │ ├── bib
│ │ │ │ ├── bib16
│ │ │ │ ├── bibfreq.input
│ │ │ │ ├── bibfreq2.input
│ │ │ │ ├── browse.input
│ │ │ │ ├── bv2string.input
│ │ │ │ ├── cat.input
│ │ │ │ ├── cat2.input
│ │ │ │ ├── cat3.input
│ │ │ │ ├── compiler.input
│ │ │ │ ├── conform.input
│ │ │ │ ├── cpstak.input
│ │ │ │ ├── ctak.input
│ │ │ │ ├── dderiv.input
│ │ │ │ ├── deriv.input
│ │ │ │ ├── destruc.input
│ │ │ │ ├── diviter.input
│ │ │ │ ├── divrec.input
│ │ │ │ ├── dynamic.data
│ │ │ │ ├── dynamic.input
│ │ │ │ ├── earley.input
│ │ │ │ ├── equal.input
│ │ │ │ ├── fft.input
│ │ │ │ ├── fib.input
│ │ │ │ ├── fibc.input
│ │ │ │ ├── fibfp.input
│ │ │ │ ├── gcbench.input
│ │ │ │ ├── graphs.input
│ │ │ │ ├── hashtable0.input
│ │ │ │ ├── lattice.input
│ │ │ │ ├── listsort.input
│ │ │ │ ├── matrix.input
│ │ │ │ ├── maze.input
│ │ │ │ ├── mazefun.input
│ │ │ │ ├── mbrot.input
│ │ │ │ ├── mbrotZ.input
│ │ │ │ ├── mperm.input
│ │ │ │ ├── nboyer.input
│ │ │ │ ├── normalization.input
│ │ │ │ ├── nqueens.input
│ │ │ │ ├── ntakl.input
│ │ │ │ ├── nucleic.input
│ │ │ │ ├── paraffins.input
│ │ │ │ ├── parsing.data
│ │ │ │ ├── parsing.input
│ │ │ │ ├── parsing16.data
│ │ │ │ ├── peval.input
│ │ │ │ ├── pi.input
│ │ │ │ ├── pnpoly.input
│ │ │ │ ├── primes.input
│ │ │ │ ├── primes2.input
│ │ │ │ ├── puzzle.input
│ │ │ │ ├── quicksort.input
│ │ │ │ ├── ray.input
│ │ │ │ ├── read0.input
│ │ │ │ ├── read1.input
│ │ │ │ ├── read2.input
│ │ │ │ ├── read3.input
│ │ │ │ ├── sboyer.input
│ │ │ │ ├── scheme.input
│ │ │ │ ├── simplex.input
│ │ │ │ ├── slatex-data/
│ │ │ │ │ ├── slatex.sty
│ │ │ │ │ └── test.tex
│ │ │ │ ├── slatex.input
│ │ │ │ ├── string.input
│ │ │ │ ├── sum.input
│ │ │ │ ├── sum1.data
│ │ │ │ ├── sum1.input
│ │ │ │ ├── sumfp.input
│ │ │ │ ├── tail.input
│ │ │ │ ├── tak.input
│ │ │ │ ├── takl.input
│ │ │ │ ├── triangl.input
│ │ │ │ ├── vecsort.input
│ │ │ │ └── wc.input
│ │ │ └── src/
│ │ │ ├── ack.sch
│ │ │ ├── array1.sch
│ │ │ ├── bibfreq.sch
│ │ │ ├── bibfreq2.sch
│ │ │ ├── browse.sch
│ │ │ ├── bv2string.sch
│ │ │ ├── cat.sch
│ │ │ ├── cat2.sch
│ │ │ ├── cat3.sch
│ │ │ ├── common.sch
│ │ │ ├── compiler.sch
│ │ │ ├── conform.sch
│ │ │ ├── cpstak.sch
│ │ │ ├── ctak.sch
│ │ │ ├── dderiv.sch
│ │ │ ├── deriv.sch
│ │ │ ├── destruc.sch
│ │ │ ├── diviter.sch
│ │ │ ├── divrec.sch
│ │ │ ├── dynamic.sch
│ │ │ ├── earley.sch
│ │ │ ├── equal.sch
│ │ │ ├── fft.sch
│ │ │ ├── fib.sch
│ │ │ ├── fibc.sch
│ │ │ ├── fibfp.sch
│ │ │ ├── gcbench.sch
│ │ │ ├── graphs.sch
│ │ │ ├── hashtable0.sch
│ │ │ ├── lattice.sch
│ │ │ ├── listsort.sch
│ │ │ ├── matrix.sch
│ │ │ ├── maze.sch
│ │ │ ├── mazefun.sch
│ │ │ ├── mbrot.sch
│ │ │ ├── mbrotZ.sch
│ │ │ ├── mperm.sch
│ │ │ ├── nboyer.sch
│ │ │ ├── normalization.sch
│ │ │ ├── nqueens.sch
│ │ │ ├── ntakl.sch
│ │ │ ├── nucleic.sch
│ │ │ ├── paraffins.sch
│ │ │ ├── parsing.sch
│ │ │ ├── peval.sch
│ │ │ ├── pi.sch
│ │ │ ├── pnpoly.sch
│ │ │ ├── primes.sch
│ │ │ ├── primes2.sch
│ │ │ ├── puzzle.sch
│ │ │ ├── quicksort.sch
│ │ │ ├── ray.sch
│ │ │ ├── read0.sch
│ │ │ ├── read1.sch
│ │ │ ├── read2.sch
│ │ │ ├── read3.sch
│ │ │ ├── sboyer.sch
│ │ │ ├── scheme.sch
│ │ │ ├── simplex.sch
│ │ │ ├── slatex.sch
│ │ │ ├── string.sch
│ │ │ ├── sum.sch
│ │ │ ├── sum1.sch
│ │ │ ├── sumfp.sch
│ │ │ ├── tail.sch
│ │ │ ├── tak.sch
│ │ │ ├── takl.sch
│ │ │ ├── triangl.sch
│ │ │ ├── vecsort.sch
│ │ │ └── wc.sch
│ │ ├── R7RS/
│ │ │ ├── README
│ │ │ ├── bench
│ │ │ ├── inputs/
│ │ │ │ ├── 29833-0.txt
│ │ │ │ ├── 7142.txt
│ │ │ │ ├── ack.input
│ │ │ │ ├── array1.input
│ │ │ │ ├── bib
│ │ │ │ ├── bibfreq.input
│ │ │ │ ├── bibfreq2.input
│ │ │ │ ├── browse.input
│ │ │ │ ├── bv2string.input
│ │ │ │ ├── cat.input
│ │ │ │ ├── charset.input
│ │ │ │ ├── chudnovsky.input
│ │ │ │ ├── compiler.input
│ │ │ │ ├── conform.input
│ │ │ │ ├── cpstak.input
│ │ │ │ ├── ctak.input
│ │ │ │ ├── dderiv.input
│ │ │ │ ├── deriv.input
│ │ │ │ ├── destruc.input
│ │ │ │ ├── diviter.input
│ │ │ │ ├── divrec.input
│ │ │ │ ├── dynamic.data
│ │ │ │ ├── dynamic.input
│ │ │ │ ├── earley.input
│ │ │ │ ├── equal.input
│ │ │ │ ├── fft.input
│ │ │ │ ├── fib.input
│ │ │ │ ├── fibc.input
│ │ │ │ ├── fibfp.input
│ │ │ │ ├── gcbench.input
│ │ │ │ ├── generator.input
│ │ │ │ ├── graphs.input
│ │ │ │ ├── hashtable0.input
│ │ │ │ ├── ilist.input
│ │ │ │ ├── lattice.input
│ │ │ │ ├── list.input
│ │ │ │ ├── listsort.input
│ │ │ │ ├── lseq.input
│ │ │ │ ├── matrix.input
│ │ │ │ ├── maze.input
│ │ │ │ ├── mazefun.input
│ │ │ │ ├── mbrot.input
│ │ │ │ ├── mbrotZ.input
│ │ │ │ ├── mperm.input
│ │ │ │ ├── nboyer.input
│ │ │ │ ├── nqueens.input
│ │ │ │ ├── ntakl.input
│ │ │ │ ├── nucleic.input
│ │ │ │ ├── paraffins.input
│ │ │ │ ├── parsing.data
│ │ │ │ ├── parsing.input
│ │ │ │ ├── peval.input
│ │ │ │ ├── pi.input
│ │ │ │ ├── pnpoly.input
│ │ │ │ ├── primes.input
│ │ │ │ ├── puzzle.input
│ │ │ │ ├── quicksort.input
│ │ │ │ ├── ray.input
│ │ │ │ ├── read0.input
│ │ │ │ ├── read1.input
│ │ │ │ ├── rlist.input
│ │ │ │ ├── sboyer.input
│ │ │ │ ├── scheme.input
│ │ │ │ ├── set.input
│ │ │ │ ├── simplex.input
│ │ │ │ ├── slatex-data/
│ │ │ │ │ ├── slatex.sty
│ │ │ │ │ └── test.tex
│ │ │ │ ├── slatex.input
│ │ │ │ ├── stream.input
│ │ │ │ ├── string.input
│ │ │ │ ├── sum.input
│ │ │ │ ├── sum1.data
│ │ │ │ ├── sum1.input
│ │ │ │ ├── sumfp.input
│ │ │ │ ├── tail.input
│ │ │ │ ├── tak.input
│ │ │ │ ├── takl.input
│ │ │ │ ├── text.input
│ │ │ │ ├── triangl.input
│ │ │ │ ├── vecsort.input
│ │ │ │ ├── vector.input
│ │ │ │ └── wc.input
│ │ │ ├── src/
│ │ │ │ ├── ack.scm
│ │ │ │ ├── array1.scm
│ │ │ │ ├── bibfreq.scm
│ │ │ │ ├── bibfreq2.scm
│ │ │ │ ├── browse.scm
│ │ │ │ ├── bv2string.scm
│ │ │ │ ├── cat.scm
│ │ │ │ ├── charset.scm
│ │ │ │ ├── chudnovsky.scm
│ │ │ │ ├── common.scm
│ │ │ │ ├── compiler.scm
│ │ │ │ ├── conform.scm
│ │ │ │ ├── cpstak.scm
│ │ │ │ ├── ctak.scm
│ │ │ │ ├── dderiv.scm
│ │ │ │ ├── deriv.scm
│ │ │ │ ├── destruc.scm
│ │ │ │ ├── diviter.scm
│ │ │ │ ├── divrec.scm
│ │ │ │ ├── dynamic.scm
│ │ │ │ ├── earley.scm
│ │ │ │ ├── equal.scm
│ │ │ │ ├── fft.scm
│ │ │ │ ├── fib.scm
│ │ │ │ ├── fibc.scm
│ │ │ │ ├── fibfp.scm
│ │ │ │ ├── gcbench.scm
│ │ │ │ ├── generator.scm
│ │ │ │ ├── graphs.scm
│ │ │ │ ├── hashtable0.scm
│ │ │ │ ├── ilist.scm
│ │ │ │ ├── lattice.scm
│ │ │ │ ├── list.scm
│ │ │ │ ├── listsort.scm
│ │ │ │ ├── lseq.scm
│ │ │ │ ├── matrix.scm
│ │ │ │ ├── maze.scm
│ │ │ │ ├── mazefun.scm
│ │ │ │ ├── mbrot.scm
│ │ │ │ ├── mbrotZ.scm
│ │ │ │ ├── mperm.scm
│ │ │ │ ├── nboyer.scm
│ │ │ │ ├── nqueens.scm
│ │ │ │ ├── ntakl.scm
│ │ │ │ ├── nucleic.scm
│ │ │ │ ├── paraffins.scm
│ │ │ │ ├── parsing.scm
│ │ │ │ ├── peval.scm
│ │ │ │ ├── pi.scm
│ │ │ │ ├── pnpoly.scm
│ │ │ │ ├── primes.scm
│ │ │ │ ├── puzzle.scm
│ │ │ │ ├── quicksort.scm
│ │ │ │ ├── ray.scm
│ │ │ │ ├── read0.scm
│ │ │ │ ├── read1.scm
│ │ │ │ ├── rlist.scm
│ │ │ │ ├── sboyer.scm
│ │ │ │ ├── scheme.scm
│ │ │ │ ├── set.scm
│ │ │ │ ├── simplex.scm
│ │ │ │ ├── slatex.scm
│ │ │ │ ├── stream.scm
│ │ │ │ ├── string.scm
│ │ │ │ ├── sum.scm
│ │ │ │ ├── sum1.scm
│ │ │ │ ├── sumfp.scm
│ │ │ │ ├── tail.scm
│ │ │ │ ├── tak.scm
│ │ │ │ ├── takl.scm
│ │ │ │ ├── text.scm
│ │ │ │ ├── triangl.scm
│ │ │ │ ├── vecsort.scm
│ │ │ │ ├── vector.scm
│ │ │ │ └── wc.scm
│ │ │ ├── summarize.sch
│ │ │ └── summarize2.sch
│ │ └── reading.sch
│ ├── Boot/
│ │ ├── README
│ │ └── fib.sch
│ ├── Compiler/
│ │ ├── README
│ │ ├── p2tests.sch
│ │ ├── p4tests.sch
│ │ ├── primtests.sch
│ │ └── run-tests.sch
│ ├── FFI/
│ │ ├── Makefile
│ │ ├── README
│ │ ├── ffi-test-ff.c
│ │ ├── ffi-test.sch
│ │ ├── ffi-tests.sch
│ │ ├── std-ffi-test-ff.c
│ │ ├── std-ffi-test.def
│ │ └── std-ffi-test.sch
│ ├── GC/
│ │ ├── Makefile
│ │ ├── README
│ │ ├── dummy.sch
│ │ ├── dynamic.sch
│ │ ├── gcbench0.sch
│ │ ├── gcbench1.sch
│ │ ├── gcbench2.sch
│ │ ├── grow.sch
│ │ ├── lattice.sch
│ │ ├── nbody.sch
│ │ ├── nboyer.sch
│ │ ├── nucleic2.sch
│ │ ├── nvboyer.sch
│ │ ├── permsort.sch
│ │ ├── process-log.sch
│ │ ├── sboyer.sch
│ │ └── support.sch
│ ├── Jaffer/
│ │ ├── README
│ │ └── r4rstest.scm
│ ├── Lib/
│ │ ├── NormalizationTest.txt
│ │ ├── README
│ │ ├── bool.sch
│ │ ├── bytevector.sch
│ │ ├── char.sch
│ │ ├── complex.sch
│ │ ├── condition.sch
│ │ ├── ctak.sch
│ │ ├── dynamic-wind.sch
│ │ ├── enum.sch
│ │ ├── env.sch
│ │ ├── except.sch
│ │ ├── fact.sch
│ │ ├── fib.sch
│ │ ├── fixnums.sch
│ │ ├── hashtable.sch
│ │ ├── io.sch
│ │ ├── load-all-tests.sch
│ │ ├── normalization.sch
│ │ ├── number.sch
│ │ ├── pred.sch
│ │ ├── print.sch
│ │ ├── record.sch
│ │ ├── regression.sch
│ │ ├── string.sch
│ │ ├── test.sch
│ │ └── wcm.sch
│ ├── Misc/
│ │ ├── README
│ │ ├── env-tests.sch
│ │ └── nucleic2.sch
│ ├── R6RS/
│ │ ├── cmdline.sch
│ │ ├── cmdline.script
│ │ ├── cpoint.sch
│ │ ├── cpointR6.sch
│ │ ├── earley.input
│ │ ├── earley.sch
│ │ ├── exceptions.sch
│ │ ├── fib.input
│ │ ├── fib.sch
│ │ ├── grabbag.sch
│ │ ├── grabbag.script
│ │ ├── hello.sch
│ │ ├── nboyer.input
│ │ ├── nboyer.sch
│ │ ├── nothing.sch
│ │ ├── nothingBig.sch
│ │ ├── regression.sch
│ │ ├── run-benchmark.sch
│ │ ├── testall
│ │ └── testall.bat
│ ├── R7RS/
│ │ ├── Lib/
│ │ │ ├── README
│ │ │ ├── README2
│ │ │ ├── testall
│ │ │ ├── testall-chibi
│ │ │ ├── testall-chicken
│ │ │ ├── testall-foment
│ │ │ ├── testall-gauche
│ │ │ ├── testall-kawa
│ │ │ ├── testall-sagittarius
│ │ │ ├── testr6rs-chibi
│ │ │ ├── testr6rs-larceny
│ │ │ ├── testr6rs-sagittarius
│ │ │ └── tests/
│ │ │ ├── r6rs/
│ │ │ │ ├── README.txt
│ │ │ │ ├── arithmetic/
│ │ │ │ │ └── fixnums.sld
│ │ │ │ ├── base.sld
│ │ │ │ ├── bytevectors.sld
│ │ │ │ ├── control.sld
│ │ │ │ ├── enums.sld
│ │ │ │ ├── eval.sld
│ │ │ │ ├── exceptions.sld
│ │ │ │ ├── hashtables.sld
│ │ │ │ ├── io/
│ │ │ │ │ └── simple.sld
│ │ │ │ ├── lists.sld
│ │ │ │ ├── mutable-pairs.sld
│ │ │ │ ├── mutable-strings.sld
│ │ │ │ ├── programs.sld
│ │ │ │ ├── r5rs.sld
│ │ │ │ ├── run/
│ │ │ │ │ ├── arithmetic/
│ │ │ │ │ │ └── fixnums.sps
│ │ │ │ │ ├── base.sps
│ │ │ │ │ ├── bytevectors.sps
│ │ │ │ │ ├── control.sps
│ │ │ │ │ ├── enums.sps
│ │ │ │ │ ├── eval.sps
│ │ │ │ │ ├── exceptions.sps
│ │ │ │ │ ├── hashtables.sps
│ │ │ │ │ ├── io/
│ │ │ │ │ │ └── simple.sps
│ │ │ │ │ ├── lists.sps
│ │ │ │ │ ├── mutable-pairs.sps
│ │ │ │ │ ├── mutable-strings.sps
│ │ │ │ │ ├── programs.sps
│ │ │ │ │ ├── r5rs.sps
│ │ │ │ │ ├── sorting.sps
│ │ │ │ │ └── unicode.sps
│ │ │ │ ├── sorting.sld
│ │ │ │ └── unicode.sld
│ │ │ └── scheme/
│ │ │ ├── base-test1.scm
│ │ │ ├── base-test2.scm
│ │ │ ├── base-test3.scm
│ │ │ ├── base-test4.scm
│ │ │ ├── base.body-closed.scm
│ │ │ ├── base.sld
│ │ │ ├── box.sld
│ │ │ ├── case-lambda.sld
│ │ │ ├── char.body-alt.scm
│ │ │ ├── char.body.scm
│ │ │ ├── char.sld
│ │ │ ├── charset.sld
│ │ │ ├── comparator.sld
│ │ │ ├── complex.body.scm
│ │ │ ├── complex.sld
│ │ │ ├── cxr.sld
│ │ │ ├── ephemeron.sld
│ │ │ ├── eval.body.scm
│ │ │ ├── eval.sld
│ │ │ ├── file.sld
│ │ │ ├── flonum.sld
│ │ │ ├── generator.sld
│ │ │ ├── hash-table.sld
│ │ │ ├── ideque.sld
│ │ │ ├── ilist.sld
│ │ │ ├── inexact.sld
│ │ │ ├── lazy.sld
│ │ │ ├── list-queue.sld
│ │ │ ├── list.sld
│ │ │ ├── load-test1.scm
│ │ │ ├── load-test2.scm
│ │ │ ├── load-test3.scm
│ │ │ ├── load.sld
│ │ │ ├── lseq.sld
│ │ │ ├── process-context.sld
│ │ │ ├── read.sld
│ │ │ ├── repl-test2.scm
│ │ │ ├── repl.sld
│ │ │ ├── rlist.sld
│ │ │ ├── run/
│ │ │ │ ├── base.sps
│ │ │ │ ├── box.sps
│ │ │ │ ├── case-lambda.sps
│ │ │ │ ├── char.sps
│ │ │ │ ├── charset.sps
│ │ │ │ ├── comparator.sps
│ │ │ │ ├── complex.sps
│ │ │ │ ├── cxr.sps
│ │ │ │ ├── ephemeron.sps
│ │ │ │ ├── eval.sps
│ │ │ │ ├── file.sps
│ │ │ │ ├── flonum.sps
│ │ │ │ ├── generator.sps
│ │ │ │ ├── hash-table.sps
│ │ │ │ ├── ideque.sps
│ │ │ │ ├── ilist.sps
│ │ │ │ ├── inexact.sps
│ │ │ │ ├── lazy.sps
│ │ │ │ ├── list-queue.sps
│ │ │ │ ├── list.sps
│ │ │ │ ├── load.sps
│ │ │ │ ├── lseq.sps
│ │ │ │ ├── process-context.sps
│ │ │ │ ├── read.sps
│ │ │ │ ├── repl.sps
│ │ │ │ ├── rlist.sps
│ │ │ │ ├── set.sps
│ │ │ │ ├── sort.sps
│ │ │ │ ├── stream.sps
│ │ │ │ ├── text.sps
│ │ │ │ ├── time.sps
│ │ │ │ ├── vector.sps
│ │ │ │ └── write.sps
│ │ │ ├── set.sld
│ │ │ ├── sort.sld
│ │ │ ├── stream.sld
│ │ │ ├── test.sld
│ │ │ ├── text.sld
│ │ │ ├── time.sld
│ │ │ ├── vector.sld
│ │ │ └── write.sld
│ │ ├── Numbers/
│ │ │ └── clisp-number-tests.sps
│ │ ├── conflicts.scm
│ │ └── srfi.scm
│ ├── README
│ ├── Scripts/
│ │ ├── autobuild-conservative
│ │ ├── autobuild-precise
│ │ ├── backup-xml-files.sh
│ │ ├── benchmark-only
│ │ ├── build-only
│ │ ├── checkout-common-larceny
│ │ ├── checkout-git
│ │ ├── checkout-git-cdash
│ │ ├── checkout-svn
│ │ ├── checkout-svn-cdash
│ │ ├── checkout-svn-dart
│ │ ├── clone-only
│ │ ├── delete-builds-from-16th-to-24th.sh
│ │ ├── delete-builds-from-16th-to-31st.sh
│ │ ├── delete-builds-from-25th-to-31st.sh
│ │ ├── delete-builds-from-2nd-to-14th.sh
│ │ ├── delete-builds-from-2nd-to-8th.sh
│ │ ├── delete-builds-from-9th-to-14th.sh
│ │ ├── gcbench-cdash
│ │ ├── nightly-build
│ │ ├── package-bin-release.sh
│ │ ├── test-only
│ │ └── test2-only
│ ├── Sparc/
│ │ ├── README
│ │ └── prim-error.sch
│ ├── Stress/
│ │ ├── README
│ │ ├── bench
│ │ ├── results.Larceny
│ │ ├── src/
│ │ │ ├── boyer.scm
│ │ │ ├── browse.scm
│ │ │ ├── conform.scm
│ │ │ ├── cpstak.scm
│ │ │ ├── crash.scm
│ │ │ ├── ctak.scm
│ │ │ ├── dderiv.scm
│ │ │ ├── deriv.scm
│ │ │ ├── destruc.scm
│ │ │ ├── diviter.scm
│ │ │ ├── divrec.scm
│ │ │ ├── dynamic.scm
│ │ │ ├── earley.scm
│ │ │ ├── fail.scm
│ │ │ ├── fft.c
│ │ │ ├── fft.scm
│ │ │ ├── fib.c
│ │ │ ├── fib.scm
│ │ │ ├── fibc.scm
│ │ │ ├── fibfp.c
│ │ │ ├── fibfp.scm
│ │ │ ├── fpsum.scm
│ │ │ ├── graphs.scm
│ │ │ ├── lattice.scm
│ │ │ ├── matrix.scm
│ │ │ ├── maze.scm
│ │ │ ├── mazefun.scm
│ │ │ ├── mbrot.c
│ │ │ ├── mbrot.scm
│ │ │ ├── nbody.scm
│ │ │ ├── nboyer.scm
│ │ │ ├── nqueens.scm
│ │ │ ├── nucleic.c
│ │ │ ├── nucleic.scm
│ │ │ ├── num-iters-int.scm
│ │ │ ├── num-iters.scm
│ │ │ ├── one-iter.scm
│ │ │ ├── perm9.scm
│ │ │ ├── peval.scm
│ │ │ ├── pnpoly.c
│ │ │ ├── pnpoly.scm
│ │ │ ├── prefix-chez.scm
│ │ │ ├── prefix-larceny.scm
│ │ │ ├── primes.scm
│ │ │ ├── puzzle.scm
│ │ │ ├── quicksort.scm
│ │ │ ├── ray.scm
│ │ │ ├── scheme.scm
│ │ │ ├── simplex.scm
│ │ │ ├── slatex.scm
│ │ │ ├── slatex.sty
│ │ │ ├── smlboyer.scm
│ │ │ ├── succeed.scm
│ │ │ ├── suffix-larceny.scm
│ │ │ ├── sum.c
│ │ │ ├── sum.scm
│ │ │ ├── sumfp.c
│ │ │ ├── sumfp.scm
│ │ │ ├── tak.c
│ │ │ ├── tak.scm
│ │ │ ├── takl.scm
│ │ │ ├── test.tex
│ │ │ ├── trav1.scm
│ │ │ ├── trav2.scm
│ │ │ └── triangl.scm
│ │ ├── summarize
│ │ ├── summarize.sch
│ │ ├── switches.scm
│ │ └── sys/
│ │ └── larceny/
│ │ └── crash.scm
│ ├── run-benchmark.sch
│ └── run-gc-tests.sch
└── tools/
├── LexGen/
│ ├── accessible.sch
│ ├── lexgen.c.sch
│ ├── lexgen.java.sch
│ ├── lexgen.scheme.sch
│ ├── loadlexgen.sch
│ ├── regexp.sch
│ └── select.sch
├── ParseGen/
│ ├── README
│ ├── follow.sch
│ ├── loadparsegen.sch
│ ├── parsegen.c.sch
│ ├── parsegen.java.sch
│ ├── parsegen.pascal.sch
│ ├── parsegen.sch
│ ├── parsegen.scheme.sch
│ ├── parsegen0.pg
│ ├── parsegen0.sch
│ ├── sets.sch
│ └── sets2.sch
├── R6RS/
│ ├── README
│ ├── download-snow
│ ├── make-snow
│ ├── r6rs/
│ │ ├── arithmetic/
│ │ │ ├── fixnums.body.scm
│ │ │ └── fixnums.sld
│ │ ├── base.body.scm
│ │ ├── base.sld
│ │ ├── bytevectors.body.scm
│ │ ├── bytevectors.sld
│ │ ├── control.sld
│ │ ├── enums.body.scm
│ │ ├── enums.sld
│ │ ├── eval.sld
│ │ ├── exceptions.sld
│ │ ├── files.sld
│ │ ├── hashtables.atop69.scm
│ │ ├── hashtables.body69.scm
│ │ ├── hashtables.sld
│ │ ├── io/
│ │ │ └── simple.sld
│ │ ├── lists.body.scm
│ │ ├── lists.sld
│ │ ├── mutable-pairs.sld
│ │ ├── mutable-strings.sld
│ │ ├── programs.sld
│ │ ├── r5rs.sld
│ │ ├── sorting.body.scm
│ │ ├── sorting.sld
│ │ ├── unicode-reference/
│ │ │ ├── unicode0.body.scm
│ │ │ ├── unicode0.sld
│ │ │ ├── unicode1.body.scm
│ │ │ ├── unicode1.sld
│ │ │ ├── unicode2.body.scm
│ │ │ ├── unicode2.sld
│ │ │ ├── unicode3.body.scm
│ │ │ ├── unicode3.sld
│ │ │ ├── unicode4.body.scm
│ │ │ └── unicode4.sld
│ │ └── unicode.sld
│ ├── r6rsDoc.html
│ └── upload-snow
├── R7RS/
│ ├── in-progress/
│ │ └── hash/
│ │ ├── bimaps.body.scm
│ │ └── bimaps.sld
│ ├── make-snow
│ └── upload-snow
└── Unicode/
└── r6rs-unicode/
├── README
├── check-normalization.scm
├── check-wordbreaking.scm
├── local/
│ ├── unicode.sls
│ ├── unicode0.sls
│ ├── unicode1.sls
│ ├── unicode2.sls
│ ├── unicode3.sls
│ └── unicode4.sls
├── parseUCD.sch
├── strategy.sch
└── unicode-tests.sch
Showing preview only (472K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (5511 symbols across 191 files)
FILE: include/Shared/millicode.h
type word (line 16) | typedef word codeptr_t;
type word (line 17) | typedef word cont_t;
FILE: include/Shared/petit-config.h
type cont_t (line 115) | typedef unsigned cont_t;
type RTYPE (line 116) | typedef RTYPE (*codeptr_t)( word *globals, unsigned k );
type RTYPE (line 127) | typedef RTYPE (*codeptr_t)( word *globals );
FILE: include/Standard-C/petit-instr.h
function RTYPE (line 282) | static RTYPE k_symbolic( CONT_PARAMS ) { \
FILE: include/Sys/larceny-types.h
type word (line 14) | typedef unsigned int word;
type s_word (line 15) | typedef int s_word;
type byte (line 16) | typedef unsigned char byte;
type gc_type_t (line 31) | typedef enum { GCTYPE_COLLECT,
type stats_timer_t (line 47) | typedef enum { TIMER_ELAPSED, /* Measure elapsed time */
type gc_t (line 52) | typedef struct gc gc_t;
type young_heap_t (line 55) | typedef struct young_heap young_heap_t;
type old_heap_t (line 58) | typedef struct old_heap old_heap_t;
type oh_type_t (line 59) | typedef enum { OHTYPE_EPHEMERAL, OHTYPE_DYNAMIC, OHTYPE_REGIONAL } oh_ty...
type region_group_t (line 61) | typedef enum {
type extbmp_t (line 76) | typedef struct extbmp extbmp_t;
type static_heap_t (line 79) | typedef struct static_heap static_heap_t;
type remset_t (line 82) | typedef struct remset remset_t;
type locset_t (line 85) | typedef struct locset locset_t;
type smircy_context_t (line 88) | typedef struct smircy_context smircy_context_t;
type summary_t (line 91) | typedef struct summary summary_t;
type loc_t (line 92) | typedef struct loc loc_t;
type summ_matrix_t (line 95) | typedef struct summ_matrix summ_matrix_t;
type seqbuf_t (line 98) | typedef struct seqbuf seqbuf_t;
type semispace_t (line 101) | typedef struct semispace semispace_t;
type ss_chunk_t (line 102) | typedef struct ss_chunk ss_chunk_t;
type uremset_t (line 105) | typedef struct uremset uremset_t;
type heapio_t (line 108) | typedef struct heapio_t heapio_t;
type metadata_block_t (line 109) | typedef struct metadata_block_t metadata_block_t;
type gclib_stats_t (line 112) | typedef struct gclib_stats gclib_stats_t;
type gc_stats_t (line 113) | typedef struct gc_stats gc_stats_t;
type gen_stats_t (line 114) | typedef struct gen_stats gen_stats_t;
type remset_stats_t (line 115) | typedef struct remset_stats remset_stats_t;
type stack_stats_t (line 116) | typedef struct stack_stats stack_stats_t;
type swb_stats_t (line 118) | typedef struct swb_stats swb_stats_t;
type gc_event_stats_t (line 120) | typedef struct gc_event_stats gc_event_stats_t;
type gc_mmu_log_t (line 123) | typedef struct gc_mmu_log gc_mmu_log_t;
type np_info_t (line 126) | typedef struct np_info np_info_t;
type sc_info_t (line 127) | typedef struct sc_info sc_info_t;
type bdw_info_t (line 128) | typedef struct bdw_info bdw_info_t;
type dof_info_t (line 129) | typedef struct dof_info dof_info_t;
type nursery_info_t (line 130) | typedef struct nursery_info nursery_info_t;
type gc_param_t (line 131) | typedef struct gc_param gc_param_t;
type old_param_t (line 132) | typedef struct old_param old_param_t;
type los_t (line 135) | typedef struct los los_t;
type hrtime_t (line 139) | typedef int hrtime_t;
FILE: lib/Experimental/socket-offset.c
type sockaddr (line 6) | struct sockaddr
type sockaddr (line 9) | struct sockaddr
type sockaddr (line 11) | struct sockaddr
FILE: lib/Experimental/socket-support.c
function get_errno (line 6) | int get_errno( void ) { return errno; }
function get_h_errno (line 7) | int get_h_errno( void ) { return h_errno; }
FILE: lib/Experimental/unix-support.c
function get_errno (line 13) | int get_errno( void ) { return errno; }
function get_h_errno (line 14) | int get_h_errno( void ) { return h_errno; }
FILE: lib/SRFI/scheme-r5rs.c
function str_end_eq (line 25) | int str_end_eq(char *s1, char *s2)
function main (line 35) | int main(int argc, char **argv)
FILE: src/Asm/Nasm/Experiments/benchmark.c
type TreeNode (line 21) | struct TreeNode
type TN (line 22) | typedef struct TreeNode TN;
type TreeNode (line 26) | struct TreeNode {
function test_entry (line 36) | int test_entry(struct TreeNode *tree, int key, int count)
function tree_init (line 54) | void tree_init(TN *thisTree, size_t size)
function TN (line 78) | TN *tree_find(TN *tree, int key)
function tree_connect (line 87) | void tree_connect(TN *src, TN *dest, nextFun_t fun)
function file_size (line 96) | size_t file_size(const char *filename)
function timing (line 137) | static inline double timing()
function main (line 151) | int main(int argc, char **argv)
FILE: src/Asm/Nasm/Experiments/loader.c
function check (line 11) | void check(int cond)
function main (line 19) | int main(int argc, char **argv, char **env)
FILE: src/Asm/Nasm/Experiments/winloader.c
function check (line 7) | void check(int cond)
function main (line 15) | int main(int argc, char **argv, char **env)
FILE: src/Asm/Nasm/NASM/assemble.c
type itemplate (line 79) | struct itemplate
type ea (line 81) | typedef struct {
type ofmt (line 90) | struct ofmt
type itemplate (line 96) | struct itemplate
function out (line 105) | static void out(long offset, long segto, const void *data,
function jmp_match (line 157) | static int jmp_match(long segment, long offset, int bits,
function assemble (line 182) | long assemble(long segment, long offset, int bits, unsigned long cp,
function insn_size (line 486) | long insn_size(long segment, long offset, int bits, unsigned long cp,
function is_sbyte (line 623) | static int is_sbyte(insn * ins, int op, int size)
function calcsize (line 640) | static long calcsize(long segment, long offset, int bits,
function gencode (line 821) | static void gencode(long segment, long offset, int bits,
function regval (line 1303) | static int regval(operand * o)
function matches (line 1311) | static int matches(struct itemplate *itemp, insn * instruction)
function ea (line 1428) | static ea *process_ea(operand * input, ea * output, int addrbits,
function chsize (line 1743) | static int chsize(operand * input, int addrbits)
FILE: src/Asm/Nasm/NASM/insns.h
type itemplate (line 22) | struct itemplate {
FILE: src/Asm/Nasm/NASM/insnsa.c
type itemplate (line 6) | struct itemplate
type itemplate (line 11) | struct itemplate
type itemplate (line 17) | struct itemplate
type itemplate (line 23) | struct itemplate
type itemplate (line 28) | struct itemplate
type itemplate (line 57) | struct itemplate
type itemplate (line 86) | struct itemplate
type itemplate (line 92) | struct itemplate
type itemplate (line 98) | struct itemplate
type itemplate (line 104) | struct itemplate
type itemplate (line 110) | struct itemplate
type itemplate (line 116) | struct itemplate
type itemplate (line 122) | struct itemplate
type itemplate (line 151) | struct itemplate
type itemplate (line 157) | struct itemplate
type itemplate (line 163) | struct itemplate
type itemplate (line 169) | struct itemplate
type itemplate (line 175) | struct itemplate
type itemplate (line 181) | struct itemplate
type itemplate (line 187) | struct itemplate
type itemplate (line 195) | struct itemplate
type itemplate (line 203) | struct itemplate
type itemplate (line 208) | struct itemplate
type itemplate (line 218) | struct itemplate
type itemplate (line 228) | struct itemplate
type itemplate (line 238) | struct itemplate
type itemplate (line 248) | struct itemplate
type itemplate (line 277) | struct itemplate
type itemplate (line 282) | struct itemplate
type itemplate (line 287) | struct itemplate
type itemplate (line 292) | struct itemplate
type itemplate (line 297) | struct itemplate
type itemplate (line 302) | struct itemplate
type itemplate (line 307) | struct itemplate
type itemplate (line 312) | struct itemplate
type itemplate (line 317) | struct itemplate
type itemplate (line 346) | struct itemplate
type itemplate (line 352) | struct itemplate
type itemplate (line 358) | struct itemplate
type itemplate (line 364) | struct itemplate
type itemplate (line 370) | struct itemplate
type itemplate (line 376) | struct itemplate
type itemplate (line 382) | struct itemplate
type itemplate (line 388) | struct itemplate
type itemplate (line 394) | struct itemplate
type itemplate (line 400) | struct itemplate
type itemplate (line 406) | struct itemplate
type itemplate (line 412) | struct itemplate
type itemplate (line 418) | struct itemplate
type itemplate (line 424) | struct itemplate
type itemplate (line 430) | struct itemplate
type itemplate (line 436) | struct itemplate
type itemplate (line 442) | struct itemplate
type itemplate (line 448) | struct itemplate
type itemplate (line 454) | struct itemplate
type itemplate (line 460) | struct itemplate
type itemplate (line 466) | struct itemplate
type itemplate (line 472) | struct itemplate
type itemplate (line 478) | struct itemplate
type itemplate (line 484) | struct itemplate
type itemplate (line 490) | struct itemplate
type itemplate (line 496) | struct itemplate
type itemplate (line 502) | struct itemplate
type itemplate (line 508) | struct itemplate
type itemplate (line 514) | struct itemplate
type itemplate (line 520) | struct itemplate
type itemplate (line 526) | struct itemplate
type itemplate (line 531) | struct itemplate
type itemplate (line 538) | struct itemplate
type itemplate (line 544) | struct itemplate
type itemplate (line 549) | struct itemplate
type itemplate (line 555) | struct itemplate
type itemplate (line 561) | struct itemplate
type itemplate (line 567) | struct itemplate
type itemplate (line 573) | struct itemplate
type itemplate (line 583) | struct itemplate
type itemplate (line 593) | struct itemplate
type itemplate (line 598) | struct itemplate
type itemplate (line 604) | struct itemplate
type itemplate (line 610) | struct itemplate
type itemplate (line 615) | struct itemplate
type itemplate (line 621) | struct itemplate
type itemplate (line 627) | struct itemplate
type itemplate (line 633) | struct itemplate
type itemplate (line 639) | struct itemplate
type itemplate (line 645) | struct itemplate
type itemplate (line 651) | struct itemplate
type itemplate (line 657) | struct itemplate
type itemplate (line 663) | struct itemplate
type itemplate (line 669) | struct itemplate
type itemplate (line 675) | struct itemplate
type itemplate (line 681) | struct itemplate
type itemplate (line 687) | struct itemplate
type itemplate (line 693) | struct itemplate
type itemplate (line 699) | struct itemplate
type itemplate (line 705) | struct itemplate
type itemplate (line 711) | struct itemplate
type itemplate (line 717) | struct itemplate
type itemplate (line 723) | struct itemplate
type itemplate (line 729) | struct itemplate
type itemplate (line 735) | struct itemplate
type itemplate (line 741) | struct itemplate
type itemplate (line 747) | struct itemplate
type itemplate (line 752) | struct itemplate
type itemplate (line 757) | struct itemplate
type itemplate (line 762) | struct itemplate
type itemplate (line 767) | struct itemplate
type itemplate (line 771) | struct itemplate
type itemplate (line 775) | struct itemplate
type itemplate (line 784) | struct itemplate
type itemplate (line 791) | struct itemplate
type itemplate (line 797) | struct itemplate
type itemplate (line 803) | struct itemplate
type itemplate (line 809) | struct itemplate
type itemplate (line 815) | struct itemplate
type itemplate (line 819) | struct itemplate
type itemplate (line 823) | struct itemplate
type itemplate (line 827) | struct itemplate
type itemplate (line 832) | struct itemplate
type itemplate (line 837) | struct itemplate
type itemplate (line 843) | struct itemplate
type itemplate (line 848) | struct itemplate
type itemplate (line 853) | struct itemplate
type itemplate (line 863) | struct itemplate
type itemplate (line 869) | struct itemplate
type itemplate (line 875) | struct itemplate
type itemplate (line 881) | struct itemplate
type itemplate (line 886) | struct itemplate
type itemplate (line 891) | struct itemplate
type itemplate (line 897) | struct itemplate
type itemplate (line 903) | struct itemplate
type itemplate (line 909) | struct itemplate
type itemplate (line 915) | struct itemplate
type itemplate (line 921) | struct itemplate
type itemplate (line 927) | struct itemplate
type itemplate (line 933) | struct itemplate
type itemplate (line 939) | struct itemplate
type itemplate (line 947) | struct itemplate
type itemplate (line 953) | struct itemplate
type itemplate (line 959) | struct itemplate
type itemplate (line 967) | struct itemplate
type itemplate (line 972) | struct itemplate
type itemplate (line 977) | struct itemplate
type itemplate (line 982) | struct itemplate
type itemplate (line 987) | struct itemplate
type itemplate (line 997) | struct itemplate
type itemplate (line 1003) | struct itemplate
type itemplate (line 1013) | struct itemplate
type itemplate (line 1019) | struct itemplate
type itemplate (line 1024) | struct itemplate
type itemplate (line 1029) | struct itemplate
type itemplate (line 1034) | struct itemplate
type itemplate (line 1039) | struct itemplate
type itemplate (line 1045) | struct itemplate
type itemplate (line 1051) | struct itemplate
type itemplate (line 1057) | struct itemplate
type itemplate (line 1063) | struct itemplate
type itemplate (line 1069) | struct itemplate
type itemplate (line 1076) | struct itemplate
type itemplate (line 1082) | struct itemplate
type itemplate (line 1087) | struct itemplate
type itemplate (line 1092) | struct itemplate
type itemplate (line 1098) | struct itemplate
type itemplate (line 1105) | struct itemplate
type itemplate (line 1112) | struct itemplate
type itemplate (line 1118) | struct itemplate
type itemplate (line 1124) | struct itemplate
type itemplate (line 1132) | struct itemplate
type itemplate (line 1137) | struct itemplate
type itemplate (line 1142) | struct itemplate
type itemplate (line 1147) | struct itemplate
type itemplate (line 1152) | struct itemplate
type itemplate (line 1157) | struct itemplate
type itemplate (line 1162) | struct itemplate
type itemplate (line 1167) | struct itemplate
type itemplate (line 1172) | struct itemplate
type itemplate (line 1177) | struct itemplate
type itemplate (line 1187) | struct itemplate
type itemplate (line 1193) | struct itemplate
type itemplate (line 1198) | struct itemplate
type itemplate (line 1203) | struct itemplate
type itemplate (line 1208) | struct itemplate
type itemplate (line 1213) | struct itemplate
type itemplate (line 1218) | struct itemplate
type itemplate (line 1223) | struct itemplate
type itemplate (line 1228) | struct itemplate
type itemplate (line 1233) | struct itemplate
type itemplate (line 1239) | struct itemplate
type itemplate (line 1244) | struct itemplate
type itemplate (line 1249) | struct itemplate
type itemplate (line 1254) | struct itemplate
type itemplate (line 1259) | struct itemplate
type itemplate (line 1264) | struct itemplate
type itemplate (line 1269) | struct itemplate
type itemplate (line 1274) | struct itemplate
type itemplate (line 1279) | struct itemplate
type itemplate (line 1284) | struct itemplate
type itemplate (line 1289) | struct itemplate
type itemplate (line 1294) | struct itemplate
type itemplate (line 1299) | struct itemplate
type itemplate (line 1306) | struct itemplate
type itemplate (line 1311) | struct itemplate
type itemplate (line 1316) | struct itemplate
type itemplate (line 1324) | struct itemplate
type itemplate (line 1330) | struct itemplate
type itemplate (line 1340) | struct itemplate
type itemplate (line 1346) | struct itemplate
type itemplate (line 1356) | struct itemplate
type itemplate (line 1362) | struct itemplate
type itemplate (line 1367) | struct itemplate
type itemplate (line 1373) | struct itemplate
type itemplate (line 1379) | struct itemplate
type itemplate (line 1385) | struct itemplate
type itemplate (line 1391) | struct itemplate
type itemplate (line 1396) | struct itemplate
type itemplate (line 1401) | struct itemplate
type itemplate (line 1406) | struct itemplate
type itemplate (line 1414) | struct itemplate
type itemplate (line 1419) | struct itemplate
type itemplate (line 1424) | struct itemplate
type itemplate (line 1429) | struct itemplate
type itemplate (line 1434) | struct itemplate
type itemplate (line 1439) | struct itemplate
type itemplate (line 1445) | struct itemplate
type itemplate (line 1451) | struct itemplate
type itemplate (line 1456) | struct itemplate
type itemplate (line 1462) | struct itemplate
type itemplate (line 1468) | struct itemplate
type itemplate (line 1476) | struct itemplate
type itemplate (line 1481) | struct itemplate
type itemplate (line 1488) | struct itemplate
type itemplate (line 1523) | struct itemplate
type itemplate (line 1533) | struct itemplate
type itemplate (line 1542) | struct itemplate
type itemplate (line 1546) | struct itemplate
type itemplate (line 1551) | struct itemplate
type itemplate (line 1556) | struct itemplate
type itemplate (line 1561) | struct itemplate
type itemplate (line 1566) | struct itemplate
type itemplate (line 1571) | struct itemplate
type itemplate (line 1576) | struct itemplate
type itemplate (line 1581) | struct itemplate
type itemplate (line 1586) | struct itemplate
type itemplate (line 1591) | struct itemplate
type itemplate (line 1596) | struct itemplate
type itemplate (line 1601) | struct itemplate
type itemplate (line 1606) | struct itemplate
type itemplate (line 1611) | struct itemplate
type itemplate (line 1616) | struct itemplate
type itemplate (line 1621) | struct itemplate
type itemplate (line 1626) | struct itemplate
type itemplate (line 1657) | struct itemplate
type itemplate (line 1666) | struct itemplate
type itemplate (line 1671) | struct itemplate
type itemplate (line 1679) | struct itemplate
type itemplate (line 1684) | struct itemplate
type itemplate (line 1689) | struct itemplate
type itemplate (line 1695) | struct itemplate
type itemplate (line 1701) | struct itemplate
type itemplate (line 1706) | struct itemplate
type itemplate (line 1712) | struct itemplate
type itemplate (line 1717) | struct itemplate
type itemplate (line 1723) | struct itemplate
type itemplate (line 1728) | struct itemplate
type itemplate (line 1734) | struct itemplate
type itemplate (line 1739) | struct itemplate
type itemplate (line 1746) | struct itemplate
type itemplate (line 1753) | struct itemplate
type itemplate (line 1758) | struct itemplate
type itemplate (line 1763) | struct itemplate
type itemplate (line 1768) | struct itemplate
type itemplate (line 1773) | struct itemplate
type itemplate (line 1778) | struct itemplate
type itemplate (line 1785) | struct itemplate
type itemplate (line 1792) | struct itemplate
type itemplate (line 1799) | struct itemplate
type itemplate (line 1806) | struct itemplate
type itemplate (line 1813) | struct itemplate
type itemplate (line 1821) | struct itemplate
type itemplate (line 1827) | struct itemplate
type itemplate (line 1834) | struct itemplate
type itemplate (line 1839) | struct itemplate
type itemplate (line 1844) | struct itemplate
type itemplate (line 1850) | struct itemplate
type itemplate (line 1856) | struct itemplate
type itemplate (line 1862) | struct itemplate
type itemplate (line 1868) | struct itemplate
type itemplate (line 1873) | struct itemplate
type itemplate (line 1879) | struct itemplate
type itemplate (line 1885) | struct itemplate
type itemplate (line 1891) | struct itemplate
type itemplate (line 1897) | struct itemplate
type itemplate (line 1903) | struct itemplate
type itemplate (line 1946) | struct itemplate
type itemplate (line 1954) | struct itemplate
type itemplate (line 1962) | struct itemplate
type itemplate (line 1974) | struct itemplate
type itemplate (line 1980) | struct itemplate
type itemplate (line 1985) | struct itemplate
type itemplate (line 1993) | struct itemplate
type itemplate (line 2001) | struct itemplate
type itemplate (line 2006) | struct itemplate
type itemplate (line 2012) | struct itemplate
type itemplate (line 2018) | struct itemplate
type itemplate (line 2023) | struct itemplate
type itemplate (line 2029) | struct itemplate
type itemplate (line 2035) | struct itemplate
type itemplate (line 2040) | struct itemplate
type itemplate (line 2045) | struct itemplate
type itemplate (line 2050) | struct itemplate
type itemplate (line 2055) | struct itemplate
type itemplate (line 2060) | struct itemplate
type itemplate (line 2065) | struct itemplate
type itemplate (line 2070) | struct itemplate
type itemplate (line 2082) | struct itemplate
type itemplate (line 2087) | struct itemplate
type itemplate (line 2092) | struct itemplate
type itemplate (line 2101) | struct itemplate
type itemplate (line 2107) | struct itemplate
type itemplate (line 2113) | struct itemplate
type itemplate (line 2121) | struct itemplate
type itemplate (line 2126) | struct itemplate
type itemplate (line 2134) | struct itemplate
type itemplate (line 2142) | struct itemplate
type itemplate (line 2150) | struct itemplate
type itemplate (line 2158) | struct itemplate
type itemplate (line 2165) | struct itemplate
type itemplate (line 2171) | struct itemplate
type itemplate (line 2177) | struct itemplate
type itemplate (line 2183) | struct itemplate
type itemplate (line 2189) | struct itemplate
type itemplate (line 2195) | struct itemplate
type itemplate (line 2202) | struct itemplate
type itemplate (line 2207) | struct itemplate
type itemplate (line 2214) | struct itemplate
type itemplate (line 2243) | struct itemplate
type itemplate (line 2249) | struct itemplate
type itemplate (line 2255) | struct itemplate
type itemplate (line 2265) | struct itemplate
type itemplate (line 2270) | struct itemplate
type itemplate (line 2275) | struct itemplate
type itemplate (line 2280) | struct itemplate
type itemplate (line 2288) | struct itemplate
type itemplate (line 2296) | struct itemplate
type itemplate (line 2304) | struct itemplate
type itemplate (line 2312) | struct itemplate
type itemplate (line 2320) | struct itemplate
type itemplate (line 2328) | struct itemplate
type itemplate (line 2336) | struct itemplate
type itemplate (line 2342) | struct itemplate
type itemplate (line 2350) | struct itemplate
type itemplate (line 2358) | struct itemplate
type itemplate (line 2366) | struct itemplate
type itemplate (line 2374) | struct itemplate
type itemplate (line 2382) | struct itemplate
type itemplate (line 2390) | struct itemplate
type itemplate (line 2395) | struct itemplate
type itemplate (line 2401) | struct itemplate
type itemplate (line 2409) | struct itemplate
type itemplate (line 2415) | struct itemplate
type itemplate (line 2423) | struct itemplate
type itemplate (line 2431) | struct itemplate
type itemplate (line 2439) | struct itemplate
type itemplate (line 2447) | struct itemplate
type itemplate (line 2455) | struct itemplate
type itemplate (line 2463) | struct itemplate
type itemplate (line 2471) | struct itemplate
type itemplate (line 2476) | struct itemplate
type itemplate (line 2482) | struct itemplate
type itemplate (line 2488) | struct itemplate
type itemplate (line 2494) | struct itemplate
type itemplate (line 2500) | struct itemplate
type itemplate (line 2506) | struct itemplate
type itemplate (line 2512) | struct itemplate
type itemplate (line 2518) | struct itemplate
type itemplate (line 2524) | struct itemplate
type itemplate (line 2530) | struct itemplate
type itemplate (line 2536) | struct itemplate
type itemplate (line 2542) | struct itemplate
type itemplate (line 2548) | struct itemplate
type itemplate (line 2554) | struct itemplate
type itemplate (line 2560) | struct itemplate
type itemplate (line 2566) | struct itemplate
type itemplate (line 2572) | struct itemplate
type itemplate (line 2578) | struct itemplate
type itemplate (line 2584) | struct itemplate
type itemplate (line 2590) | struct itemplate
type itemplate (line 2596) | struct itemplate
type itemplate (line 2602) | struct itemplate
type itemplate (line 2608) | struct itemplate
type itemplate (line 2620) | struct itemplate
type itemplate (line 2625) | struct itemplate
type itemplate (line 2633) | struct itemplate
type itemplate (line 2639) | struct itemplate
type itemplate (line 2647) | struct itemplate
type itemplate (line 2655) | struct itemplate
type itemplate (line 2663) | struct itemplate
type itemplate (line 2671) | struct itemplate
type itemplate (line 2677) | struct itemplate
type itemplate (line 2683) | struct itemplate
type itemplate (line 2689) | struct itemplate
type itemplate (line 2695) | struct itemplate
type itemplate (line 2703) | struct itemplate
type itemplate (line 2711) | struct itemplate
type itemplate (line 2719) | struct itemplate
type itemplate (line 2727) | struct itemplate
type itemplate (line 2732) | struct itemplate
type itemplate (line 2737) | struct itemplate
type itemplate (line 2742) | struct itemplate
type itemplate (line 2747) | struct itemplate
type itemplate (line 2758) | struct itemplate
type itemplate (line 2763) | struct itemplate
type itemplate (line 2768) | struct itemplate
type itemplate (line 2773) | struct itemplate
type itemplate (line 2778) | struct itemplate
type itemplate (line 2783) | struct itemplate
type itemplate (line 2788) | struct itemplate
type itemplate (line 2796) | struct itemplate
type itemplate (line 2801) | struct itemplate
type itemplate (line 2806) | struct itemplate
type itemplate (line 2811) | struct itemplate
type itemplate (line 2816) | struct itemplate
type itemplate (line 2821) | struct itemplate
type itemplate (line 2826) | struct itemplate
type itemplate (line 2834) | struct itemplate
type itemplate (line 2840) | struct itemplate
type itemplate (line 2846) | struct itemplate
type itemplate (line 2852) | struct itemplate
type itemplate (line 2858) | struct itemplate
type itemplate (line 2868) | struct itemplate
type itemplate (line 2873) | struct itemplate
type itemplate (line 2883) | struct itemplate
type itemplate (line 2893) | struct itemplate
type itemplate (line 2903) | struct itemplate
type itemplate (line 2913) | struct itemplate
type itemplate (line 2923) | struct itemplate
type itemplate (line 2928) | struct itemplate
type itemplate (line 2938) | struct itemplate
type itemplate (line 2948) | struct itemplate
type itemplate (line 2956) | struct itemplate
type itemplate (line 2964) | struct itemplate
type itemplate (line 2972) | struct itemplate
type itemplate (line 2980) | struct itemplate
type itemplate (line 2986) | struct itemplate
type itemplate (line 2994) | struct itemplate
type itemplate (line 3002) | struct itemplate
type itemplate (line 3010) | struct itemplate
type itemplate (line 3018) | struct itemplate
type itemplate (line 3024) | struct itemplate
type itemplate (line 3032) | struct itemplate
type itemplate (line 3040) | struct itemplate
type itemplate (line 3046) | struct itemplate
type itemplate (line 3054) | struct itemplate
type itemplate (line 3062) | struct itemplate
type itemplate (line 3070) | struct itemplate
type itemplate (line 3076) | struct itemplate
type itemplate (line 3084) | struct itemplate
type itemplate (line 3100) | struct itemplate
type itemplate (line 3105) | struct itemplate
type itemplate (line 3110) | struct itemplate
type itemplate (line 3115) | struct itemplate
type itemplate (line 3120) | struct itemplate
type itemplate (line 3125) | struct itemplate
type itemplate (line 3130) | struct itemplate
type itemplate (line 3138) | struct itemplate
type itemplate (line 3151) | struct itemplate
type itemplate (line 3157) | struct itemplate
type itemplate (line 3163) | struct itemplate
type itemplate (line 3176) | struct itemplate
type itemplate (line 3181) | struct itemplate
type itemplate (line 3186) | struct itemplate
type itemplate (line 3191) | struct itemplate
type itemplate (line 3196) | struct itemplate
type itemplate (line 3201) | struct itemplate
type itemplate (line 3205) | struct itemplate
type itemplate (line 3209) | struct itemplate
type itemplate (line 3213) | struct itemplate
type itemplate (line 3217) | struct itemplate
type itemplate (line 3223) | struct itemplate
type itemplate (line 3229) | struct itemplate
type itemplate (line 3235) | struct itemplate
type itemplate (line 3248) | struct itemplate
type itemplate (line 3261) | struct itemplate
type itemplate (line 3266) | struct itemplate
type itemplate (line 3271) | struct itemplate
type itemplate (line 3276) | struct itemplate
type itemplate (line 3282) | struct itemplate
type itemplate (line 3288) | struct itemplate
type itemplate (line 3293) | struct itemplate
type itemplate (line 3298) | struct itemplate
type itemplate (line 3311) | struct itemplate
type itemplate (line 3316) | struct itemplate
type itemplate (line 3329) | struct itemplate
type itemplate (line 3358) | struct itemplate
type itemplate (line 3363) | struct itemplate
type itemplate (line 3368) | struct itemplate
type itemplate (line 3373) | struct itemplate
type itemplate (line 3378) | struct itemplate
type itemplate (line 3383) | struct itemplate
type itemplate (line 3396) | struct itemplate
type itemplate (line 3408) | struct itemplate
type itemplate (line 3421) | struct itemplate
type itemplate (line 3433) | struct itemplate
type itemplate (line 3439) | struct itemplate
type itemplate (line 3445) | struct itemplate
type itemplate (line 3450) | struct itemplate
type itemplate (line 3458) | struct itemplate
type itemplate (line 3463) | struct itemplate
type itemplate (line 3468) | struct itemplate
type itemplate (line 3473) | struct itemplate
type itemplate (line 3481) | struct itemplate
type itemplate (line 3487) | struct itemplate
type itemplate (line 3493) | struct itemplate
type itemplate (line 3499) | struct itemplate
type itemplate (line 3505) | struct itemplate
type itemplate (line 3510) | struct itemplate
type itemplate (line 3515) | struct itemplate
type itemplate (line 3520) | struct itemplate
type itemplate (line 3525) | struct itemplate
type itemplate (line 3530) | struct itemplate
type itemplate (line 3535) | struct itemplate
type itemplate (line 3540) | struct itemplate
type itemplate (line 3548) | struct itemplate
type itemplate (line 3577) | struct itemplate
type itemplate (line 3583) | struct itemplate
type itemplate (line 3589) | struct itemplate
type itemplate (line 3595) | struct itemplate
type itemplate (line 3601) | struct itemplate
type itemplate (line 3606) | struct itemplate
type itemplate (line 3611) | struct itemplate
type itemplate (line 3616) | struct itemplate
type itemplate (line 3621) | struct itemplate
type itemplate (line 3626) | struct itemplate
type itemplate (line 3631) | struct itemplate
type itemplate (line 3636) | struct itemplate
type itemplate (line 3658) | struct itemplate
type itemplate (line 3664) | struct itemplate
type itemplate (line 3670) | struct itemplate
type itemplate (line 3675) | struct itemplate
type itemplate (line 3680) | struct itemplate
type itemplate (line 3685) | struct itemplate
type itemplate (line 3701) | struct itemplate
type itemplate (line 3707) | struct itemplate
type itemplate (line 3713) | struct itemplate
type itemplate (line 3719) | struct itemplate
type itemplate (line 3725) | struct itemplate
type itemplate (line 3732) | struct itemplate
type itemplate (line 3739) | struct itemplate
type itemplate (line 3744) | struct itemplate
type itemplate (line 3749) | struct itemplate
type itemplate (line 3754) | struct itemplate
type itemplate (line 3759) | struct itemplate
type itemplate (line 3769) | struct itemplate
type itemplate (line 3777) | struct itemplate
type itemplate (line 3797) | struct itemplate
type itemplate (line 3802) | struct itemplate
type itemplate (line 3807) | struct itemplate
type itemplate (line 3836) | struct itemplate
type itemplate (line 3842) | struct itemplate
type itemplate (line 3848) | struct itemplate
type itemplate (line 3853) | struct itemplate
type itemplate (line 3861) | struct itemplate
type itemplate (line 3873) | struct itemplate
type itemplate (line 3879) | struct itemplate
FILE: src/Asm/Nasm/NASM/insnsd.c
type itemplate (line 6) | struct itemplate
type itemplate (line 1560) | struct itemplate
type itemplate (line 1566) | struct itemplate
type itemplate (line 1574) | struct itemplate
type itemplate (line 1580) | struct itemplate
type itemplate (line 1588) | struct itemplate
type itemplate (line 1593) | struct itemplate
type itemplate (line 1599) | struct itemplate
type itemplate (line 1605) | struct itemplate
type itemplate (line 1610) | struct itemplate
type itemplate (line 1616) | struct itemplate
type itemplate (line 1624) | struct itemplate
type itemplate (line 1630) | struct itemplate
type itemplate (line 1638) | struct itemplate
type itemplate (line 1643) | struct itemplate
type itemplate (line 1649) | struct itemplate
type itemplate (line 1655) | struct itemplate
type itemplate (line 2207) | struct itemplate
type itemplate (line 2213) | struct itemplate
type itemplate (line 2221) | struct itemplate
type itemplate (line 2227) | struct itemplate
type itemplate (line 2235) | struct itemplate
type itemplate (line 2240) | struct itemplate
type itemplate (line 2246) | struct itemplate
type itemplate (line 2252) | struct itemplate
type itemplate (line 2257) | struct itemplate
type itemplate (line 2263) | struct itemplate
type itemplate (line 2271) | struct itemplate
type itemplate (line 2277) | struct itemplate
type itemplate (line 2285) | struct itemplate
type itemplate (line 2290) | struct itemplate
type itemplate (line 2296) | struct itemplate
type itemplate (line 2302) | struct itemplate
type itemplate (line 2307) | struct itemplate
type itemplate (line 2313) | struct itemplate
type itemplate (line 2321) | struct itemplate
type itemplate (line 2327) | struct itemplate
type itemplate (line 2335) | struct itemplate
type itemplate (line 2340) | struct itemplate
type itemplate (line 2346) | struct itemplate
type itemplate (line 2350) | struct itemplate
type itemplate (line 2355) | struct itemplate
type itemplate (line 2361) | struct itemplate
type itemplate (line 2369) | struct itemplate
type itemplate (line 2375) | struct itemplate
type itemplate (line 2383) | struct itemplate
type itemplate (line 2388) | struct itemplate
type itemplate (line 2394) | struct itemplate
type itemplate (line 2398) | struct itemplate
type itemplate (line 2403) | struct itemplate
type itemplate (line 2409) | struct itemplate
type itemplate (line 2417) | struct itemplate
type itemplate (line 2423) | struct itemplate
type itemplate (line 2431) | struct itemplate
type itemplate (line 2436) | struct itemplate
type itemplate (line 2442) | struct itemplate
type itemplate (line 2446) | struct itemplate
type itemplate (line 2451) | struct itemplate
type itemplate (line 2457) | struct itemplate
type itemplate (line 2465) | struct itemplate
type itemplate (line 2471) | struct itemplate
type itemplate (line 2479) | struct itemplate
type itemplate (line 2484) | struct itemplate
type itemplate (line 2490) | struct itemplate
type itemplate (line 2494) | struct itemplate
type itemplate (line 2499) | struct itemplate
type itemplate (line 2505) | struct itemplate
type itemplate (line 2511) | struct itemplate
type itemplate (line 2517) | struct itemplate
type itemplate (line 2523) | struct itemplate
type itemplate (line 2529) | struct itemplate
type itemplate (line 2535) | struct itemplate
type itemplate (line 2541) | struct itemplate
type itemplate (line 2547) | struct itemplate
type itemplate (line 2553) | struct itemplate
type itemplate (line 2559) | struct itemplate
type itemplate (line 2565) | struct itemplate
type itemplate (line 2571) | struct itemplate
type itemplate (line 2577) | struct itemplate
type itemplate (line 2583) | struct itemplate
type itemplate (line 2589) | struct itemplate
type itemplate (line 2595) | struct itemplate
type itemplate (line 2601) | struct itemplate
type itemplate (line 2607) | struct itemplate
type itemplate (line 2613) | struct itemplate
type itemplate (line 2619) | struct itemplate
type itemplate (line 2625) | struct itemplate
type itemplate (line 2631) | struct itemplate
type itemplate (line 2637) | struct itemplate
type itemplate (line 2643) | struct itemplate
type itemplate (line 2649) | struct itemplate
type itemplate (line 2655) | struct itemplate
type itemplate (line 2661) | struct itemplate
type itemplate (line 2667) | struct itemplate
type itemplate (line 2673) | struct itemplate
type itemplate (line 2679) | struct itemplate
type itemplate (line 2685) | struct itemplate
type itemplate (line 2691) | struct itemplate
type itemplate (line 2698) | struct itemplate
type itemplate (line 2705) | struct itemplate
type itemplate (line 2711) | struct itemplate
type itemplate (line 2717) | struct itemplate
type itemplate (line 2721) | struct itemplate
type itemplate (line 2725) | struct itemplate
type itemplate (line 2953) | struct itemplate
type itemplate (line 2957) | struct itemplate
type itemplate (line 2964) | struct itemplate
type itemplate (line 2974) | struct itemplate
type itemplate (line 2979) | struct itemplate
type itemplate (line 2989) | struct itemplate
type itemplate (line 2994) | struct itemplate
type itemplate (line 3000) | struct itemplate
type itemplate (line 3005) | struct itemplate
type itemplate (line 3011) | struct itemplate
type itemplate (line 3016) | struct itemplate
type itemplate (line 3021) | struct itemplate
type itemplate (line 3026) | struct itemplate
type itemplate (line 3031) | struct itemplate
type itemplate (line 3036) | struct itemplate
type itemplate (line 3041) | struct itemplate
type itemplate (line 3046) | struct itemplate
type itemplate (line 3051) | struct itemplate
type itemplate (line 3056) | struct itemplate
type itemplate (line 3061) | struct itemplate
type itemplate (line 3066) | struct itemplate
type itemplate (line 3071) | struct itemplate
type itemplate (line 3076) | struct itemplate
type itemplate (line 3081) | struct itemplate
type itemplate (line 3086) | struct itemplate
type itemplate (line 3091) | struct itemplate
type itemplate (line 3111) | struct itemplate
type itemplate (line 3147) | struct itemplate
type itemplate (line 3151) | struct itemplate
type itemplate (line 3171) | struct itemplate
type itemplate (line 3178) | struct itemplate
type itemplate (line 3188) | struct itemplate
type itemplate (line 3196) | struct itemplate
type itemplate (line 3208) | struct itemplate
type itemplate (line 3214) | struct itemplate
type itemplate (line 3222) | struct itemplate
type itemplate (line 3228) | struct itemplate
type itemplate (line 3236) | struct itemplate
type itemplate (line 3243) | struct itemplate
type itemplate (line 3249) | struct itemplate
type itemplate (line 3256) | struct itemplate
type itemplate (line 3262) | struct itemplate
type itemplate (line 3272) | struct itemplate
type itemplate (line 3280) | struct itemplate
type itemplate (line 3288) | struct itemplate
type itemplate (line 3296) | struct itemplate
type itemplate (line 3304) | struct itemplate
type itemplate (line 3312) | struct itemplate
type itemplate (line 3320) | struct itemplate
type itemplate (line 3328) | struct itemplate
type itemplate (line 3334) | struct itemplate
type itemplate (line 3340) | struct itemplate
type itemplate (line 3349) | struct itemplate
type itemplate (line 3364) | struct itemplate
type itemplate (line 3371) | struct itemplate
type itemplate (line 3378) | struct itemplate
type itemplate (line 3383) | struct itemplate
type itemplate (line 3388) | struct itemplate
type itemplate (line 3393) | struct itemplate
type itemplate (line 3399) | struct itemplate
type itemplate (line 3404) | struct itemplate
type itemplate (line 3410) | struct itemplate
type itemplate (line 3415) | struct itemplate
type itemplate (line 3421) | struct itemplate
type itemplate (line 3426) | struct itemplate
type itemplate (line 3432) | struct itemplate
type itemplate (line 3437) | struct itemplate
type itemplate (line 3443) | struct itemplate
type itemplate (line 3448) | struct itemplate
type itemplate (line 3454) | struct itemplate
type itemplate (line 3459) | struct itemplate
type itemplate (line 3465) | struct itemplate
type itemplate (line 3470) | struct itemplate
type itemplate (line 3476) | struct itemplate
type itemplate (line 3481) | struct itemplate
type itemplate (line 3486) | struct itemplate
type itemplate (line 3491) | struct itemplate
type itemplate (line 3496) | struct itemplate
type itemplate (line 3501) | struct itemplate
type itemplate (line 3506) | struct itemplate
type itemplate (line 3511) | struct itemplate
type itemplate (line 3516) | struct itemplate
type itemplate (line 3522) | struct itemplate
type itemplate (line 3528) | struct itemplate
type itemplate (line 3534) | struct itemplate
type itemplate (line 3540) | struct itemplate
type itemplate (line 3546) | struct itemplate
type itemplate (line 3552) | struct itemplate
type itemplate (line 3558) | struct itemplate
type itemplate (line 3564) | struct itemplate
type itemplate (line 3575) | struct itemplate
type itemplate (line 3593) | struct itemplate
type itemplate (line 3599) | struct itemplate
type itemplate (line 3605) | struct itemplate
type itemplate (line 3611) | struct itemplate
type itemplate (line 3617) | struct itemplate
type itemplate (line 3623) | struct itemplate
type itemplate (line 3631) | struct itemplate
type itemplate (line 3636) | struct itemplate
type itemplate (line 3641) | struct itemplate
type itemplate (line 3646) | struct itemplate
type itemplate (line 3651) | struct itemplate
type itemplate (line 3656) | struct itemplate
type itemplate (line 3661) | struct itemplate
type itemplate (line 3666) | struct itemplate
type itemplate (line 3673) | struct itemplate
type itemplate (line 3684) | struct itemplate
type itemplate (line 3702) | struct itemplate
type itemplate (line 3713) | struct itemplate
type itemplate (line 3731) | struct itemplate
type itemplate (line 3737) | struct itemplate
type itemplate (line 3743) | struct itemplate
type itemplate (line 3748) | struct itemplate
type itemplate (line 3754) | struct itemplate
type itemplate (line 3782) | struct itemplate
type itemplate (line 3826) | struct itemplate
type itemplate (line 3847) | struct itemplate
type itemplate (line 3874) | struct itemplate
type itemplate (line 3898) | struct itemplate
type itemplate (line 3916) | struct itemplate
type itemplate (line 3941) | struct itemplate
type itemplate (line 3961) | struct itemplate
type itemplate (line 3971) | struct itemplate
type itemplate (line 3981) | struct itemplate
type itemplate (line 3988) | struct itemplate
type itemplate (line 3994) | struct itemplate
type itemplate (line 3999) | struct itemplate
type itemplate (line 4005) | struct itemplate
type itemplate (line 4010) | struct itemplate
type itemplate (line 4016) | struct itemplate
type itemplate (line 4026) | struct itemplate
type itemplate (line 4033) | struct itemplate
type itemplate (line 4042) | struct itemplate
type itemplate (line 4047) | struct itemplate
type itemplate (line 4052) | struct itemplate
type itemplate (line 4058) | struct itemplate
type itemplate (line 4063) | struct itemplate
type itemplate (line 4069) | struct itemplate
type itemplate (line 4073) | struct itemplate
type itemplate (line 4079) | struct itemplate
type itemplate (line 4141) | struct itemplate
type itemplate (line 4149) | struct itemplate
type itemplate (line 4154) | struct itemplate
type itemplate (line 4159) | struct itemplate
type itemplate (line 4171) | struct itemplate
type itemplate (line 4191) | struct itemplate
type itemplate (line 4196) | struct itemplate
type itemplate (line 4201) | struct itemplate
type itemplate (line 4206) | struct itemplate
type itemplate (line 4211) | struct itemplate
type itemplate (line 4216) | struct itemplate
type itemplate (line 4221) | struct itemplate
type itemplate (line 4227) | struct itemplate
type itemplate (line 4259) | struct itemplate
FILE: src/Asm/Nasm/NASM/nasm.h
type ofmt (line 58) | struct ofmt
type ofmt (line 121) | struct ofmt
type ListGen (line 126) | typedef struct {
type tokenval (line 191) | struct tokenval {
type tokenval (line 196) | struct tokenval
type loc_t (line 219) | typedef struct {
type expr (line 237) | typedef struct {
type eval_hints (line 247) | struct eval_hints {
type expr (line 277) | typedef expr *(*evalfunc) (scanner sc, void *scprivate,
type Preproc (line 297) | typedef struct {
type operand (line 471) | typedef struct { /* operand to an instruction */
type extop (line 486) | typedef struct extop { /* extended operand */
type insn (line 498) | typedef struct { /* an instruction itself */
type geninfo (line 513) | enum geninfo { GI_SWITCH }
type ofmt (line 521) | struct ofmt {
type dfmt (line 736) | struct dfmt {
FILE: src/Compat/Chez/bitpattern.c
function bitpattern (line 7) | unsigned bitpattern( i, f )
FILE: src/Compat/Chez/mtime.c
function mtime (line 11) | unsigned mtime( fn )
FILE: src/Compat/Petite/bitpattern.c
function bitpattern (line 7) | unsigned bitpattern( i, f )
FILE: src/Compat/Petite/mtime.c
function mtime (line 11) | unsigned mtime( fn )
FILE: src/Rts/DotNet/Call.cs
class Call (line 10) | public class Call {
method applySetup (line 27) | public static int applySetup(int k1, int k2) {
method call1 (line 56) | public static CodeAddress call1 (Procedure p, int argc)
method call (line 64) | public static CodeAddress call (CodeVector code, int jumpIndex)
method call0 (line 76) | public static CodeAddress call0 (Procedure p)
method call1 (line 91) | public static CodeAddress call1 (Procedure p)
method call2 (line 106) | public static CodeAddress call2 (Procedure p)
method call3 (line 121) | public static CodeAddress call3 (Procedure p)
method call (line 136) | public static CodeAddress call (Procedure p, int argc)
method callback (line 153) | public static SObject callback (Procedure p) {
method callback (line 167) | public static SObject callback (Procedure p, SObject arg0) {
method callback (line 182) | public static SObject callback (Procedure p, SObject arg0, SObject arg...
method callback (line 198) | public static SObject callback (Procedure p, SObject arg0, SObject arg...
method callback (line 215) | public static SObject callback (Procedure p, SObject arg0, SObject arg...
method trampoline (line 233) | public static void trampoline (Procedure p, int argc)
method contagion (line 256) | public static void contagion(SObject a, SObject b, SObject retry) {
method pcontagion (line 259) | public static void pcontagion(SObject a, SObject b, SObject retry) {
method econtagion (line 262) | public static void econtagion(SObject a, SObject b, SObject retry) {
method callExceptionHandler (line 266) | public static CodeAddress callExceptionHandler (SObject result, SObjec...
method callExceptionHandler (line 281) | public static CodeAddress callExceptionHandler (SObject[] values)
method callInterruptHandler (line 299) | public static CodeAddress callInterruptHandler(int excode)
method callMillicodeSupport3 (line 309) | public static void callMillicodeSupport3(int procIndex, SObject a,
method callMillicodeSupport2 (line 321) | public static void callMillicodeSupport2(int procIndex, SObject a,
method callMillicodeSupport1 (line 332) | public static void callMillicodeSupport1(int procIndex, SObject a) {
method getSupportProcedure (line 341) | public static Procedure getSupportProcedure(int index) {
method saveContext (line 365) | public static void saveContext(bool full) {
method exit (line 381) | public static void exit(int returnCode) {
class InitialContinuation (line 391) | public class InitialContinuation : CodeVector {
method InitialContinuation (line 395) | private InitialContinuation() : base (1) {}
method call (line 397) | public override CodeAddress call (int jump_index)
class RestoreContextCode (line 409) | public class RestoreContextCode : CodeVector {
method RestoreContextCode (line 414) | private RestoreContextCode() : base (CONTROL_POINT_LIMIT) {}
method call (line 416) | public override CodeAddress call (int jumpIndex)
class BounceException (line 438) | public class BounceException : Exception
method BounceException (line 442) | public BounceException (CodeAddress pc)
method prepareForBounce (line 447) | public virtual void prepareForBounce()
class CodeVectorCallException (line 455) | public class CodeVectorCallException : BounceException
method CodeVectorCallException (line 457) | public CodeVectorCallException (CodeVector rtn, int j)
class SchemeCallException (line 467) | public class SchemeCallException : BounceException
method SchemeCallException (line 471) | public SchemeCallException (Procedure p, int argc) :
method prepareForBounce (line 477) | public override void prepareForBounce() {
class SchemeExitException (line 485) | public class SchemeExitException : Exception {
method SchemeExitException (line 487) | public SchemeExitException(int returnCode) {
FILE: src/Rts/DotNet/ClassicOps.cs
class Ops (line 6) | public class Ops {
method expect1 (line 12) | public static void expect1(bool b, SObject arg, int blame) {
method expect2 (line 18) | public static void expect2(bool b1, SObject arg1,
method expect3 (line 29) | public static void expect3(bool b1, SObject arg1,
method rangeCheckBVL (line 43) | public static void rangeCheckBVL(SObject arg1, SObject arg2, int blame) {
method rangeCheckBVL (line 53) | public static void rangeCheckBVL(SObject arg1, SObject arg2, SObject a...
method rangeCheckVL (line 63) | public static void rangeCheckVL(SObject arg1, SObject arg2, int blame) {
method rangeCheckVL (line 73) | public static void rangeCheckVL(SObject arg1, SObject arg2, SObject ar...
method op1_creg (line 90) | public static SObject op1_creg(SObject unused) {
method op1_creg_set (line 94) | public static SObject op1_creg_set(SObject arg) {
method op1_break (line 99) | public static SObject op1_break(SObject arg) {
method op1_gc_counter (line 105) | public static SObject op1_gc_counter(SObject arg) {
method op1_not (line 110) | public static SObject op1_not(SObject arg) {
method op1_complexp (line 121) | public static SObject op1_complexp(SObject arg) {
method op1_realp (line 124) | public static SObject op1_realp(SObject arg) {
method op1_rationalp (line 127) | public static SObject op1_rationalp(SObject arg) {
method op1_integerp (line 130) | public static SObject op1_integerp(SObject arg) {
method op1_exactp (line 133) | public static SObject op1_exactp(SObject arg) {
method op1_inexactp (line 137) | public static SObject op1_inexactp(SObject arg) {
method op2_eqp (line 145) | public static SObject op2_eqp(SObject arg1, SObject arg2) {
method op1_fixnump (line 149) | public static SObject op1_fixnump(SObject arg) {
method op1_pairp (line 152) | public static SObject op1_pairp(SObject arg) {
method op1_flonump (line 155) | public static SObject op1_flonump(SObject arg) {
method op1_compnump (line 158) | public static SObject op1_compnump(SObject arg) {
method op1_symbolp (line 161) | public static SObject op1_symbolp(SObject arg) {
method op1_vectorp (line 164) | public static SObject op1_vectorp(SObject arg) {
method op1_vector_likep (line 167) | public static SObject op1_vector_likep(SObject arg) {
method op1_portp (line 170) | public static SObject op1_portp(SObject arg) {
method op1_structurep (line 173) | public static SObject op1_structurep(SObject arg) {
method op1_bytevector_likep (line 176) | public static SObject op1_bytevector_likep(SObject arg) {
method op1_stringp (line 179) | public static SObject op1_stringp(SObject arg) {
method op1_bytevectorp (line 182) | public static SObject op1_bytevectorp(SObject arg) {
method op1_charp (line 185) | public static SObject op1_charp(SObject arg) {
method op1_procedurep (line 188) | public static SObject op1_procedurep(SObject arg) {
method op1_nullp (line 194) | public static SObject op1_nullp(SObject arg) {
method op1_eof_objectp (line 197) | public static SObject op1_eof_objectp(SObject arg) {
method op1_unspecifiedp (line 200) | public static SObject op1_unspecifiedp(SObject arg) {
method op1_undefinedp (line 203) | public static SObject op1_undefinedp(SObject arg) {
method op1_unspecified (line 215) | public static SObject op1_unspecified(SObject unused) {
method op1_undefined (line 218) | public static SObject op1_undefined(SObject unused) {
method op1_eof_object (line 221) | public static SObject op1_eof_object(SObject unused) {
method op2_char_lt (line 228) | public static SObject op2_char_lt(SObject arg1, SObject arg2) {
method op2_char_le (line 233) | public static SObject op2_char_le(SObject arg1, SObject arg2) {
method op2_char_gt (line 238) | public static SObject op2_char_gt(SObject arg1, SObject arg2) {
method op2_char_ge (line 243) | public static SObject op2_char_ge(SObject arg1, SObject arg2) {
method op2_char_equals (line 248) | public static SObject op2_char_equals(SObject arg1, SObject arg2) {
method op1_char2integer (line 253) | public static SObject op1_char2integer(SObject arg) {
method op1_integer2char (line 258) | public static SObject op1_integer2char(SObject arg) {
method op1_make_cell (line 266) | public static SObject op1_make_cell(SObject arg) {
method op1_cell_ref (line 269) | public static SObject op1_cell_ref(SObject arg) {
method op2_cell_set (line 272) | public static SObject op2_cell_set(SObject arg1, SObject arg2) {
method op2_cons (line 281) | public static SObject op2_cons(SObject arg1, SObject arg2) {
method op1_car (line 285) | public static SObject op1_car(SObject arg) {
method op1_car_pair (line 289) | public static SObject op1_car_pair(SObject arg) {
method op1_cdr (line 293) | public static SObject op1_cdr(SObject arg) {
method op1_cdr_pair (line 297) | public static SObject op1_cdr_pair(SObject arg) {
method op2_set_car (line 301) | public static SObject op2_set_car(SObject arg1, SObject arg2) {
method op2_set_car_pair (line 306) | public static SObject op2_set_car_pair(SObject arg1, SObject arg2) {
method op2_set_cdr (line 311) | public static SObject op2_set_cdr(SObject arg1, SObject arg2) {
method op2_set_cdr_pair (line 316) | public static SObject op2_set_cdr_pair(SObject arg1, SObject arg2) {
method op1_typetag (line 324) | public static SObject op1_typetag(SObject arg) {
method op2_typetag_set (line 335) | public static SObject op2_typetag_set(SObject arg1, SObject arg2) {
method op1_vector_like_length (line 352) | public static SObject op1_vector_like_length(SObject arg) {
method op2_vector_like_ref (line 356) | public static SObject op2_vector_like_ref(SObject arg1, SObject arg2) {
method op3_vector_like_set (line 364) | public static SObject op3_vector_like_set(SObject arg1, SObject arg2,
method op2_make_vector (line 377) | public static SObject op2_make_vector(SObject arg1, SObject arg2) {
method op1_vector_length (line 382) | public static SObject op1_vector_length(SObject arg) {
method op1_vector_length_vec (line 386) | public static SObject op1_vector_length_vec(SObject arg) {
method op2_vector_ref (line 390) | public static SObject op2_vector_ref(SObject arg1, SObject arg2) {
method op2_vector_ref_trusted (line 395) | public static SObject op2_vector_ref_trusted(SObject arg1, SObject arg...
method op3_vector_set (line 399) | public static SObject op3_vector_set(SObject arg1, SObject arg2, SObje...
method op3_vector_set_trusted (line 405) | public static SObject op3_vector_set_trusted(SObject arg1, SObject arg...
method op2_sys_partial_list__vector (line 410) | public static SObject op2_sys_partial_list__vector(SObject arg1, SObje...
method op1_procedure_length (line 424) | public static SObject op1_procedure_length(SObject arg) {
method op1_make_procedure (line 431) | public static SObject op1_make_procedure(SObject arg) {
method op2_procedure_ref (line 444) | public static SObject op2_procedure_ref(SObject arg1, SObject arg2) {
method op3_procedure_set (line 465) | public static SObject op3_procedure_set(SObject arg1, SObject arg2, SO...
method op1_make_string (line 499) | public static SObject op1_make_string(SObject arg) {
method op2_make_string (line 503) | public static SObject op2_make_string(SObject arg1, SObject arg2) {
method op1_string_length (line 508) | public static SObject op1_string_length(SObject arg) {
method op1_string_length_str (line 512) | public static SObject op1_string_length_str(SObject arg) {
method op2_string_ref (line 516) | public static SObject op2_string_ref(SObject arg1, SObject arg2) {
method op2_string_ref_trusted (line 521) | public static SObject op2_string_ref_trusted(SObject arg1, SObject arg...
method op3_string_set (line 525) | public static SObject op3_string_set(SObject arg1, SObject arg2, SObje...
method op3_string_set_trusted (line 533) | public static SObject op3_string_set_trusted(SObject arg1, SObject arg...
method op1_make_bytevector (line 542) | public static SObject op1_make_bytevector(SObject arg) {
method op1_bytevector_length (line 546) | public static SObject op1_bytevector_length(SObject arg) {
method op2_bytevector_ref (line 550) | public static SObject op2_bytevector_ref(SObject arg1, SObject arg2) {
method op3_bytevector_set (line 555) | public static SObject op3_bytevector_set(SObject arg1, SObject arg2,
method op2_bytevector_equal (line 563) | public static SObject op2_bytevector_equal(SObject arg1, SObject arg2) {
method op2_bytevector_fill (line 575) | public static SObject op2_bytevector_fill(SObject arg1, SObject arg2) {
method op1_bytevector_like_length (line 584) | public static SObject op1_bytevector_like_length(SObject arg) {
method op2_bytevector_like_ref (line 588) | public static SObject op2_bytevector_like_ref(SObject arg1, SObject ar...
method op3_bytevector_like_set (line 593) | public static SObject op3_bytevector_like_set(SObject arg1, SObject ar...
method op2_sys_bvlcmp (line 600) | public static SObject op2_sys_bvlcmp(SObject arg1, SObject arg2) {
method op1_fxzerop (line 619) | public static SObject op1_fxzerop(SObject arg) {
method op1_fxpositivep (line 623) | public static SObject op1_fxpositivep(SObject arg) {
method op1_fxnegativep (line 628) | public static SObject op1_fxnegativep(SObject arg) {
method op1_fxnegative (line 633) | public static SObject op1_fxnegative(SObject arg) {
method op2_fxplus (line 641) | public static SObject op2_fxplus(SObject arg1, SObject arg2) {
method op2_fxminus (line 651) | public static SObject op2_fxminus(SObject arg1, SObject arg2) {
method op2_fxmul (line 661) | public static SObject op2_fxmul(SObject arg1, SObject arg2) {
method op2_fxless (line 671) | public static SObject op2_fxless(SObject arg1, SObject arg2) {
method op2_fxgreater (line 677) | public static SObject op2_fxgreater(SObject arg1, SObject arg2) {
method op2_fxless_equal (line 683) | public static SObject op2_fxless_equal(SObject arg1, SObject arg2) {
method op2_fxgreater_equal (line 689) | public static SObject op2_fxgreater_equal(SObject arg1, SObject arg2) {
method op2_fxequal (line 695) | public static SObject op2_fxequal(SObject arg1, SObject arg2) {
method op1_most_positive_fixnum (line 702) | public static SObject op1_most_positive_fixnum(SObject unused) {
method op1_most_negative_fixnum (line 705) | public static SObject op1_most_negative_fixnum(SObject unused) {
method op1_lognot (line 715) | public static SObject op1_lognot(SObject arg) {
method op2_logand (line 720) | public static SObject op2_logand(SObject arg1, SObject arg2) {
method op2_logior (line 726) | public static SObject op2_logior(SObject arg1, SObject arg2) {
method op2_logxor (line 732) | public static SObject op2_logxor(SObject arg1, SObject arg2) {
method op2_lsh (line 738) | public static SObject op2_lsh(SObject arg1, SObject arg2) {
method op2_rsh (line 744) | public static SObject op2_rsh(SObject arg1, SObject arg2) {
method op2_rsha (line 750) | public static SObject op2_rsha(SObject arg1, SObject arg2) {
method op2_rshl (line 756) | public static SObject op2_rshl(SObject arg1, SObject arg2) {
method op1_real_part (line 768) | public static SObject op1_real_part(SObject arg) {
method op1_imag_part (line 792) | public static SObject op1_imag_part(SObject arg) {
method op2_plus_idx_idx (line 816) | public static SObject op2_plus_idx_idx(SObject arg1, SObject arg2) {
method op2_minus_idx_idx (line 821) | public static SObject op2_minus_idx_idx(SObject arg1, SObject arg2) {
method op2_equal_fix_fix (line 826) | public static SObject op2_equal_fix_fix(SObject arg1, SObject arg2) {
method op2_less_fix_fix (line 830) | public static SObject op2_less_fix_fix(SObject arg1, SObject arg2) {
method op2_lessequal_fix_fix (line 834) | public static SObject op2_lessequal_fix_fix(SObject arg1, SObject arg2) {
method op2_greater_fix_fix (line 838) | public static SObject op2_greater_fix_fix(SObject arg1, SObject arg2) {
method op2_greaterequal_fix_fix (line 842) | public static SObject op2_greaterequal_fix_fix(SObject arg1, SObject a...
FILE: src/Rts/DotNet/ClassicOpsSpecial.cs
class OpsSpecial (line 6) | public class OpsSpecial {
method op1_enable_interrupts (line 11) | public static void op1_enable_interrupts(SObject arg) {
method op1_disable_interrupts (line 26) | public static void op1_disable_interrupts(SObject arg) {
method op1_syscall (line 43) | public static void op1_syscall(SObject arg) {
method op1_zerop (line 55) | public static void op1_zerop(SObject arg) {
method op2_eqvp (line 86) | public static void op2_eqvp(SObject arg1, SObject arg2) {
method op2_numeric_equals (line 140) | public static void op2_numeric_equals(SObject arg1, SObject arg2) {
method op2_less_than (line 182) | public static void op2_less_than(SObject arg1, SObject arg2) {
method op2_greater_than (line 219) | public static void op2_greater_than(SObject arg1, SObject arg2) {
method op2_less_or_equal (line 257) | public static void op2_less_or_equal(SObject arg1, SObject arg2) {
method op2_greater_or_equal (line 295) | public static void op2_greater_or_equal(SObject arg1, SObject arg2) {
method op2_plus (line 336) | public static void op2_plus(SObject arg1, SObject arg2) {
method op2_minus (line 379) | public static void op2_minus(SObject arg1, SObject arg2) {
method op2_multiply (line 424) | public static void op2_multiply(SObject arg1, SObject arg2) {
method op2_divide (line 489) | public static void op2_divide(SObject arg1, SObject arg2) {
method op2_quotient (line 546) | public static void op2_quotient(SObject arg1, SObject arg2) {
method op2_remainder (line 580) | public static void op2_remainder(SObject arg1, SObject arg2) {
method op1_truncate (line 613) | public static void op1_truncate(SObject arg) {
method op1_round (line 641) | public static void op1_round(SObject arg) {
method op1_negative (line 663) | public static void op1_negative(SObject arg) {
method op1_exact2inexact (line 696) | public static void op1_exact2inexact(SObject arg) {
method op1_inexact2exact (line 715) | public static void op1_inexact2exact(SObject arg) {
FILE: src/Rts/DotNet/CodeAddress.cs
class CodeAddress (line 7) | public sealed class CodeAddress
method CodeAddress (line 12) | public CodeAddress (CodeVector code)
method CodeAddress (line 18) | public CodeAddress (CodeVector code, int label)
method CodeAddress (line 24) | public CodeAddress (Procedure p)
FILE: src/Rts/DotNet/ContinuationISH.cs
class Cont (line 28) | public sealed class Cont {
method Initialize (line 71) | public static void Initialize ()
method reset (line 92) | public static void reset()
method clear (line 104) | public static void clear()
method save (line 115) | public static void save (int lastslot)
method save0 (line 126) | public static void save0 ()
method save_small (line 138) | public static void save_small (int lastslot)
method pop (line 151) | public static void pop()
method copyOutStack (line 163) | public static SObject copyOutStack()
method fillCache (line 177) | public static void fillCache()
method getCC (line 222) | public static SObject getCC()
method setCC (line 230) | public static void setCC (SObject k)
class ContinuationFrame (line 237) | public class ContinuationFrame
method ContinuationFrame (line 267) | public ContinuationFrame()
method capacity (line 275) | private int capacity()
method toVector (line 284) | public SObject toVector (SObject parent)
method fillFromVector (line 366) | public void fillFromVector (SVL hframe)
method getSlot (line 377) | public SObject getSlot (int slot)
method setSlot (line 393) | public void setSlot (int slot, SObject value)
method saveRegisters (line 415) | public void saveRegisters (Procedure restore, bool full)
method prepare (line 455) | public void prepare (int lastslot)
method prepare0 (line 481) | public void prepare0 ()
method prepare_small (line 490) | public void prepare_small (int lastslot)
method clear (line 499) | public void clear()
method checkPop (line 510) | public void checkPop (int lastslot, Procedure reg0)
method SafePop (line 521) | public void SafePop (int lastslot)
class StackCacheFrame (line 543) | public sealed class StackCacheFrame : ContinuationFrame
method StackCacheFrame (line 548) | public StackCacheFrame()
FILE: src/Rts/DotNet/DynLoad.cs
class DynLoad (line 11) | public class DynLoad {
method Main (line 12) | public static void Main(string[] args) {
FILE: src/Rts/DotNet/Exn.cs
class Exn (line 9) | public class Exn {
method registerNamespace (line 15) | public static void registerNamespace (string ns, string source)
method internalError (line 24) | public static void internalError (string message)
method fault (line 35) | public static CodeAddress fault (int excode)
method fault (line 40) | public static CodeAddress fault (int blame, string m, SObject arg)
method fault (line 46) | public static CodeAddress fault (int blame, string m, SObject arg1, SO...
method fault (line 53) | public static CodeAddress fault (int blame, string m,
method fault (line 66) | public static CodeAddress fault (int excode, string message)
method faultTimer (line 80) | public static CodeAddress faultTimer (int j)
method faultGlobal (line 98) | public static CodeAddress faultGlobal (int global)
method faultArgCount (line 104) | public static CodeAddress faultArgCount (int expectedc)
method faultVarArgCount (line 111) | public static CodeAddress faultVarArgCount (int expectedc)
method faultInvokeNonProc (line 118) | public static CodeAddress faultInvokeNonProc (int argc)
method faultApplyNonProc (line 123) | public static CodeAddress faultApplyNonProc (int k1, int k2)
method Exn (line 132) | static Exn() {
method checkSignals (line 147) | public static void checkSignals()
method myHandler (line 156) | private static void myHandler(object sender,
method error (line 178) | public static CodeAddress error (string msg)
method error (line 186) | public static CodeAddress error (string msg, SObject value)
method dumpSpecialRegisters (line 200) | public static void dumpSpecialRegisters (bool includeReg0)
method dumpGeneralRegisters (line 211) | public static void dumpGeneralRegisters()
method dumpEnvironment (line 218) | public static void dumpEnvironment()
method dumpContinuation (line 232) | public static void dumpContinuation()
method dumpFrame (line 247) | public static void dumpFrame (SObject[] frame, int i)
method dumpNativeStack (line 268) | public static void dumpNativeStack (Exception e)
method dumpTotalTime (line 285) | public static void dumpTotalTime()
method miniCoreDump (line 292) | public static void miniCoreDump (Timer timer)
method coredump (line 298) | public static void coredump()
method fullCoreDump (line 304) | public static void fullCoreDump()
method fullCoreDump (line 309) | public static void fullCoreDump (Exception e)
class Timer (line 327) | public class Timer {
method Timer (line 330) | static Timer()
method Timer (line 336) | public Timer()
method reset (line 344) | public void reset()
method getElapsedTime (line 350) | public long getElapsedTime()
FILE: src/Rts/DotNet/FFI.cs
class FFI_message_filter (line 20) | public class FFI_message_filter : IMessageFilter
method FFI_message_filter (line 24) | public FFI_message_filter (Procedure _scheme_filter)
method PreFilterMessage (line 29) | public bool PreFilterMessage (ref Message m)
class FFI (line 37) | public class FFI
method ffi_syscall (line 46) | public static void ffi_syscall()
method ffi_syscall_main (line 59) | private static void ffi_syscall_main(int code)
method wrapF (line 690) | private static SObject wrapF(object o)
method unwrapF (line 701) | private static object unwrapF(SObject s)
method datum2foreign (line 718) | private static SObject datum2foreign(int conversion, SObject obj)
method foreign2datum (line 913) | private static SObject foreign2datum(int conversion, SObject obj)
FILE: src/Rts/DotNet/Factory.cs
class Tags (line 14) | public sealed class Tags {
class Factory (line 33) | public sealed class Factory {
method makeBoolean (line 63) | public static SImmediate makeBoolean(bool b) {
method makeFixnum (line 70) | public static SFixnum makeFixnum (sbyte num) {
method makeFixnum (line 73) | public static SFixnum makeFixnum (byte num) {
method makeFixnum (line 76) | public static SFixnum makeFixnum (short num) {
method makeFixnum (line 79) | public static SFixnum makeFixnum (ushort num) {
method makeFixnum (line 83) | public static SFixnum makeFixnum(int num) {
method makeNumber (line 86) | public static SObject makeNumber(int num) {
method makeNumber (line 97) | public static SObject makeNumber (uint num) {
method makeNumber (line 102) | public static SObject makeNumber (long num) {
method makeNumber (line 118) | public static SObject makeNumber (ulong num) {
method makeBignum (line 124) | public static SByteVL makeBignum(int num) {
method makeBignum (line 134) | public static SByteVL makeBignum(ulong value, bool positive) {
method makeBignum (line 137) | public static SByteVL makeBignum(short[] data, bool positive) {
method makeRatnum (line 140) | public static SVL makeRatnum(SObject num, SObject denom) {
method makeRectnum (line 144) | public static SVL makeRectnum(SObject real, SObject imag) {
method makeFlonum (line 147) | public static SByteVL makeFlonum(double num) {
method makeFlonum (line 155) | public static SByteVL makeFlonum(long num) {
method makeCompnum (line 164) | public static SByteVL makeCompnum(double real, double imag) {
method makeCompnum (line 176) | public static SByteVL makeCompnum(long real, long imag) {
method makeChar (line 193) | public static SChar makeChar(int val) {
method makePair (line 201) | public static SPair makePair(SObject first, SObject rest) {
method makePairReversed (line 204) | public static SPair makePairReversed(SObject rest, SObject first) {
method makeVector (line 207) | public static SVL makeVector(SObject[] objs) {
method makeVector (line 210) | public static SVL makeVector(int size, SObject fill) {
method internSymbol (line 229) | public static SVL internSymbol(string str) {
method makeSymbolUninterned (line 242) | public static SVL makeSymbolUninterned(string str) {
method stringHash (line 250) | private static int stringHash(string str) {
method stopSymbolInterning (line 269) | public static SObject stopSymbolInterning() {
method makeUString (line 302) | public static SByteVL makeUString(string s) {
method makeUString (line 309) | public static SByteVL makeUString(int length, int fill) {
method makeUString (line 317) | public static SByteVL makeUString(byte[] bytes) {
method makeByteVector (line 327) | public static SByteVL makeByteVector(int size, byte fill) {
method makeByteVector (line 331) | public static SByteVL makeByteVector(byte[] bytes) {
method makeAsciiByteVector (line 334) | public static SByteVL makeAsciiByteVector(string s) {
method copyList (line 345) | public static SObject copyList(SObject list) {
method arrayToList (line 365) | public static SObject arrayToList(SObject[] array, int start) {
method makeForeignBox (line 373) | public static SObject makeForeignBox (object x) {
method wrap (line 381) | public static SObject wrap(int n) {
method wrap (line 384) | public static SObject wrap(short n) {
method wrap (line 387) | public static SObject wrap(long n) {
method wrap (line 390) | public static SObject wrap(uint n) {
method wrap (line 393) | public static SObject wrap(ushort n) {
method wrap (line 396) | public static SObject wrap(ulong n) {
method wrap (line 399) | public static SObject wrap(string s) {
method wrap (line 402) | public static SObject wrap(double d) {
method wrap (line 405) | public static SObject wrap(bool b) {
method wrap (line 408) | public static SObject wrap(SObject[] items) {
method wrapAsList (line 411) | public static SObject wrapAsList(SObject[] items) {
class DelegateCodeVector (line 416) | public class DelegateCodeVector : CodeVector {
method DelegateCodeVector (line 418) | public DelegateCodeVector( int controlPointCount,
method call (line 423) | public override CodeAddress call(int label) {
method makeCodeVector (line 429) | public static CodeVector makeCodeVector( int controlPointCount,
FILE: src/Rts/DotNet/Instructions.cs
class Instructions (line 6) | public sealed class Instructions
method nop (line 14) | public static void nop()
method global (line 23) | public static void global (int index, string name)
method setglbl (line 57) | public static void setglbl (int index)
method constant (line 64) | public static void constant (int constIndex)
method constant1 (line 70) | public static void constant1 () { Reg.Result = Reg.ProcRegister0.const...
method constant2 (line 71) | public static void constant2 () { Reg.Result = Reg.ProcRegister0.const...
method constant3 (line 72) | public static void constant3 () { Reg.Result = Reg.ProcRegister0.const...
method constant4 (line 73) | public static void constant4 () { Reg.Result = Reg.ProcRegister0.const...
method constant5 (line 74) | public static void constant5 () { Reg.Result = Reg.ProcRegister0.const...
method constant6 (line 75) | public static void constant6 () { Reg.Result = Reg.ProcRegister0.const...
method constant7 (line 76) | public static void constant7 () { Reg.Result = Reg.ProcRegister0.const...
method constant8 (line 77) | public static void constant8 () { Reg.Result = Reg.ProcRegister0.const...
method imm_constant (line 82) | public static void imm_constant (SObject immediate)
method imm_const_setreg (line 90) | public static void imm_const_setreg (SObject immediate, int register)
method reg (line 98) | public static void reg (int k)
method reg0 (line 104) | public static void reg0 () { Reg.Result = Reg.Register0; }
method reg1 (line 105) | public static void reg1 () { Reg.Result = Reg.Register1; }
method reg2 (line 106) | public static void reg2 () { Reg.Result = Reg.Register2; }
method reg3 (line 107) | public static void reg3 () { Reg.Result = Reg.Register3; }
method reg4 (line 108) | public static void reg4 () { Reg.Result = Reg.Register4; }
method reg5 (line 109) | public static void reg5 () { Reg.Result = Reg.Register5; }
method reg6 (line 110) | public static void reg6 () { Reg.Result = Reg.Register6; }
method reg7 (line 111) | public static void reg7 () { Reg.Result = Reg.Register7; }
method reg8 (line 112) | public static void reg8 () { Reg.Result = Reg.Register8; }
method reg9 (line 113) | public static void reg9 () { Reg.Result = Reg.Register9; }
method reg10 (line 114) | public static void reg10 () { Reg.Result = Reg.Register10; }
method reg11 (line 115) | public static void reg11 () { Reg.Result = Reg.Register11; }
method reg12 (line 116) | public static void reg12 () { Reg.Result = Reg.Register12; }
method reg13 (line 117) | public static void reg13 () { Reg.Result = Reg.Register13; }
method reg14 (line 118) | public static void reg14 () { Reg.Result = Reg.Register14; }
method reg15 (line 119) | public static void reg15 () { Reg.Result = Reg.Register15; }
method reg16 (line 120) | public static void reg16 () { Reg.Result = Reg.Register16; }
method reg17 (line 121) | public static void reg17 () { Reg.Result = Reg.Register17; }
method reg18 (line 122) | public static void reg18 () { Reg.Result = Reg.Register18; }
method reg19 (line 123) | public static void reg19 () { Reg.Result = Reg.Register19; }
method reg20 (line 124) | public static void reg20 () { Reg.Result = Reg.Register20; }
method reg21 (line 125) | public static void reg21 () { Reg.Result = Reg.Register21; }
method reg22 (line 126) | public static void reg22 () { Reg.Result = Reg.Register22; }
method reg23 (line 127) | public static void reg23 () { Reg.Result = Reg.Register23; }
method reg24 (line 128) | public static void reg24 () { Reg.Result = Reg.Register24; }
method reg25 (line 129) | public static void reg25 () { Reg.Result = Reg.Register25; }
method reg26 (line 130) | public static void reg26 () { Reg.Result = Reg.Register26; }
method reg27 (line 131) | public static void reg27 () { Reg.Result = Reg.Register27; }
method reg28 (line 132) | public static void reg28 () { Reg.Result = Reg.Register28; }
method reg29 (line 133) | public static void reg29 () { Reg.Result = Reg.Register29; }
method reg30 (line 134) | public static void reg30 () { Reg.Result = Reg.Register30; }
method reg31 (line 135) | public static void reg31 () { Reg.Result = Reg.Register31; }
method setreg (line 140) | public static void setreg (int k)
method setreg0 (line 145) | public static void setreg0 () { Reg.Register0 = Reg.Result; }
method setreg1 (line 146) | public static void setreg1 () { Reg.Register1 = Reg.Result; }
method setreg2 (line 147) | public static void setreg2 () { Reg.Register2 = Reg.Result; }
method setreg3 (line 148) | public static void setreg3 () { Reg.Register3 = Reg.Result; }
method setreg4 (line 149) | public static void setreg4 () { Reg.Register4 = Reg.Result; }
method setreg5 (line 150) | public static void setreg5 () { Reg.Register5 = Reg.Result; }
method setreg6 (line 151) | public static void setreg6 () { Reg.Register6 = Reg.Result; }
method setreg7 (line 152) | public static void setreg7 () { Reg.Register7 = Reg.Result; }
method setreg8 (line 153) | public static void setreg8 () { Reg.Register8 = Reg.Result; }
method setreg9 (line 154) | public static void setreg9 () { Reg.Register9 = Reg.Result; }
method setreg10 (line 155) | public static void setreg10 () { Reg.Register10 = Reg.Result; }
method setreg11 (line 156) | public static void setreg11 () { Reg.Register11 = Reg.Result; }
method setreg12 (line 157) | public static void setreg12 () { Reg.Register12 = Reg.Result; }
method setreg13 (line 158) | public static void setreg13 () { Reg.Register13 = Reg.Result; }
method setreg14 (line 159) | public static void setreg14 () { Reg.Register14 = Reg.Result; }
method setreg15 (line 160) | public static void setreg15 () { Reg.Register15 = Reg.Result; }
method setreg16 (line 161) | public static void setreg16 () { Reg.Register16 = Reg.Result; }
method setreg17 (line 162) | public static void setreg17 () { Reg.Register17 = Reg.Result; }
method setreg18 (line 163) | public static void setreg18 () { Reg.Register18 = Reg.Result; }
method setreg19 (line 164) | public static void setreg19 () { Reg.Register19 = Reg.Result; }
method setreg20 (line 165) | public static void setreg20 () { Reg.Register20 = Reg.Result; }
method setreg21 (line 166) | public static void setreg21 () { Reg.Register21 = Reg.Result; }
method setreg22 (line 167) | public static void setreg22 () { Reg.Register22 = Reg.Result; }
method setreg23 (line 168) | public static void setreg23 () { Reg.Register23 = Reg.Result; }
method setreg24 (line 169) | public static void setreg24 () { Reg.Register24 = Reg.Result; }
method setreg25 (line 170) | public static void setreg25 () { Reg.Register25 = Reg.Result; }
method setreg26 (line 171) | public static void setreg26 () { Reg.Register26 = Reg.Result; }
method setreg27 (line 172) | public static void setreg27 () { Reg.Register27 = Reg.Result; }
method setreg28 (line 173) | public static void setreg28 () { Reg.Register28 = Reg.Result; }
method setreg29 (line 174) | public static void setreg29 () { Reg.Register29 = Reg.Result; }
method setreg30 (line 175) | public static void setreg30 () { Reg.Register30 = Reg.Result; }
method setreg31 (line 176) | public static void setreg31 () { Reg.Register31 = Reg.Result; }
method movereg (line 181) | public static void movereg (int src, int dst)
method movereg_0_1 (line 186) | public static void movereg_0_1 () { Reg.Register1 = Reg.Register0; }
method movereg_1_2 (line 187) | public static void movereg_1_2 () { Reg.Register2 = Reg.Register1; }
method movereg_1_3 (line 188) | public static void movereg_1_3 () { Reg.Register3 = Reg.Register1; }
method movereg_1_4 (line 189) | public static void movereg_1_4 () { Reg.Register4 = Reg.Register1; }
method movereg_1_5 (line 190) | public static void movereg_1_5 () { Reg.Register5 = Reg.Register1; }
method movereg_1_6 (line 191) | public static void movereg_1_6 () { Reg.Register6 = Reg.Register1; }
method movereg_1_7 (line 192) | public static void movereg_1_7 () { Reg.Register7 = Reg.Register1; }
method movereg_1_8 (line 193) | public static void movereg_1_8 () { Reg.Register8 = Reg.Register1; }
method movereg_1_9 (line 194) | public static void movereg_1_9 () { Reg.Register9 = Reg.Register1; }
method movereg_1_10 (line 195) | public static void movereg_1_10 () { Reg.Register10 = Reg.Register1; }
method movereg_1_11 (line 196) | public static void movereg_1_11 () { Reg.Register11 = Reg.Register1; }
method movereg_1_12 (line 197) | public static void movereg_1_12 () { Reg.Register12 = Reg.Register1; }
method movereg_1_13 (line 198) | public static void movereg_1_13 () { Reg.Register13 = Reg.Register1; }
method movereg_1_14 (line 199) | public static void movereg_1_14 () { Reg.Register14 = Reg.Register1; }
method movereg_1_15 (line 200) | public static void movereg_1_15 () { Reg.Register15 = Reg.Register1; }
method movereg_1_16 (line 201) | public static void movereg_1_16 () { Reg.Register16 = Reg.Register1; }
method movereg_1_17 (line 202) | public static void movereg_1_17 () { Reg.Register17 = Reg.Register1; }
method movereg_1_18 (line 203) | public static void movereg_1_18 () { Reg.Register18 = Reg.Register1; }
method movereg_1_19 (line 204) | public static void movereg_1_19 () { Reg.Register19 = Reg.Register1; }
method movereg_1_20 (line 205) | public static void movereg_1_20 () { Reg.Register20 = Reg.Register1; }
method movereg_1_21 (line 206) | public static void movereg_1_21 () { Reg.Register21 = Reg.Register1; }
method movereg_1_22 (line 207) | public static void movereg_1_22 () { Reg.Register22 = Reg.Register1; }
method movereg_1_23 (line 208) | public static void movereg_1_23 () { Reg.Register23 = Reg.Register1; }
method movereg_1_24 (line 209) | public static void movereg_1_24 () { Reg.Register24 = Reg.Register1; }
method movereg_1_25 (line 210) | public static void movereg_1_25 () { Reg.Register25 = Reg.Register1; }
method movereg_1_26 (line 211) | public static void movereg_1_26 () { Reg.Register26 = Reg.Register1; }
method movereg_1_27 (line 212) | public static void movereg_1_27 () { Reg.Register27 = Reg.Register1; }
method movereg_1_28 (line 213) | public static void movereg_1_28 () { Reg.Register28 = Reg.Register1; }
method movereg_1_29 (line 214) | public static void movereg_1_29 () { Reg.Register29 = Reg.Register1; }
method movereg_1_30 (line 215) | public static void movereg_1_30 () { Reg.Register30 = Reg.Register1; }
method movereg_1_31 (line 216) | public static void movereg_1_31 () { Reg.Register31 = Reg.Register1; }
method movereg_2_1 (line 217) | public static void movereg_2_1 () { Reg.Register1 = Reg.Register2; }
method movereg_2_3 (line 218) | public static void movereg_2_3 () { Reg.Register3 = Reg.Register2; }
method movereg_2_4 (line 219) | public static void movereg_2_4 () { Reg.Register4 = Reg.Register2; }
method movereg_2_5 (line 220) | public static void movereg_2_5 () { Reg.Register5 = Reg.Register2; }
method movereg_2_6 (line 221) | public static void movereg_2_6 () { Reg.Register6 = Reg.Register2; }
method movereg_2_7 (line 222) | public static void movereg_2_7 () { Reg.Register7 = Reg.Register2; }
method movereg_2_8 (line 223) | public static void movereg_2_8 () { Reg.Register8 = Reg.Register2; }
method movereg_2_9 (line 224) | public static void movereg_2_9 () { Reg.Register9 = Reg.Register2; }
method movereg_2_10 (line 225) | public static void movereg_2_10 () { Reg.Register10 = Reg.Register2; }
method movereg_2_11 (line 226) | public static void movereg_2_11 () { Reg.Register11 = Reg.Register2; }
method movereg_2_12 (line 227) | public static void movereg_2_12 () { Reg.Register12 = Reg.Register2; }
method movereg_2_13 (line 228) | public static void movereg_2_13 () { Reg.Register13 = Reg.Register2; }
method movereg_2_14 (line 229) | public static void movereg_2_14 () { Reg.Register14 = Reg.Register2; }
method movereg_2_15 (line 230) | public static void movereg_2_15 () { Reg.Register15 = Reg.Register2; }
method movereg_2_16 (line 231) | public static void movereg_2_16 () { Reg.Register16 = Reg.Register2; }
method movereg_2_17 (line 232) | public static void movereg_2_17 () { Reg.Register17 = Reg.Register2; }
method movereg_2_18 (line 233) | public static void movereg_2_18 () { Reg.Register18 = Reg.Register2; }
method movereg_2_19 (line 234) | public static void movereg_2_19 () { Reg.Register19 = Reg.Register2; }
method movereg_2_20 (line 235) | public static void movereg_2_20 () { Reg.Register20 = Reg.Register2; }
method movereg_2_21 (line 236) | public static void movereg_2_21 () { Reg.Register21 = Reg.Register2; }
method movereg_2_22 (line 237) | public static void movereg_2_22 () { Reg.Register22 = Reg.Register2; }
method movereg_2_23 (line 238) | public static void movereg_2_23 () { Reg.Register23 = Reg.Register2; }
method movereg_2_24 (line 239) | public static void movereg_2_24 () { Reg.Register24 = Reg.Register2; }
method movereg_2_25 (line 240) | public static void movereg_2_25 () { Reg.Register25 = Reg.Register2; }
method movereg_2_26 (line 241) | public static void movereg_2_26 () { Reg.Register26 = Reg.Register2; }
method movereg_2_27 (line 242) | public static void movereg_2_27 () { Reg.Register27 = Reg.Register2; }
method movereg_2_28 (line 243) | public static void movereg_2_28 () { Reg.Register28 = Reg.Register2; }
method movereg_2_29 (line 244) | public static void movereg_2_29 () { Reg.Register29 = Reg.Register2; }
method movereg_2_30 (line 245) | public static void movereg_2_30 () { Reg.Register30 = Reg.Register2; }
method movereg_2_31 (line 246) | public static void movereg_2_31 () { Reg.Register31 = Reg.Register2; }
method movereg_3_1 (line 247) | public static void movereg_3_1 () { Reg.Register1 = Reg.Register3; }
method movereg_3_2 (line 248) | public static void movereg_3_2 () { Reg.Register2 = Reg.Register3; }
method movereg_3_4 (line 249) | public static void movereg_3_4 () { Reg.Register4 = Reg.Register3; }
method movereg_3_5 (line 250) | public static void movereg_3_5 () { Reg.Register5 = Reg.Register3; }
method movereg_3_6 (line 251) | public static void movereg_3_6 () { Reg.Register6 = Reg.Register3; }
method movereg_3_7 (line 252) | public static void movereg_3_7 () { Reg.Register7 = Reg.Register3; }
method movereg_3_8 (line 253) | public static void movereg_3_8 () { Reg.Register8 = Reg.Register3; }
method movereg_3_9 (line 254) | public static void movereg_3_9 () { Reg.Register9 = Reg.Register3; }
method movereg_3_10 (line 255) | public static void movereg_3_10 () { Reg.Register10 = Reg.Register3; }
method movereg_3_11 (line 256) | public static void movereg_3_11 () { Reg.Register11 = Reg.Register3; }
method movereg_3_12 (line 257) | public static void movereg_3_12 () { Reg.Register12 = Reg.Register3; }
method movereg_3_13 (line 258) | public static void movereg_3_13 () { Reg.Register13 = Reg.Register3; }
method movereg_3_14 (line 259) | public static void movereg_3_14 () { Reg.Register14 = Reg.Register3; }
method movereg_3_15 (line 260) | public static void movereg_3_15 () { Reg.Register15 = Reg.Register3; }
method movereg_3_16 (line 261) | public static void movereg_3_16 () { Reg.Register16 = Reg.Register3; }
method movereg_3_17 (line 262) | public static void movereg_3_17 () { Reg.Register17 = Reg.Register3; }
method movereg_3_18 (line 263) | public static void movereg_3_18 () { Reg.Register18 = Reg.Register3; }
method movereg_3_19 (line 264) | public static void movereg_3_19 () { Reg.Register19 = Reg.Register3; }
method movereg_3_20 (line 265) | public static void movereg_3_20 () { Reg.Register20 = Reg.Register3; }
method movereg_3_21 (line 266) | public static void movereg_3_21 () { Reg.Register21 = Reg.Register3; }
method movereg_3_22 (line 267) | public static void movereg_3_22 () { Reg.Register22 = Reg.Register3; }
method movereg_3_23 (line 268) | public static void movereg_3_23 () { Reg.Register23 = Reg.Register3; }
method movereg_3_24 (line 269) | public static void movereg_3_24 () { Reg.Register24 = Reg.Register3; }
method movereg_3_25 (line 270) | public static void movereg_3_25 () { Reg.Register25 = Reg.Register3; }
method movereg_3_26 (line 271) | public static void movereg_3_26 () { Reg.Register26 = Reg.Register3; }
method movereg_3_27 (line 272) | public static void movereg_3_27 () { Reg.Register27 = Reg.Register3; }
method movereg_3_28 (line 273) | public static void movereg_3_28 () { Reg.Register28 = Reg.Register3; }
method movereg_3_29 (line 274) | public static void movereg_3_29 () { Reg.Register29 = Reg.Register3; }
method movereg_3_30 (line 275) | public static void movereg_3_30 () { Reg.Register30 = Reg.Register3; }
method movereg_3_31 (line 276) | public static void movereg_3_31 () { Reg.Register31 = Reg.Register3; }
method movereg_4_1 (line 277) | public static void movereg_4_1 () { Reg.Register1 = Reg.Register4; }
method movereg_4_2 (line 278) | public static void movereg_4_2 () { Reg.Register2 = Reg.Register4; }
method movereg_4_3 (line 279) | public static void movereg_4_3 () { Reg.Register3 = Reg.Register4; }
method movereg_4_5 (line 280) | public static void movereg_4_5 () { Reg.Register5 = Reg.Register4; }
method movereg_4_6 (line 281) | public static void movereg_4_6 () { Reg.Register6 = Reg.Register4; }
method movereg_4_7 (line 282) | public static void movereg_4_7 () { Reg.Register7 = Reg.Register4; }
method movereg_4_8 (line 283) | public static void movereg_4_8 () { Reg.Register8 = Reg.Register4; }
method movereg_4_9 (line 284) | public static void movereg_4_9 () { Reg.Register9 = Reg.Register4; }
method movereg_4_10 (line 285) | public static void movereg_4_10 () { Reg.Register10 = Reg.Register4; }
method movereg_4_11 (line 286) | public static void movereg_4_11 () { Reg.Register11 = Reg.Register4; }
method movereg_4_12 (line 287) | public static void movereg_4_12 () { Reg.Register12 = Reg.Register4; }
method movereg_4_13 (line 288) | public static void movereg_4_13 () { Reg.Register13 = Reg.Register4; }
method movereg_4_14 (line 289) | public static void movereg_4_14 () { Reg.Register14 = Reg.Register4; }
method movereg_4_15 (line 290) | public static void movereg_4_15 () { Reg.Register15 = Reg.Register4; }
method movereg_4_16 (line 291) | public static void movereg_4_16 () { Reg.Register16 = Reg.Register4; }
method movereg_4_17 (line 292) | public static void movereg_4_17 () { Reg.Register17 = Reg.Register4; }
method movereg_4_18 (line 293) | public static void movereg_4_18 () { Reg.Register18 = Reg.Register4; }
method movereg_4_19 (line 294) | public static void movereg_4_19 () { Reg.Register19 = Reg.Register4; }
method movereg_4_20 (line 295) | public static void movereg_4_20 () { Reg.Register20 = Reg.Register4; }
method movereg_4_21 (line 296) | public static void movereg_4_21 () { Reg.Register21 = Reg.Register4; }
method movereg_4_22 (line 297) | public static void movereg_4_22 () { Reg.Register22 = Reg.Register4; }
method movereg_4_23 (line 298) | public static void movereg_4_23 () { Reg.Register23 = Reg.Register4; }
method movereg_4_24 (line 299) | public static void movereg_4_24 () { Reg.Register24 = Reg.Register4; }
method movereg_4_25 (line 300) | public static void movereg_4_25 () { Reg.Register25 = Reg.Register4; }
method movereg_4_26 (line 301) | public static void movereg_4_26 () { Reg.Register26 = Reg.Register4; }
method movereg_4_27 (line 302) | public static void movereg_4_27 () { Reg.Register27 = Reg.Register4; }
method movereg_4_28 (line 303) | public static void movereg_4_28 () { Reg.Register28 = Reg.Register4; }
method movereg_4_29 (line 304) | public static void movereg_4_29 () { Reg.Register29 = Reg.Register4; }
method movereg_4_30 (line 305) | public static void movereg_4_30 () { Reg.Register30 = Reg.Register4; }
method movereg_4_31 (line 306) | public static void movereg_4_31 () { Reg.Register31 = Reg.Register4; }
method movereg_5_1 (line 307) | public static void movereg_5_1 () { Reg.Register1 = Reg.Register5; }
method movereg_5_2 (line 308) | public static void movereg_5_2 () { Reg.Register2 = Reg.Register5; }
method movereg_5_3 (line 309) | public static void movereg_5_3 () { Reg.Register3 = Reg.Register5; }
method movereg_5_4 (line 310) | public static void movereg_5_4 () { Reg.Register4 = Reg.Register5; }
method movereg_5_6 (line 311) | public static void movereg_5_6 () { Reg.Register6 = Reg.Register5; }
method movereg_5_7 (line 312) | public static void movereg_5_7 () { Reg.Register7 = Reg.Register5; }
method movereg_5_8 (line 313) | public static void movereg_5_8 () { Reg.Register8 = Reg.Register5; }
method movereg_5_9 (line 314) | public static void movereg_5_9 () { Reg.Register9 = Reg.Register5; }
method movereg_5_10 (line 315) | public static void movereg_5_10 () { Reg.Register10 = Reg.Register5; }
method movereg_5_11 (line 316) | public static void movereg_5_11 () { Reg.Register11 = Reg.Register5; }
method movereg_5_12 (line 317) | public static void movereg_5_12 () { Reg.Register12 = Reg.Register5; }
method movereg_5_13 (line 318) | public static void movereg_5_13 () { Reg.Register13 = Reg.Register5; }
method movereg_5_14 (line 319) | public static void movereg_5_14 () { Reg.Register14 = Reg.Register5; }
method movereg_5_15 (line 320) | public static void movereg_5_15 () { Reg.Register15 = Reg.Register5; }
method movereg_5_16 (line 321) | public static void movereg_5_16 () { Reg.Register16 = Reg.Register5; }
method movereg_5_17 (line 322) | public static void movereg_5_17 () { Reg.Register17 = Reg.Register5; }
method movereg_5_18 (line 323) | public static void movereg_5_18 () { Reg.Register18 = Reg.Register5; }
method movereg_5_19 (line 324) | public static void movereg_5_19 () { Reg.Register19 = Reg.Register5; }
method movereg_5_20 (line 325) | public static void movereg_5_20 () { Reg.Register20 = Reg.Register5; }
method movereg_5_21 (line 326) | public static void movereg_5_21 () { Reg.Register21 = Reg.Register5; }
method movereg_5_22 (line 327) | public static void movereg_5_22 () { Reg.Register22 = Reg.Register5; }
method movereg_5_23 (line 328) | public static void movereg_5_23 () { Reg.Register23 = Reg.Register5; }
method movereg_5_24 (line 329) | public static void movereg_5_24 () { Reg.Register24 = Reg.Register5; }
method movereg_5_25 (line 330) | public static void movereg_5_25 () { Reg.Register25 = Reg.Register5; }
method movereg_5_26 (line 331) | public static void movereg_5_26 () { Reg.Register26 = Reg.Register5; }
method movereg_5_27 (line 332) | public static void movereg_5_27 () { Reg.Register27 = Reg.Register5; }
method movereg_5_28 (line 333) | public static void movereg_5_28 () { Reg.Register28 = Reg.Register5; }
method movereg_5_29 (line 334) | public static void movereg_5_29 () { Reg.Register29 = Reg.Register5; }
method movereg_5_30 (line 335) | public static void movereg_5_30 () { Reg.Register30 = Reg.Register5; }
method movereg_5_31 (line 336) | public static void movereg_5_31 () { Reg.Register31 = Reg.Register5; }
method movereg_6_1 (line 337) | public static void movereg_6_1 () { Reg.Register1 = Reg.Register6; }
method movereg_6_2 (line 338) | public static void movereg_6_2 () { Reg.Register2 = Reg.Register6; }
method movereg_6_3 (line 339) | public static void movereg_6_3 () { Reg.Register3 = Reg.Register6; }
method movereg_6_4 (line 340) | public static void movereg_6_4 () { Reg.Register4 = Reg.Register6; }
method movereg_6_5 (line 341) | public static void movereg_6_5 () { Reg.Register5 = Reg.Register6; }
method movereg_6_7 (line 342) | public static void movereg_6_7 () { Reg.Register7 = Reg.Register6; }
method movereg_6_8 (line 343) | public static void movereg_6_8 () { Reg.Register8 = Reg.Register6; }
method movereg_6_9 (line 344) | public static void movereg_6_9 () { Reg.Register9 = Reg.Register6; }
method movereg_6_10 (line 345) | public static void movereg_6_10 () { Reg.Register10 = Reg.Register6; }
method movereg_6_11 (line 346) | public static void movereg_6_11 () { Reg.Register11 = Reg.Register6; }
method movereg_6_12 (line 347) | public static void movereg_6_12 () { Reg.Register12 = Reg.Register6; }
method movereg_6_13 (line 348) | public static void movereg_6_13 () { Reg.Register13 = Reg.Register6; }
method movereg_6_14 (line 349) | public static void movereg_6_14 () { Reg.Register14 = Reg.Register6; }
method movereg_6_15 (line 350) | public static void movereg_6_15 () { Reg.Register15 = Reg.Register6; }
method movereg_6_16 (line 351) | public static void movereg_6_16 () { Reg.Register16 = Reg.Register6; }
method movereg_6_17 (line 352) | public static void movereg_6_17 () { Reg.Register17 = Reg.Register6; }
method movereg_6_18 (line 353) | public static void movereg_6_18 () { Reg.Register18 = Reg.Register6; }
method movereg_6_19 (line 354) | public static void movereg_6_19 () { Reg.Register19 = Reg.Register6; }
method movereg_6_20 (line 355) | public static void movereg_6_20 () { Reg.Register20 = Reg.Register6; }
method movereg_6_21 (line 356) | public static void movereg_6_21 () { Reg.Register21 = Reg.Register6; }
method movereg_6_22 (line 357) | public static void movereg_6_22 () { Reg.Register22 = Reg.Register6; }
method movereg_6_23 (line 358) | public static void movereg_6_23 () { Reg.Register23 = Reg.Register6; }
method movereg_6_24 (line 359) | public static void movereg_6_24 () { Reg.Register24 = Reg.Register6; }
method movereg_6_25 (line 360) | public static void movereg_6_25 () { Reg.Register25 = Reg.Register6; }
method movereg_6_26 (line 361) | public static void movereg_6_26 () { Reg.Register26 = Reg.Register6; }
method movereg_6_27 (line 362) | public static void movereg_6_27 () { Reg.Register27 = Reg.Register6; }
method movereg_6_28 (line 363) | public static void movereg_6_28 () { Reg.Register28 = Reg.Register6; }
method movereg_6_29 (line 364) | public static void movereg_6_29 () { Reg.Register29 = Reg.Register6; }
method movereg_6_30 (line 365) | public static void movereg_6_30 () { Reg.Register30 = Reg.Register6; }
method movereg_6_31 (line 366) | public static void movereg_6_31 () { Reg.Register31 = Reg.Register6; }
method movereg_7_1 (line 367) | public static void movereg_7_1 () { Reg.Register1 = Reg.Register7; }
method movereg_7_2 (line 368) | public static void movereg_7_2 () { Reg.Register2 = Reg.Register7; }
method movereg_7_3 (line 369) | public static void movereg_7_3 () { Reg.Register3 = Reg.Register7; }
method movereg_7_4 (line 370) | public static void movereg_7_4 () { Reg.Register4 = Reg.Register7; }
method movereg_7_5 (line 371) | public static void movereg_7_5 () { Reg.Register5 = Reg.Register7; }
method movereg_7_6 (line 372) | public static void movereg_7_6 () { Reg.Register6 = Reg.Register7; }
method movereg_7_8 (line 373) | public static void movereg_7_8 () { Reg.Register8 = Reg.Register7; }
method movereg_7_9 (line 374) | public static void movereg_7_9 () { Reg.Register9 = Reg.Register7; }
method movereg_7_10 (line 375) | public static void movereg_7_10 () { Reg.Register10 = Reg.Register7; }
method movereg_7_11 (line 376) | public static void movereg_7_11 () { Reg.Register11 = Reg.Register7; }
method movereg_7_12 (line 377) | public static void movereg_7_12 () { Reg.Register12 = Reg.Register7; }
method movereg_7_13 (line 378) | public static void movereg_7_13 () { Reg.Register13 = Reg.Register7; }
method movereg_7_14 (line 379) | public static void movereg_7_14 () { Reg.Register14 = Reg.Register7; }
method movereg_7_15 (line 380) | public static void movereg_7_15 () { Reg.Register15 = Reg.Register7; }
method movereg_7_16 (line 381) | public static void movereg_7_16 () { Reg.Register16 = Reg.Register7; }
method movereg_7_17 (line 382) | public static void movereg_7_17 () { Reg.Register17 = Reg.Register7; }
method movereg_7_18 (line 383) | public static void movereg_7_18 () { Reg.Register18 = Reg.Register7; }
method movereg_7_19 (line 384) | public static void movereg_7_19 () { Reg.Register19 = Reg.Register7; }
method movereg_7_20 (line 385) | public static void movereg_7_20 () { Reg.Register20 = Reg.Register7; }
method movereg_7_21 (line 386) | public static void movereg_7_21 () { Reg.Register21 = Reg.Register7; }
method movereg_7_22 (line 387) | public static void movereg_7_22 () { Reg.Register22 = Reg.Register7; }
method movereg_7_23 (line 388) | public static void movereg_7_23 () { Reg.Register23 = Reg.Register7; }
method movereg_7_24 (line 389) | public static void movereg_7_24 () { Reg.Register24 = Reg.Register7; }
method movereg_7_25 (line 390) | public static void movereg_7_25 () { Reg.Register25 = Reg.Register7; }
method movereg_7_26 (line 391) | public static void movereg_7_26 () { Reg.Register26 = Reg.Register7; }
method movereg_7_27 (line 392) | public static void movereg_7_27 () { Reg.Register27 = Reg.Register7; }
method movereg_7_28 (line 393) | public static void movereg_7_28 () { Reg.Register28 = Reg.Register7; }
method movereg_7_29 (line 394) | public static void movereg_7_29 () { Reg.Register29 = Reg.Register7; }
method movereg_7_30 (line 395) | public static void movereg_7_30 () { Reg.Register30 = Reg.Register7; }
method movereg_7_31 (line 396) | public static void movereg_7_31 () { Reg.Register31 = Reg.Register7; }
method movereg_8_1 (line 397) | public static void movereg_8_1 () { Reg.Register1 = Reg.Register8; }
method movereg_8_2 (line 398) | public static void movereg_8_2 () { Reg.Register2 = Reg.Register8; }
method movereg_8_3 (line 399) | public static void movereg_8_3 () { Reg.Register3 = Reg.Register8; }
method movereg_8_4 (line 400) | public static void movereg_8_4 () { Reg.Register4 = Reg.Register8; }
method movereg_8_5 (line 401) | public static void movereg_8_5 () { Reg.Register5 = Reg.Register8; }
method movereg_8_6 (line 402) | public static void movereg_8_6 () { Reg.Register6 = Reg.Register8; }
method movereg_8_7 (line 403) | public static void movereg_8_7 () { Reg.Register7 = Reg.Register8; }
method movereg_8_9 (line 404) | public static void movereg_8_9 () { Reg.Register9 = Reg.Register8; }
method movereg_8_10 (line 405) | public static void movereg_8_10 () { Reg.Register10 = Reg.Register8; }
method movereg_8_11 (line 406) | public static void movereg_8_11 () { Reg.Register11 = Reg.Register8; }
method movereg_8_12 (line 407) | public static void movereg_8_12 () { Reg.Register12 = Reg.Register8; }
method movereg_8_13 (line 408) | public static void movereg_8_13 () { Reg.Register13 = Reg.Register8; }
method movereg_8_14 (line 409) | public static void movereg_8_14 () { Reg.Register14 = Reg.Register8; }
method movereg_8_15 (line 410) | public static void movereg_8_15 () { Reg.Register15 = Reg.Register8; }
method movereg_8_16 (line 411) | public static void movereg_8_16 () { Reg.Register16 = Reg.Register8; }
method movereg_8_17 (line 412) | public static void movereg_8_17 () { Reg.Register17 = Reg.Register8; }
method movereg_8_18 (line 413) | public static void movereg_8_18 () { Reg.Register18 = Reg.Register8; }
method movereg_8_19 (line 414) | public static void movereg_8_19 () { Reg.Register19 = Reg.Register8; }
method movereg_8_20 (line 415) | public static void movereg_8_20 () { Reg.Register20 = Reg.Register8; }
method movereg_8_21 (line 416) | public static void movereg_8_21 () { Reg.Register21 = Reg.Register8; }
method movereg_8_22 (line 417) | public static void movereg_8_22 () { Reg.Register22 = Reg.Register8; }
method movereg_8_23 (line 418) | public static void movereg_8_23 () { Reg.Register23 = Reg.Register8; }
method movereg_8_24 (line 419) | public static void movereg_8_24 () { Reg.Register24 = Reg.Register8; }
method movereg_8_25 (line 420) | public static void movereg_8_25 () { Reg.Register25 = Reg.Register8; }
method movereg_8_26 (line 421) | public static void movereg_8_26 () { Reg.Register26 = Reg.Register8; }
method movereg_8_27 (line 422) | public static void movereg_8_27 () { Reg.Register27 = Reg.Register8; }
method movereg_8_28 (line 423) | public static void movereg_8_28 () { Reg.Register28 = Reg.Register8; }
method movereg_8_29 (line 424) | public static void movereg_8_29 () { Reg.Register29 = Reg.Register8; }
method movereg_8_30 (line 425) | public static void movereg_8_30 () { Reg.Register30 = Reg.Register8; }
method movereg_8_31 (line 426) | public static void movereg_8_31 () { Reg.Register31 = Reg.Register8; }
method movereg_9_1 (line 427) | public static void movereg_9_1 () { Reg.Register1 = Reg.Register9; }
method movereg_9_2 (line 428) | public static void movereg_9_2 () { Reg.Register2 = Reg.Register9; }
method movereg_9_3 (line 429) | public static void movereg_9_3 () { Reg.Register3 = Reg.Register9; }
method movereg_9_4 (line 430) | public static void movereg_9_4 () { Reg.Register4 = Reg.Register9; }
method movereg_9_5 (line 431) | public static void movereg_9_5 () { Reg.Register5 = Reg.Register9; }
method movereg_9_6 (line 432) | public static void movereg_9_6 () { Reg.Register6 = Reg.Register9; }
method movereg_9_7 (line 433) | public static void movereg_9_7 () { Reg.Register7 = Reg.Register9; }
method movereg_9_8 (line 434) | public static void movereg_9_8 () { Reg.Register8 = Reg.Register9; }
method movereg_9_10 (line 435) | public static void movereg_9_10 () { Reg.Register10 = Reg.Register9; }
method movereg_9_11 (line 436) | public static void movereg_9_11 () { Reg.Register11 = Reg.Register9; }
method movereg_9_12 (line 437) | public static void movereg_9_12 () { Reg.Register12 = Reg.Register9; }
method movereg_9_13 (line 438) | public static void movereg_9_13 () { Reg.Register13 = Reg.Register9; }
method movereg_9_14 (line 439) | public static void movereg_9_14 () { Reg.Register14 = Reg.Register9; }
method movereg_9_15 (line 440) | public static void movereg_9_15 () { Reg.Register15 = Reg.Register9; }
method movereg_9_16 (line 441) | public static void movereg_9_16 () { Reg.Register16 = Reg.Register9; }
method movereg_9_17 (line 442) | public static void movereg_9_17 () { Reg.Register17 = Reg.Register9; }
method movereg_9_18 (line 443) | public static void movereg_9_18 () { Reg.Register18 = Reg.Register9; }
method movereg_9_19 (line 444) | public static void movereg_9_19 () { Reg.Register19 = Reg.Register9; }
method movereg_9_20 (line 445) | public static void movereg_9_20 () { Reg.Register20 = Reg.Register9; }
method movereg_9_21 (line 446) | public static void movereg_9_21 () { Reg.Register21 = Reg.Register9; }
method movereg_9_22 (line 447) | public static void movereg_9_22 () { Reg.Register22 = Reg.Register9; }
method movereg_9_23 (line 448) | public static void movereg_9_23 () { Reg.Register23 = Reg.Register9; }
method movereg_9_24 (line 449) | public static void movereg_9_24 () { Reg.Register24 = Reg.Register9; }
method movereg_9_25 (line 450) | public static void movereg_9_25 () { Reg.Register25 = Reg.Register9; }
method movereg_9_26 (line 451) | public static void movereg_9_26 () { Reg.Register26 = Reg.Register9; }
method movereg_9_27 (line 452) | public static void movereg_9_27 () { Reg.Register27 = Reg.Register9; }
method movereg_9_28 (line 453) | public static void movereg_9_28 () { Reg.Register28 = Reg.Register9; }
method movereg_9_29 (line 454) | public static void movereg_9_29 () { Reg.Register29 = Reg.Register9; }
method movereg_9_30 (line 455) | public static void movereg_9_30 () { Reg.Register30 = Reg.Register9; }
method movereg_9_31 (line 456) | public static void movereg_9_31 () { Reg.Register31 = Reg.Register9; }
method movereg_10_1 (line 457) | public static void movereg_10_1 () { Reg.Register1 = Reg.Register10; }
method movereg_10_2 (line 458) | public static void movereg_10_2 () { Reg.Register2 = Reg.Register10; }
method movereg_10_3 (line 459) | public static void movereg_10_3 () { Reg.Register3 = Reg.Register10; }
method movereg_10_4 (line 460) | public static void movereg_10_4 () { Reg.Register4 = Reg.Register10; }
method movereg_10_5 (line 461) | public static void movereg_10_5 () { Reg.Register5 = Reg.Register10; }
method movereg_10_6 (line 462) | public static void movereg_10_6 () { Reg.Register6 = Reg.Register10; }
method movereg_10_7 (line 463) | public static void movereg_10_7 () { Reg.Register7 = Reg.Register10; }
method movereg_10_8 (line 464) | public static void movereg_10_8 () { Reg.Register8 = Reg.Register10; }
method movereg_10_9 (line 465) | public static void movereg_10_9 () { Reg.Register9 = Reg.Register10; }
method movereg_10_11 (line 466) | public static void movereg_10_11 () { Reg.Register11 = Reg.Register10; }
method movereg_10_12 (line 467) | public static void movereg_10_12 () { Reg.Register12 = Reg.Register10; }
method movereg_10_13 (line 468) | public static void movereg_10_13 () { Reg.Register13 = Reg.Register10; }
method movereg_10_14 (line 469) | public static void movereg_10_14 () { Reg.Register14 = Reg.Register10; }
method movereg_10_15 (line 470) | public static void movereg_10_15 () { Reg.Register15 = Reg.Register10; }
method movereg_10_16 (line 471) | public static void movereg_10_16 () { Reg.Register16 = Reg.Register10; }
method movereg_10_17 (line 472) | public static void movereg_10_17 () { Reg.Register17 = Reg.Register10; }
method movereg_10_18 (line 473) | public static void movereg_10_18 () { Reg.Register18 = Reg.Register10; }
method movereg_10_19 (line 474) | public static void movereg_10_19 () { Reg.Register19 = Reg.Register10; }
method movereg_10_20 (line 475) | public static void movereg_10_20 () { Reg.Register20 = Reg.Register10; }
method movereg_10_21 (line 476) | public static void movereg_10_21 () { Reg.Register21 = Reg.Register10; }
method movereg_10_22 (line 477) | public static void movereg_10_22 () { Reg.Register22 = Reg.Register10; }
method movereg_10_23 (line 478) | public static void movereg_10_23 () { Reg.Register23 = Reg.Register10; }
method movereg_10_24 (line 479) | public static void movereg_10_24 () { Reg.Register24 = Reg.Register10; }
method movereg_10_25 (line 480) | public static void movereg_10_25 () { Reg.Register25 = Reg.Register10; }
method movereg_10_26 (line 481) | public static void movereg_10_26 () { Reg.Register26 = Reg.Register10; }
method movereg_10_27 (line 482) | public static void movereg_10_27 () { Reg.Register27 = Reg.Register10; }
method movereg_10_28 (line 483) | public static void movereg_10_28 () { Reg.Register28 = Reg.Register10; }
method movereg_10_29 (line 484) | public static void movereg_10_29 () { Reg.Register29 = Reg.Register10; }
method movereg_10_30 (line 485) | public static void movereg_10_30 () { Reg.Register30 = Reg.Register10; }
method movereg_10_31 (line 486) | public static void movereg_10_31 () { Reg.Register31 = Reg.Register10; }
method movereg_11_1 (line 487) | public static void movereg_11_1 () { Reg.Register1 = Reg.Register11; }
method movereg_11_2 (line 488) | public static void movereg_11_2 () { Reg.Register2 = Reg.Register11; }
method movereg_11_3 (line 489) | public static void movereg_11_3 () { Reg.Register3 = Reg.Register11; }
method movereg_11_4 (line 490) | public static void movereg_11_4 () { Reg.Register4 = Reg.Register11; }
method movereg_11_5 (line 491) | public static void movereg_11_5 () { Reg.Register5 = Reg.Register11; }
method movereg_11_6 (line 492) | public static void movereg_11_6 () { Reg.Register6 = Reg.Register11; }
method movereg_11_7 (line 493) | public static void movereg_11_7 () { Reg.Register7 = Reg.Register11; }
method movereg_11_8 (line 494) | public static void movereg_11_8 () { Reg.Register8 = Reg.Register11; }
method movereg_11_9 (line 495) | public static void movereg_11_9 () { Reg.Register9 = Reg.Register11; }
method movereg_11_10 (line 496) | public static void movereg_11_10 () { Reg.Register10 = Reg.Register11; }
method movereg_11_12 (line 497) | public static void movereg_11_12 () { Reg.Register12 = Reg.Register11; }
method movereg_11_13 (line 498) | public static void movereg_11_13 () { Reg.Register13 = Reg.Register11; }
method movereg_11_14 (line 499) | public static void movereg_11_14 () { Reg.Register14 = Reg.Register11; }
method movereg_11_15 (line 500) | public static void movereg_11_15 () { Reg.Register15 = Reg.Register11; }
method movereg_11_16 (line 501) | public static void movereg_11_16 () { Reg.Register16 = Reg.Register11; }
method movereg_11_17 (line 502) | public static void movereg_11_17 () { Reg.Register17 = Reg.Register11; }
method movereg_11_18 (line 503) | public static void movereg_11_18 () { Reg.Register18 = Reg.Register11; }
method movereg_11_19 (line 504) | public static void movereg_11_19 () { Reg.Register19 = Reg.Register11; }
method movereg_11_20 (line 505) | public static void movereg_11_20 () { Reg.Register20 = Reg.Register11; }
method movereg_11_21 (line 506) | public static void movereg_11_21 () { Reg.Register21 = Reg.Register11; }
method movereg_11_22 (line 507) | public static void movereg_11_22 () { Reg.Register22 = Reg.Register11; }
method movereg_11_23 (line 508) | public static void movereg_11_23 () { Reg.Register23 = Reg.Register11; }
method movereg_11_24 (line 509) | public static void movereg_11_24 () { Reg.Register24 = Reg.Register11; }
method movereg_11_25 (line 510) | public static void movereg_11_25 () { Reg.Register25 = Reg.Register11; }
method movereg_11_26 (line 511) | public static void movereg_11_26 () { Reg.Register26 = Reg.Register11; }
method movereg_11_27 (line 512) | public static void movereg_11_27 () { Reg.Register27 = Reg.Register11; }
method movereg_11_28 (line 513) | public static void movereg_11_28 () { Reg.Register28 = Reg.Register11; }
method movereg_11_29 (line 514) | public static void movereg_11_29 () { Reg.Register29 = Reg.Register11; }
method movereg_11_30 (line 515) | public static void movereg_11_30 () { Reg.Register30 = Reg.Register11; }
method movereg_11_31 (line 516) | public static void movereg_11_31 () { Reg.Register31 = Reg.Register11; }
method movereg_12_1 (line 517) | public static void movereg_12_1 () { Reg.Register1 = Reg.Register12; }
method movereg_12_2 (line 518) | public static void movereg_12_2 () { Reg.Register2 = Reg.Register12; }
method movereg_12_3 (line 519) | public static void movereg_12_3 () { Reg.Register3 = Reg.Register12; }
method movereg_12_4 (line 520) | public static void movereg_12_4 () { Reg.Register4 = Reg.Register12; }
method movereg_12_5 (line 521) | public static void movereg_12_5 () { Reg.Register5 = Reg.Register12; }
method movereg_12_6 (line 522) | public static void movereg_12_6 () { Reg.Register6 = Reg.Register12; }
method movereg_12_7 (line 523) | public static void movereg_12_7 () { Reg.Register7 = Reg.Register12; }
method movereg_12_8 (line 524) | public static void movereg_12_8 () { Reg.Register8 = Reg.Register12; }
method movereg_12_9 (line 525) | public static void movereg_12_9 () { Reg.Register9 = Reg.Register12; }
method movereg_12_10 (line 526) | public static void movereg_12_10 () { Reg.Register10 = Reg.Register12; }
method movereg_12_11 (line 527) | public static void movereg_12_11 () { Reg.Register11 = Reg.Register12; }
method movereg_12_13 (line 528) | public static void movereg_12_13 () { Reg.Register13 = Reg.Register12; }
method movereg_12_14 (line 529) | public static void movereg_12_14 () { Reg.Register14 = Reg.Register12; }
method movereg_12_15 (line 530) | public static void movereg_12_15 () { Reg.Register15 = Reg.Register12; }
method movereg_12_16 (line 531) | public static void movereg_12_16 () { Reg.Register16 = Reg.Register12; }
method movereg_12_17 (line 532) | public static void movereg_12_17 () { Reg.Register17 = Reg.Register12; }
method movereg_12_18 (line 533) | public static void movereg_12_18 () { Reg.Register18 = Reg.Register12; }
method movereg_12_19 (line 534) | public static void movereg_12_19 () { Reg.Register19 = Reg.Register12; }
method movereg_12_20 (line 535) | public static void movereg_12_20 () { Reg.Register20 = Reg.Register12; }
method movereg_12_21 (line 536) | public static void movereg_12_21 () { Reg.Register21 = Reg.Register12; }
method movereg_12_22 (line 537) | public static void movereg_12_22 () { Reg.Register22 = Reg.Register12; }
method movereg_12_23 (line 538) | public static void movereg_12_23 () { Reg.Register23 = Reg.Register12; }
method movereg_12_24 (line 539) | public static void movereg_12_24 () { Reg.Register24 = Reg.Register12; }
method movereg_12_25 (line 540) | public static void movereg_12_25 () { Reg.Register25 = Reg.Register12; }
method movereg_12_26 (line 541) | public static void movereg_12_26 () { Reg.Register26 = Reg.Register12; }
method movereg_12_27 (line 542) | public static void movereg_12_27 () { Reg.Register27 = Reg.Register12; }
method movereg_12_28 (line 543) | public static void movereg_12_28 () { Reg.Register28 = Reg.Register12; }
method movereg_12_29 (line 544) | public static void movereg_12_29 () { Reg.Register29 = Reg.Register12; }
method movereg_12_30 (line 545) | public static void movereg_12_30 () { Reg.Register30 = Reg.Register12; }
method movereg_12_31 (line 546) | public static void movereg_12_31 () { Reg.Register31 = Reg.Register12; }
method movereg_13_1 (line 547) | public static void movereg_13_1 () { Reg.Register1 = Reg.Register13; }
method movereg_13_2 (line 548) | public static void movereg_13_2 () { Reg.Register2 = Reg.Register13; }
method movereg_13_3 (line 549) | public static void movereg_13_3 () { Reg.Register3 = Reg.Register13; }
method movereg_13_4 (line 550) | public static void movereg_13_4 () { Reg.Register4 = Reg.Register13; }
method movereg_13_5 (line 551) | public static void movereg_13_5 () { Reg.Register5 = Reg.Register13; }
method movereg_13_6 (line 552) | public static void movereg_13_6 () { Reg.Register6 = Reg.Register13; }
method movereg_13_7 (line 553) | public static void movereg_13_7 () { Reg.Register7 = Reg.Register13; }
method movereg_13_8 (line 554) | public static void movereg_13_8 () { Reg.Register8 = Reg.Register13; }
method movereg_13_9 (line 555) | public static void movereg_13_9 () { Reg.Register9 = Reg.Register13; }
method movereg_13_10 (line 556) | public static void movereg_13_10 () { Reg.Register10 = Reg.Register13; }
method movereg_13_11 (line 557) | public static void movereg_13_11 () { Reg.Register11 = Reg.Register13; }
method movereg_13_12 (line 558) | public static void movereg_13_12 () { Reg.Register12 = Reg.Register13; }
method movereg_13_14 (line 559) | public static void movereg_13_14 () { Reg.Register14 = Reg.Register13; }
method movereg_13_15 (line 560) | public static void movereg_13_15 () { Reg.Register15 = Reg.Register13; }
method movereg_13_16 (line 561) | public static void movereg_13_16 () { Reg.Register16 = Reg.Register13; }
method movereg_13_17 (line 562) | public static void movereg_13_17 () { Reg.Register17 = Reg.Register13; }
method movereg_13_18 (line 563) | public static void movereg_13_18 () { Reg.Register18 = Reg.Register13; }
method movereg_13_19 (line 564) | public static void movereg_13_19 () { Reg.Register19 = Reg.Register13; }
method movereg_13_20 (line 565) | public static void movereg_13_20 () { Reg.Register20 = Reg.Register13; }
method movereg_13_21 (line 566) | public static void movereg_13_21 () { Reg.Register21 = Reg.Register13; }
method movereg_13_22 (line 567) | public static void movereg_13_22 () { Reg.Register22 = Reg.Register13; }
method movereg_13_23 (line 568) | public static void movereg_13_23 () { Reg.Register23 = Reg.Register13; }
method movereg_13_24 (line 569) | public static void movereg_13_24 () { Reg.Register24 = Reg.Register13; }
method movereg_13_25 (line 570) | public static void movereg_13_25 () { Reg.Register25 = Reg.Register13; }
method movereg_13_26 (line 571) | public static void movereg_13_26 () { Reg.Register26 = Reg.Register13; }
method movereg_13_27 (line 572) | public static void movereg_13_27 () { Reg.Register27 = Reg.Register13; }
method movereg_13_28 (line 573) | public static void movereg_13_28 () { Reg.Register28 = Reg.Register13; }
method movereg_13_29 (line 574) | public static void movereg_13_29 () { Reg.Register29 = Reg.Register13; }
method movereg_13_30 (line 575) | public static void movereg_13_30 () { Reg.Register30 = Reg.Register13; }
method movereg_13_31 (line 576) | public static void movereg_13_31 () { Reg.Register31 = Reg.Register13; }
method movereg_14_1 (line 577) | public static void movereg_14_1 () { Reg.Register1 = Reg.Register14; }
method movereg_14_2 (line 578) | public static void movereg_14_2 () { Reg.Register2 = Reg.Register14; }
method movereg_14_3 (line 579) | public static void movereg_14_3 () { Reg.Register3 = Reg.Register14; }
method movereg_14_4 (line 580) | public static void movereg_14_4 () { Reg.Register4 = Reg.Register14; }
method movereg_14_5 (line 581) | public static void movereg_14_5 () { Reg.Register5 = Reg.Register14; }
method movereg_14_6 (line 582) | public static void movereg_14_6 () { Reg.Register6 = Reg.Register14; }
method movereg_14_7 (line 583) | public static void movereg_14_7 () { Reg.Register7 = Reg.Register14; }
method movereg_14_8 (line 584) | public static void movereg_14_8 () { Reg.Register8 = Reg.Register14; }
method movereg_14_9 (line 585) | public static void movereg_14_9 () { Reg.Register9 = Reg.Register14; }
method movereg_14_10 (line 586) | public static void movereg_14_10 () { Reg.Register10 = Reg.Register14; }
method movereg_14_11 (line 587) | public static void movereg_14_11 () { Reg.Register11 = Reg.Register14; }
method movereg_14_12 (line 588) | public static void movereg_14_12 () { Reg.Register12 = Reg.Register14; }
method movereg_14_13 (line 589) | public static void movereg_14_13 () { Reg.Register13 = Reg.Register14; }
method movereg_14_15 (line 590) | public static void movereg_14_15 () { Reg.Register15 = Reg.Register14; }
method movereg_14_16 (line 591) | public static void movereg_14_16 () { Reg.Register16 = Reg.Register14; }
method movereg_14_17 (line 592) | public static void movereg_14_17 () { Reg.Register17 = Reg.Register14; }
method movereg_14_18 (line 593) | public static void movereg_14_18 () { Reg.Register18 = Reg.Register14; }
method movereg_14_19 (line 594) | public static void movereg_14_19 () { Reg.Register19 = Reg.Register14; }
method movereg_14_20 (line 595) | public static void movereg_14_20 () { Reg.Register20 = Reg.Register14; }
method movereg_14_21 (line 596) | public static void movereg_14_21 () { Reg.Register21 = Reg.Register14; }
method movereg_14_22 (line 597) | public static void movereg_14_22 () { Reg.Register22 = Reg.Register14; }
method movereg_14_23 (line 598) | public static void movereg_14_23 () { Reg.Register23 = Reg.Register14; }
method movereg_14_24 (line 599) | public static void movereg_14_24 () { Reg.Register24 = Reg.Register14; }
method movereg_14_25 (line 600) | public static void movereg_14_25 () { Reg.Register25 = Reg.Register14; }
method movereg_14_26 (line 601) | public static void movereg_14_26 () { Reg.Register26 = Reg.Register14; }
method movereg_14_27 (line 602) | public static void movereg_14_27 () { Reg.Register27 = Reg.Register14; }
method movereg_14_28 (line 603) | public static void movereg_14_28 () { Reg.Register28 = Reg.Register14; }
method movereg_14_29 (line 604) | public static void movereg_14_29 () { Reg.Register29 = Reg.Register14; }
method movereg_14_30 (line 605) | public static void movereg_14_30 () { Reg.Register30 = Reg.Register14; }
method movereg_14_31 (line 606) | public static void movereg_14_31 () { Reg.Register31 = Reg.Register14; }
method movereg_15_1 (line 607) | public static void movereg_15_1 () { Reg.Register1 = Reg.Register15; }
method movereg_15_2 (line 608) | public static void movereg_15_2 () { Reg.Register2 = Reg.Register15; }
method movereg_15_3 (line 609) | public static void movereg_15_3 () { Reg.Register3 = Reg.Register15; }
method movereg_15_4 (line 610) | public static void movereg_15_4 () { Reg.Register4 = Reg.Register15; }
method movereg_15_5 (line 611) | public static void movereg_15_5 () { Reg.Register5 = Reg.Register15; }
method movereg_15_6 (line 612) | public static void movereg_15_6 () { Reg.Register6 = Reg.Register15; }
method movereg_15_7 (line 613) | public static void movereg_15_7 () { Reg.Register7 = Reg.Register15; }
method movereg_15_8 (line 614) | public static void movereg_15_8 () { Reg.Register8 = Reg.Register15; }
method movereg_15_9 (line 615) | public static void movereg_15_9 () { Reg.Register9 = Reg.Register15; }
method movereg_15_10 (line 616) | public static void movereg_15_10 () { Reg.Register10 = Reg.Register15; }
method movereg_15_11 (line 617) | public static void movereg_15_11 () { Reg.Register11 = Reg.Register15; }
method movereg_15_12 (line 618) | public static void movereg_15_12 () { Reg.Register12 = Reg.Register15; }
method movereg_15_13 (line 619) | public static void movereg_15_13 () { Reg.Register13 = Reg.Register15; }
method movereg_15_14 (line 620) | public static void movereg_15_14 () { Reg.Register14 = Reg.Register15; }
method movereg_15_16 (line 621) | public static void movereg_15_16 () { Reg.Register16 = Reg.Register15; }
method movereg_15_17 (line 622) | public static void movereg_15_17 () { Reg.Register17 = Reg.Register15; }
method movereg_15_18 (line 623) | public static void movereg_15_18 () { Reg.Register18 = Reg.Register15; }
method movereg_15_19 (line 624) | public static void movereg_15_19 () { Reg.Register19 = Reg.Register15; }
method movereg_15_20 (line 625) | public static void movereg_15_20 () { Reg.Register20 = Reg.Register15; }
method movereg_15_21 (line 626) | public static void movereg_15_21 () { Reg.Register21 = Reg.Register15; }
method movereg_15_22 (line 627) | public static void movereg_15_22 () { Reg.Register22 = Reg.Register15; }
method movereg_15_23 (line 628) | public static void movereg_15_23 () { Reg.Register23 = Reg.Register15; }
method movereg_15_24 (line 629) | public static void movereg_15_24 () { Reg.Register24 = Reg.Register15; }
method movereg_15_25 (line 630) | public static void movereg_15_25 () { Reg.Register25 = Reg.Register15; }
method movereg_15_26 (line 631) | public static void movereg_15_26 () { Reg.Register26 = Reg.Register15; }
method movereg_15_27 (line 632) | public static void movereg_15_27 () { Reg.Register27 = Reg.Register15; }
method movereg_15_28 (line 633) | public static void movereg_15_28 () { Reg.Register28 = Reg.Register15; }
method movereg_15_29 (line 634) | public static void movereg_15_29 () { Reg.Register29 = Reg.Register15; }
method movereg_15_30 (line 635) | public static void movereg_15_30 () { Reg.Register30 = Reg.Register15; }
method movereg_15_31 (line 636) | public static void movereg_15_31 () { Reg.Register31 = Reg.Register15; }
method movereg_16_1 (line 637) | public static void movereg_16_1 () { Reg.Register1 = Reg.Register16; }
method movereg_16_2 (line 638) | public static void movereg_16_2 () { Reg.Register2 = Reg.Register16; }
method movereg_16_3 (line 639) | public static void movereg_16_3 () { Reg.Register3 = Reg.Register16; }
method movereg_16_4 (line 640) | public static void movereg_16_4 () { Reg.Register4 = Reg.Register16; }
method movereg_16_5 (line 641) | public static void movereg_16_5 () { Reg.Register5 = Reg.Register16; }
method movereg_16_6 (line 642) | public static void movereg_16_6 () { Reg.Register6 = Reg.Register16; }
method movereg_16_7 (line 643) | public static void movereg_16_7 () { Reg.Register7 = Reg.Register16; }
method movereg_16_8 (line 644) | public static void movereg_16_8 () { Reg.Register8 = Reg.Register16; }
method movereg_16_9 (line 645) | public static void movereg_16_9 () { Reg.Register9 = Reg.Register16; }
method movereg_16_10 (line 646) | public static void movereg_16_10 () { Reg.Register10 = Reg.Register16; }
method movereg_16_11 (line 647) | public static void movereg_16_11 () { Reg.Register11 = Reg.Register16; }
method movereg_16_12 (line 648) | public static void movereg_16_12 () { Reg.Register12 = Reg.Register16; }
method movereg_16_13 (line 649) | public static void movereg_16_13 () { Reg.Register13 = Reg.Register16; }
method movereg_16_14 (line 650) | public static void movereg_16_14 () { Reg.Register14 = Reg.Register16; }
method movereg_16_15 (line 651) | public static void movereg_16_15 () { Reg.Register15 = Reg.Register16; }
method movereg_16_17 (line 652) | public static void movereg_16_17 () { Reg.Register17 = Reg.Register16; }
method movereg_16_18 (line 653) | public static void movereg_16_18 () { Reg.Register18 = Reg.Register16; }
method movereg_16_19 (line 654) | public static void movereg_16_19 () { Reg.Register19 = Reg.Register16; }
method movereg_16_20 (line 655) | public static void movereg_16_20 () { Reg.Register20 = Reg.Register16; }
method movereg_16_21 (line 656) | public static void movereg_16_21 () { Reg.Register21 = Reg.Register16; }
method movereg_16_22 (line 657) | public static void movereg_16_22 () { Reg.Register22 = Reg.Register16; }
method movereg_16_23 (line 658) | public static void movereg_16_23 () { Reg.Register23 = Reg.Register16; }
method movereg_16_24 (line 659) | public static void movereg_16_24 () { Reg.Register24 = Reg.Register16; }
method movereg_16_25 (line 660) | public static void movereg_16_25 () { Reg.Register25 = Reg.Register16; }
method movereg_16_26 (line 661) | public static void movereg_16_26 () { Reg.Register26 = Reg.Register16; }
method movereg_16_27 (line 662) | public static void movereg_16_27 () { Reg.Register27 = Reg.Register16; }
method movereg_16_28 (line 663) | public static void movereg_16_28 () { Reg.Register28 = Reg.Register16; }
method movereg_16_29 (line 664) | public static void movereg_16_29 () { Reg.Register29 = Reg.Register16; }
method movereg_16_30 (line 665) | public static void movereg_16_30 () { Reg.Register30 = Reg.Register16; }
method movereg_16_31 (line 666) | public static void movereg_16_31 () { Reg.Register31 = Reg.Register16; }
method movereg_17_1 (line 667) | public static void movereg_17_1 () { Reg.Register1 = Reg.Register17; }
method movereg_17_2 (line 668) | public static void movereg_17_2 () { Reg.Register2 = Reg.Register17; }
method movereg_17_3 (line 669) | public static void movereg_17_3 () { Reg.Register3 = Reg.Register17; }
method movereg_17_4 (line 670) | public static void movereg_17_4 () { Reg.Register4 = Reg.Register17; }
method movereg_17_5 (line 671) | public static void movereg_17_5 () { Reg.Register5 = Reg.Register17; }
method movereg_17_6 (line 672) | public static void movereg_17_6 () { Reg.Register6 = Reg.Register17; }
method movereg_17_7 (line 673) | public static void movereg_17_7 () { Reg.Register7 = Reg.Register17; }
method movereg_17_8 (line 674) | public static void movereg_17_8 () { Reg.Register8 = Reg.Register17; }
method movereg_17_9 (line 675) | public static void movereg_17_9 () { Reg.Register9 = Reg.Register17; }
method movereg_17_10 (line 676) | public static void movereg_17_10 () { Reg.Register10 = Reg.Register17; }
method movereg_17_11 (line 677) | public static void movereg_17_11 () { Reg.Register11 = Reg.Register17; }
method movereg_17_12 (line 678) | public static void movereg_17_12 () { Reg.Register12 = Reg.Register17; }
method movereg_17_13 (line 679) | public static void movereg_17_13 () { Reg.Register13 = Reg.Register17; }
method movereg_17_14 (line 680) | public static void movereg_17_14 () { Reg.Register14 = Reg.Register17; }
method movereg_17_15 (line 681) | public static void movereg_17_15 () { Reg.Register15 = Reg.Register17; }
method movereg_17_16 (line 682) | public static void movereg_17_16 () { Reg.Register16 = Reg.Register17; }
method movereg_17_18 (line 683) | public static void movereg_17_18 () { Reg.Register18 = Reg.Register17; }
method movereg_17_19 (line 684) | public static void movereg_17_19 () { Reg.Register19 = Reg.Register17; }
method movereg_17_20 (line 685) | public static void movereg_17_20 () { Reg.Register20 = Reg.Register17; }
method movereg_17_21 (line 686) | public static void movereg_17_21 () { Reg.Register21 = Reg.Register17; }
method movereg_17_22 (line 687) | public static void movereg_17_22 () { Reg.Register22 = Reg.Register17; }
method movereg_17_23 (line 688) | public static void movereg_17_23 () { Reg.Register23 = Reg.Register17; }
method movereg_17_24 (line 689) | public static void movereg_17_24 () { Reg.Register24 = Reg.Register17; }
method movereg_17_25 (line 690) | public static void movereg_17_25 () { Reg.Register25 = Reg.Register17; }
method movereg_17_26 (line 691) | public static void movereg_17_26 () { Reg.Register26 = Reg.Register17; }
method movereg_17_27 (line 692) | public static void movereg_17_27 () { Reg.Register27 = Reg.Register17; }
method movereg_17_28 (line 693) | public static void movereg_17_28 () { Reg.Register28 = Reg.Register17; }
method movereg_17_29 (line 694) | public static void movereg_17_29 () { Reg.Register29 = Reg.Register17; }
method movereg_17_30 (line 695) | public static void movereg_17_30 () { Reg.Register30 = Reg.Register17; }
method movereg_17_31 (line 696) | public static void movereg_17_31 () { Reg.Register31 = Reg.Register17; }
method movereg_18_1 (line 697) | public static void movereg_18_1 () { Reg.Register1 = Reg.Register18; }
method movereg_18_2 (line 698) | public static void movereg_18_2 () { Reg.Register2 = Reg.Register18; }
method movereg_18_3 (line 699) | public static void movereg_18_3 () { Reg.Register3 = Reg.Register18; }
method movereg_18_4 (line 700) | public static void movereg_18_4 () { Reg.Register4 = Reg.Register18; }
method movereg_18_5 (line 701) | public static void movereg_18_5 () { Reg.Register5 = Reg.Register18; }
method movereg_18_6 (line 702) | public static void movereg_18_6 () { Reg.Register6 = Reg.Register18; }
method movereg_18_7 (line 703) | public static void movereg_18_7 () { Reg.Register7 = Reg.Register18; }
method movereg_18_8 (line 704) | public static void movereg_18_8 () { Reg.Register8 = Reg.Register18; }
method movereg_18_9 (line 705) | public static void movereg_18_9 () { Reg.Register9 = Reg.Register18; }
method movereg_18_10 (line 706) | public static void movereg_18_10 () { Reg.Register10 = Reg.Register18; }
method movereg_18_11 (line 707) | public static void movereg_18_11 () { Reg.Register11 = Reg.Register18; }
method movereg_18_12 (line 708) | public static void movereg_18_12 () { Reg.Register12 = Reg.Register18; }
method movereg_18_13 (line 709) | public static void movereg_18_13 () { Reg.Register13 = Reg.Register18; }
method movereg_18_14 (line 710) | public static void movereg_18_14 () { Reg.Register14 = Reg.Register18; }
method movereg_18_15 (line 711) | public static void movereg_18_15 () { Reg.Register15 = Reg.Register18; }
method movereg_18_16 (line 712) | public static void movereg_18_16 () { Reg.Register16 = Reg.Register18; }
method movereg_18_17 (line 713) | public static void movereg_18_17 () { Reg.Register17 = Reg.Register18; }
method movereg_18_19 (line 714) | public static void movereg_18_19 () { Reg.Register19 = Reg.Register18; }
method movereg_18_20 (line 715) | public static void movereg_18_20 () { Reg.Register20 = Reg.Register18; }
method movereg_18_21 (line 716) | public static void movereg_18_21 () { Reg.Register21 = Reg.Register18; }
method movereg_18_22 (line 717) | public static void movereg_18_22 () { Reg.Register22 = Reg.Register18; }
method movereg_18_23 (line 718) | public static void movereg_18_23 () { Reg.Register23 = Reg.Register18; }
method movereg_18_24 (line 719) | public static void movereg_18_24 () { Reg.Register24 = Reg.Register18; }
method movereg_18_25 (line 720) | public static void movereg_18_25 () { Reg.Register25 = Reg.Register18; }
method movereg_18_26 (line 721) | public static void movereg_18_26 () { Reg.Register26 = Reg.Register18; }
method movereg_18_27 (line 722) | public static void movereg_18_27 () { Reg.Register27 = Reg.Register18; }
method movereg_18_28 (line 723) | public static void movereg_18_28 () { Reg.Register28 = Reg.Register18; }
method movereg_18_29 (line 724) | public static void movereg_18_29 () { Reg.Register29 = Reg.Register18; }
method movereg_18_30 (line 725) | public static void movereg_18_30 () { Reg.Register30 = Reg.Register18; }
method movereg_18_31 (line 726) | public static void movereg_18_31 () { Reg.Register31 = Reg.Register18; }
method movereg_19_1 (line 727) | public static void movereg_19_1 () { Reg.Register1 = Reg.Register19; }
method movereg_19_2 (line 728) | public static void movereg_19_2 () { Reg.Register2 = Reg.Register19; }
method movereg_19_3 (line 729) | public static void movereg_19_3 () { Reg.Register3 = Reg.Register19; }
method movereg_19_4 (line 730) | public static void movereg_19_4 () { Reg.Register4 = Reg.Register19; }
method movereg_19_5 (line 731) | public static void movereg_19_5 () { Reg.Register5 = Reg.Register19; }
method movereg_19_6 (line 732) | public static void movereg_19_6 () { Reg.Register6 = Reg.Register19; }
method movereg_19_7 (line 733) | public static void movereg_19_7 () { Reg.Register7 = Reg.Register19; }
method movereg_19_8 (line 734) | public static void movereg_19_8 () { Reg.Register8 = Reg.Register19; }
method movereg_19_9 (line 735) | public static void movereg_19_9 () { Reg.Register9 = Reg.Register19; }
method movereg_19_10 (line 736) | public static void movereg_19_10 () { Reg.Register10 = Reg.Register19; }
method movereg_19_11 (line 737) | public static void movereg_19_11 () { Reg.Register11 = Reg.Register19; }
method movereg_19_12 (line 738) | public static void movereg_19_12 () { Reg.Register12 = Reg.Register19; }
method movereg_19_13 (line 739) | public static void movereg_19_13 () { Reg.Register13 = Reg.Register19; }
method movereg_19_14 (line 740) | public static void movereg_19_14 () { Reg.Register14 = Reg.Register19; }
method movereg_19_15 (line 741) | public static void movereg_19_15 () { Reg.Register15 = Reg.Register19; }
method movereg_19_16 (line 742) | public static void movereg_19_16 () { Reg.Register16 = Reg.Register19; }
method movereg_19_17 (line 743) | public static void movereg_19_17 () { Reg.Register17 = Reg.Register19; }
method movereg_19_18 (line 744) | public static void movereg_19_18 () { Reg.Register18 = Reg.Register19; }
method movereg_19_20 (line 745) | public static void movereg_19_20 () { Reg.Register20 = Reg.Register19; }
method movereg_19_21 (line 746) | public static void movereg_19_21 () { Reg.Register21 = Reg.Register19; }
method movereg_19_22 (line 747) | public static void movereg_19_22 () { Reg.Register22 = Reg.Register19; }
method movereg_19_23 (line 748) | public static void movereg_19_23 () { Reg.Register23 = Reg.Register19; }
method movereg_19_24 (line 749) | public static void movereg_19_24 () { Reg.Register24 = Reg.Register19; }
method movereg_19_25 (line 750) | public static void movereg_19_25 () { Reg.Register25 = Reg.Register19; }
method movereg_19_26 (line 751) | public static void movereg_19_26 () { Reg.Register26 = Reg.Register19; }
method movereg_19_27 (line 752) | public static void movereg_19_27 () { Reg.Register27 = Reg.Register19; }
method movereg_19_28 (line 753) | public static void movereg_19_28 () { Reg.Register28 = Reg.Register19; }
method movereg_19_29 (line 754) | public static void movereg_19_29 () { Reg.Register29 = Reg.Register19; }
method movereg_19_30 (line 755) | public static void movereg_19_30 () { Reg.Register30 = Reg.Register19; }
method movereg_19_31 (line 756) | public static void movereg_19_31 () { Reg.Register31 = Reg.Register19; }
method movereg_20_1 (line 757) | public static void movereg_20_1 () { Reg.Register1 = Reg.Register20; }
method movereg_20_2 (line 758) | public static void movereg_20_2 () { Reg.Register2 = Reg.Register20; }
method movereg_20_3 (line 759) | public static void movereg_20_3 () { Reg.Register3 = Reg.Register20; }
method movereg_20_4 (line 760) | public static void movereg_20_4 () { Reg.Register4 = Reg.Register20; }
method movereg_20_5 (line 761) | public static void movereg_20_5 () { Reg.Register5 = Reg.Register20; }
method movereg_20_6 (line 762) | public static void movereg_20_6 () { Reg.Register6 = Reg.Register20; }
method movereg_20_7 (line 763) | public static void movereg_20_7 () { Reg.Register7 = Reg.Register20; }
method movereg_20_8 (line 764) | public static void movereg_20_8 () { Reg.Register8 = Reg.Register20; }
method movereg_20_9 (line 765) | public static void movereg_20_9 () { Reg.Register9 = Reg.Register20; }
method movereg_20_10 (line 766) | public static void movereg_20_10 () { Reg.Register10 = Reg.Register20; }
method movereg_20_11 (line 767) | public static void movereg_20_11 () { Reg.Register11 = Reg.Register20; }
method movereg_20_12 (line 768) | public static void movereg_20_12 () { Reg.Register12 = Reg.Register20; }
method movereg_20_13 (line 769) | public static void movereg_20_13 () { Reg.Register13 = Reg.Register20; }
method movereg_20_14 (line 770) | public static void movereg_20_14 () { Reg.Register14 = Reg.Register20; }
method movereg_20_15 (line 771) | public static void movereg_20_15 () { Reg.Register15 = Reg.Register20; }
method movereg_20_16 (line 772) | public static void movereg_20_16 () { Reg.Register16 = Reg.Register20; }
method movereg_20_17 (line 773) | public static void movereg_20_17 () { Reg.Register17 = Reg.Register20; }
method movereg_20_18 (line 774) | public static void movereg_20_18 () { Reg.Register18 = Reg.Register20; }
method movereg_20_19 (line 775) | public static void movereg_20_19 () { Reg.Register19 = Reg.Register20; }
method movereg_20_21 (line 776) | public static void movereg_20_21 () { Reg.Register21 = Reg.Register20; }
method movereg_20_22 (line 777) | public static void movereg_20_22 () { Reg.Register22 = Reg.Register20; }
method movereg_20_23 (line 778) | public static void movereg_20_23 () { Reg.Register23 = Reg.Register20; }
method movereg_20_24 (line 779) | public static void movereg_20_24 () { Reg.Register24 = Reg.Register20; }
method movereg_20_25 (line 780) | public static void movereg_20_25 () { Reg.Register25 = Reg.Register20; }
method movereg_20_26 (line 781) | public static void movereg_20_26 () { Reg.Register26 = Reg.Register20; }
method movereg_20_27 (line 782) | public static void movereg_20_27 () { Reg.Register27 = Reg.Register20; }
method movereg_20_28 (line 783) | public static void movereg_20_28 () { Reg.Register28 = Reg.Register20; }
method movereg_20_29 (line 784) | public static void movereg_20_29 () { Reg.Register29 = Reg.Register20; }
method movereg_20_30 (line 785) | public static void movereg_20_30 () { Reg.Register30 = Reg.Register20; }
method movereg_20_31 (line 786) | public static void movereg_20_31 () { Reg.Register31 = Reg.Register20; }
method movereg_21_1 (line 787) | public static void movereg_21_1 () { Reg.Register1 = Reg.Register21; }
method movereg_21_2 (line 788) | public static void movereg_21_2 () { Reg.Register2 = Reg.Register21; }
method movereg_21_3 (line 789) | public static void movereg_21_3 () { Reg.Register3 = Reg.Register21; }
method movereg_21_4 (line 790) | public static void movereg_21_4 () { Reg.Register4 = Reg.Register21; }
method movereg_21_5 (line 791) | public static void movereg_21_5 () { Reg.Register5 = Reg.Register21; }
method movereg_21_6 (line 792) | public static void movereg_21_6 () { Reg.Register6 = Reg.Register21; }
method movereg_21_7 (line 793) | public static void movereg_21_7 () { Reg.Register7 = Reg.Register21; }
method movereg_21_8 (line 794) | public static void movereg_21_8 () { Reg.Register8 = Reg.Register21; }
method movereg_21_9 (line 795) | public static void movereg_21_9 () { Reg.Register9 = Reg.Register21; }
method movereg_21_10 (line 796) | public static void movereg_21_10 () { Reg.Register10 = Reg.Register21; }
method movereg_21_11 (line 797) | public static void movereg_21_11 () { Reg.Register11 = Reg.Register21; }
method movereg_21_12 (line 798) | public static void movereg_21_12 () { Reg.Register12 = Reg.Register21; }
method movereg_21_13 (line 799) | public static void movereg_21_13 () { Reg.Register13 = Reg.Register21; }
method movereg_21_14 (line 800) | public static void movereg_21_14 () { Reg.Register14 = Reg.Register21; }
method movereg_21_15 (line 801) | public static void movereg_21_15 () { Reg.Register15 = Reg.Register21; }
method movereg_21_16 (line 802) | public static void movereg_21_16 () { Reg.Register16 = Reg.Register21; }
method movereg_21_17 (line 803) | public static void movereg_21_17 () { Reg.Register17 = Reg.Register21; }
method movereg_21_18 (line 804) | public static void movereg_21_18 () { Reg.Register18 = Reg.Register21; }
method movereg_21_19 (line 805) | public static void movereg_21_19 () { Reg.Register19 = Reg.Register21; }
method movereg_21_20 (line 806) | public static void movereg_21_20 () { Reg.Register20 = Reg.Register21; }
method movereg_21_22 (line 807) | public static void movereg_21_22 () { Reg.Register22 = Reg.Register21; }
method movereg_21_23 (line 808) | public static void movereg_21_23 () { Reg.Register23 = Reg.Register21; }
method movereg_21_24 (line 809) | public static void movereg_21_24 () { Reg.Register24 = Reg.Register21; }
method movereg_21_25 (line 810) | public static void movereg_21_25 () { Reg.Register25 = Reg.Register21; }
method movereg_21_26 (line 811) | public static void movereg_21_26 () { Reg.Register26 = Reg.Register21; }
method movereg_21_27 (line 812) | public static void movereg_21_27 () { Reg.Register27 = Reg.Register21; }
method movereg_21_28 (line 813) | public static void movereg_21_28 () { Reg.Register28 = Reg.Register21; }
method movereg_21_29 (line 814) | public static void movereg_21_29 () { Reg.Register29 = Reg.Register21; }
method movereg_21_30 (line 815) | public static void movereg_21_30 () { Reg.Register30 = Reg.Register21; }
method movereg_21_31 (line 816) | public static void movereg_21_31 () { Reg.Register31 = Reg.Register21; }
method movereg_22_1 (line 817) | public static void movereg_22_1 () { Reg.Register1 = Reg.Register22; }
method movereg_22_2 (line 818) | public static void movereg_22_2 () { Reg.Register2 = Reg.Register22; }
method movereg_22_3 (line 819) | public static void movereg_22_3 () { Reg.Register3 = Reg.Register22; }
method movereg_22_4 (line 820) | public static void movereg_22_4 () { Reg.Register4 = Reg.Register22; }
method movereg_22_5 (line 821) | public static void movereg_22_5 () { Reg.Register5 = Reg.Register22; }
method movereg_22_6 (line 822) | public static void movereg_22_6 () { Reg.Register6 = Reg.Register22; }
method movereg_22_7 (line 823) | public static void movereg_22_7 () { Reg.Register7 = Reg.Register22; }
method movereg_22_8 (line 824) | public static void movereg_22_8 () { Reg.Register8 = Reg.Register22; }
method movereg_22_9 (line 825) | public static void movereg_22_9 () { Reg.Register9 = Reg.Register22; }
method movereg_22_10 (line 826) | public static void movereg_22_10 () { Reg.Register10 = Reg.Register22; }
method movereg_22_11 (line 827) | public static void movereg_22_11 () { Reg.Register11 = Reg.Register22; }
method movereg_22_12 (line 828) | public static void movereg_22_12 () { Reg.Register12 = Reg.Register22; }
method movereg_22_13 (line 829) | public static void movereg_22_13 () { Reg.Register13 = Reg.Register22; }
method movereg_22_14 (line 830) | public static void movereg_22_14 () { Reg.Register14 = Reg.Register22; }
method movereg_22_15 (line 831) | public static void movereg_22_15 () { Reg.Register15 = Reg.Register22; }
method movereg_22_16 (line 832) | public static void movereg_22_16 () { Reg.Register16 = Reg.Register22; }
method movereg_22_17 (line 833) | public static void movereg_22_17 () { Reg.Register17 = Reg.Register22; }
method movereg_22_18 (line 834) | public static void movereg_22_18 () { Reg.Register18 = Reg.Register22; }
method movereg_22_19 (line 835) | public static void movereg_22_19 () { Reg.Register19 = Reg.Register22; }
method movereg_22_20 (line 836) | public static void movereg_22_20 () { Reg.Register20 = Reg.Register22; }
method movereg_22_21 (line 837) | public static void movereg_22_21 () { Reg.Register21 = Reg.Register22; }
method movereg_22_23 (line 838) | public static void movereg_22_23 () { Reg.Register23 = Reg.Register22; }
method movereg_22_24 (line 839) | public static void movereg_22_24 () { Reg.Register24 = Reg.Register22; }
method movereg_22_25 (line 840) | public static void movereg_22_25 () { Reg.Register25 = Reg.Register22; }
method movereg_22_26 (line 841) | public static void movereg_22_26 () { Reg.Register26 = Reg.Register22; }
method movereg_22_27 (line 842) | public static void movereg_22_27 () { Reg.Register27 = Reg.Register22; }
method movereg_22_28 (line 843) | public static void movereg_22_28 () { Reg.Register28 = Reg.Register22; }
method movereg_22_29 (line 844) | public static void movereg_22_29 () { Reg.Register29 = Reg.Register22; }
method movereg_22_30 (line 845) | public static void movereg_22_30 () { Reg.Register30 = Reg.Register22; }
method movereg_22_31 (line 846) | public static void movereg_22_31 () { Reg.Register31 = Reg.Register22; }
method movereg_23_1 (line 847) | public static void movereg_23_1 () { Reg.Register1 = Reg.Register23; }
method movereg_23_2 (line 848) | public static void movereg_23_2 () { Reg.Register2 = Reg.Register23; }
method movereg_23_3 (line 849) | public static void movereg_23_3 () { Reg.Register3 = Reg.Register23; }
method movereg_23_4 (line 850) | public static void movereg_23_4 () { Reg.Register4 = Reg.Register23; }
method movereg_23_5 (line 851) | public static void movereg_23_5 () { Reg.Register5 = Reg.Register23; }
method movereg_23_6 (line 852) | public static void movereg_23_6 () { Reg.Register6 = Reg.Register23; }
method movereg_23_7 (line 853) | public static void movereg_23_7 () { Reg.Register7 = Reg.Register23; }
method movereg_23_8 (line 854) | public static void movereg_23_8 () { Reg.Register8 = Reg.Register23; }
method movereg_23_9 (line 855) | public static void movereg_23_9 () { Reg.Register9 = Reg.Register23; }
method movereg_23_10 (line 856) | public static void movereg_23_10 () { Reg.Register10 = Reg.Register23; }
method movereg_23_11 (line 857) | public static void movereg_23_11 () { Reg.Register11 = Reg.Register23; }
method movereg_23_12 (line 858) | public static void movereg_23_12 () { Reg.Register12 = Reg.Register23; }
method movereg_23_13 (line 859) | public static void movereg_23_13 () { Reg.Register13 = Reg.Register23; }
method movereg_23_14 (line 860) | public static void movereg_23_14 () { Reg.Register14 = Reg.Register23; }
method movereg_23_15 (line 861) | public static void movereg_23_15 () { Reg.Register15 = Reg.Register23; }
method movereg_23_16 (line 862) | public static void movereg_23_16 () { Reg.Register16 = Reg.Register23; }
method movereg_23_17 (line 863) | public static void movereg_23_17 () { Reg.Register17 = Reg.Register23; }
method movereg_23_18 (line 864) | public static void movereg_23_18 () { Reg.Register18 = Reg.Register23; }
method movereg_23_19 (line 865) | public static void movereg_23_19 () { Reg.Register19 = Reg.Register23; }
method movereg_23_20 (line 866) | public static void movereg_23_20 () { Reg.Register20 = Reg.Register23; }
method movereg_23_21 (line 867) | public static void movereg_23_21 () { Reg.Register21 = Reg.Register23; }
method movereg_23_22 (line 868) | public static void movereg_23_22 () { Reg.Register22 = Reg.Register23; }
method movereg_23_24 (line 869) | public static void movereg_23_24 () { Reg.Register24 = Reg.Register23; }
method movereg_23_25 (line 870) | public static void movereg_23_25 () { Reg.Register25 = Reg.Register23; }
method movereg_23_26 (line 871) | public static void movereg_23_26 () { Reg.Register26 = Reg.Register23; }
method movereg_23_27 (line 872) | public static void movereg_23_27 () { Reg.Register27 = Reg.Register23; }
method movereg_23_28 (line 873) | public static void movereg_23_28 () { Reg.Register28 = Reg.Register23; }
method movereg_23_29 (line 874) | public static void movereg_23_29 () { Reg.Register29 = Reg.Register23; }
method movereg_23_30 (line 875) | public static void movereg_23_30 () { Reg.Register30 = Reg.Register23; }
method movereg_23_31 (line 876) | public static void movereg_23_31 () { Reg.Register31 = Reg.Register23; }
method movereg_24_1 (line 877) | public static void movereg_24_1 () { Reg.Register1 = Reg.Register24; }
method movereg_24_2 (line 878) | public static void movereg_24_2 () { Reg.Register2 = Reg.Register24; }
method movereg_24_3 (line 879) | public static void movereg_24_3 () { Reg.Register3 = Reg.Register24; }
method movereg_24_4 (line 880) | public static void movereg_24_4 () { Reg.Register4 = Reg.Register24; }
method movereg_24_5 (line 881) | public static void movereg_24_5 () { Reg.Register5 = Reg.Register24; }
method movereg_24_6 (line 882) | public static void movereg_24_6 () { Reg.Register6 = Reg.Register24; }
method movereg_24_7 (line 883) | public static void movereg_24_7 () { Reg.Register7 = Reg.Register24; }
method movereg_24_8 (line 884) | public static void movereg_24_8 () { Reg.Register8 = Reg.Register24; }
method movereg_24_9 (line 885) | public static void movereg_24_9 () { Reg.Register9 = Reg.Register24; }
method movereg_24_10 (line 886) | public static void movereg_24_10 () { Reg.Register10 = Reg.Register24; }
method movereg_24_11 (line 887) | public static void movereg_24_11 () { Reg.Register11 = Reg.Register24; }
method movereg_24_12 (line 888) | public static void movereg_24_12 () { Reg.Register12 = Reg.Register24; }
method movereg_24_13 (line 889) | public static void movereg_24_13 () { Reg.Register13 = Reg.Register24; }
method movereg_24_14 (line 890) | public static void movereg_24_14 () { Reg.Register14 = Reg.Register24; }
method movereg_24_15 (line 891) | public static void movereg_24_15 () { Reg.Register15 = Reg.Register24; }
method movereg_24_16 (line 892) | public static void movereg_24_16 () { Reg.Register16 = Reg.Register24; }
method movereg_24_17 (line 893) | public static void movereg_24_17 () { Reg.Register17 = Reg.Register24; }
method movereg_24_18 (line 894) | public static void movereg_24_18 () { Reg.Register18 = Reg.Register24; }
method movereg_24_19 (line 895) | public static void movereg_24_19 () { Reg.Register19 = Reg.Register24; }
method movereg_24_20 (line 896) | public static void movereg_24_20 () { Reg.Register20 = Reg.Register24; }
method movereg_24_21 (line 897) | public static void movereg_24_21 () { Reg.Register21 = Reg.Register24; }
method movereg_24_22 (line 898) | public static void movereg_24_22 () { Reg.Register22 = Reg.Register24; }
method movereg_24_23 (line 899) | public static void movereg_24_23 () { Reg.Register23 = Reg.Register24; }
method movereg_24_25 (line 900) | public static void movereg_24_25 () { Reg.Register25 = Reg.Register24; }
method movereg_24_26 (line 901) | public static void movereg_24_26 () { Reg.Register26 = Reg.Register24; }
method movereg_24_27 (line 902) | public static void movereg_24_27 () { Reg.Register27 = Reg.Register24; }
method movereg_24_28 (line 903) | public static void movereg_24_28 () { Reg.Register28 = Reg.Register24; }
method movereg_24_29 (line 904) | public static void movereg_24_29 () { Reg.Register29 = Reg.Register24; }
method movereg_24_30 (line 905) | public static void movereg_24_30 () { Reg.Register30 = Reg.Register24; }
method movereg_24_31 (line 906) | public static void movereg_24_31 () { Reg.Register31 = Reg.Register24; }
method movereg_25_1 (line 907) | public static void movereg_25_1 () { Reg.Register1 = Reg.Register25; }
method movereg_25_2 (line 908) | public static void movereg_25_2 () { Reg.Register2 = Reg.Register25; }
method movereg_25_3 (line 909) | public static void movereg_25_3 () { Reg.Register3 = Reg.Register25; }
method movereg_25_4 (line 910) | public static void movereg_25_4 () { Reg.Register4 = Reg.Register25; }
method movereg_25_5 (line 911) | public static void movereg_25_5 () { Reg.Register5 = Reg.Register25; }
method movereg_25_6 (line 912) | public static void movereg_25_6 () { Reg.Register6 = Reg.Register25; }
method movereg_25_7 (line 913) | public static void movereg_25_7 () { Reg.Register7 = Reg.Register25; }
method movereg_25_8 (line 914) | public static void movereg_25_8 () { Reg.Register8 = Reg.Register25; }
method movereg_25_9 (line 915) | public static void movereg_25_9 () { Reg.Register9 = Reg.Register25; }
method movereg_25_10 (line 916) | public static void movereg_25_10 () { Reg.Register10 = Reg.Register25; }
method movereg_25_11 (line 917) | public static void movereg_25_11 () { Reg.Register11 = Reg.Register25; }
method movereg_25_12 (line 918) | public static void movereg_25_12 () { Reg.Register12 = Reg.Register25; }
method movereg_25_13 (line 919) | public static void movereg_25_13 () { Reg.Register13 = Reg.Register25; }
method movereg_25_14 (line 920) | public static void movereg_25_14 () { Reg.Register14 = Reg.Register25; }
method movereg_25_15 (line 921) | public static void movereg_25_15 () { Reg.Register15 = Reg.Register25; }
method movereg_25_16 (line 922) | public static void movereg_25_16 () { Reg.Register16 = Reg.Register25; }
method movereg_25_17 (line 923) | public static void movereg_25_17 () { Reg.Register17 = Reg.Register25; }
method movereg_25_18 (line 924) | public static void movereg_25_18 () { Reg.Register18 = Reg.Register25; }
method movereg_25_19 (line 925) | public static void movereg_25_19 () { Reg.Register19 = Reg.Register25; }
method movereg_25_20 (line 926) | public static void movereg_25_20 () { Reg.Register20 = Reg.Register25; }
method movereg_25_21 (line 927) | public static void movereg_25_21 () { Reg.Register21 = Reg.Register25; }
method movereg_25_22 (line 928) | public static void movereg_25_22 () { Reg.Register22 = Reg.Register25; }
method movereg_25_23 (line 929) | public static void movereg_25_23 () { Reg.Register23 = Reg.Register25; }
method movereg_25_24 (line 930) | public static void movereg_25_24 () { Reg.Register24 = Reg.Register25; }
method movereg_25_26 (line 931) | public static void movereg_25_26 () { Reg.Register26 = Reg.Register25; }
method movereg_25_27 (line 932) | public static void movereg_25_27 () { Reg.Register27 = Reg.Register25; }
method movereg_25_28 (line 933) | public static void movereg_25_28 () { Reg.Register28 = Reg.Register25; }
method movereg_25_29 (line 934) | public static void movereg_25_29 () { Reg.Register29 = Reg.Register25; }
method movereg_25_30 (line 935) | public static void movereg_25_30 () { Reg.Register30 = Reg.Register25; }
method movereg_25_31 (line 936) | public static void movereg_25_31 () { Reg.Register31 = Reg.Register25; }
method movereg_26_1 (line 937) | public static void movereg_26_1 () { Reg.Register1 = Reg.Register26; }
method movereg_26_2 (line 938) | public static void movereg_26_2 () { Reg.Register2 = Reg.Register26; }
method movereg_26_3 (line 939) | public static void movereg_26_3 () { Reg.Register3 = Reg.Register26; }
method movereg_26_4 (line 940) | public static void movereg_26_4 () { Reg.Register4 = Reg.Register26; }
method movereg_26_5 (line 941) | public static void movereg_26_5 () { Reg.Register5 = Reg.Register26; }
method movereg_26_6 (line 942) | public static void movereg_26_6 () { Reg.Register6 = Reg.Register26; }
method movereg_26_7 (line 943) | public static void movereg_26_7 () { Reg.Register7 = Reg.Register26; }
method movereg_26_8 (line 944) | public static void movereg_26_8 () { Reg.Register8 = Reg.Register26; }
method movereg_26_9 (line 945) | public static void movereg_26_9 () { Reg.Register9 = Reg.Register26; }
method movereg_26_10 (line 946) | public static void movereg_26_10 () { Reg.Register10 = Reg.Register26; }
method movereg_26_11 (line 947) | public static void movereg_26_11 () { Reg.Register11 = Reg.Register26; }
method movereg_26_12 (line 948) | public static void movereg_26_12 () { Reg.Register12 = Reg.Register26; }
method movereg_26_13 (line 949) | public static void movereg_26_13 () { Reg.Register13 = Reg.Register26; }
method movereg_26_14 (line 950) | public static void movereg_26_14 () { Reg.Register14 = Reg.Register26; }
method movereg_26_15 (line 951) | public static void movereg_26_15 () { Reg.Register15 = Reg.Register26; }
method movereg_26_16 (line 952) | public static void movereg_26_16 () { Reg.Register16 = Reg.Register26; }
method movereg_26_17 (line 953) | public static void movereg_26_17 () { Reg.Register17 = Reg.Register26; }
method movereg_26_18 (line 954) | public static void movereg_26_18 () { Reg.Register18 = Reg.Register26; }
method movereg_26_19 (line 955) | public static void movereg_26_19 () { Reg.Register19 = Reg.Register26; }
method movereg_26_20 (line 956) | public static void movereg_26_20 () { Reg.Register20 = Reg.Register26; }
method movereg_26_21 (line 957) | public static void movereg_26_21 () { Reg.Register21 = Reg.Register26; }
method movereg_26_22 (line 958) | public static void movereg_26_22 () { Reg.Register22 = Reg.Register26; }
method movereg_26_23 (line 959) | public static void movereg_26_23 () { Reg.Register23 = Reg.Register26; }
method movereg_26_24 (line 960) | public static void movereg_26_24 () { Reg.Register24 = Reg.Register26; }
method movereg_26_25 (line 961) | public static void movereg_26_25 () { Reg.Register25 = Reg.Register26; }
method movereg_26_27 (line 962) | public static void movereg_26_27 () { Reg.Register27 = Reg.Register26; }
method movereg_26_28 (line 963) | public static void movereg_26_28 () { Reg.Register28 = Reg.Register26; }
method movereg_26_29 (line 964) | public static void movereg_26_29 () { Reg.Register29 = Reg.Register26; }
method movereg_26_30 (line 965) | public static void movereg_26_30 () { Reg.Register30 = Reg.Register26; }
method movereg_26_31 (line 966) | public static void movereg_26_31 () { Reg.Register31 = Reg.Register26; }
method movereg_27_1 (line 967) | public static void movereg_27_1 () { Reg.Register1 = Reg.Register27; }
method movereg_27_2 (line 968) | public static void movereg_27_2 () { Reg.Register2 = Reg.Register27; }
method movereg_27_3 (line 969) | public static void movereg_27_3 () { Reg.Register3 = Reg.Register27; }
method movereg_27_4 (line 970) | public static void movereg_27_4 () { Reg.Register4 = Reg.Register27; }
method movereg_27_5 (line 971) | public static void movereg_27_5 () { Reg.Register5 = Reg.Register27; }
method movereg_27_6 (line 972) | public static void movereg_27_6 () { Reg.Register6 = Reg.Register27; }
method movereg_27_7 (line 973) | public static void movereg_27_7 () { Reg.Register7 = Reg.Register27; }
method movereg_27_8 (line 974) | public static void movereg_27_8 () { Reg.Register8 = Reg.Register27; }
method movereg_27_9 (line 975) | public static void movereg_27_9 () { Reg.Register9 = Reg.Register27; }
method movereg_27_10 (line 976) | public static void movereg_27_10 () { Reg.Register10 = Reg.Register27; }
method movereg_27_11 (line 977) | public static void movereg_27_11 () { Reg.Register11 = Reg.Register27; }
method movereg_27_12 (line 978) | public static void movereg_27_12 () { Reg.Register12 = Reg.Register27; }
method movereg_27_13 (line 979) | public static void movereg_27_13 () { Reg.Register13 = Reg.Register27; }
method movereg_27_14 (line 980) | public static void movereg_27_14 () { Reg.Register14 = Reg.Register27; }
method movereg_27_15 (line 981) | public static void movereg_27_15 () { Reg.Register15 = Reg.Register27; }
method movereg_27_16 (line 982) | public static void movereg_27_16 () { Reg.Register16 = Reg.Register27; }
method movereg_27_17 (line 983) | public static void movereg_27_17 () { Reg.Register17 = Reg.Register27; }
method movereg_27_18 (line 984) | public static void movereg_27_18 () { Reg.Register18 = Reg.Register27; }
method movereg_27_19 (line 985) | public static void movereg_27_19 () { Reg.Register19 = Reg.Register27; }
method movereg_27_20 (line 986) | public static void movereg_27_20 () { Reg.Register20 = Reg.Register27; }
method movereg_27_21 (line 987) | public static void movereg_27_21 () { Reg.Register21 = Reg.Register27; }
method movereg_27_22 (line 988) | public static void movereg_27_22 () { Reg.Register22 = Reg.Register27; }
method movereg_27_23 (line 989) | public static void movereg_27_23 () { Reg.Register23 = Reg.Register27; }
method movereg_27_24 (line 990) | public static void movereg_27_24 () { Reg.Register24 = Reg.Register27; }
method movereg_27_25 (line 991) | public static void movereg_27_25 () { Reg.Register25 = Reg.Register27; }
method movereg_27_26 (line 992) | public static void movereg_27_26 () { Reg.Register26 = Reg.Register27; }
method movereg_27_28 (line 993) | public static void movereg_27_28 () { Reg.Register28 = Reg.Register27; }
method movereg_27_29 (line 994) | public static void movereg_27_29 () { Reg.Register29 = Reg.Register27; }
method movereg_27_30 (line 995) | public static void movereg_27_30 () { Reg.Register30 = Reg.Register27; }
method movereg_27_31 (line 996) | public static void movereg_27_31 () { Reg.Register31 = Reg.Register27; }
method movereg_28_1 (line 997) | public static void movereg_28_1 () { Reg.Register1 = Reg.Register28; }
method movereg_28_2 (line 998) | public static void movereg_28_2 () { Reg.Register2 = Reg.Register28; }
method movereg_28_3 (line 999) | public static void movereg_28_3 () { Reg.Register3 = Reg.Register28; }
method movereg_28_4 (line 1000) | public static void movereg_28_4 () { Reg.Register4 = Reg.Register28; }
method movereg_28_5 (line 1001) | public static void movereg_28_5 () { Reg.Register5 = Reg.Register28; }
method movereg_28_6 (line 1002) | public static void movereg_28_6 () { Reg.Register6 = Reg.Register28; }
method movereg_28_7 (line 1003) | public static void movereg_28_7 () { Reg.Register7 = Reg.Register28; }
method movereg_28_8 (line 1004) | public static void movereg_28_8 () { Reg.Register8 = Reg.Register28; }
method movereg_28_9 (line 1005) | public static void movereg_28_9 () { Reg.Register9 = Reg.Register28; }
method movereg_28_10 (line 1006) | public static void movereg_28_10 () { Reg.Register10 = Reg.Register28; }
method movereg_28_11 (line 1007) | public static void movereg_28_11 () { Reg.Register11 = Reg.Register28; }
method movereg_28_12 (line 1008) | public static void movereg_28_12 () { Reg.Register12 = Reg.Register28; }
method movereg_28_13 (line 1009) | public static void movereg_28_13 () { Reg.Register13 = Reg.Register28; }
method movereg_28_14 (line 1010) | public static void movereg_28_14 () { Reg.Register14 = Reg.Register28; }
method movereg_28_15 (line 1011) | public static void movereg_28_15 () { Reg.Register15 = Reg.Register28; }
method movereg_28_16 (line 1012) | public static void movereg_28_16 () { Reg.Register16 = Reg.Register28; }
method movereg_28_17 (line 1013) | public static void movereg_28_17 () { Reg.Register17 = Reg.Register28; }
method movereg_28_18 (line 1014) | public static void movereg_28_18 () { Reg.Register18 = Reg.Register28; }
method movereg_28_19 (line 1015) | public static void movereg_28_19 () { Reg.Register19 = Reg.Register28; }
method movereg_28_20 (line 1016) | public static void movereg_28_20 () { Reg.Register20 = Reg.Register28; }
method movereg_28_21 (line 1017) | public static void movereg_28_21 () { Reg.Register21 = Reg.Register28; }
method movereg_28_22 (line 1018) | public static void movereg_28_22 () { Reg.Register22 = Reg.Register28; }
method movereg_28_23 (line 1019) | public static void movereg_28_23 () { Reg.Register23 = Reg.Register28; }
method movereg_28_24 (line 1020) | public static void movereg_28_24 () { Reg.Register24 = Reg.Register28; }
method movereg_28_25 (line 1021) | public static void movereg_28_25 () { Reg.Register25 = Reg.Register28; }
method movereg_28_26 (line 1022) | public static void movereg_28_26 () { Reg.Register26 = Reg.Register28; }
method movereg_28_27 (line 1023) | public static void movereg_28_27 () { Reg.Register27 = Reg.Register28; }
method movereg_28_29 (line 1024) | public static void movereg_28_29 () { Reg.Register29 = Reg.Register28; }
method movereg_28_30 (line 1025) | public static void movereg_28_30 () { Reg.Register30 = Reg.Register28; }
method movereg_28_31 (line 1026) | public static void movereg_28_31 () { Reg.Register31 = Reg.Register28; }
method movereg_29_1 (line 1027) | public static void movereg_29_1 () { Reg.Register1 = Reg.Register29; }
method movereg_29_2 (line 1028) | public static void movereg_29_2 () { Reg.Register2 = Reg.Register29; }
method movereg_29_3 (line 1029) | public static void movereg_29_3 () { Reg.Register3 = Reg.Register29; }
method movereg_29_4 (line 1030) | public static void movereg_29_4 () { Reg.Register4 = Reg.Register29; }
method movereg_29_5 (line 1031) | public static void movereg_29_5 () { Reg.Register5 = Reg.Register29; }
method movereg_29_6 (line 1032) | public static void movereg_29_6 () { Reg.Register6 = Reg.Register29; }
method movereg_29_7 (line 1033) | public static void movereg_29_7 () { Reg.Register7 = Reg.Register29; }
method movereg_29_8 (line 1034) | public static void movereg_29_8 () { Reg.Register8 = Reg.Register29; }
method movereg_29_9 (line 1035) | public static void movereg_29_9 () { Reg.Register9 = Reg.Register29; }
method movereg_29_10 (line 1036) | public static void movereg_29_10 () { Reg.Register10 = Reg.Register29; }
method movereg_29_11 (line 1037) | public static void movereg_29_11 () { Reg.Register11 = Reg.Register29; }
method movereg_29_12 (line 1038) | public static void movereg_29_12 () { Reg.Register12 = Reg.Register29; }
method movereg_29_13 (line 1039) | public static void movereg_29_13 () { Reg.Register13 = Reg.Register29; }
method movereg_29_14 (line 1040) | public static void movereg_29_14 () { Reg.Register14 = Reg.Register29; }
method movereg_29_15 (line 1041) | public static void movereg_29_15 () { Reg.Register15 = Reg.Register29; }
method movereg_29_16 (line 1042) | public static void movereg_29_16 () { Reg.Register16 = Reg.Register29; }
method movereg_29_17 (line 1043) | public static void movereg_29_17 () { Reg.Register17 = Reg.Register29; }
method movereg_29_18 (line 1044) | public static void movereg_29_18 () { Reg.Register18 = Reg.Register29; }
method movereg_29_19 (line 1045) | public static void movereg_29_19 () { Reg.Register19 = Reg.Register29; }
method movereg_29_20 (line 1046) | public static void movereg_29_20 () { Reg.Register20 = Reg.Register29; }
method movereg_29_21 (line 1047) | public static void movereg_29_21 () { Reg.Register21 = Reg.Register29; }
method movereg_29_22 (line 1048) | public static void movereg_29_22 () { Reg.Register22 = Reg.Register29; }
method movereg_29_23 (line 1049) | public static void movereg_29_23 () { Reg.Register23 = Reg.Register29; }
method movereg_29_24 (line 1050) | public static void movereg_29_24 () { Reg.Register24 = Reg.Register29; }
method movereg_29_25 (line 1051) | public static void movereg_29_25 () { Reg.Register25 = Reg.Register29; }
method movereg_29_26 (line 1052) | public static void movereg_29_26 () { Reg.Register26 = Reg.Register29; }
method movereg_29_27 (line 1053) | public static void movereg_29_27 () { Reg.Register27 = Reg.Register29; }
method movereg_29_28 (line 1054) | public static void movereg_29_28 () { Reg.Register28 = Reg.Register29; }
method movereg_29_30 (line 1055) | public static void movereg_29_30 () { Reg.Register30 = Reg.Register29; }
method movereg_29_31 (line 1056) | public static void movereg_29_31 () { Reg.Register31 = Reg.Register29; }
method movereg_30_1 (line 1057) | public static void movereg_30_1 () { Reg.Register1 = Reg.Register30; }
method movereg_30_2 (line 1058) | public static void movereg_30_2 () { Reg.Register2 = Reg.Register30; }
method movereg_30_3 (line 1059) | public static void movereg_30_3 () { Reg.Register3 = Reg.Register30; }
method movereg_30_4 (line 1060) | public static void movereg_30_4 () { Reg.Register4 = Reg.Register30; }
method movereg_30_5 (line 1061) | public static void movereg_30_5 () { Reg.Register5 = Reg.Register30; }
method movereg_30_6 (line 1062) | public static void movereg_30_6 () { Reg.Register6 = Reg.Register30; }
method movereg_30_7 (line 1063) | public static void movereg_30_7 () { Reg.Register7 = Reg.Register30; }
method movereg_30_8 (line 1064) | public static void movereg_30_8 () { Reg.Register8 = Reg.Register30; }
method movereg_30_9 (line 1065) | public static void movereg_30_9 () { Reg.Register9 = Reg.Register30; }
method movereg_30_10 (line 1066) | public static void movereg_30_10 () { Reg.Register10 = Reg.Register30; }
method movereg_30_11 (line 1067) | public static void movereg_30_11 () { Reg.Register11 = Reg.Register30; }
method movereg_30_12 (line 1068) | public static void movereg_30_12 () { Reg.Register12 = Reg.Register30; }
method movereg_30_13 (line 1069) | public static void movereg_30_13 () { Reg.Register13 = Reg.Register30; }
method movereg_30_14 (line 1070) | public static void movereg_30_14 () { Reg.Register14 = Reg.Register30; }
method movereg_30_15 (line 1071) | public static void movereg_30_15 () { Reg.Register15 = Reg.Register30; }
method movereg_30_16 (line 1072) | public static void movereg_30_16 () { Reg.Register16 = Reg.Register30; }
method movereg_30_17 (line 1073) | public static void movereg_30_17 () { Reg.Register17 = Reg.Register30; }
method movereg_30_18 (line 1074) | public static void movereg_30_18 () { Reg.Register18 = Reg.Register30; }
method movereg_30_19 (line 1075) | public static void movereg_30_19 () { Reg.Register19 = Reg.Register30; }
method movereg_30_20 (line 1076) | public static void movereg_30_20 () { Reg.Register20 = Reg.Register30; }
method movereg_30_21 (line 1077) | public static void movereg_30_21 () { Reg.Register21 = Reg.Register30; }
method movereg_30_22 (line 1078) | public static void movereg_30_22 () { Reg.Register22 = Reg.Register30; }
method movereg_30_23 (line 1079) | public static void movereg_30_23 () { Reg.Register23 = Reg.Register30; }
method movereg_30_24 (line 1080) | public static void movereg_30_24 () { Reg.Register24 = Reg.Register30; }
method movereg_30_25 (line 1081) | public static void movereg_30_25 () { Reg.Register25 = Reg.Register30; }
method movereg_30_26 (line 1082) | public static void movereg_30_26 () { Reg.Register26 = Reg.Register30; }
method movereg_30_27 (line 1083) | public static void movereg_30_27 () { Reg.Register27 = Reg.Register30; }
method movereg_30_28 (line 1084) | public static void movereg_30_28 () { Reg.Register28 = Reg.Register30; }
method movereg_30_29 (line 1085) | public static void movereg_30_29 () { Reg.Register29 = Reg.Register30; }
method movereg_30_31 (line 1086) | public static void movereg_30_31 () { Reg.Register31 = Reg.Register30; }
method movereg_31_1 (line 1087) | public static void movereg_31_1 () { Reg.Register1 = Reg.Register31; }
method movereg_31_2 (line 1088) | public static void movereg_31_2 () { Reg.Register2 = Reg.Register31; }
method movereg_31_3 (line 1089) | public static void movereg_31_3 () { Reg.Register3 = Reg.Register31; }
method movereg_31_4 (line 1090) | public static void movereg_31_4 () { Reg.Register4 = Reg.Register31; }
method movereg_31_5 (line 1091) | public static void movereg_31_5 () { Reg.Register5 = Reg.Register31; }
method movereg_31_6 (line 1092) | public static void movereg_31_6 () { Reg.Register6 = Reg.Register31; }
method movereg_31_7 (line 1093) | public static void movereg_31_7 () { Reg.Register7 = Reg.Register31; }
method movereg_31_8 (line 1094) | public static void movereg_31_8 () { Reg.Register8 = Reg.Register31; }
method movereg_31_9 (line 1095) | public static void movereg_31_9 () { Reg.Register9 = Reg.Register31; }
method movereg_31_10 (line 1096) | public static void movereg_31_10 () { Reg.Register10 = Reg.Register31; }
method movereg_31_11 (line 1097) | public static void movereg_31_11 () { Reg.Register11 = Reg.Register31; }
method movereg_31_12 (line 1098) | public static void movereg_31_12 () { Reg.Register12 = Reg.Register31; }
method movereg_31_13 (line 1099) | public static void movereg_31_13 () { Reg.Register13 = Reg.Register31; }
method movereg_31_14 (line 1100) | public static void movereg_31_14 () { Reg.Register14 = Reg.Register31; }
method movereg_31_15 (line 1101) | public static void movereg_31_15 () { Reg.Register15 = Reg.Register31; }
method movereg_31_16 (line 1102) | public static void movereg_31_16 () { Reg.Register16 = Reg.Register31; }
method movereg_31_17 (line 1103) | public static void movereg_31_17 () { Reg.Register17 = Reg.Register31; }
method movereg_31_18 (line 1104) | public static void movereg_31_18 () { Reg.Register18 = Reg.Register31; }
method movereg_31_19 (line 1105) | public static void movereg_31_19 () { Reg.Register19 = Reg.Register31; }
method movereg_31_20 (line 1106) | public static void movereg_31_20 () { Reg.Register20 = Reg.Register31; }
method movereg_31_21 (line 1107) | public static void movereg_31_21 () { Reg.Register21 = Reg.Register31; }
method movereg_31_22 (line 1108) | public static void movereg_31_22 () { Reg.Register22 = Reg.Register31; }
method movereg_31_23 (line 1109) | public static void movereg_31_23 () { Reg.Register23 = Reg.Register31; }
method movereg_31_24 (line 1110) | public static void movereg_31_24 () { Reg.Register24 = Reg.Register31; }
method movereg_31_25 (line 1111) | public static void movereg_31_25 () { Reg.Register25 = Reg.Register31; }
method movereg_31_26 (line 1112) | public static void movereg_31_26 () { Reg.Register26 = Reg.Register31; }
method movereg_31_27 (line 1113) | public static void movereg_31_27 () { Reg.Register27 = Reg.Register31; }
method movereg_31_28 (line 1114) | public static void movereg_31_28 () { Reg.Register28 = Reg.Register31; }
method movereg_31_29 (line 1115) | public static void movereg_31_29 () { Reg.Register29 = Reg.Register31; }
method movereg_31_30 (line 1116) | public static void movereg_31_30 () { Reg.Register30 = Reg.Register31; }
method invoke (line 1126) | public static CodeAddress invoke (int argc)
method invoke0 (line 1137) | public static CodeAddress invoke0 ()
method invoke1 (line 1148) | public static CodeAddress invoke1 ()
method invoke2 (line 1159) | public static CodeAddress invoke2 ()
method invoke3 (line 1170) | public static CodeAddress invoke3 ()
method invoke4 (line 1181) | public static CodeAddress invoke4 () { return invoke (4); }
method invoke5 (line 1182) | public static CodeAddress invoke5 () { return invoke (5); }
method invoke6 (line 1183) | public static CodeAddress invoke6 () { return invoke (6); }
method invoke7 (line 1184) | public static CodeAddress invoke7 () { return invoke (7); }
method apply (line 1192) | public static CodeAddress apply (int k1, int k2)
method lambda (line 1210) | public static void lambda (CodeVector codevector, int constIndex, int ...
method lexes (line 1241) | public static void lexes(int numRegs)
method lexical (line 1273) | public static void lexical (int rib, int slot)
method setlex (line 1283) | public static void setlex (int rib, int slot)
method argseq (line 1292) | public static void argseq (int n)
method argsge (line 1302) | public static void argsge (int n)
method save (line 1353) | public static void save (int lastslot)
method save0 (line 1358) | public static void save0 () {Cont.save0 ();}
method save1 (line 1359) | public static void save1 () {Cont.save_small (1);}
method save2 (line 1360) | public static void save2 () {Cont.save_small (2);}
method save3 (line 1361) | public static void save3 () {Cont.save_small (3);}
method save4 (line 1362) | public static void save4 () {Cont.save_small (4);}
method save5 (line 1363) | public static void save5 () {Cont.save_small (5);}
method save6 (line 1364) | public static void save6 () {Cont.save_small (6);}
method save7 (line 1365) | public static void save7 () {Cont.save_small (7);}
method pop (line 1367) | public static void pop (int slots)
method pop0 (line 1373) | public static void pop0 () { Cont.cont.SafePop (0); }
method pop1 (line 1374) | public static void pop1 () { Cont.cont.SafePop (1); }
method pop2 (line 1375) | public static void pop2 () { Cont.cont.SafePop (2); }
method pop3 (line 1376) | public static void pop3 () { Cont.cont.SafePop (3); }
method pop4 (line 1377) | public static void pop4 () { Cont.cont.SafePop (4); }
method pop5 (line 1378) | public static void pop5 () { Cont.cont.SafePop (5); }
method pop6 (line 1379) | public static void pop6 () { Cont.cont.SafePop (6); }
method pop7 (line 1380) | public static void pop7 () { Cont.cont.SafePop (7); }
method rtn (line 1382) | public static CodeAddress rtn ()
method setrtn (line 1387) | public static void setrtn (CodeVector code, int index)
method stack1 (line 1396) | public static void stack1 () { Reg.Result = Cont.cont.Slot1; }
method stack2 (line 1397) | public static void stack2 () { Reg.Result = Cont.cont.Slot2; }
method stack3 (line 1398) | public static void stack3 () { Reg.Result = Cont.cont.Slot3; }
method stack4 (line 1399) | public static void stack4 () { Reg.Result = Cont.cont.Slot4; }
method stack5 (line 1400) | public static void stack5 () { Reg.Result = Cont.cont.Slot5; }
method stack6 (line 1401) | public static void stack6 () { Reg.Result = Cont.cont.Slot6; }
method stack7 (line 1402) | public static void stack7 () { Reg.Result = Cont.cont.Slot7; }
method stack (line 1404) | public static void stack (int slot)
method setstk (line 1409) | public static void setstk (int slot)
method load (line 1414) | public static void load (int k, int slot)
method loadm_uniform (line 1420) | public static void loadm_uniform (int k)
method load_0_0 (line 1427) | public static void load_0_0 () { Reg.Register0 = Cont.cont.Slot0; }
method load_1_0 (line 1428) | public static void load_1_0 () { Reg.Register1 = Cont.cont.Slot0; }
method load_2_0 (line 1429) | public static void load_2_0 () { Reg.Register2 = Cont.cont.Slot0; }
method load_3_0 (line 1430) | public static void load_3_0 () { Reg.Register3 = Cont.cont.Slot0; }
method load_4_0 (line 1431) | public static void load_4_0 () { Reg.Register4 = Cont.cont.Slot0; }
method load_5_0 (line 1432) | public static void load_5_0 () { Reg.Register5 = Cont.cont.Slot0; }
method load_6_0 (line 1433) | public static void load_6_0 () { Reg.Register6 = Cont.cont.Slot0; }
method load_7_0 (line 1434) | public static void load_7_0 () { Reg.Register7 = Cont.cont.Slot0; }
method load_8_0 (line 1435) | public static void load_8_0 () { Reg.Register8 = Cont.cont.Slot0; }
method load_9_0 (line 1436) | public static void load_9_0 () { Reg.Register9 = Cont.cont.Slot0; }
method load_10_0 (line 1437) | public static void load_10_0 () { Reg.Register10 = Cont.cont.Slot0; }
method load_11_0 (line 1438) | public static void load_11_0 () { Reg.Register11 = Cont.cont.Slot0; }
method load_12_0 (line 1439) | public static void load_12_0 () { Reg.Register12 = Cont.cont.Slot0; }
method load_13_0 (line 1440) | public static void load_13_0 () { Reg.Register13 = Cont.cont.Slot0; }
method load_14_0 (line 1441) | public static void load_14_0 () { Reg.Register14 = Cont.cont.Slot0; }
method load_15_0 (line 1442) | public static void load_15_0 () { Reg.Register15 = Cont.cont.Slot0; }
method load_16_0 (line 1443) | public static void load_16_0 () { Reg.Register16 = Cont.cont.Slot0; }
method load_17_0 (line 1444) | public static void load_17_0 () { Reg.Register17 = Cont.cont.Slot0; }
method load_18_0 (line 1445) | public static void load_18_0 () { Reg.Register18 = Cont.cont.Slot0; }
method load_19_0 (line 1446) | public static void load_19_0 () { Reg.Register19 = Cont.cont.Slot0; }
method load_20_0 (line 1447) | public static void load_20_0 () { Reg.Register20 = Cont.cont.Slot0; }
method load_21_0 (line 1448) | public static void load_21_0 () { Reg.Register21 = Cont.cont.Slot0; }
method load_22_0 (line 1449) | public static void load_22_0 () { Reg.Register22 = Cont.cont.Slot0; }
method load_23_0 (line 1450) | public static void load_23_0 () { Reg.Register23 = Cont.cont.Slot0; }
method load_24_0 (line 1451) | public static void load_24_0 () { Reg.Register24 = Cont.cont.Slot0; }
method load_25_0 (line 1452) | public static void load_25_0 () { Reg.Register25 = Cont.cont.Slot0; }
method load_26_0 (line 1453) | public static void load_26_0 () { Reg.Register26 = Cont.cont.Slot0; }
method load_27_0 (line 1454) | public static void load_27_0 () { Reg.Register27 = Cont.cont.Slot0; }
method load_28_0 (line 1455) | public static void load_28_0 () { Reg.Register28 = Cont.cont.Slot0; }
method load_29_0 (line 1456) | public static void load_29_0 () { Reg.Register29 = Cont.cont.Slot0; }
method load_30_0 (line 1457) | public static void load_30_0 () { Reg.Register30 = Cont.cont.Slot0; }
method load_31_0 (line 1458) | public static void load_31_0 () { Reg.Register31 = Cont.cont.Slot0; }
method load_0_1 (line 1460) | public static void load_0_1 () { Reg.Register0 = Cont.cont.Slot1; }
method load_1_1 (line 1461) | public static void load_1_1 () { Reg.Register1 = Cont.cont.Slot1; }
method load_2_1 (line 1462) | public static void load_2_1 () { Reg.Register2 = Cont.cont.Slot1; }
method load_3_1 (line 1463) | public static void load_3_1 () { Reg.Register3 = Cont.cont.Slot1; }
method load_4_1 (line 1464) | public static void load_4_1 () { Reg.Register4 = Cont.cont.Slot1; }
method load_5_1 (line 1465) | public static void load_5_1 () { Reg.Register5 = Cont.cont.Slot1; }
method load_6_1 (line 1466) | public static void load_6_1 () { Reg.Register6 = Cont.cont.Slot1; }
method load_7_1 (line 1467) | public static void load_7_1 () { Reg.Register7 = Cont.cont.Slot1; }
method load_8_1 (line 1468) | public static void load_8_1 () { Reg.Register8 = Cont.cont.Slot1; }
method load_9_1 (line 1469) | public static void load_9_1 () { Reg.Register9 = Cont.cont.Slot1; }
method load_10_1 (line 1470) | public static void load_10_1 () { Reg.Register10 = Cont.cont.Slot1; }
method load_11_1 (line 1471) | public static void load_11_1 () { Reg.Register11 = Cont.cont.Slot1; }
method load_12_1 (line 1472) | public static void load_12_1 () { Reg.Register12 = Cont.cont.Slot1; }
method load_13_1 (line 1473) | public static void load_13_1 () { Reg.Register13 = Cont.cont.Slot1; }
method load_14_1 (line 1474) | public static void load_14_1 () { Reg.Register14 = Cont.cont.Slot1; }
method load_15_1 (line 1475) | public static void load_15_1 () { Reg.Register15 = Cont.cont.Slot1; }
method load_16_1 (line 1476) | public static void load_16_1 () { Reg.Register16 = Cont.cont.Slot1; }
method load_17_1 (line 1477) | public static void load_17_1 () { Reg.Register17 = Cont.cont.Slot1; }
method load_18_1 (line 1478) | public static void load_18_1 () { Reg.Register18 = Cont.cont.Slot1; }
method load_19_1 (line 1479) | public static void load_19_1 () { Reg.Register19 = Cont.cont.Slot1; }
method load_20_1 (line 1480) | public static void load_20_1 () { Reg.Register20 = Cont.cont.Slot1; }
method load_21_1 (line 1481) | public static void load_21_1 () { Reg.Register21 = Cont.cont.Slot1; }
method load_22_1 (line 1482) | public static void load_22_1 () { Reg.Register22 = Cont.cont.Slot1; }
method load_23_1 (line 1483) | public static void load_23_1 () { Reg.Register23 = Cont.cont.Slot1; }
method load_24_1 (line 1484) | public static void load_24_1 () { Reg.Register24 = Cont.cont.Slot1; }
method load_25_1 (line 1485) | public static void load_25_1 () { Reg.Register25 = Cont.cont.Slot1; }
method load_26_1 (line 1486) | public static void load_26_1 () { Reg.Register26 = Cont.cont.Slot1; }
method load_27_1 (line 1487) | public static void load_27_1 () { Reg.Register27 = Cont.cont.Slot1; }
method load_28_1 (line 1488) | public static void load_28_1 () { Reg.Register28 = Cont.cont.Slot1; }
method load_29_1 (line 1489) | public static void load_29_1 () { Reg.Register29 = Cont.cont.Slot1; }
method load_30_1 (line 1490) | public static void load_30_1 () { Reg.Register30 = Cont.cont.Slot1; }
method load_31_1 (line 1491) | public static void load_31_1 () { Reg.Register31 = Cont.cont.Slot1; }
method load_0_2 (line 1492) | public static void load_0_2 () { Reg.Register0 = Cont.cont.Slot2; }
method load_1_2 (line 1493) | public static void load_1_2 () { Reg.Register1 = Cont.cont.Slot2; }
method load_2_2 (line 1494) | public static void load_2_2 () { Reg.Register2 = Cont.cont.Slot2; }
method load_3_2 (line 1495) | public static void load_3_2 () { Reg.Register3 = Cont.cont.Slot2; }
method load_4_2 (line 1496) | public static void load_4_2 () { Reg.Register4 = Cont.cont.Slot2; }
method load_5_2 (line 1497) | public static void load_5_2 () { Reg.Register5 = Cont.cont.Slot2; }
method load_6_2 (line 1498) | public static void load_6_2 () { Reg.Register6 = Cont.cont.Slot2; }
method load_7_2 (line 1499) | public static void load_7_2 () { Reg.Register7 = Cont.cont.Slot2; }
method load_8_2 (line 1500) | public static void load_8_2 () { Reg.Register8 = Cont.cont.Slot2; }
method load_9_2 (line 1501) | public static void load_9_2 () { Reg.Register9 = Cont.cont.Slot2; }
method load_10_2 (line 1502) | public static void load_10_2 () { Reg.Register10 = Cont.cont.Slot2; }
method load_11_2 (line 1503) | public static void load_11_2 () { Reg.Register11 = Cont.cont.Slot2; }
method load_12_2 (line 1504) | public static void load_12_2 () { Reg.Register12 = Cont.cont.Slot2; }
method load_13_2 (line 1505) | public static void load_13_2 () { Reg.Register13 = Cont.cont.Slot2; }
method load_14_2 (line 1506) | public static void load_14_2 () { Reg.Register14 = Cont.cont.Slot2; }
method load_15_2 (line 1507) | public static void load_15_2 () { Reg.Register15 = Cont.cont.Slot2; }
method load_16_2 (line 1508) | public static void load_16_2 () { Reg.Register16 = Cont.cont.Slot2; }
method load_17_2 (line 1509) | public static void load_17_2 () { Reg.Register17 = Cont.cont.Slot2; }
method load_18_2 (line 1510) | public static void load_18_2 () { Reg.Register18 = Cont.cont.Slot2; }
method load_19_2 (line 1511) | public static void load_19_2 () { Reg.Register19 = Cont.cont.Slot2; }
method load_20_2 (line 1512) | public static void load_20_2 () { Reg.Register20 = Cont.cont.Slot2; }
method load_21_2 (line 1513) | public static void load_21_2 () { Reg.Register21 = Cont.cont.Slot2; }
method load_22_2 (line 1514) | public static void load_22_2 () { Reg.Register22 = Cont.cont.Slot2; }
method load_23_2 (line 1515) | public static void load_23_2 () { Reg.Register23 = Cont.cont.Slot2; }
method load_24_2 (line 1516) | public static void load_24_2 () { Reg.Register24 = Cont.cont.Slot2; }
method load_25_2 (line 1517) | public static void load_25_2 () { Reg.Register25 = Cont.cont.Slot2; }
method load_26_2 (line 1518) | public static void load_26_2 () { Reg.Register26 = Cont.cont.Slot2; }
method load_27_2 (line 1519) | public static void load_27_2 () { Reg.Register27 = Cont.cont.Slot2; }
method load_28_2 (line 1520) | public static void load_28_2 () { Reg.Register28 = Cont.cont.Slot2; }
method load_29_2 (line 1521) | public static void load_29_2 () { Reg.Register29 = Cont.cont.Slot2; }
method load_30_2 (line 1522) | public static void load_30_2 () { Reg.Register30 = Cont.cont.Slot2; }
method load_31_2 (line 1523) | public static void load_31_2 () { Reg.Register31 = Cont.cont.Slot2; }
method load_0_3 (line 1524) | public static void load_0_3 () { Reg.Register0 = Cont.cont.Slot3; }
method load_1_3 (line 1525) | public static void load_1_3 () { Reg.Register1 = Cont.cont.Slot3; }
method load_2_3 (line 1526) | public static void load_2_3 () { Reg.Register2 = Cont.cont.Slot3; }
method load_3_3 (line 1527) | public static void load_3_3 () { Reg.Register3 = Cont.cont.Slot3; }
method load_4_3 (line 1528) | public static void load_4_3 () { Reg.Register4 = Cont.cont.Slot3; }
method load_5_3 (line 1529) | public static void load_5_3 () { Reg.Register5 = Cont.cont.Slot3; }
method load_6_3 (line 1530) | public static void load_6_3 () { Reg.Register6 = Cont.c
Copy disabled (too large)
Download .json
Condensed preview — 3022 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (58,470K chars).
[
{
"path": ".gitattributes",
"chars": 31,
"preview": "*.sch linguist-language=Scheme\n"
},
{
"path": ".gitignore",
"chars": 944,
"preview": "*~\n*.fasl\n*.slfasl\n*.o\n*.obj\n*.lap\n*.lop\ninclude/asmdefs.h\ninclude/cdefs.h\ninclude/config.ah\ninclude/config.h\ninclude/ex"
},
{
"path": "COPYRIGHT",
"chars": 23171,
"preview": "Copyright 1991, 1994, 1998 William D Clinger\nCopyright 1998 Lars T Hansen\nCopyright 1984 - 1993 Lightsh"
},
{
"path": "README-COMMON-LARCENY.txt",
"chars": 2138,
"preview": "SYSTEM REQUIREMENTS\r\n\r\nCurrently, this software is distributed for\r\n - Windows on Intel x86 machines, Microsoft .NET Fra"
},
{
"path": "README-FIRST.txt",
"chars": 3692,
"preview": "SYSTEM REQUIREMENTS\n\nCurrently, this software is distributed for:\n - Windows on Intel x86 machines (native IA32 backend)"
},
{
"path": "README.md",
"chars": 876,
"preview": "Larceny is a simple and efficient implementation of the Scheme\nprogramming language. It supports the R7RS Red Edition, "
},
{
"path": "compile-larceny",
"chars": 6372,
"preview": "#!/usr/bin/env scheme-script\n\n#!r7rs\n\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;;;\n;;; Usage:\n;;"
},
{
"path": "compile-stale",
"chars": 2222,
"preview": "#!/usr/bin/env scheme-script\n\n#!r7rs\n\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;;;\n;;; Compiles "
},
{
"path": "doc/.gitignore",
"chars": 247,
"preview": "LarcenyNotes/larceny-notes.xml\nUserManual/user-manual.fo\nUserManual/user-manual.xml\nbuilddate.html\nbuildlog.html\nlarceny"
},
{
"path": "doc/CommonLarceny/image-teachpack.html",
"chars": 14702,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\"\r\n \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\r\n<html xmlns=\"htt"
},
{
"path": "doc/CommonLarceny/image-teachpack.txt",
"chars": 8634,
"preview": "= Common Larceny Image Teachpack\r\n\r\nThis teachpack provides primitives for constructing and manipulating images. \r\nVecto"
},
{
"path": "doc/CommonLarceny/user-manual.txt",
"chars": 12768,
"preview": "= Common Larceny User Manual\r\n\r\nThe most recent revision of this manual can always be found at\r\nhttp://larceny.ccs.neu.e"
},
{
"path": "doc/CommonLarceny/world-teachpack.html",
"chars": 10807,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\"\r\n \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\r\n<html xmlns=\"htt"
},
{
"path": "doc/CommonLarceny/world-teachpack.txt",
"chars": 5015,
"preview": "= Common Larceny World Teachpack\r\n\r\nThe world teachpack provides two kinds of functions. Those of the first kind \r\nallow"
},
{
"path": "doc/DevManual/auxlib.txt",
"chars": 1928,
"preview": "Auxiliary Library\n~~~~~~~~~~~~~~~~~\n\n[WARNING]\n================================================================\nMost of "
},
{
"path": "doc/DevManual/bdw.txt",
"chars": 5796,
"preview": "Using the Boehm-Demers-Weiser conservative GC\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nINSERT INTRODUCTORY TEXT HE"
},
{
"path": "doc/DevManual/bytevectors.txt",
"chars": 2667,
"preview": "Bytevectors\n~~~~~~~~~~~\n\nA _bytevector_ is a data structure that stores bytes -- exact\n8-bit unsigned integers. Bytevect"
},
{
"path": "doc/DevManual/compiling.txt",
"chars": 5448,
"preview": "Compiling and Installing Larceny\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nINSERT INTRODUCTORY TEXT HERE (compiling.txt).\n\n[WARN"
},
{
"path": "doc/DevManual/concept.txt",
"chars": 2280,
"preview": "Concept Index \n~~~~~~~~~~~~~\n\n///////////////////////////////////////////////////////////////////////\nWe should be able "
},
{
"path": "doc/DevManual/control.txt",
"chars": 7061,
"preview": "Control Features\n~~~~~~~~~~~~~~~~\n\nFor more information about the countdown timer and timer interrupts, see \nlink:Larcen"
},
{
"path": "doc/DevManual/developing.txt",
"chars": 9007,
"preview": "Using The Development System\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n[WARNING]\n==================================================="
},
{
"path": "doc/DevManual/environ.txt",
"chars": 3484,
"preview": "anchor:environ[]\n\nEnvironments\n~~~~~~~~~~~~\n\nEnvironments are a deprecated feature of Larceny.\n(During Larceny's convers"
},
{
"path": "doc/DevManual/ephemeral.txt",
"chars": 2133,
"preview": "Ephemeral functionality\n~~~~~~~~~~~~~~~~~~~~~~~\n\n[WARNING]\n============================================================="
},
{
"path": "doc/DevManual/lowlevel.txt",
"chars": 1246,
"preview": "Low-level Functionality\n~~~~~~~~~~~~~~~~~~~~~~~\n\nproc:current-continuation-structure[args=\"none\"]\n\nReturns a transparent"
},
{
"path": "doc/DevManual/memstats.txt",
"chars": 4315,
"preview": "# Data Returned by Memstats\n\nThe vector returned from memstats has the content as shown below, ordered by increasing ind"
},
{
"path": "doc/DevManual/nasm-representations.txt",
"chars": 3833,
"preview": "Representations and register assignments for i386\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n2002-11-06\n\n[WARNING"
},
{
"path": "doc/DevManual/procidx.txt",
"chars": 10548,
"preview": "Index of Library Procedures\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n///////////////////////////////////////////////////////////////"
},
{
"path": "doc/DevManual/repl.txt",
"chars": 1801,
"preview": "anchor:repl[]\n\nThe Read-Eval-Print Loop (\"REPL\")\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nanchor:repl-level[]\nindexterm:[repl-"
},
{
"path": "doc/DevManual/starting.txt",
"chars": 9701,
"preview": "Running Larceny\n~~~~~~~~~~~~~~~\n\nWARNING: Some of this section is wildly out of date. But other parts are unchanged. B"
},
{
"path": "doc/DevManual/structures.txt",
"chars": 2805,
"preview": "Structures\n~~~~~~~~~~\n\nLarceny now provides\nhttp://scheme-punks.org/wiki/index.php?title=Main_Page[ERR5RS-compatible]\nre"
},
{
"path": "doc/HOWTO-BUILD",
"chars": 9096,
"preview": "Building Larceny\n\n\nWHAT YOU NEED\n\nMost users of Larceny will never need to build Larceny from source,\nand can ignore thi"
},
{
"path": "doc/HOWTO-ERR5RS",
"chars": 6498,
"preview": "ABOUT ERR5RS\n\nERR5RS is an expeditious revision of the R5RS to fill part\nof the gap that lies between the R5RS and R6RS "
},
{
"path": "doc/HOWTO-FENCE",
"chars": 10276,
"preview": "2 August 2012 / lth@acm.org\n5 May 2015 / WillClinger (updated status)\n\n\nOverview.\n\nThis file contains some information a"
},
{
"path": "doc/HOWTO-INSTALL",
"chars": 4725,
"preview": "Installing Larceny\n\n\nShort version:\n\nPut Larceny's main directory wherever you like, and give it\nwhatever name you like."
},
{
"path": "doc/HOWTO-R6RS",
"chars": 7665,
"preview": "Although Larceny continues to support the R6RS standard, parts\nof that standard (notably lexical syntax) have been super"
},
{
"path": "doc/HOWTO-R7RS",
"chars": 4542,
"preview": "ABOUT R7RS\n\nThe Scheme programming language is described by the R7RS (small)\nstandard, which was approved in 2013 by 86%"
},
{
"path": "doc/HOWTO-SCRIPT",
"chars": 2013,
"preview": "R6RS SCHEME SCRIPTS\n\nOn most Unix systems (including MacOS X and Linux), Larceny's\nscheme-script will execute Scheme scr"
},
{
"path": "doc/HOWTO-SLIB",
"chars": 1972,
"preview": "Installing and using SLIB\n\n\nLarceny supports SLIB via SRFI 96, not via a larceny.init\nfile. That gives the Larceny deve"
},
{
"path": "doc/HOWTO-SRFI",
"chars": 1565,
"preview": "SRFI Support\n\n\nSRFIs, which are Scheme Requests for Implementation, are\nspecifications of libraries that have been desig"
},
{
"path": "doc/KNOWN-BUGS",
"chars": 1406,
"preview": "* Most of the SRFI's require an initial import of\n srfi-0 with the invocation: (require 'srfi-0)\n\n* Not all of the SRFI"
},
{
"path": "doc/LarcenyNotes/generic-add.html",
"chars": 4419,
"preview": "<html>\n<head>\n<title>Code for Generic Add</title>\n</head>\n\n<body>\n<pre>\n! Addition\n! The fixnum case is done in line, so"
},
{
"path": "doc/LarcenyNotes/larceny-notes.txt",
"chars": 1024,
"preview": "Larceny Notes\n=============\nLarceny Developers <larceny@ccs.neu.edu>\n\nThe Larceny Notes are design and user notes for th"
},
{
"path": "doc/LarcenyNotes/note1-timer.html",
"chars": 6803,
"preview": "<html>\n<head>\n<title>Larceny Note #1: Timer Interrupts</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny Note #1: Timer Inte"
},
{
"path": "doc/LarcenyNotes/note10-primops.html",
"chars": 10767,
"preview": "<html>\n<head>\n<title>Larceny Note #10: Adding Primitives</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny Note #10: Adding "
},
{
"path": "doc/LarcenyNotes/note11-bdw.html",
"chars": 1703,
"preview": "<html>\n<head>\n<title>Larceny Note #11: Experiences with the Conservative Collector</title>\n</head>\n\n<body>\n\n<center><h2>"
},
{
"path": "doc/LarcenyNotes/note12-procinfo.html",
"chars": 3042,
"preview": "<html>\n<head>\n<title>Larceny Note #12: Procedure Documentation</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny Note #12: P"
},
{
"path": "doc/LarcenyNotes/note13-malcode.html",
"chars": 14728,
"preview": "<html>\n<head>\n<title>Larceny Note #13: MacScheme Machine Instruction Set</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny N"
},
{
"path": "doc/LarcenyNotes/note14-petit.html",
"chars": 25413,
"preview": "<!-- Copyright 1999 Lars T Hansen -*- indent-tabs-mode: nil -*- -->\n<!-- $id$-->\n<!-- Petit Larceny Architecture-->\n"
},
{
"path": "doc/LarcenyNotes/note2-repr.html",
"chars": 11838,
"preview": "<html>\n<head>\n<title>Larceny Note #2: Data Representations</title>\n<link rev=\"made\" href=\"mailto:larceny@ccs.neu.edu\">\n<"
},
{
"path": "doc/LarcenyNotes/note3-arithmetic.html",
"chars": 9052,
"preview": "<HTML>\n<HEAD>\n<TITLE>Larceny Note #3: Generic arithmetic implementation</TITLE>\n</HEAD>\n\n<BODY>\n\n<center>\n<H2>Larceny No"
},
{
"path": "doc/LarcenyNotes/note4-exceptions.html",
"chars": 7841,
"preview": "<html>\n<head>\n<title>Larceny Note #4: Exceptions and exception handling</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny No"
},
{
"path": "doc/LarcenyNotes/note5-heap.html",
"chars": 1280,
"preview": "<html>\n<head>\n<title>Larceny Note #5: Dumped Heap Images</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny Note #5: Dumped H"
},
{
"path": "doc/LarcenyNotes/note6-sparc.html",
"chars": 21183,
"preview": "<html>\n<head>\n<title>Larceny Note #6: Larceny on the SPARC</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny Note #6: Larcen"
},
{
"path": "doc/LarcenyNotes/note7-ffi.html",
"chars": 39679,
"preview": "<html>\n<head>\n<title>Larceny Note #7: Foreign Function Interfaces</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny Note #7:"
},
{
"path": "doc/LarcenyNotes/note8-release.html",
"chars": 1813,
"preview": "<html>\n<head>\n<title>Larceny Note #8: Larceny Release Procedures</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny Note #8: "
},
{
"path": "doc/LarcenyNotes/note9-iosys.html",
"chars": 9260,
"preview": "<html>\n<head>\n<title>Larceny Note #9: The I/O system</title>\n</head>\n\n<body>\n\n<center>\n<h2>\nLarceny Note #9: The I/O sys"
},
{
"path": "doc/LarcenyNotes/noteX-gc.html",
"chars": 3545,
"preview": "<html>\n<head>\n<title>Larceny: Garbage Collection and Memory Management</title>\n</head>\n\n<body>\n<h2>Garbage Collection an"
},
{
"path": "doc/LarcenyNotes/noteX-newgc.html",
"chars": 11795,
"preview": "<HTML>\n<HEAD>\n<TITLE>Larceny's new garbage collector: design notes</TITLE>\n</HEAD>\n\n<BODY>\n<H2>Larceny's new garbage col"
},
{
"path": "doc/LarcenyNotes/noteX-petit.html",
"chars": 1946,
"preview": "<html>\n<head>\n<title>Petit Larceny</title>\n</head>\n\n<body>\n\n<center>\n<h1>\nPetit Larceny\n</h1>\nlth / 5 October 1998\n</cen"
},
{
"path": "doc/LarcenyNotes/noteX-rts.html",
"chars": 6141,
"preview": "<HTML>\n<HEAD>\n<TITLE>Larceny: Run-time System Overview</TITLE>\n<LINK REV=\"made\" HREF=\"mailto:larceny@ccs.neu.edu\">\n</HEA"
},
{
"path": "doc/LarcenyNotes/noteX-sc-heap.html",
"chars": 6278,
"preview": "<html>\n<head>\n<title>Larceny: Stop-and-copy heap: Design Notes</title>\n</head>\n\n<body>\n\n<h2>Stop-and-copy Heap: Design N"
},
{
"path": "doc/LarcenyNotes/template.html",
"chars": 291,
"preview": "<html>\n<head>\n<title>Larceny Note #XXX: XXX</title>\n</head>\n\n<body>\n\n<center><h2>\nLarceny Note #XXX: XXX\n</h2>\nAuthor / "
},
{
"path": "doc/Makefile",
"chars": 4615,
"preview": "# This Makefile is known to work\n# for the target(s): artichoke \n# and for the users: pnkfelix henchman \n#\n# It would be"
},
{
"path": "doc/OldDocs/BUGS",
"chars": 27941,
"preview": "\nCopyright 1998 Lars T Hansen. -*- text -*-\n\n$Id$\n\n\n\t\t\t KNOWN BUGS IN LARCENY\n\n\nThese are bugs that ar"
},
{
"path": "doc/OldDocs/BUGS-FIXED",
"chars": 77069,
"preview": "Copyright 1998 Lars T Hansen. -*- text -*-\n\n$Id$\n\n\t Known bugs in Larceny that have been fixed.\n\n\t "
},
{
"path": "doc/OldDocs/BUGS-RETIRED",
"chars": 14653,
"preview": "Copyright 1998 Lars T Hansen. -*- text -*-\n\n$Id$\n\n\n\t\t\t List of bugs retired\n\t\t (not fixed but no longer "
},
{
"path": "doc/OldDocs/HOWTO-BUILD",
"chars": 4787,
"preview": "Building and using Larceny and Petit Larceny\n12 December 2004 / lth\n\n\nHOW TO BUILD LARCENY AND USE THE BUILD ENVIRONMENT"
},
{
"path": "doc/OldDocs/HOWTO-CVS",
"chars": 3864,
"preview": "$Id$\n\n\nThis is the file ${LARCENY}/HOWTO-CVS. It contains information about\nhow to get started with CVS and how CVS is "
},
{
"path": "doc/OldDocs/HOWTO-I386",
"chars": 13679,
"preview": "Information about native Larceny on Intel 386-class systems\n12 December 2004 / lth\n\n\nINTRODUCTION.\n\nThere is a version P"
},
{
"path": "doc/OldDocs/HOWTO-MACOSX",
"chars": 1470,
"preview": "Information about Petit Larceny on MacOS X\n25 November 2004 / lth\n\nNOTE FOR Mac OS X 10.4 (Tiger) USERS:\nThe version of "
},
{
"path": "doc/OldDocs/HOWTO-PETIT",
"chars": 7225,
"preview": "Building and using Petit Larceny\n23 November 2004 / lth\n\n\nHOW TO BUILD PETIT LARCENY AND USE THE BUILD ENVIRONMENT\n\nGene"
},
{
"path": "doc/OldDocs/HOWTO-PPC",
"chars": 3194,
"preview": "Information about native Larceny on PPC systems\n2 July 2004 / lth\n\n\nI've done nothing here yet. I would like to use the"
},
{
"path": "doc/OldDocs/HOWTO-SCREEN",
"chars": 1491,
"preview": "Information about how to use SCREEN.\n$Id$\n\n\n\"screen\" is a useful program for managing one or more long-running\ncomputati"
},
{
"path": "doc/OldDocs/HOWTO-SPARC",
"chars": 3250,
"preview": "Building and using SPARC-native Larceny\n24 November 2004 / lth\n\n\nHOW TO BUILD LARCENY AND USE THE BUILD ENVIRONMENT\n\nGen"
},
{
"path": "doc/OldDocs/HOWTO-UNIX",
"chars": 3542,
"preview": "Information about Petit Larceny on Unix systems\n23 November 2004 / lth\n\n\nHOW TO BUILD AND USE.\n\nSee HOWTO-BUILD and HOWT"
},
{
"path": "doc/OldDocs/HOWTO-WIN32",
"chars": 8972,
"preview": "Information about Petit Larceny on Win32\n29 November 2004 / lth\n\n\nHOW TO BUILD\n\nSee HOWTO-BUILD and HOWTO-PETIT for info"
},
{
"path": "doc/OldDocs/TODO",
"chars": 39616,
"preview": "Copyright 1998 Lars T Hansen. -*- Indented-Text -*-\n\n$Id$\n\n\n\t\t\tGrand Unified TO-DO List\n\n\nThis is the Gra"
},
{
"path": "doc/OldDocs/TODO-PETIT",
"chars": 5684,
"preview": "$Id$\n\nTODO / IN PROGRESS\n28 July 2003 / lth\n\nPetit Larceny on Sparc/Solaris and other big-endian Unix:\n - have defined U"
},
{
"path": "doc/OldDocs/TODO-RAINYDAY",
"chars": 3310,
"preview": "; -*- Text -*-\n; \n; $Id$\n\n\n\t Rainy day projects for the Larceny hacker\n\n\nProjects currently under-way (not up-to-d"
},
{
"path": "doc/OldDocs/TODO-RELEASE",
"chars": 4657,
"preview": "$Id$\n\nRelease 2 todo and check lists\n\nThings That Must Be Done (tm) aka Significant Usability Bugs (r)\n\n * Test Win32 po"
},
{
"path": "doc/OldDocs/USER-REQUESTS",
"chars": 2597,
"preview": "-*- text -*-\n\n$Id$\n\n\n\t\t LIST OF USER REQUESTS FOR LARCENY\n\n\nThis is the list of (largely minor) requests for larceny t"
},
{
"path": "doc/UserManual/benchmarking.txt",
"chars": 1534,
"preview": "[[LarcenyBenchmarkingSection]]\n\nBenchmarking\n~~~~~~~~~~~~\n\nThe `(larceny benchmarking)` library exports the\n`time` synta"
},
{
"path": "doc/UserManual/bytevectors.txt",
"chars": 2903,
"preview": "Bytevectors\n~~~~~~~~~~~\n\nA _bytevector_ is a data structure that stores bytes -- exact\n8-bit unsigned integers. Bytevect"
},
{
"path": "doc/UserManual/compiler.txt",
"chars": 10806,
"preview": "[[LarcenyCompilerSection]]\n\nCompiler\n~~~~~~~~\n\nThe `(larceny compiler)` library exports the\n`load` and `r5rs:require` pr"
},
{
"path": "doc/UserManual/compiling.txt",
"chars": 8544,
"preview": "[[CompilingChapter]]\n\nCompiling Files and Libraries\n-----------------------------\n\nThis chapter explains how you can use"
},
{
"path": "doc/UserManual/debugging.txt",
"chars": 5055,
"preview": "[[DebuggingChapter]]\n\nDebugging\n---------\n\nLarceny's debugging functionality is implemented in Scheme, using some\nof Lar"
},
{
"path": "doc/UserManual/draft.txt",
"chars": 2272,
"preview": "# Larceny User's Manual\n\nLarceny provides all of the required and optional parts of Scheme as described in the [Revised^"
},
{
"path": "doc/UserManual/entry.txt",
"chars": 61,
"preview": "proc:FIXME[args=\"FIXME ...\",result=\"FIXME\"]\n\n ***Desc***\n"
},
{
"path": "doc/UserManual/err5rs.txt",
"chars": 11142,
"preview": "[[Err5rsChapter]]\n\nERR5RS Standard Libraries\n-------------------------\n\n<<Standards,ERR5RS>> has been superseded by the "
},
{
"path": "doc/UserManual/ffi.txt",
"chars": 47793,
"preview": "[[FfiChapter]]\n\nForeign-Function Interface to C\n-------------------------------\n\nLarceny provides a general foreign-func"
},
{
"path": "doc/UserManual/fixnums.txt",
"chars": 3968,
"preview": "[[FixnumPrimitives]]\nFixnum primitives\n~~~~~~~~~~~~~~~~~\n\nFixnums are small exact integers that are likely to be\nreprese"
},
{
"path": "doc/UserManual/hashtable.txt",
"chars": 5601,
"preview": "Hashtables and hash functions\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nHashtables represent finite mappings from keys to values.\nI"
},
{
"path": "doc/UserManual/ieee-std.txt",
"chars": 2742,
"preview": "////////////////////////////////////////////////////////////////\n_$Id$_ \n//////////////////////////////////////////////"
},
{
"path": "doc/UserManual/intro.txt",
"chars": 9335,
"preview": "[[InstallationChapter]]\n\nInstalling Larceny\n------------------\n\n[[VarietiesSection]]\n\nVarieties of Larceny\n~~~~~~~~~~~~~"
},
{
"path": "doc/UserManual/io.txt",
"chars": 5419,
"preview": "Input, Output, and Files\n~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe `(scheme base)`, `(scheme file)`, `(rnrs io ports)`,\nand `(rnrs f"
},
{
"path": "doc/UserManual/lexical.txt",
"chars": 6450,
"preview": "[[LexicalChapter]]\n\nLexical syntax\n--------------\n\nLarceny's default lexical syntax extends the lexical syntax\nrequired "
},
{
"path": "doc/UserManual/libraries.txt",
"chars": 21054,
"preview": "[[LibrariesChapter]]\n\nR7RS/R6RS Libraries\n-------------------\n\nThe R6RS standard added a `library` mechanism for batch p"
},
{
"path": "doc/UserManual/load.txt",
"chars": 1497,
"preview": "[[LarcenyLoadSection]]\n\nLoad\n~~~~\n\nThe `(larceny load)` library exports both the\n`load` procedure of `(scheme load)`\nand"
},
{
"path": "doc/UserManual/naming.txt",
"chars": 13750,
"preview": "[[NamingChapter]]\n\nFile Naming Conventions\n-----------------------\n\n\n[[SuffixSection]]\n\nSuffixes\n~~~~~~~~\n\nIn Larceny, f"
},
{
"path": "doc/UserManual/numbers.txt",
"chars": 1072,
"preview": "Numbers\n~~~~~~~\n\nLarceny has six representations for numbers: _fixnums_ are small,\nexact integers; _bignums_ are unlimit"
},
{
"path": "doc/UserManual/os.txt",
"chars": 2245,
"preview": "Operating System Interface\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nproc:command-line-arguments[args=\"\",result=\"vector\"]\n\nReturns a v"
},
{
"path": "doc/UserManual/pairs_lists.txt",
"chars": 2899,
"preview": "Pairs and Lists\n~~~~~~~~~~~~~~~\n\nThe `(scheme list)` and `(rnrs lists)` libraries now\nprovide a set of procedures that m"
},
{
"path": "doc/UserManual/parameters.txt",
"chars": 3946,
"preview": "Parameters\n~~~~~~~~~~\n\nParameters are procedures that serve as containers for values.\n\nWhen called with no arguments, a "
},
{
"path": "doc/UserManual/procedures.txt",
"chars": 4338,
"preview": "Procedures\n~~~~~~~~~~\n\n_Operations on procedures_\n\nproctempl:make-procedure[args=\"length\",result=\"procedure\"]\nproctempl:"
},
{
"path": "doc/UserManual/procidx.txt",
"chars": 10503,
"preview": "Index of Library Procedures\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n///////////////////////////////////////////////////////////////"
},
{
"path": "doc/UserManual/proplist.txt",
"chars": 888,
"preview": "Property Lists\n~~~~~~~~~~~~~~\n\nThe _property list_ of a symbol is an association list that is\nattached to that symbol. T"
},
{
"path": "doc/UserManual/r6rs.txt",
"chars": 12653,
"preview": "[[R6rsChapter]]\n\nR6RS Standard Libraries\n-----------------------\n\nThis chapter explains which features of the R6RS stand"
},
{
"path": "doc/UserManual/r7rs.txt",
"chars": 10161,
"preview": "[[R7rsChapter]]\n\nR7RS Standard Libraries\n-----------------------\n\nThe R7RS standard libraries are described by the\n<<Sta"
},
{
"path": "doc/UserManual/records.txt",
"chars": 7416,
"preview": "Records\n~~~~~~~\n\nThe `(scheme base)`, `(srfi 9)`, `(srfi 99)`, `(srfi 131)`,\n`(rnrs records procedural)`, and `(rnrs rec"
},
{
"path": "doc/UserManual/recprinter.txt",
"chars": 803,
"preview": "[[RecordsPrinterSection]]\n\nRecords printer\n~~~~~~~~~~~~~~~\n\nThe `(larceny records printer)` library exports the\ntwo proc"
},
{
"path": "doc/UserManual/running.txt",
"chars": 21434,
"preview": "[[RunningChapter]]\n\nRunning Larceny\n---------------\n\nFor a summary of Larceny's command-line options, ask for help:\n\n---"
},
{
"path": "doc/UserManual/slib.txt",
"chars": 445,
"preview": "SLIB support\n~~~~~~~~~~~~\n\nhttp://www-swiss.ai.mit.edu/~jaffer/SLIB.html[SLIB]\nis a large collection of useful libraries"
},
{
"path": "doc/UserManual/sorting.txt",
"chars": 721,
"preview": "Sorting\n~~~~~~~\n\nThe `(scheme sort)` and `(rnrs sorting)` libraries now\nprovide procedures that supersede those describe"
},
{
"path": "doc/UserManual/sparc-cache.txt",
"chars": 1110,
"preview": "## Sparc cache flush issues (obscure)\n\nLarceny detects whether cache flushing is necessary on your machine. You can also"
},
{
"path": "doc/UserManual/srfi.txt",
"chars": 2085,
"preview": "SRFI Support\n~~~~~~~~~~~~\n\nSRFIs (Scheme Requests For Implementations) describe and implement\nadditional Scheme librarie"
},
{
"path": "doc/UserManual/starting.txt",
"chars": 9689,
"preview": "Running Larceny\n~~~~~~~~~~~~~~~\n\nWARNING: Some of this section is wildly out of date. But other parts are unchanged. B"
},
{
"path": "doc/UserManual/strings.txt",
"chars": 416,
"preview": "Strings\n~~~~~~~\n\nLarceny provides Unicode strings with\nhttp://www.scheme-reports.org/[R7RS]\nand\nhttp://www.r6rs.org/[R6R"
},
{
"path": "doc/UserManual/symbols.txt",
"chars": 641,
"preview": "Symbols\n~~~~~~~\n\nproc:gensym[args=\"string\",result=\"symbol\"]\n\nGensym returns a new uninterned symbol, the name of which c"
},
{
"path": "doc/UserManual/syscontrol.txt",
"chars": 9973,
"preview": "System Control and Performance Measurement\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nproc:collect[args=\"\",result=\"unsp"
},
{
"path": "doc/UserManual/template.txt",
"chars": 90,
"preview": "# FIXME\n\n* * *\n\n_$Id$_ \n[larceny@ccs.neu.edu][1] \n\n\n [1]: mailto:larceny@ccs.neu.edu\n\n"
},
{
"path": "doc/UserManual/unprovided.txt",
"chars": 238,
"preview": "# Unprovided Procedures\n\nThere are presently no procedures from the Revised^4 Report, Revised^5 Report, or IEEE Standard"
},
{
"path": "doc/UserManual/user-manual.txt",
"chars": 4543,
"preview": "////////////////////////////////////////////////////////////////\nLarceny User Manual\n\n$Id$\n\nFor documentation on AsciiDo"
},
{
"path": "doc/UserManual/vectors.txt",
"chars": 1303,
"preview": "Vectors\n~~~~~~~\n\nThe `(scheme vector)` library now\nprovides a set of procedures that may supersede some\nof the procedure"
},
{
"path": "doc/index.html",
"chars": 1334,
"preview": "<html>\n<head>\n<title>Larceny Documentation</title>\n<body>\n\n<!--\nThese are <a href=\"builddate.html\">autobuilt</a>\ncopies "
},
{
"path": "doc/larcenydoc.conf",
"chars": 3901,
"preview": "# Run with this configuration file by typing:\n# a2x --asciidoc-opts=--conf-file=larcenydoc.conf -f pdf -D . UserManu"
},
{
"path": "examples/CommonLarceny/event-handling-demo1.sch",
"chars": 2365,
"preview": "(clr/%load-assembly \"System.Windows.Forms\" \"2.0.0.0\" \"\" \"b77a5c561934e089\")\n\n(define form-type (find-clr-"
},
{
"path": "examples/CommonLarceny/event-handling-demo2.sch",
"chars": 1668,
"preview": "(define (add-event-handler publisher event-name procedure) \n (clr/%add-event-handler (clr-object/clr-handle publisher) "
},
{
"path": "examples/CommonLarceny/form-graphics.sch",
"chars": 3627,
"preview": ";; helper functions\n(define (find-clr-color name)\n (let ((name (if (symbol? name) (symbol->string name) name)))\n (cl"
},
{
"path": "include/Nasm/i386-instr.ah",
"chars": 50089,
"preview": ";;; NASM/i386 macros for the MacScheme instruction set.\n;;;\n;;; $Id$\n;;; \n;;; On the i386 architecture, the Twobit nativ"
},
{
"path": "include/Shared/i386-machine.ah",
"chars": 2897,
"preview": "; -*- mode: asm -*-\n;\n; Copyright 2003 Lars T Hansen\n; Machine description for x86-nasm port of Larceny.\n;\n; $Id$\n;\n; No"
},
{
"path": "include/Shared/millicode.h",
"chars": 15266,
"preview": "/* Copyright 1998 Lars T Hansen.\n *\n * $Id$\n *\n * Petit Larceny -- run-time-support prototypes.\n */\n\n#ifndef MILLICODE_H"
},
{
"path": "include/Shared/petit-config.h",
"chars": 5588,
"preview": "/* Copyright 1998 Lars T Hansen.\n *\n * $Id$\n *\n * Petit Larceny control-flow discipline configuration.\n */\n\n#ifndef PETI"
},
{
"path": "include/Shared/petit-machine.h",
"chars": 2595,
"preview": "/* Copyright 1998 Lars T Hansen.\n *\n * $Id$\n *\n * Abstractions for the instruction macros defined in twobit.h. The\n * d"
},
{
"path": "include/Standard-C/petit-instr.h",
"chars": 71533,
"preview": "/* Copyright 1998 Lars T Hansen.\n * \n * $Id$\n *\n * Petit Larceny -- Twobit instruction and primitive macros.\n *\n * The a"
},
{
"path": "include/Sys/larceny-types.h",
"chars": 4496,
"preview": "/* Copyright 1998 Lars T Hansen.\n *\n * $Id$\n *\n * Larceny run-time system -- Opaque type declarations.\n */\n\n#ifndef INCL"
},
{
"path": "include/Sys/macros.h",
"chars": 5086,
"preview": "/* Copyright 1998 Lars T Hansen.\n *\n * $Id$\n *\n * Larceny run-time system -- macros\n *\n * Machine and representation dep"
},
{
"path": "lib/Base/defaults.sch",
"chars": 1090,
"preview": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;\n; $Id$\n;\n; Default parameter settings for all heap im"
},
{
"path": "lib/Base/dotnet-compile-file.sch",
"chars": 1738,
"preview": ";; This file defines a (hackish) implementation of COMPILE-FILE that\n;; should work out-of-the-box.\n\n;; pass1-block must"
},
{
"path": "lib/Base/format.sch",
"chars": 665,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Useful formatting procedures.\n\n(define (format-left-justified x n . rest)\n "
},
{
"path": "lib/Base/io.sch",
"chars": 2920,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Useful I/O procedures.\n\n; Read the next line and return it as a string, wit"
},
{
"path": "lib/Base/list.sch",
"chars": 3870,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Useful list functions.\n;\n; Notes:\n; * Reduce, reduce-right, fold-right, fol"
},
{
"path": "lib/Base/load.sch",
"chars": 5791,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; A smart-but-not-intelligent 'load' procedure.\n;\n; Exported procedures:\n; "
},
{
"path": "lib/Base/macros.sch",
"chars": 819,
"preview": "; Copyright 1998 Lars T Hansen\n;\n; $Id$\n;\n; A collection of useful and common macros.\n;\n; Some macros that used to be he"
},
{
"path": "lib/Base/misc.sch",
"chars": 518,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Miscellaneous functions and constants.\n\n;;; System information procedures.\n"
},
{
"path": "lib/Base/osdep-macos.sch",
"chars": 1011,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Operating-system-dependent functionality for Macintosh.\n\n; A \"file name\" is"
},
{
"path": "lib/Base/osdep-unix.sch",
"chars": 1955,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Operating-system-dependent functionality for Unix.\n\n; A \"file name\" is a st"
},
{
"path": "lib/Base/osdep-win32.sch",
"chars": 2319,
"preview": "; Copyright 2006 Jesse A Tov and Felix S Klock.\n; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Operating-system-dependent "
},
{
"path": "lib/Base/petit-compile-file.sch",
"chars": 1198,
"preview": ";; This file defines a (hackish) implementation of COMPILE-FILE that\n;; should work out-of-the-box, provided CURRENT-LAR"
},
{
"path": "lib/Base/pp.sch",
"chars": 16250,
"preview": "; Copyright (c) 1991, Marc Feeley. -*- indent-tabs-mode: nil -*-\n; \n; Permission to copy this software, in wh"
},
{
"path": "lib/Base/process-stats.sch",
"chars": 13999,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Accessor procedures for the statistics dump output format as generated\n; by"
},
{
"path": "lib/Base/shivers-syntax.sch",
"chars": 5679,
"preview": "; Syntax that tends to occur in SRFIs written by Olin Shivers :-)\n; 2004-01-02 / lth and others, see below\n\n(define-synt"
},
{
"path": "lib/Base/std-ffi.sch",
"chars": 27322,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Simple C callout interface to the FFI system.\n;\n; This file must be loaded "
},
{
"path": "lib/Base/string.sch",
"chars": 2419,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Useful string functions\n\n; (substring-match s1 s2) => i iff \n; (string="
},
{
"path": "lib/Base/unix-functions.sch",
"chars": 1809,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Some Unix functionality imported as foreign function.\n\n; CD and PWD\n; Simul"
},
{
"path": "lib/Base/vector.sch",
"chars": 323,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Useful vector functions.\n\n; This is now standard (with variable arity) in R"
},
{
"path": "lib/Broken/nonblocking-console.sch",
"chars": 1639,
"preview": "; Copyright 1999 Lars T Hansen\n;\n; $Id$\n\n(require 'experimental/iosys)\n(require 'experimental/unix)\n(require 'experiment"
},
{
"path": "lib/Broken/read-circular.sch",
"chars": 3281,
"preview": "; Copyright 1999 Lars T Hansen\n;\n; $Id$\n;\n; Reader for circular and shared structures.\n;\n; The syntax #n=<object> makes "
},
{
"path": "lib/Broken/read-source.sch",
"chars": 1082,
"preview": "; Copyright 1999 Lars T Hansen\n;\n; $Id$\n;\n; Read source code and return both datum and source locations\n\n; Returns two v"
},
{
"path": "lib/Broken/task-test.sch",
"chars": 3163,
"preview": "; Copyright 1999 Lars T Hansen\n;\n; $Id$\n;\n; Test program to exhibit the nonblocking I/O system and tasking along \n; with"
},
{
"path": "lib/Broken/task-test2.sch",
"chars": 3206,
"preview": "; Copyright 1999 Lars T Hansen\n;\n; $Id$\n;\n; This uses a quasi-cooperative KILL to stop the threads, which is really\n; th"
},
{
"path": "lib/Broken/transcript.sch",
"chars": 4118,
"preview": "; Copyright 1999 Lars T Hansen\n;\n; $Id$\n;\n; Transcript ports. Simple implementation based on user ports and\n; a nested "
},
{
"path": "lib/Broken/unix-descriptor.sch",
"chars": 3742,
"preview": "; Copyright 1999 Lars T Hansen\n; \n; $Id$\n;\n; Code that creates blocking and nonblocking ports on Unix file descriptors.\n"
},
{
"path": "lib/Debugger/call-cc.sch",
"chars": 6149,
"preview": "; Proof-of-concept code; do not toss.\n; 9 June 1999 / lth\n\n; This file defines an experimental implementation of the CON"
},
{
"path": "lib/Debugger/countcalls.sch",
"chars": 4792,
"preview": "; Copyright 1998 William D Clinger.\n;\n; $Id$\n;\n; Call count profiling of top-level named procedures.\n; This code must be"
},
{
"path": "lib/Debugger/debug-info.txt",
"chars": 2332,
"preview": "This is the file Debugger/debug-info.txt\n$Id$\n\nInformation to allow debugger to print variable names and values\n\nThree s"
},
{
"path": "lib/Debugger/debug.sch",
"chars": 13744,
"preview": "; Copyright 1998 Lars T Hansen\n;\n; $Id$\n;\n; Bare-bones debugger.\n;\n; The debugger will be invoked automatically when an "
},
{
"path": "lib/Debugger/debugging.txt",
"chars": 3338,
"preview": "Debugging.\n\nSome things that are important:\n * Trace procedures rather than names. [DONE]\n * "
},
{
"path": "lib/Debugger/inspect-cont.sch",
"chars": 5292,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Continuation and frame inspector.\n\n; Continuation inspector.\n;\n; (c 'type) "
},
{
"path": "lib/Debugger/new-debugger.sch",
"chars": 969,
"preview": "; A thought experiment.\n\n(define install-debugger)\n(define uninstall-debugger)\n\n(let ((old-evaluator #f))\n (set! instal"
},
{
"path": "lib/Debugger/profile.sch",
"chars": 6102,
"preview": "; Copyright 2008 Felix S Klock II\n;\n; $Id$\n;\n; Extremely rough but slightly useful prototype of procedure\n; profiling.\n;"
},
{
"path": "lib/Debugger/trace.sch",
"chars": 12263,
"preview": "; Copyright 1999 Lars T Hansen\n;\n; $Id$\n;\n; Trace and breakpoint facilities for Larceny.\n;\n; (trace <proc>) "
},
{
"path": "lib/Debugger/variables.sch",
"chars": 6749,
"preview": "; Support for variable names in the debugger -- preliminary.\n;\n; A hack has been inserted in cg-lambda in pass4p1.sch th"
},
{
"path": "lib/Experimental/Beginning/beginning.txt",
"chars": 6932,
"preview": "Beginning Student Language\n\n* PROGRAM\n* DEF-OR-EXP ...\n* DEF-OR-EXP\n* DEFINITION\n* EXPRESSION\n* DEFINITION\n* (define (NA"
},
{
"path": "lib/Experimental/Beginning/colors.txt",
"chars": 1654,
"preview": "From schanzer@ccs.neu.edu Tue Jun 10 13:15:48 2008\nReturn-path: <schanzer@ccs.neu.edu>\nX-Spam-Checker-Version: SpamAssas"
},
{
"path": "lib/Experimental/Beginning/interpreter.sch",
"chars": 12559,
"preview": "; A simple interpreter for the beginning student language.\n;\n; Uses ERR5RS records.\n; Uses R6RS hashtables.\n; Uses the f"
},
{
"path": "lib/Experimental/Beginning/loadall.sch",
"chars": 158,
"preview": "; Loads interpreter etc for the beginning language.\n\n(load \"posn.sch\")\n(load \"syntax.sch\")\n(load \"interpreter.sch\")\n(loa"
},
{
"path": "lib/Experimental/Beginning/posn.sch",
"chars": 322,
"preview": "; The posn data type for the beginning student language.\n;\n; Uses ERR5RS records.\n\n(define rtd:posn (make-rtd 'posn '#(("
},
{
"path": "lib/Experimental/Beginning/primops.sch",
"chars": 15500,
"preview": "; Hashtable of primop types for the beginning student language.\n;\n; FIXME: type processing isn't implemented yet.\n; FIXM"
},
{
"path": "lib/Experimental/Beginning/stepper.sch",
"chars": 14465,
"preview": "; Prototype of stepper for the beginning language.\n;\n; Redefines four procedures that were defined as stubs\n; by the int"
},
{
"path": "lib/Experimental/Beginning/syntax.sch",
"chars": 7355,
"preview": "; Syntax checker for the beginning student language.\n;\n; Given a program, represented as a list of definitions\n; and exp"
},
{
"path": "lib/Experimental/Beginning/tests.sch",
"chars": 2181,
"preview": "; Tests for the beginning language.\n\n(define (test pgm expected)\n (check-beginning-program pgm)\n (let ((results (inter"
},
{
"path": "lib/Experimental/DotNet/collections.sch",
"chars": 5575,
"preview": ";;; Useful procedures defined below:\n\n;;; make-enumerator : T:ForeignType get-enum-meth-name:String -> x:T -> [Listof Fo"
},
{
"path": "lib/Experimental/DotNet/dotnet-ffi-lcg.sch",
"chars": 19430,
"preview": "(define clr-method->procedure/clr-invoke\r\n (let* ((mi-type (find-clr-type \"System.Reflection.MethodInfo\"))\r\n\t (is-stati"
},
{
"path": "lib/Experimental/DotNet/example.sch",
"chars": 3303,
"preview": ";; Demo of how to start up wnd with behavior dictated by an agent.\n\n(load \"lib/Experimental/DotNet/collections.sch\")\n(lo"
},
{
"path": "lib/Experimental/DotNet/gui-inspection.sch",
"chars": 3808,
"preview": ";;; Useful procedures defined below:\n\n;;; object->property-form\n\n'(require \"Experimental/DotNet/simple-inspection\")\ntype"
},
{
"path": "lib/Experimental/DotNet/maybe-read.sch",
"chars": 887,
"preview": ";; A MaybeReadResult is one of:\r\n;; - (list 'sexp Sexp Nat) : read N chars to create S\r\n;; - (list 'eof) : "
},
{
"path": "lib/Experimental/DotNet/protoobj.sch",
"chars": 7708,
"preview": ";; Prototype based object system, with \"features\" like operation\n;; reflection, inline documentation and delegation supp"
},
{
"path": "lib/Experimental/DotNet/simple-inspection.sch",
"chars": 18877,
"preview": ";;; Useful procedures defined below:\n\n;;; describe-type\n;;; type->name type->full-name \n;;; type->superclass type->ances"
},
{
"path": "lib/Experimental/DotNet/simple-reflection.sch",
"chars": 13617,
"preview": ";;; Procedures of interest:\n;;; define-type\n;;; define-constructor\n;;; define-method\n;;; constructor->ilgen \n;;; method-"
},
{
"path": "lib/Experimental/DotNet/stepper-gui.sch",
"chars": 7522,
"preview": "(define (make-beginning-editor-agent wnd textmodel)\r\n (let ((agent (extend-with-file-handling\r\n\t\t(extend-with-paren-mat"
},
{
"path": "lib/Experimental/DotNet/stepper-menus.sch",
"chars": 1887,
"preview": ";;; === START largely cut-and-pasted from code in example.sch ===\r\n\r\n(define (make-file-menu editor-wnd)\r\n (define file"
},
{
"path": "lib/Experimental/DotNet/stepper-overrides.sch",
"chars": 3748,
"preview": ";; Will's \"hooks\" of display-step and really-display-step are not\n;; parameterized over *anything*; they're just thunks."
},
{
"path": "lib/Experimental/DotNet/toolsmith-form.sch",
"chars": 75885,
"preview": "(clr/%load-assembly \"System.Windows.Forms\" \"2.0.0.0\" \"\" \"b77a5c561934e089\")\n\n(define clr/method2proc\n (lambda args (clr"
},
{
"path": "lib/Experimental/DotNet/toolsmith-shared.sch",
"chars": 70132,
"preview": ";; :Basic:make-trap.sch is Mac specific\n;; :Basic:mac-type is Mac specific \n;; :Basic:general is FFI stuff that we can d"
},
{
"path": "lib/Experimental/DotNet/toolsmith-stepper.sch",
"chars": 847,
"preview": "(require 'pretty)\r\n\r\n(load \"lib/Experimental/DotNet/collections.sch\")\r\n(load \"lib/Experimental/DotNet/simple-inspection."
},
{
"path": "lib/Experimental/Makefile",
"chars": 241,
"preview": "# $Id$\n# Experimental/Makefile\n\ndefault:\n\n# Solaris, at least\n#unix-support.so:\n#\tgcc -fPIC -shared unix-support.c -lsoc"
},
{
"path": "lib/Experimental/accum-profile.sch",
"chars": 3922,
"preview": ";; exports:\n;; make-accum-profile \n;; accum-profile-times\n;; instrument-accumulating-time!\n;; remove-instrumentation-fro"
},
{
"path": "lib/Experimental/applyhook.sch",
"chars": 2044,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Larceny library -- application hooks: generalized procedures.\n;\n; The conce"
},
{
"path": "lib/Experimental/applyhook0.mal",
"chars": 2078,
"preview": "; Copyright 1998 Lars T Hansen. -*- scheme -*-\n; \n; $Id$\n; \n; Larceny library -- apply-hook support code.\n\n;"
},
{
"path": "lib/Experimental/apropos.sch",
"chars": 1539,
"preview": "; Copyright 1998 Lars T Hansen.\n;\n; $Id$\n;\n; Apropos function.\n;\n; Idea from Alexander Taranov <tay@jet.msk.su>\n; Could "
}
]
// ... and 2822 more files (download for full content)
About this extraction
This page contains the full source code of the larcenists/larceny GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 3022 files (53.0 MB), approximately 14.0M tokens, and a symbol index with 5511 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.