├── .cvsignore ├── .gitignore ├── .mailmap ├── BUGS ├── COPYING ├── CREDITS ├── HACKING ├── INSTALL ├── NEWS ├── OPTIMIZATIONS ├── PRINCIPLES ├── README ├── README.sbcl-win32-threads.txt ├── TLA ├── TODO ├── base-target-features.lisp-expr ├── binary-distribution.sh ├── branch-version.lisp-expr ├── build-order.lisp-expr ├── clean.sh ├── common-lisp-exports.lisp-expr ├── contrib ├── .cvsignore ├── README ├── STANDARDS ├── asdf-install │ ├── .cvsignore │ ├── Makefile │ ├── README │ ├── asdf-install.asd │ ├── defpackage.lisp │ └── installer.lisp ├── asdf-module.mk ├── asdf-stub.lisp ├── asdf │ ├── .cvsignore │ ├── Makefile │ ├── README │ ├── README.SBCL │ ├── asdf.lisp │ ├── asdf.texinfo │ └── pull-asdf.sh ├── code-extras.lisp ├── compiler-extras.lisp ├── sb-aclrepl │ ├── .cvsignore │ ├── Makefile │ ├── README │ ├── debug.lisp │ ├── inspect.lisp │ ├── repl.lisp │ ├── sb-aclrepl.asd │ ├── sb-aclrepl.texinfo │ ├── tests.lisp │ └── toplevel.lisp ├── sb-bsd-sockets │ ├── .cvsignore │ ├── FAQ │ ├── Makefile │ ├── NEWS │ ├── TODO │ ├── constants.lisp │ ├── defpackage.lisp │ ├── inet.lisp │ ├── local.lisp │ ├── misc.lisp │ ├── name-service.lisp │ ├── sb-bsd-sockets.asd │ ├── sb-bsd-sockets.texinfo │ ├── sockets.lisp │ ├── sockopt.lisp │ ├── split.lisp │ ├── tests.lisp │ ├── win32-constants.lisp │ ├── win32-lib.lisp │ └── win32-sockets.lisp ├── sb-cltl2 │ ├── .cvsignore │ ├── Makefile │ ├── compiler-let.lisp │ ├── defpackage.lisp │ ├── env.lisp │ ├── macroexpand.lisp │ ├── sb-cltl2.asd │ └── tests.lisp ├── sb-concurrency │ ├── .cvsignore │ ├── Makefile │ ├── frlock.lisp │ ├── gate.lisp │ ├── mailbox.lisp │ ├── package.lisp │ ├── queue.lisp │ ├── sb-concurrency.asd │ ├── sb-concurrency.texinfo │ └── tests │ │ ├── package.lisp │ │ ├── test-frlock.lisp │ │ ├── test-gate.lisp │ │ ├── test-mailbox.lisp │ │ ├── test-queue.lisp │ │ └── test-utils.lisp ├── sb-cover │ ├── .cvsignore │ ├── Makefile │ ├── cover.lisp │ ├── sb-cover.asd │ ├── sb-cover.texinfo │ ├── test-data-1.lisp │ ├── test-data-2.lisp │ ├── test-data-3.lisp │ └── tests.lisp ├── sb-executable │ ├── .cvsignore │ ├── Makefile │ └── sb-executable.lisp ├── sb-grovel │ ├── .cvsignore │ ├── Makefile │ ├── def-to-lisp.lisp │ ├── defpackage.lisp │ ├── example-constants.lisp │ ├── foreign-glue.lisp │ ├── sb-grovel.asd │ └── sb-grovel.texinfo ├── sb-introspect │ ├── .cvsignore │ ├── Makefile │ ├── introspect.lisp │ ├── load-test.lisp │ ├── sb-introspect.asd │ ├── test-driver.lisp │ ├── test.lisp │ ├── xref-test-data.lisp │ └── xref-test.lisp ├── sb-md5 │ ├── .cvsignore │ ├── Makefile │ ├── README │ ├── md5-tests.lisp │ ├── md5.lisp │ ├── sb-md5.asd │ └── sb-md5.texinfo ├── sb-posix │ ├── .cvsignore │ ├── Makefile │ ├── README │ ├── TODO │ ├── constants.lisp │ ├── defpackage.lisp │ ├── designator.lisp │ ├── interface.lisp │ ├── macros.lisp │ ├── posix-tests.lisp │ ├── sb-posix.asd │ └── sb-posix.texinfo ├── sb-queue │ ├── .cvsignore │ ├── Makefile │ ├── package.lisp │ ├── sb-queue.asd │ └── sb-queue.texinfo ├── sb-rotate-byte │ ├── .cvsignore │ ├── Makefile │ ├── README │ ├── compiler.lisp │ ├── package.lisp │ ├── ppc-vm.lisp │ ├── rotate-byte-tests.lisp │ ├── rotate-byte.lisp │ ├── sb-rotate-byte.asd │ ├── sb-rotate-byte.texinfo │ ├── x86-64-vm.lisp │ └── x86-vm.lisp ├── sb-rt │ ├── .cvsignore │ ├── Makefile │ ├── rt.lisp │ └── sb-rt.asd ├── sb-simple-streams │ ├── .cvsignore │ ├── Makefile │ ├── README │ ├── TODO │ ├── classes.lisp │ ├── direct.lisp │ ├── file.lisp │ ├── fndb.lisp │ ├── impl.lisp │ ├── internal.lisp │ ├── iodefs.lisp │ ├── lp491087.txt │ ├── null.lisp │ ├── package.lisp │ ├── sb-simple-streams.asd │ ├── sb-simple-streams.texinfo │ ├── simple-stream-tests.lisp │ ├── socket.lisp │ ├── strategy.lisp │ ├── string.lisp │ └── terminal.lisp ├── sb-sprof │ ├── .cvsignore │ ├── Makefile │ ├── sb-sprof.lisp │ ├── sb-sprof.texinfo │ └── test.lisp ├── stale-symbols.lisp └── vanilla-module.mk ├── distclean.sh ├── doc ├── .cvsignore ├── FOR-CMUCL-DEVELOPERS ├── GIT-FOR-SBCL-HACKERS.txt ├── GIT-WORKFLOW.md ├── PACKAGING-SBCL.txt ├── README ├── clean.sh ├── entities.inc ├── internals-notes │ ├── GENCGC-PORTING-NOTES │ ├── mach-exception-handler-notes │ ├── release-checklist.txt │ └── threading-specials ├── internals │ ├── .cvsignore │ ├── Makefile │ ├── build.texinfo │ ├── calling-convention.texinfo │ ├── discriminating-functions.dot │ ├── discriminating-functions.texinfo │ ├── foreign-linkage.texinfo │ ├── funcallable-instances.texinfo │ ├── make-top.sh │ ├── objects-in-memory.texinfo │ ├── sbcl-internals.texinfo │ ├── signals.texinfo │ ├── slot-value.texinfo │ ├── specials.texinfo │ ├── string-types.texinfo │ └── threads.texinfo ├── make-doc.sh ├── manual │ ├── .cvsignore │ ├── .gitignore │ ├── Makefile │ ├── TEXINFO-HINTS │ ├── backmatter.texinfo │ ├── beyond-ansi.texinfo │ ├── clean.sh │ ├── compiler.texinfo │ ├── contrib-modules.texinfo │ ├── create-contrib-doc-list.lisp │ ├── debugger.texinfo │ ├── deprecated.texinfo │ ├── docstrings.lisp │ ├── efficiency.texinfo │ ├── ffi.texinfo │ ├── gray-streams-examples.texinfo │ ├── intro.texinfo │ ├── make-tempfiles.sh │ ├── package-locks-basic.texinfo │ ├── package-locks-extended.texinfo │ ├── pathnames.texinfo │ ├── profiling.texinfo │ ├── sbcl.texinfo │ ├── start-stop.texinfo │ ├── streams.texinfo │ ├── style-multi.css │ ├── style-single.css │ ├── support-and-bugs.texinfo │ ├── texinfo-macros.texinfo │ ├── threading.texinfo │ ├── timers.texinfo │ └── variables.template ├── sbcl-asdf-install.1 └── sbcl.1 ├── find-gnumake.sh ├── generate-version.sh ├── git ├── README ├── post-receive ├── post-receive-email └── update ├── guess-environment.sh ├── html-distribution.sh ├── install.sh ├── make-config.sh ├── make-genesis-1a.lisp ├── make-genesis-2.lisp ├── make-genesis-2.sh ├── make-host-1.lisp ├── make-host-1.sh ├── make-host-1a.sh ├── make-host-2.lisp ├── make-host-2.sh ├── make-target-1.sh ├── make-target-1a.sh ├── make-target-2-load.lisp ├── make-target-2.lisp ├── make-target-2.sh ├── make-target-contrib.sh ├── make-windows-installer.sh ├── make.sh ├── package-data-list.lisp-expr ├── pubring.pgp ├── release.sh ├── run-sbcl.sh ├── sbcl-pwd.sh ├── slam.sh ├── source-distribution.sh ├── src ├── assembly │ ├── alpha │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── assem-rtns.lisp │ │ └── support.lisp │ ├── assemfile.lisp │ ├── hppa │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── assem-rtns.lisp │ │ └── support.lisp │ ├── mips │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── assem-rtns.lisp │ │ └── support.lisp │ ├── ppc │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── assem-rtns.lisp │ │ └── support.lisp │ ├── sparc │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── assem-rtns.lisp │ │ └── support.lisp │ ├── x86-64 │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── assem-rtns.lisp │ │ ├── bit-bash.lisp │ │ └── support.lisp │ └── x86 │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── assem-rtns.lisp │ │ ├── bit-bash.lisp │ │ └── support.lisp ├── code │ ├── abstract-os.lisp │ ├── alien-type.lisp │ ├── alloc.lisp │ ├── alpha-vm.lisp │ ├── ansi-stream.lisp │ ├── array.lisp │ ├── backq.lisp │ ├── barrier.lisp │ ├── bignum-random.lisp │ ├── bignum.lisp │ ├── bit-bash.lisp │ ├── bsd-os.lisp │ ├── cas.lisp │ ├── char.lisp │ ├── cl-specials.lisp │ ├── class-init.lisp │ ├── class.lisp │ ├── coerce.lisp │ ├── cold-error.lisp │ ├── cold-init-helper-macros.lisp │ ├── cold-init.lisp │ ├── common-os.lisp │ ├── condition.lisp │ ├── cross-boole.lisp │ ├── cross-byte.lisp │ ├── cross-char.lisp │ ├── cross-condition.lisp │ ├── cross-early.lisp │ ├── cross-float.lisp │ ├── cross-io.lisp │ ├── cross-make-load-form.lisp │ ├── cross-misc.lisp │ ├── cross-modular.lisp │ ├── cross-sap.lisp │ ├── cross-thread.lisp │ ├── cross-type.lisp │ ├── deadline.lisp │ ├── debug-info.lisp │ ├── debug-int.lisp │ ├── debug-var-io.lisp │ ├── debug.lisp │ ├── defbangconstant.lisp │ ├── defbangmacro.lisp │ ├── defbangstruct.lisp │ ├── defbangtype.lisp │ ├── defboot.lisp │ ├── defmacro.lisp │ ├── defpackage.lisp │ ├── defsetfs.lisp │ ├── defstruct.lisp │ ├── deftypes-for-target.lisp │ ├── describe-policy.lisp │ ├── describe.lisp │ ├── destructuring-bind.lisp │ ├── dyncount.lisp │ ├── early-alieneval.lisp │ ├── early-array.lisp │ ├── early-cl.lisp │ ├── early-constants.lisp │ ├── early-defbangmethod.lisp │ ├── early-defstruct-args.lisp-expr │ ├── early-defstructs.lisp │ ├── early-extensions.lisp │ ├── early-fasl.lisp │ ├── early-float.lisp │ ├── early-format.lisp │ ├── early-full-eval.lisp │ ├── early-impl.lisp │ ├── early-package.lisp │ ├── early-pprint.lisp │ ├── early-print.lisp │ ├── early-setf.lisp │ ├── early-source-location.lisp │ ├── early-step.lisp │ ├── early-thread.lisp │ ├── early-time.lisp │ ├── early-type.lisp │ ├── error-error.lisp │ ├── error.lisp │ ├── eval.lisp │ ├── exhaust.lisp │ ├── external-formats │ │ ├── enc-basic.lisp │ │ ├── enc-cn-tbl.lisp │ │ ├── enc-cn.lisp │ │ ├── enc-cyr.lisp │ │ ├── enc-dos.lisp │ │ ├── enc-ebcdic.lisp │ │ ├── enc-iso.lisp │ │ ├── enc-jpn-tbl.lisp │ │ ├── enc-jpn.lisp │ │ ├── enc-ucs.lisp │ │ ├── enc-utf.lisp │ │ ├── enc-win.lisp │ │ └── mb-util.lisp │ ├── fd-stream.lisp │ ├── fdefinition.lisp │ ├── fiber.lisp │ ├── filesys.lisp │ ├── final.lisp │ ├── float-trap.lisp │ ├── float.lisp │ ├── fop.lisp │ ├── force-delayed-defbangconstants.lisp │ ├── force-delayed-defbangmacros.lisp │ ├── force-delayed-defbangmethods.lisp │ ├── force-delayed-defbangstructs.lisp │ ├── foreign-load.lisp │ ├── foreign.lisp │ ├── format-time.lisp │ ├── full-eval.lisp │ ├── function-names.lisp │ ├── funutils.lisp │ ├── gc.lisp │ ├── globals.lisp │ ├── hash-table.lisp │ ├── host-alieneval.lisp │ ├── host-c-call.lisp │ ├── host-pprint.lisp │ ├── hppa-vm.lisp │ ├── hpux-os.lisp │ ├── huffman.lisp │ ├── inspect.lisp │ ├── interr.lisp │ ├── irrat.lisp │ ├── kernel.lisp │ ├── late-cas.lisp │ ├── late-condition.lisp │ ├── late-defbangmethod.lisp │ ├── late-deftypes-for-target.lisp │ ├── late-extensions.lisp │ ├── late-format.lisp │ ├── late-setf.lisp │ ├── late-type.lisp │ ├── linkage-table.lisp │ ├── linux-os.lisp │ ├── list.lisp │ ├── load.lisp │ ├── loop.lisp │ ├── macroexpand.lisp │ ├── macros.lisp │ ├── mips-vm.lisp │ ├── mipsstrops.lisp │ ├── misc-aliens.lisp │ ├── misc.lisp │ ├── module.lisp │ ├── ntrace.lisp │ ├── numbers.lisp │ ├── octets.lisp │ ├── osf1-os.lisp │ ├── package.lisp │ ├── parse-body.lisp │ ├── parse-defmacro-errors.lisp │ ├── parse-defmacro.lisp │ ├── pathname.lisp │ ├── pp-backq.lisp │ ├── ppc-vm.lisp │ ├── pprint.lisp │ ├── pred.lisp │ ├── primordial-extensions.lisp │ ├── primordial-type.lisp │ ├── print.lisp │ ├── profile.lisp │ ├── purify.lisp │ ├── query.lisp │ ├── random.lisp │ ├── reader.lisp │ ├── readtable.lisp │ ├── room.lisp │ ├── run-program.lisp │ ├── save.lisp │ ├── sc-offset.lisp │ ├── seq.lisp │ ├── serve-event.lisp │ ├── setf-funs.lisp │ ├── sharpm.lisp │ ├── show.lisp │ ├── signal.lisp │ ├── sort.lisp │ ├── source-location.lisp │ ├── sparc-vm.lisp │ ├── specializable-array.lisp │ ├── step.lisp │ ├── stream.lisp │ ├── string.lisp │ ├── stubs.lisp │ ├── sunos-os.lisp │ ├── sxhash.lisp │ ├── symbol.lisp │ ├── sysmacs.lisp │ ├── target-alieneval.lisp │ ├── target-allocate.lisp │ ├── target-c-call.lisp │ ├── target-char.lisp │ ├── target-defbangmethod.lisp │ ├── target-defstruct.lisp │ ├── target-error.lisp │ ├── target-exception.lisp │ ├── target-extensions.lisp │ ├── target-format.lisp │ ├── target-hash-table.lisp │ ├── target-load.lisp │ ├── target-misc.lisp │ ├── target-package.lisp │ ├── target-pathname.lisp │ ├── target-random.lisp │ ├── target-sap.lisp │ ├── target-signal.lisp │ ├── target-stream.lisp │ ├── target-sxhash.lisp │ ├── target-thread.lisp │ ├── target-type.lisp │ ├── thread.lisp │ ├── time.lisp │ ├── timer.lisp │ ├── toplevel.lisp │ ├── type-class.lisp │ ├── type-init.lisp │ ├── typecheckfuns.lisp │ ├── typedefs.lisp │ ├── typep.lisp │ ├── uncross.lisp │ ├── unix-foreign-load.lisp │ ├── unix-pathname.lisp │ ├── unix.lisp │ ├── unportable-float.lisp │ ├── warm-lib.lisp │ ├── warm-mswin-mp.lisp │ ├── warm-mswin.lisp │ ├── weak.lisp │ ├── win32-foreign-load.lisp │ ├── win32-os.lisp │ ├── win32-pathname.lisp │ ├── win32.lisp │ ├── x86-64-vm.lisp │ ├── x86-vm.lisp │ └── xset.lisp ├── cold │ ├── ansify.lisp │ ├── chill.lisp │ ├── compile-cold-sbcl.lisp │ ├── defun-load-or-cload-xcompiler.lisp │ ├── read-from-file.lisp │ ├── rename-package-carefully.lisp │ ├── set-up-cold-packages.lisp │ ├── shared.lisp │ ├── shebang.lisp │ ├── slam.lisp │ ├── snapshot.lisp │ ├── warm.lisp │ └── with-stuff.lisp ├── compiler │ ├── aliencomp.lisp │ ├── alpha │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── backend-parms.lisp │ │ ├── c-call.lisp │ │ ├── call.lisp │ │ ├── cell.lisp │ │ ├── char.lisp │ │ ├── debug.lisp │ │ ├── float.lisp │ │ ├── insts.lisp │ │ ├── macros.lisp │ │ ├── memory.lisp │ │ ├── move.lisp │ │ ├── nlx.lisp │ │ ├── parms.lisp │ │ ├── pred.lisp │ │ ├── sanctify.lisp │ │ ├── sap.lisp │ │ ├── show.lisp │ │ ├── static-fn.lisp │ │ ├── subprim.lisp │ │ ├── system.lisp │ │ ├── target-insts.lisp │ │ ├── type-vops.lisp │ │ ├── values.lisp │ │ └── vm.lisp │ ├── array-tran.lisp │ ├── assem.lisp │ ├── backend.lisp │ ├── bit-util.lisp │ ├── checkgen.lisp │ ├── codegen.lisp │ ├── compiler-deftype.lisp │ ├── compiler-error.lisp │ ├── constantp.lisp │ ├── constraint.lisp │ ├── control.lisp │ ├── copyprop.lisp │ ├── ctype.lisp │ ├── debug-dump.lisp │ ├── debug.lisp │ ├── defconstant.lisp │ ├── deftype.lisp │ ├── dfo.lisp │ ├── disassem.lisp │ ├── dump.lisp │ ├── dyncount.lisp │ ├── early-aliencomp.lisp │ ├── early-assem.lisp │ ├── early-backend.lisp │ ├── early-c.lisp │ ├── entry.lisp │ ├── fixup-type.lisp │ ├── fixup.lisp │ ├── float-tran.lisp │ ├── fndb.lisp │ ├── fopcompile.lisp │ ├── fun-info-funs.lisp │ ├── generic │ │ ├── array.lisp │ │ ├── core.lisp │ │ ├── early-objdef.lisp │ │ ├── early-type-vops.lisp │ │ ├── early-vm.lisp │ │ ├── genesis.lisp │ │ ├── interr.lisp │ │ ├── late-nlx.lisp │ │ ├── late-type-vops.lisp │ │ ├── objdef.lisp │ │ ├── parms.lisp │ │ ├── primtype.lisp │ │ ├── target-core.lisp │ │ ├── utils.lisp │ │ ├── vm-array.lisp │ │ ├── vm-fndb.lisp │ │ ├── vm-ir2tran.lisp │ │ ├── vm-macs.lisp │ │ ├── vm-tran.lisp │ │ ├── vm-type.lisp │ │ └── vm-typetran.lisp │ ├── globaldb.lisp │ ├── gtn.lisp │ ├── hppa │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── backend-parms.lisp │ │ ├── c-call.lisp │ │ ├── call.lisp │ │ ├── cell.lisp │ │ ├── char.lisp │ │ ├── debug.lisp │ │ ├── float.lisp │ │ ├── insts.lisp │ │ ├── macros.lisp │ │ ├── memory.lisp │ │ ├── move.lisp │ │ ├── nlx.lisp │ │ ├── parms.lisp │ │ ├── pred.lisp │ │ ├── sanctify.lisp │ │ ├── sap.lisp │ │ ├── show.lisp │ │ ├── static-fn.lisp │ │ ├── subprim.lisp │ │ ├── system.lisp │ │ ├── target-insts.lisp │ │ ├── type-vops.lisp │ │ ├── values.lisp │ │ └── vm.lisp │ ├── info-functions.lisp │ ├── integer-tran.lisp │ ├── ir1-translators.lisp │ ├── ir1final.lisp │ ├── ir1opt.lisp │ ├── ir1report.lisp │ ├── ir1tran-lambda.lisp │ ├── ir1tran.lisp │ ├── ir1util.lisp │ ├── ir2opt.lisp │ ├── ir2tran.lisp │ ├── knownfun.lisp │ ├── late-macros.lisp │ ├── late-proclaim.lisp │ ├── late-vmdef.lisp │ ├── lexenv.lisp │ ├── life.lisp │ ├── locall.lisp │ ├── loop.lisp │ ├── ltn.lisp │ ├── ltv.lisp │ ├── macros.lisp │ ├── main.lisp │ ├── meta-vmdef.lisp │ ├── mips │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── backend-parms.lisp │ │ ├── c-call.lisp │ │ ├── call.lisp │ │ ├── cell.lisp │ │ ├── char.lisp │ │ ├── debug.lisp │ │ ├── float.lisp │ │ ├── insts.lisp │ │ ├── macros.lisp │ │ ├── memory.lisp │ │ ├── move.lisp │ │ ├── nlx.lisp │ │ ├── parms.lisp │ │ ├── pred.lisp │ │ ├── sanctify.lisp │ │ ├── sap.lisp │ │ ├── show.lisp │ │ ├── static-fn.lisp │ │ ├── subprim.lisp │ │ ├── system.lisp │ │ ├── target-insts.lisp │ │ ├── type-vops.lisp │ │ ├── values.lisp │ │ └── vm.lisp │ ├── node.lisp │ ├── pack.lisp │ ├── parse-lambda-list.lisp │ ├── physenvanal.lisp │ ├── policies.lisp │ ├── policy.lisp │ ├── ppc │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── backend-parms.lisp │ │ ├── c-call.lisp │ │ ├── call.lisp │ │ ├── cell.lisp │ │ ├── char.lisp │ │ ├── debug.lisp │ │ ├── float.lisp │ │ ├── insts.lisp │ │ ├── macros.lisp │ │ ├── memory.lisp │ │ ├── move.lisp │ │ ├── nlx.lisp │ │ ├── parms.lisp │ │ ├── pred.lisp │ │ ├── sanctify.lisp │ │ ├── sap.lisp │ │ ├── show.lisp │ │ ├── static-fn.lisp │ │ ├── subprim.lisp │ │ ├── system.lisp │ │ ├── target-insts.lisp │ │ ├── type-vops.lisp │ │ ├── values.lisp │ │ └── vm.lisp │ ├── proclaim.lisp │ ├── pseudo-vops.lisp │ ├── represent.lisp │ ├── saptran.lisp │ ├── seqtran.lisp │ ├── sparc │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── backend-parms.lisp │ │ ├── c-call.lisp │ │ ├── call.lisp │ │ ├── cell.lisp │ │ ├── char.lisp │ │ ├── debug.lisp │ │ ├── float.lisp │ │ ├── insts.lisp │ │ ├── macros.lisp │ │ ├── memory.lisp │ │ ├── move.lisp │ │ ├── nlx.lisp │ │ ├── parms.lisp │ │ ├── pred.lisp │ │ ├── sanctify.lisp │ │ ├── sap.lisp │ │ ├── show.lisp │ │ ├── static-fn.lisp │ │ ├── subprim.lisp │ │ ├── system.lisp │ │ ├── target-insts.lisp │ │ ├── type-vops.lisp │ │ ├── values.lisp │ │ └── vm.lisp │ ├── srctran.lisp │ ├── sset.lisp │ ├── stack.lisp │ ├── target-disassem.lisp │ ├── target-dump.lisp │ ├── target-main.lisp │ ├── tn.lisp │ ├── trace-table.lisp │ ├── typetran.lisp │ ├── vmdef.lisp │ ├── vop.lisp │ ├── x86-64 │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── backend-parms.lisp │ │ ├── c-call.lisp │ │ ├── call.lisp │ │ ├── cell.lisp │ │ ├── char.lisp │ │ ├── debug.lisp │ │ ├── float.lisp │ │ ├── insts.lisp │ │ ├── macros.lisp │ │ ├── memory.lisp │ │ ├── move.lisp │ │ ├── nlx.lisp │ │ ├── parms.lisp │ │ ├── pred.lisp │ │ ├── sanctify.lisp │ │ ├── sap.lisp │ │ ├── show.lisp │ │ ├── static-fn.lisp │ │ ├── subprim.lisp │ │ ├── system.lisp │ │ ├── target-insts.lisp │ │ ├── type-vops.lisp │ │ ├── values.lisp │ │ └── vm.lisp │ ├── x86 │ │ ├── alloc.lisp │ │ ├── arith.lisp │ │ ├── array.lisp │ │ ├── backend-parms.lisp │ │ ├── c-call.lisp │ │ ├── call.lisp │ │ ├── cell.lisp │ │ ├── char.lisp │ │ ├── debug.lisp │ │ ├── float.lisp │ │ ├── insts.lisp │ │ ├── macros.lisp │ │ ├── memory.lisp │ │ ├── move.lisp │ │ ├── nlx.lisp │ │ ├── parms.lisp │ │ ├── pred.lisp │ │ ├── sanctify.lisp │ │ ├── sap.lisp │ │ ├── show.lisp │ │ ├── static-fn.lisp │ │ ├── subprim.lisp │ │ ├── system.lisp │ │ ├── target-insts.lisp │ │ ├── type-vops.lisp │ │ ├── values.lisp │ │ └── vm.lisp │ └── xref.lisp ├── pcl │ ├── boot.lisp │ ├── braid.lisp │ ├── cache.lisp │ ├── combin.lisp │ ├── compiler-support.lisp │ ├── cpl.lisp │ ├── ctor.lisp │ ├── ctypes.lisp │ ├── defclass.lisp │ ├── defcombin.lisp │ ├── defs.lisp │ ├── dfun.lisp │ ├── dlisp.lisp │ ├── dlisp3.lisp │ ├── documentation.lisp │ ├── early-low.lisp │ ├── env.lisp │ ├── fixup.lisp │ ├── fngen.lisp │ ├── fsc.lisp │ ├── generic-functions.lisp │ ├── gray-streams-class.lisp │ ├── gray-streams.lisp │ ├── init.lisp │ ├── low.lisp │ ├── macros.lisp │ ├── methods.lisp │ ├── precom1.lisp │ ├── precom2.lisp │ ├── print-object.lisp │ ├── sequence.lisp │ ├── slot-name.lisp │ ├── slots-boot.lisp │ ├── slots.lisp │ ├── std-class.lisp │ ├── time.lisp │ ├── vector.lisp │ ├── walk.lisp │ └── wrapper.lisp └── runtime │ ├── .cvsignore │ ├── Config.alpha-linux │ ├── Config.alpha-osf1 │ ├── Config.generic-openbsd │ ├── Config.hppa-hpux │ ├── Config.hppa-linux │ ├── Config.mips-linux │ ├── Config.ppc-darwin │ ├── Config.ppc-linux │ ├── Config.ppc-netbsd │ ├── Config.ppc-openbsd │ ├── Config.sparc-linux │ ├── Config.sparc-netbsd │ ├── Config.sparc-sunos │ ├── Config.x86-64-bsd │ ├── Config.x86-64-darwin │ ├── Config.x86-64-freebsd │ ├── Config.x86-64-netbsd │ ├── Config.x86-64-openbsd │ ├── Config.x86-64-sunos │ ├── Config.x86-64-win32 │ ├── Config.x86-bsd │ ├── Config.x86-darwin │ ├── Config.x86-freebsd │ ├── Config.x86-linux │ ├── Config.x86-netbsd │ ├── Config.x86-openbsd │ ├── Config.x86-sunos │ ├── Config.x86-win32 │ ├── Config.x86_64-linux │ ├── GNUmakefile │ ├── alloc.c │ ├── alloc.h │ ├── alpha-arch.c │ ├── alpha-arch.h │ ├── alpha-assem.S │ ├── alpha-linux-os.c │ ├── alpha-linux-os.h │ ├── alpha-lispregs.h │ ├── alpha-osf1-os.c │ ├── alpha-osf1-os.h │ ├── arch.h │ ├── backtrace.c │ ├── breakpoint.c │ ├── breakpoint.h │ ├── bsd-os.c │ ├── bsd-os.h │ ├── cheneygc-internal.h │ ├── cheneygc.c │ ├── core.h │ ├── coreparse.c │ ├── cpputil.h │ ├── darwin-os.c │ ├── darwin-os.h │ ├── dynbind.c │ ├── dynbind.h │ ├── fixnump.h │ ├── funcall.c │ ├── gc-common.c │ ├── gc-internal.h │ ├── gc.h │ ├── gencgc-alloc-region.h │ ├── gencgc-internal.h │ ├── gencgc.c │ ├── gencgc.h │ ├── globals.c │ ├── globals.h │ ├── hppa-arch.c │ ├── hppa-arch.h │ ├── hppa-assem.S │ ├── hppa-hpux-os.c │ ├── hppa-hpux-os.h │ ├── hppa-linux-os.c │ ├── hppa-linux-os.h │ ├── hppa-lispregs.h │ ├── hpux-os.c │ ├── hpux-os.h │ ├── interr.c │ ├── interr.h │ ├── interrupt.c │ ├── interrupt.h │ ├── largefile.c │ ├── ld-script.alpha-linux │ ├── linux-nm │ ├── linux-os.c │ ├── linux-os.h │ ├── lispregs.h │ ├── mips-arch.c │ ├── mips-arch.h │ ├── mips-assem.S │ ├── mips-linux-os.c │ ├── mips-linux-os.h │ ├── mips-lispregs.h │ ├── monitor.c │ ├── monitor.h │ ├── mswin.def │ ├── mswin64.def │ ├── os-common.c │ ├── os-default.h │ ├── os.h │ ├── osf1-os.c │ ├── osf1-os.h │ ├── parse.c │ ├── parse.h │ ├── ppc-arch.c │ ├── ppc-arch.h │ ├── ppc-assem.S │ ├── ppc-bsd-os.c │ ├── ppc-bsd-os.h │ ├── ppc-darwin-os.c │ ├── ppc-darwin-os.h │ ├── ppc-linux-os.c │ ├── ppc-linux-os.h │ ├── ppc-lispregs.h │ ├── print.c │ ├── print.h │ ├── pseudo-atomic.h │ ├── pthread-futex.c │ ├── pthreads_win32.c │ ├── pthreads_win32.h │ ├── purify.c │ ├── purify.h │ ├── regnames.c │ ├── run-program.c │ ├── runtime-options.h │ ├── runtime.c │ ├── runtime.h │ ├── save.c │ ├── save.h │ ├── sbcl-win.rc │ ├── sbcl-win32.manifest │ ├── sbcl-win64.manifest │ ├── search.c │ ├── search.h │ ├── sparc-arch.c │ ├── sparc-arch.h │ ├── sparc-assem.S │ ├── sparc-bsd-os.c │ ├── sparc-bsd-os.h │ ├── sparc-linux-os.c │ ├── sparc-linux-os.h │ ├── sparc-lispregs.h │ ├── sparc-sunos-os.c │ ├── sparc-sunos-os.h │ ├── sunos-os.c │ ├── sunos-os.h │ ├── thread.c │ ├── thread.h │ ├── time.c │ ├── trymap.c │ ├── undefineds.c │ ├── undefineds.h │ ├── util.c │ ├── util.h │ ├── validate.c │ ├── validate.h │ ├── vars.c │ ├── vars.h │ ├── win32-os.c │ ├── win32-os.h │ ├── win32-stub.S │ ├── win32-thread-private-events.h │ ├── wrap.c │ ├── wrap.h │ ├── x86-64-arch.c │ ├── x86-64-arch.h │ ├── x86-64-assem.S │ ├── x86-64-bsd-os.c │ ├── x86-64-bsd-os.h │ ├── x86-64-darwin-os.c │ ├── x86-64-darwin-os.h │ ├── x86-64-linux-os.c │ ├── x86-64-linux-os.h │ ├── x86-64-lispregs.h │ ├── x86-64-sunos-os.c │ ├── x86-64-sunos-os.h │ ├── x86-64-win32-os.c │ ├── x86-64-win32-os.h │ ├── x86-arch.c │ ├── x86-arch.h │ ├── x86-assem.S │ ├── x86-bsd-os.c │ ├── x86-bsd-os.h │ ├── x86-darwin-os.c │ ├── x86-darwin-os.h │ ├── x86-fpu-x87.h │ ├── x86-linux-os.c │ ├── x86-linux-os.h │ ├── x86-lispregs.h │ ├── x86-sunos-os.c │ ├── x86-sunos-os.h │ ├── x86-win32-os.c │ └── x86-win32-os.h ├── tagify.sh ├── tests ├── .cvsignore ├── .gitignore ├── alien.impure.lisp ├── arith.impure.lisp ├── arith.pure.lisp ├── array.pure.lisp ├── assertoid.lisp ├── backq.impure.lisp ├── bit-vector.impure-cload.lisp ├── bivalent-stream.impure.lisp ├── break-on-signals.impure.lisp ├── bug-414.lisp ├── bug-417.lisp ├── bug-doug-mcnaught-20030914.lisp ├── bug204-test.lisp ├── callback.impure.lisp ├── case.pure.lisp ├── character.pure.lisp ├── circ-tree-test.lisp ├── clocc-ansi-test-known-bugs.lisp ├── clocc-ansi.test.sh ├── clos-1.impure.lisp ├── clos-add-remove-method.impure.lisp ├── clos-cache.impure.lisp ├── clos-ignore.interactive.lisp ├── clos-interrupts.impure.lisp ├── clos-typechecking.impure.lisp ├── clos.impure-cload.lisp ├── clos.impure.lisp ├── clos.pure.lisp ├── clos.test.sh ├── compare-and-swap.impure.lisp ├── compiler-1.impure-cload.lisp ├── compiler-2.impure-cload.lisp ├── compiler-output-test.lisp ├── compiler-test-util.lisp ├── compiler.impure-cload.lisp ├── compiler.impure.lisp ├── compiler.pure-cload.lisp ├── compiler.pure.lisp ├── compiler.test.sh ├── compound-cons.impure.lisp ├── condition-wait-sigcont.lisp ├── condition.impure.lisp ├── condition.pure.lisp ├── core.test.sh ├── ctor.impure.lisp ├── custom-sysinit.lisp ├── custom-userinit.lisp ├── deadline.impure.lisp ├── debug.impure.lisp ├── defglobal.impure.lisp ├── define-compiler-macro.impure.lisp ├── defmacro-test.lisp ├── defstruct.impure.lisp ├── deftype.impure.lisp ├── destructure.impure.lisp ├── dump.impure-cload.lisp ├── dynamic-extent.impure.lisp ├── enc-cn.impure.lisp ├── enc-jpn.impure.lisp ├── eval.impure.lisp ├── exhaust.impure.lisp ├── expect.sh ├── external-format.impure.lisp ├── filesys.pure.lisp ├── filesys.test.sh ├── finalize.test.sh ├── float.impure.lisp ├── float.pure.lisp ├── fopcompiler.impure-cload.lisp ├── foreign-stack-alignment.impure.lisp ├── foreign.test.sh ├── full-eval.impure.lisp ├── gc.impure.lisp ├── gcd.pure.lisp ├── gcrace.impure.lisp ├── gray-streams.impure.lisp ├── hash.impure.lisp ├── hash.pure.lisp ├── info.before-xc.lisp ├── info.impure.lisp ├── init.test.sh ├── interface.impure.lisp ├── interface.pure.lisp ├── interface.test.sh ├── kill-non-lisp-thread.c ├── kill-non-lisp-thread.impure.lisp ├── lambda-list.pure.lisp ├── list.pure.lisp ├── load.impure.lisp ├── load.pure.lisp ├── loop.impure.lisp ├── loop.pure.lisp ├── macroexpand.impure.lisp ├── map-tests.impure.lisp ├── mop-1.impure-cload.lisp ├── mop-10.impure-cload.lisp ├── mop-11.impure-cload.lisp ├── mop-12.impure-cload.lisp ├── mop-13.impure-cload.lisp ├── mop-14.impure-cload.lisp ├── mop-15.impure-cload.lisp ├── mop-16.impure-cload.lisp ├── mop-17.impure-cload.lisp ├── mop-18.impure-cload.lisp ├── mop-19.impure-cload.lisp ├── mop-2.impure-cload.lisp ├── mop-20.impure-cload.lisp ├── mop-21.impure-cload.lisp ├── mop-22.impure-cload.lisp ├── mop-23.impure.lisp ├── mop-24.impure.lisp ├── mop-25.impure.lisp ├── mop-26.impure.lisp ├── mop-27.impure.lisp ├── mop-28.impure.lisp ├── mop-29.impure.lisp ├── mop-3.impure-cload.lisp ├── mop-30.impure.lisp ├── mop-4.impure-cload.lisp ├── mop-5.impure-cload.lisp ├── mop-6.impure-cload.lisp ├── mop-7.impure-cload.lisp ├── mop-8.impure-cload.lisp ├── mop-9.impure-cload.lisp ├── mop.impure-cload.lisp ├── mop.impure.lisp ├── mop.pure.lisp ├── octets.pure.lisp ├── package-ctor-bug.lisp ├── package-locks.impure.lisp ├── packages.impure.lisp ├── parallel-fasl-load-test.lisp ├── pathnames.impure.lisp ├── pprint.impure.lisp ├── print.impure.lisp ├── profile.impure.lisp ├── properties.impure.lisp ├── pure.lisp ├── random.pure.lisp ├── reader.impure.lisp ├── reader.pure.lisp ├── room.test.sh ├── run-compiler.sh ├── run-program.impure.lisp ├── run-program.test.sh ├── run-tests.lisp ├── run-tests.sh ├── script.test.sh ├── seq.impure.lisp ├── seq.pure.lisp ├── setf.impure.lisp ├── side-effectful-pathnames.test.sh ├── signals.impure.lisp ├── smoke.impure.lisp ├── stack-alignment-offset.c ├── static-alloc.impure.lisp ├── step.impure.lisp ├── stream.impure-cload.lisp ├── stream.impure.lisp ├── stream.pure.lisp ├── stream.test.sh ├── stress-gc.lisp ├── stress-gc.sh ├── string.pure.lisp ├── subr.sh ├── swap-lispobjs.c ├── swap-lispobjs.impure.lisp ├── symbol-macrolet-test.lisp ├── symbol.impure.lisp ├── symbol.pure.lisp ├── test-util.lisp ├── th4gdb.lisp ├── threads.impure.lisp ├── threads.pure.lisp ├── threads.test.sh ├── time.pure.lisp ├── timer.impure.lisp ├── toplevel.test.sh ├── type.after-xc.lisp ├── type.before-xc.lisp ├── type.impure.lisp ├── type.pure.lisp ├── undefined-classoid-bug-1.lisp ├── undefined-classoid-bug-2.lisp ├── undefined-classoid-bug.test.sh ├── unwind-to-frame-and-call.impure.lisp ├── vector.impure.lisp ├── vector.pure.lisp ├── vm.before-xc.lisp ├── walk.impure.lisp ├── win32-foreign-stack-unwind.impure.lisp ├── win32-stack-unwind.c └── with-compilation-unit.impure.lisp ├── tools-for-build ├── .cvsignore ├── Jamo.txt ├── Makefile ├── UnicodeData.txt ├── canonicalize-whitespace ├── canonicalize-whitespace-1 ├── check-canonical-whitespace ├── determine-endianness.c ├── grep-noncanonical-whitespace ├── grovel-features.sh ├── grovel-headers.c ├── ldso-stubs.lisp ├── openbsd-sigcontext.sh ├── os-provides-blksize-t-test.c ├── os-provides-dladdr-test.c ├── os-provides-dlopen-test.c ├── os-provides-getprotoby-r-test.c ├── os-provides-poll-test.c ├── os-provides-putwc-test.c ├── os-provides-suseconds-t-test.c ├── rtf.lisp ├── sparc-funcdef.sh ├── ucd.lisp ├── where-is-mcontext.c ├── whitespacely-canonical-filenames └── wxs.lisp └── wc.sh /.cvsignore: -------------------------------------------------------------------------------- 1 | obj 2 | output 3 | ChangeLog 4 | customize-backend-subfeatures.lisp 5 | customize-target-features.lisp 6 | local-target-features.lisp-expr 7 | TAGS 8 | whitespace-stamp 9 | .svn 10 | .gdbinit 11 | .hg 12 | -------------------------------------------------------------------------------- /BUGS: -------------------------------------------------------------------------------- 1 | SBCL uses Launchpad to track bugs. The bug database is available at: 2 | 3 | https://bugs.launchpad.net/sbcl 4 | 5 | Reporting bugs there requires registering at Launchpad. However, bugs 6 | can also be reported on the mailing list sbcl-bugs, which is 7 | moderated but does _not_ require subscribing. Simply send email to 8 | 9 | sbcl-bugs@lists.sourceforge.net 10 | 11 | and the bug will be checked and added to Launchpad by SBCL maintainers. 12 | 13 | Historical note: before Launchpad was adopted this file contained a 14 | list of currently open bugs. If you run into an SBCL bug number in the 15 | range 1-431 inclusive, it refers to that list. 16 | 17 | Refer to User Manual for more details. 18 | -------------------------------------------------------------------------------- /COPYING: -------------------------------------------------------------------------------- 1 | Steel Bank Common Lisp (SBCL) is free software, and comes with 2 | absolutely no warranty. 3 | 4 | SBCL is derived from CMU CL, which was released into the public 5 | domain, subject only to the BSD-style "free, but credit must be given 6 | and copyright notices must be retained" licenses in the LOOP macro 7 | (from MIT and Symbolics) and in the PCL implementation of CLOS (from 8 | Xerox). 9 | 10 | After CMU CL was released into the public domain, it was maintained by 11 | volunteers, who continued the tradition of releasing their work into 12 | the public domain. 13 | 14 | All changes to SBCL since the fork from CMU CL have been released into 15 | the public domain in jurisdictions where this is possible, or under 16 | the FreeBSD licence where not. 17 | 18 | Thus, there are no known obstacles to copying, using, and modifying 19 | SBCL freely, as long as copyright notices of MIT, Symbolics, Xerox and 20 | Gerd Moellmann are retained. 21 | -------------------------------------------------------------------------------- /README.sbcl-win32-threads.txt: -------------------------------------------------------------------------------- 1 | UNOFFICIAL TEMPORAL FORK [SBCL-WIN32-THREADS] SPECIFIC NOTES 2 | 3 | Project home: http://github.com/akovalenko/sbcl-win32-threads 4 | NEWS: 5 | * Fixed issue #8 in external build scripts: x86-64 MSI build now includes ASDF. 6 | * Prebuilt binaries: make :qslime REPL extension work again after 2011-11-27 SLIME update. 7 | 8 | -------------------------------------------------------------------------------- /binary-distribution.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | set -e 3 | 4 | # Create a binary distribution. (make.sh should be run first to create 5 | # the various binary files, and make-doc.sh should also be run to 6 | # create the HTML version of the documentation.) 7 | 8 | # (Before sbcl-0.6.10, this was run in the sbcl/ directory and created 9 | # a tar file with no directory prefixes. Since sbcl-0.6.10, we've 10 | # switched over to trying to do this the way everyone else does.) 11 | 12 | b=${1:?"missing base directory name argument"} 13 | tar -cf $b-binary.tar \ 14 | $b/output/sbcl.core $b/src/runtime/sbcl $b/output/prefix.def \ 15 | $b/BUGS $b/COPYING $b/CREDITS $b/INSTALL $b/NEWS $b/README \ 16 | $b/install.sh $b/find-gnumake.sh $b/sbcl-pwd.sh $b/run-sbcl.sh \ 17 | $b/doc/sbcl.1 \ 18 | $b/pubring.pgp \ 19 | $b/contrib/asdf-module.mk \ 20 | $b/contrib/vanilla-module.mk \ 21 | `for dir in $b/contrib/*; do 22 | if test -d $dir && test -f $dir/test-passed; then 23 | find $dir -name CVS -type d -prune -o \! -type d \! -name '.cvsignore' -print 24 | fi 25 | done` 26 | -------------------------------------------------------------------------------- /branch-version.lisp-expr: -------------------------------------------------------------------------------- 1 | "299.wth.kovalenko" 2 | -------------------------------------------------------------------------------- /contrib/.cvsignore: -------------------------------------------------------------------------------- 1 | systems 2 | -------------------------------------------------------------------------------- /contrib/asdf-install/.cvsignore: -------------------------------------------------------------------------------- 1 | asdf-install 2 | test-passed 3 | -------------------------------------------------------------------------------- /contrib/asdf-install/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=asdf-install 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/asdf-install/asdf-install.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | (defpackage #:asdf-install-system 4 | (:use #:cl #:asdf)) 5 | 6 | (in-package #:asdf-install-system) 7 | 8 | (defsystem asdf-install 9 | :depends-on (sb-posix sb-bsd-sockets) 10 | :version "0.2" 11 | #+sb-building-contrib :pathname 12 | #+sb-building-contrib #p"SYS:CONTRIB;ASDF-INSTALL;" 13 | :components ((:file "defpackage") 14 | (:file "installer" :depends-on ("defpackage")))) 15 | 16 | (defmethod perform :after ((o load-op) (c (eql (find-system :asdf-install)))) 17 | (provide 'asdf-install)) 18 | 19 | (defmethod perform ((o test-op) (c (eql (find-system :asdf-install)))) 20 | t) 21 | -------------------------------------------------------------------------------- /contrib/asdf-install/defpackage.lisp: -------------------------------------------------------------------------------- 1 | (cl:in-package :cl-user) 2 | (defpackage :asdf-install 3 | (:use "CL" "SB-EXT" "SB-BSD-SOCKETS") 4 | (:export 5 | ;; customizable variables 6 | #:*proxy* #:*cclan-mirror* #:*sbcl-home* 7 | #:*locations* 8 | ;; external entry points 9 | #:uninstall #:install)) 10 | 11 | (defpackage :asdf-install-customize 12 | (:use "CL" "SB-EXT" "SB-BSD-SOCKETS" "ASDF-INSTALL")) 13 | -------------------------------------------------------------------------------- /contrib/asdf-stub.lisp: -------------------------------------------------------------------------------- 1 | (load "SYS:CONTRIB;ASDF;ASDF.FASL") 2 | 3 | (let ((asdf:*central-registry* nil)) 4 | (push :sb-building-contrib *features*) 5 | (asdf:operate 'asdf:load-op *system*) 6 | (let ((stub (make-pathname :name *system* :type "lisp"))) 7 | (when (probe-file (compile-file-pathname stub)) 8 | (error "fasl file exists")) 9 | (with-open-file (s stub :direction :output :if-exists :error) 10 | (print '(unless (member "ASDF" *modules* :test #'string=) 11 | (require :asdf)) 12 | s) 13 | ;; we find our contribs without reference to *central-registry*. 14 | (print `(let ((asdf:*central-registry* nil)) 15 | (asdf::module-provide-asdf ,*system*)) 16 | s)) 17 | (compile-file stub) 18 | (delete-file stub))) 19 | -------------------------------------------------------------------------------- /contrib/asdf/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/asdf/Makefile: -------------------------------------------------------------------------------- 1 | MODULE=asdf 2 | include ../vanilla-module.mk 3 | 4 | 5 | test:: 6 | true 7 | 8 | up: 9 | sh pull-asdf.sh 10 | cp asdf-upstream/asdf.lisp asdf.lisp 11 | cp asdf-upstream/doc/asdf.texinfo asdf.texinfo 12 | cp asdf-upstream/README README 13 | -------------------------------------------------------------------------------- /contrib/asdf/README: -------------------------------------------------------------------------------- 1 | ASDF: another system definition facility 2 | ======================================== 3 | 4 | If you want to use ASDF, read our manual: 5 | 6 | http://common-lisp.net/project/asdf/asdf.html 7 | 8 | The first few sections, Loading ASDF, Configuring ASDF and Using ASDF, 9 | will get you started as a simple user. 10 | 11 | If you want to define your own systems, further read the section 12 | Defining systems with defsystem. 13 | 14 | More information and additional links can be found on ASDF's 15 | home page at: 16 | 17 | http://common-lisp.net/project/asdf/ 18 | 19 | 20 | last updated Wednesday; May 5, 2010 21 | -------------------------------------------------------------------------------- /contrib/asdf/README.SBCL: -------------------------------------------------------------------------------- 1 | The copies of asdf.lisp, asdf.texinfo, README, and LICENSE in this 2 | directory are complete and unchanged from the canonical versions at 3 | 4 | http://common-lisp.net/project/asdf/asdf.git 5 | 6 | They may lag the upstream version by a few revisions (but shouldn't 7 | usually) but unless we've fouled up horribly, are not forked. 8 | 9 | The README file thus applies in its entirety apart from the scary 10 | warnings about making sure you have the right version and it has not 11 | been mutilated. 12 | -------------------------------------------------------------------------------- /contrib/asdf/pull-asdf.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | # Get the current ASDF release from the upstream repo. 4 | 5 | if test -d asdf-upstream 6 | then 7 | cd asdf-upstream 8 | git checkout release 9 | git reset --hard release 10 | git pull -a 11 | else 12 | git clone --branch release git://common-lisp.net/projects/asdf/asdf.git asdf-upstream 13 | fi 14 | -------------------------------------------------------------------------------- /contrib/code-extras.lisp: -------------------------------------------------------------------------------- 1 | ;;;; (See the comments at the head of the file compiler-extras.lisp.) 2 | 3 | (in-package "SB-IMPL") 4 | 5 | (declaim (optimize (speed 3) (space 1))) 6 | 7 | ;;; FIXME: should DEFUN REPLACE in terms of same expansion as 8 | ;;; DEFTRANSFORM 9 | #+nil 10 | (defun replace (..) 11 | (cond ((and (typep seq1 'simple-vector) 12 | (typep seq2 'simple-vector)) 13 | (%replace-vector-vector ..)) 14 | ((and (typep seq1 'simple-string) 15 | (typep seq2 'simple-string)) 16 | (%replace-vector-vector ..)) 17 | (t 18 | ..))) 19 | 20 | -------------------------------------------------------------------------------- /contrib/sb-aclrepl/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-aclrepl/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-aclrepl 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-aclrepl/sb-aclrepl.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | (defpackage #:sb-aclrepl-system (:use #:asdf #:cl)) 4 | (in-package #:sb-aclrepl-system) 5 | 6 | (defsystem sb-aclrepl 7 | :author "Kevin Rosenberg " 8 | :description "An AllegroCL compatible REPL" 9 | #+sb-building-contrib :pathname 10 | #+sb-building-contrib #p"SYS:CONTRIB;SB-ACLREPL;" 11 | :components ((:file "toplevel") 12 | (:file "repl" :depends-on ("toplevel")) 13 | (:file "inspect" :depends-on ("repl")) 14 | (:file "debug" :depends-on ("repl")))) 15 | 16 | (defmethod perform :after ((o load-op) (c (eql (find-system :sb-aclrepl)))) 17 | (provide 'sb-aclrepl)) 18 | 19 | (defmethod perform ((o test-op) (c (eql (find-system :sb-aclrepl)))) 20 | (oos 'load-op 'sb-aclrepl-tests) 21 | (oos 'test-op 'sb-aclrepl-tests)) 22 | 23 | (defsystem sb-aclrepl-tests 24 | :depends-on (sb-rt) 25 | :components ((:file "tests"))) 26 | 27 | (defmethod perform ((o test-op) (c (eql (find-system :sb-aclrepl-tests)))) 28 | (or (funcall (intern "DO-TESTS" (find-package "SB-RT"))) 29 | (error "test-op failed"))) 30 | -------------------------------------------------------------------------------- /contrib/sb-bsd-sockets/.cvsignore: -------------------------------------------------------------------------------- 1 | a.out 2 | *.lisp-temp 3 | foo.c 4 | test-passed 5 | -------------------------------------------------------------------------------- /contrib/sb-bsd-sockets/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-bsd-sockets 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-bsd-sockets/TODO: -------------------------------------------------------------------------------- 1 | 2 | Things To Do - Urgent! (with apologies to Douglas Adams) 3 | 4 | I probably have opinions about how to do most of these. Even if not, 5 | I almost certainly have opinions on how not to. Send me a proposal 6 | before spending serious amounts of time on it. 7 | 8 | - the rest of the functions. A socket-send that doesn't use streams 9 | would be a good one 10 | 11 | - the rest of the errors 12 | 13 | - the rest of the socket options: integer and boolean socket-level 14 | options are in but need odd ones, plus tcp, udp, ip 15 | 16 | - async name service lookups. 17 | 18 | - write tests for socket-name and socket-peername 19 | 20 | -------------------------------------------------------------------------------- /contrib/sb-bsd-sockets/split.lisp: -------------------------------------------------------------------------------- 1 | (in-package :sb-bsd-sockets) 2 | 3 | ;;; This courtesy of Pierre Mai in comp.lang.lisp 08 Jan 1999 00:51:44 +0100 4 | ;;; Message-ID: <87lnjebq0f.fsf@orion.dent.isdn.cs.tu-berlin.de> 5 | 6 | (defun split (string &optional max (ws '(#\Space #\Tab))) 7 | "Split `string' along whitespace as defined by the sequence `ws'. 8 | The whitespace is elided from the result. The whole string will be 9 | split, unless `max' is a non-negative integer, in which case the 10 | string will be split into `max' tokens at most, the last one 11 | containing the whole rest of the given `string', if any." 12 | (flet ((is-ws (char) (find char ws))) 13 | (loop for start = (position-if-not #'is-ws string) 14 | then (position-if-not #'is-ws string :start index) 15 | for index = (and start 16 | (if (and max (= (1+ word-count) max)) 17 | nil 18 | (position-if #'is-ws string :start start))) 19 | while start 20 | collect (subseq string start index) 21 | count 1 into word-count 22 | while index))) 23 | 24 | -------------------------------------------------------------------------------- /contrib/sb-bsd-sockets/win32-lib.lisp: -------------------------------------------------------------------------------- 1 | (eval-when (:compile-toplevel :load-toplevel :execute) 2 | (sb-alien:load-shared-object "ws2_32.dll") 3 | (sb-alien:load-shared-object "msvcrt.dll")) 4 | -------------------------------------------------------------------------------- /contrib/sb-cltl2/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-cltl2/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-cltl2 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-cltl2/defpackage.lisp: -------------------------------------------------------------------------------- 1 | (defpackage :sb-cltl2 2 | (:use :cl :sb-c :sb-int :sb-kernel) 3 | (:export #:compiler-let 4 | #:macroexpand-all 5 | ;; environment access 6 | #:variable-information 7 | #:function-information 8 | #:declaration-information 9 | #:augment-environment 10 | #:define-declaration 11 | #:parse-macro 12 | #:enclose 13 | )) 14 | -------------------------------------------------------------------------------- /contrib/sb-cltl2/macroexpand.lisp: -------------------------------------------------------------------------------- 1 | (in-package :sb-cltl2) 2 | 3 | (defun macroexpand-all (form &optional environment) 4 | (let ((sb-walker::*walk-form-expand-macros-p* t)) 5 | (sb-walker:walk-form form environment))) 6 | -------------------------------------------------------------------------------- /contrib/sb-cltl2/sb-cltl2.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | (defpackage #:sb-cltl2-system (:use #:asdf #:cl)) 4 | (in-package #:sb-cltl2-system) 5 | 6 | (defsystem sb-cltl2 7 | :description "Functionality mentioned in CLtL2 but not present in ANSI." 8 | #+sb-building-contrib :pathname 9 | #+sb-building-contrib #p"SYS:CONTRIB;SB-CLTL2;" 10 | :components ((:file "defpackage") 11 | (:file "compiler-let" :depends-on ("defpackage")) 12 | (:file "macroexpand" :depends-on ("defpackage")) 13 | (:file "env" :depends-on ("defpackage")))) 14 | 15 | (defmethod perform :after ((o load-op) (c (eql (find-system :sb-cltl2)))) 16 | (provide 'sb-cltl2)) 17 | 18 | (defmethod perform ((o test-op) (c (eql (find-system :sb-cltl2)))) 19 | (oos 'load-op 'sb-cltl2-tests) 20 | (oos 'test-op 'sb-cltl2-tests)) 21 | 22 | (defsystem sb-cltl2-tests 23 | :depends-on (sb-rt) 24 | :components ((:file "tests"))) 25 | 26 | (defmethod perform ((o test-op) (c (eql (find-system :sb-cltl2-tests)))) 27 | (or (funcall (find-symbol "DO-TESTS" "SB-RT")) 28 | (error "test-op failed"))) 29 | -------------------------------------------------------------------------------- /contrib/sb-concurrency/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-concurrency/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-concurrency 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-concurrency/tests/package.lisp: -------------------------------------------------------------------------------- 1 | 2 | (in-package :cl-user) 3 | 4 | (defpackage :sb-concurrency-test 5 | (:use :cl :sb-thread :sb-concurrency :sb-rt)) -------------------------------------------------------------------------------- /contrib/sb-concurrency/tests/test-utils.lisp: -------------------------------------------------------------------------------- 1 | ;;;; -*- Lisp -*- 2 | ;;;; 3 | ;;;; This software is part of the SBCL system. See the README file for 4 | ;;;; more information. 5 | ;;;; 6 | ;;;; This software is derived from the CMU CL system, which was 7 | ;;;; written at Carnegie Mellon University and released into the 8 | ;;;; public domain. The software is in the public domain and is 9 | ;;;; provided with absolutely no warranty. See the COPYING and CREDITS 10 | ;;;; files for more information. 11 | 12 | (in-package :sb-concurrency-test) 13 | 14 | #+sb-thread 15 | (progn 16 | 17 | (defparameter +timeout+ 120.0) 18 | 19 | (defun make-threads (n name fn) 20 | (loop for i from 1 to n 21 | collect (make-thread fn :name (format nil "~A-~D" name i)))) 22 | 23 | (defun timed-join-thread (thread &optional (timeout +timeout+)) 24 | (handler-case (sb-sys:with-deadline (:seconds timeout) 25 | (join-thread thread :default :aborted)) 26 | (sb-ext:timeout () 27 | :timeout))) 28 | 29 | (defun hang () 30 | (join-thread *current-thread*)) 31 | 32 | (defun kill-thread (thread) 33 | (when (thread-alive-p thread) 34 | (ignore-errors 35 | (terminate-thread thread)))) 36 | 37 | ) ;; #+sb-thread (progn ... 38 | -------------------------------------------------------------------------------- /contrib/sb-cover/.cvsignore: -------------------------------------------------------------------------------- 1 | test-output 2 | test-passed 3 | -------------------------------------------------------------------------------- /contrib/sb-cover/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-cover 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-cover/sb-cover.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | (defsystem sb-cover 4 | #+sb-building-contrib :pathname 5 | #+sb-building-contrib #p"SYS:CONTRIB;SB-COVER;" 6 | :depends-on (sb-md5) 7 | :components ((:file "cover"))) 8 | 9 | (defsystem sb-cover-tests 10 | :components ((:file "tests"))) 11 | 12 | (defmethod perform :after ((o load-op) (c (eql (find-system :sb-cover)))) 13 | (provide 'sb-cover)) 14 | 15 | (defmethod perform ((o test-op) (c (eql (find-system :sb-cover)))) 16 | (operate 'load-op 'sb-cover-tests) 17 | (operate 'test-op 'sb-cover-tests)) 18 | -------------------------------------------------------------------------------- /contrib/sb-cover/test-data-1.lisp: -------------------------------------------------------------------------------- 1 | (in-package sb-cover-test) 2 | 3 | (defun test1 () 4 | (+ 1 2)) 5 | 6 | -------------------------------------------------------------------------------- /contrib/sb-cover/test-data-2.lisp: -------------------------------------------------------------------------------- 1 | (in-package sb-cover-test) 2 | 3 | (defun test2 (x) 4 | (let ((a 0)) 5 | (when (plusp x) 6 | (incf a)) 7 | a)) 8 | 9 | ;;; Test for a bad interaction between *READ-SUPPRESS* and #. in 10 | ;;; source location recording. 11 | (identity #+sbcl #.1 12 | #+cmu #.3) 13 | 14 | ;;; This test would show that we do correct detection of non-cons 15 | ;;; source forms in non-PROGN-contexts. Which we don't, so this test 16 | ;;; is commented out. 17 | #+nil 18 | (defun test2-b (x) 19 | (let ((a 0)) 20 | (when x 21 | (incf a)) 22 | a)) 23 | -------------------------------------------------------------------------------- /contrib/sb-cover/test-data-3.lisp: -------------------------------------------------------------------------------- 1 | (declaim (optimize sb-c::store-coverage-data)) 2 | 3 | (defun test-1 () 4 | (print '((1 3 1)))) 5 | 6 | (defun test-2 () 7 | (assert (equal (test-1) 8 | (list (list 1 3 1))))) 9 | -------------------------------------------------------------------------------- /contrib/sb-executable/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-executable/Makefile: -------------------------------------------------------------------------------- 1 | MODULE=sb-executable 2 | include ../vanilla-module.mk 3 | 4 | test:: 5 | true 6 | -------------------------------------------------------------------------------- /contrib/sb-grovel/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-grovel/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-grovel 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-grovel/defpackage.lisp: -------------------------------------------------------------------------------- 1 | (defpackage "SB-GROVEL" 2 | (:export "GROVEL-CONSTANTS-FILE") 3 | (:shadow "TYPE" "UNION") 4 | ;; FIXME: This is a really quick and dirty package lock compliance 5 | ;; fix, that should be redone. Specifically, this is needed to address the 6 | ;; nasty things done with SB-ALIEN:STRUCT. 7 | #+sb-package-locks 8 | (:implement "SB-ALIEN") 9 | (:use "COMMON-LISP" "SB-ALIEN" "ASDF" "SB-EXT")) 10 | -------------------------------------------------------------------------------- /contrib/sb-grovel/sb-grovel.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | (defpackage #:sb-grovel-system (:use #:asdf #:cl)) 4 | (in-package #:sb-grovel-system) 5 | 6 | (defsystem sb-grovel 7 | :version "0.01" 8 | #+sb-building-contrib :pathname 9 | #+sb-building-contrib #p"SYS:CONTRIB;SB-GROVEL;" 10 | :components ((:file "defpackage") 11 | (:file "def-to-lisp" :depends-on ("defpackage")) 12 | (:file "foreign-glue" :depends-on ("defpackage")))) 13 | 14 | (defmethod perform :after ((o load-op) (c (eql (find-system :sb-grovel)))) 15 | (provide 'sb-grovel)) 16 | 17 | (defmethod perform ((o test-op) (c (eql (find-system :sb-grovel)))) 18 | t) 19 | 20 | -------------------------------------------------------------------------------- /contrib/sb-introspect/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-introspect/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-introspect 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-introspect/load-test.lisp: -------------------------------------------------------------------------------- 1 | ;;; 2 | ;;; The order of the forms must not change, as the order is checked in 3 | ;;; `test-driver.lisp'. Thus do not alter this file unless you edit 4 | ;;; test-driver.lisp to match. 5 | ;;; 6 | 7 | (declaim (optimize (debug 3))) 8 | (in-package :cl-user) 9 | 10 | (eval-when (:compile-toplevel) 11 | (error "load-test.lisp needs to be loaded as source")) 12 | 13 | (defun loaded-as-source-fun () 14 | t) 15 | -------------------------------------------------------------------------------- /contrib/sb-md5/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-md5/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-md5 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-md5/sb-md5.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | (defpackage #:sb-md5-system 4 | (:use #:cl #:asdf)) 5 | 6 | (in-package #:sb-md5-system) 7 | 8 | (defsystem sb-md5 9 | :depends-on (sb-rotate-byte) 10 | :version "1.8" 11 | #+sb-building-contrib :pathname 12 | #+sb-building-contrib #p"SYS:CONTRIB;SB-MD5;" 13 | :components ((:file "md5"))) 14 | 15 | (defmethod perform :after ((o load-op) (c (eql (find-system :sb-md5)))) 16 | (provide 'sb-md5)) 17 | 18 | (defmethod perform ((o test-op) (c (eql (find-system :sb-md5)))) 19 | (operate 'load-op 'sb-md5-tests) 20 | (operate 'test-op 'sb-md5-tests)) 21 | 22 | (defsystem sb-md5-tests 23 | :depends-on (sb-md5 sb-rt) 24 | :version "1.8" 25 | :components ((:file "md5-tests"))) 26 | 27 | (defmethod perform ((o test-op) (c (eql (find-system :sb-md5-tests)))) 28 | (or (funcall (intern "DO-TESTS" (find-package "SB-RT"))) 29 | (error "test-op failed"))) 30 | -------------------------------------------------------------------------------- /contrib/sb-md5/sb-md5.texinfo: -------------------------------------------------------------------------------- 1 | @node sb-md5 2 | @section sb-md5 3 | @cindex Hashing, cryptographic 4 | 5 | The @code{sb-md5} module implements the RFC1321 MD5 Message Digest 6 | Algorithm. [FIXME cite] 7 | 8 | @include fun-sb-md5-md5sum-file.texinfo 9 | 10 | @include fun-sb-md5-md5sum-sequence.texinfo 11 | 12 | @include fun-sb-md5-md5sum-stream.texinfo 13 | 14 | @include fun-sb-md5-md5sum-string.texinfo 15 | 16 | @subsection Credits 17 | 18 | The implementation for CMUCL was largely done by Pierre Mai, with help 19 | from members of the @code{cmucl-help} mailing list. Since CMUCL and 20 | SBCL are similar in many respects, it was not too difficult to extend 21 | the low-level implementation optimizations for CMUCL to SBCL. 22 | Following this, SBCL's compiler was extended to implement efficient 23 | compilation of modular arithmetic (@pxref{Modular arithmetic}), which 24 | enabled the implementation to be expressed in portable arithmetical 25 | terms, apart from the use of @code{rotate-byte} for bitwise rotation. 26 | @findex @sbrotatebyte{rotate-byte} 27 | 28 | -------------------------------------------------------------------------------- /contrib/sb-posix/.cvsignore: -------------------------------------------------------------------------------- 1 | a.out 2 | *.lisp-temp 3 | foo.c 4 | test-output 5 | test-passed 6 | -------------------------------------------------------------------------------- /contrib/sb-posix/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-posix 2 | include ../asdf-module.mk 3 | 4 | -------------------------------------------------------------------------------- /contrib/sb-posix/defpackage.lisp: -------------------------------------------------------------------------------- 1 | (defpackage :sb-posix (:use #:sb-alien #:cl) 2 | (:shadow abort close open ftruncate truncate time read write) 3 | (:export #:syscall-error #:syscall-errno #:syscall-name 4 | 5 | ;; types and type conversion 6 | #:file-descriptor-designator 7 | #:file-descriptor 8 | #:filename-designator 9 | #:filename 10 | 11 | ;; grovel structure accessors 12 | #:dirent-name #-win32 #:dirent-ino 13 | 14 | ;; wrapper class accessors 15 | #:passwd-name #:passwd-passwd #:passwd-uid #:passwd-gid 16 | #:passwd-gecos #:passwd-dir #:passwd-shell 17 | #:group-name #:group-gid #:group-passwd 18 | #:stat-mode #:stat-ino #:stat-dev #:stat-nlink #:stat-uid 19 | #:stat-gid #:stat-size #:stat-atime #:stat-mtime #:stat-ctime 20 | #:stat-rdev 21 | #:termios-iflag #:termios-oflag #:termios-cflag 22 | #:termios-lflag #:termios-cc #:timeval-sec #:timeval-usec 23 | #:flock-type #:flock-whence #:flock-start #:flock-len 24 | #:flock-pid)) 25 | 26 | #+win32 27 | (sb-alien:load-shared-object "msvcrt.dll") 28 | -------------------------------------------------------------------------------- /contrib/sb-posix/designator.lisp: -------------------------------------------------------------------------------- 1 | (in-package :sb-posix) 2 | (defvar *designator-types* (make-hash-table :test #'equal)) 3 | 4 | (defmacro define-designator (name (lisp-type alien-type) doc 5 | &body conversions) 6 | (let ((designator-type `(or ,@(mapcar #'car conversions))) 7 | (designator-name (intern (format nil "~A-~A" 8 | (symbol-name name) 9 | (symbol-name :designator)) 10 | #.*package*)) 11 | (name (intern (symbol-name name) :sb-posix))) 12 | `(progn 13 | (deftype ,name () 14 | ,@(when doc (list (first doc))) 15 | ',lisp-type) 16 | (deftype ,designator-name () 17 | ,@(when doc (list (second doc))) 18 | ',designator-type) 19 | (eval-when (:compile-toplevel :load-toplevel :execute) 20 | (setf (gethash ',name *designator-types*) ',alien-type)) 21 | (declaim (ftype (function (t) (values ,lisp-type &optional)) ,name)) 22 | (defun ,name (,name) 23 | ,@(when doc (list (third doc))) 24 | (etypecase ,name 25 | ,@conversions))))) 26 | 27 | -------------------------------------------------------------------------------- /contrib/sb-queue/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-queue/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-queue 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-queue/package.lisp: -------------------------------------------------------------------------------- 1 | ;;;; This software is part of the SBCL system. See the README file for 2 | ;;;; more information. 3 | ;;;; 4 | ;;;; This software is derived from the CMU CL system, which was written at 5 | ;;;; Carnegie Mellon University and released into the public domain. The 6 | ;;;; software is in the public domain and is provided with absolutely no 7 | ;;;; warranty. See the COPYING and CREDITS files for more information. 8 | 9 | ;;; SB-QUEUE has been slurped in SB-CONCURRENCY. 10 | 11 | ;;; Here we just provide a reexporting stub for backwards 12 | ;;; compatibility. 13 | 14 | (defpackage :sb-queue 15 | (:use :cl :sb-concurrency) 16 | (:export 17 | "DEQUEUE" 18 | "ENQUEUE" 19 | "LIST-QUEUE-CONTENTS" 20 | "MAKE-QUEUE" 21 | "QUEUE" 22 | "QUEUE-COUNT" 23 | "QUEUE-EMPTY-P" 24 | "QUEUE-NAME" 25 | "QUEUEP")) -------------------------------------------------------------------------------- /contrib/sb-queue/sb-queue.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | ;;;; This software is part of the SBCL system. See the README file for 4 | ;;;; more information. 5 | ;;;; 6 | ;;;; This software is derived from the CMU CL system, which was 7 | ;;;; written at Carnegie Mellon University and released into the 8 | ;;;; public domain. The software is in the public domain and is 9 | ;;;; provided with absolutely no warranty. See the COPYING and CREDITS 10 | ;;;; files for more information. 11 | 12 | (in-package :cl-user) 13 | 14 | (asdf:defsystem :sb-queue 15 | :depends-on (:sb-concurrency) 16 | :components ((:file "package"))) 17 | 18 | (defmethod asdf:perform :after ((o asdf:load-op) 19 | (c (eql (asdf:find-system :sb-queue)))) 20 | (provide 'sb-queue)) 21 | 22 | 23 | (defmethod asdf:perform ((o asdf:test-op) 24 | (c (eql (asdf:find-system :sb-queue)))) 25 | :pass) -------------------------------------------------------------------------------- /contrib/sb-queue/sb-queue.texinfo: -------------------------------------------------------------------------------- 1 | @node sb-queue 2 | @section sb-queue 3 | @cindex Queue, FIFO 4 | 5 | Since SBCL 1.0.38, the @code{sb-queue} module has been merged into the 6 | @code{sb-concurrency} module (@pxref{sb-concurrency}.) 7 | -------------------------------------------------------------------------------- /contrib/sb-rotate-byte/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-rotate-byte/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-rotate-byte 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-rotate-byte/README: -------------------------------------------------------------------------------- 1 | This module provides an implementation of ROTATE-BYTE, described at 2 | . Its inclusion is hoped to 3 | achieve two aims: 4 | 5 | (1) to provide the necessary functionality for implementations of 6 | cryptographic and hashing algorithms (e.g. MD5); 7 | 8 | (2) to provide an example of the things that can be achieved by using 9 | the external but unsupported interfaces to the compiler. 10 | 11 | Included in the module as of 2003-02-11 is an efficient implementation 12 | of unsigned 32-bit rotation for the x86; when the compiler can prove 13 | that the rotation in question is of an (UNSIGNED-BYTE 32) over the 14 | byte specifier (BYTE 32 0), it will compile directly to machine 15 | rotation instructions. Patches for similar functionality on other 16 | platforms are welcome. 17 | -------------------------------------------------------------------------------- /contrib/sb-rotate-byte/package.lisp: -------------------------------------------------------------------------------- 1 | (defpackage "SB-ROTATE-BYTE" 2 | (:use "CL" "SB-C" "SB-VM" "SB-INT" "SB-KERNEL" "SB-ASSEM") 3 | (:export "ROTATE-BYTE")) 4 | -------------------------------------------------------------------------------- /contrib/sb-rotate-byte/rotate-byte.lisp: -------------------------------------------------------------------------------- 1 | (in-package "SB-ROTATE-BYTE") 2 | 3 | (defun rotate-byte (count bytespec integer) 4 | "Rotates a field of bits within INTEGER; specifically, returns an 5 | integer that contains the bits of INTEGER rotated COUNT times 6 | leftwards within the byte specified by BYTESPEC, and elsewhere 7 | contains the bits of INTEGER." 8 | (rotate-byte count bytespec integer)) 9 | 10 | (defun %rotate-byte (count size pos integer) 11 | (let ((count (nth-value 1 (round count size))) 12 | (mask (1- (ash 1 size)))) 13 | (logior (logand integer (lognot (ash mask pos))) 14 | (let ((field (logand (ash mask pos) integer))) 15 | (logand (ash mask pos) 16 | (if (> count 0) 17 | (logior (ash field count) 18 | (ash field (- count size))) 19 | (logior (ash field count) 20 | (ash field (+ count size))))))))) 21 | 22 | (defun %unsigned-32-rotate-byte (count integer) 23 | ;; inhibit transforms 24 | (declare (notinline %rotate-byte)) 25 | (%rotate-byte count 32 0 integer)) -------------------------------------------------------------------------------- /contrib/sb-rotate-byte/sb-rotate-byte.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | (cl:defpackage #:sb-rotate-byte-system 4 | (:use #:asdf #:cl)) 5 | (cl:in-package #:sb-rotate-byte-system) 6 | 7 | (defsystem sb-rotate-byte 8 | :version "0.1" 9 | #+sb-building-contrib :pathname 10 | #+sb-building-contrib #p"SYS:CONTRIB;SB-ROTATE-BYTE;" 11 | :components 12 | ((:file "package") 13 | (:file "compiler" :depends-on ("package")) 14 | (:module "vm" 15 | :depends-on ("compiler") 16 | :components 17 | (#+x86 18 | (:file "x86-vm") 19 | #+x86-64 20 | (:file "x86-64-vm") 21 | #+ppc 22 | (:file "ppc-vm")) 23 | :pathname 24 | #+sb-building-contrib #p"SYS:CONTRIB;SB-ROTATE-BYTE;" 25 | #-sb-building-contrib #.(make-pathname :directory '(:relative))) 26 | (:file "rotate-byte" :depends-on ("compiler")))) 27 | 28 | (defmethod perform :after ((o load-op) (c (eql (find-system :sb-rotate-byte)))) 29 | (provide 'sb-rotate-byte)) 30 | 31 | (defmethod perform ((o test-op) (c (eql (find-system :sb-rotate-byte)))) 32 | (or (load (compile-file "rotate-byte-tests.lisp")) 33 | (error "test-op failed"))) 34 | -------------------------------------------------------------------------------- /contrib/sb-rotate-byte/sb-rotate-byte.texinfo: -------------------------------------------------------------------------------- 1 | @node sb-rotate-byte 2 | @section sb-rotate-byte 3 | @cindex Modular arithmetic 4 | @cindex Arithmetic, modular 5 | @cindex Arithmetic, hardware 6 | 7 | The @code{sb-rotate-byte} module offers an interface to bitwise 8 | rotation, with an efficient implementation for operations which can be 9 | performed directly using the platform's arithmetic routines. It 10 | implements the specification at 11 | @uref{http://www.cliki.net/ROTATE-BYTE}. 12 | @comment FIXME: except when someone scribbles all over it. Hmm. 13 | 14 | Bitwise rotation is a component of various cryptographic or hashing 15 | algorithms: MD5, SHA-1, etc.; often these algorithms are specified on 16 | 32-bit rings. [FIXME cite cite cite]. 17 | 18 | @include fun-sb-rotate-byte-rotate-byte.texinfo 19 | -------------------------------------------------------------------------------- /contrib/sb-rt/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed 2 | -------------------------------------------------------------------------------- /contrib/sb-rt/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-rt 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-rt/sb-rt.asd: -------------------------------------------------------------------------------- 1 | ;;; -*- Lisp -*- 2 | 3 | (cl:defpackage #:sb-rt-system 4 | (:use #:asdf #:cl)) 5 | (cl:in-package #:sb-rt-system) 6 | 7 | (defsystem sb-rt 8 | :version "0.1.7" ; our version "0", GCL CVS version "1.7" 9 | #+sb-building-contrib :pathname 10 | #+sb-building-contrib #p"SYS:CONTRIB;SB-RT;" 11 | :components ((:file "rt"))) 12 | 13 | (defmethod perform :after ((o load-op) (c (eql (find-system :sb-rt)))) 14 | (provide 'sb-rt)) 15 | 16 | (defmethod perform ((o test-op) (c (eql (find-system :sb-rt)))) 17 | ;; FIXME: Maybe also import rt-tests.lisp? 18 | t) 19 | -------------------------------------------------------------------------------- /contrib/sb-simple-streams/.cvsignore: -------------------------------------------------------------------------------- 1 | a.out 2 | *.lisp-temp 3 | foo.c 4 | test-passed 5 | test-data.tmp 6 | -------------------------------------------------------------------------------- /contrib/sb-simple-streams/Makefile: -------------------------------------------------------------------------------- 1 | SYSTEM=sb-simple-streams 2 | include ../asdf-module.mk 3 | -------------------------------------------------------------------------------- /contrib/sb-simple-streams/TODO: -------------------------------------------------------------------------------- 1 | -*- text -*- 2 | 3 | - Implement & test read-sequence, write-sequence for (un)signed-8 vectors 4 | 5 | - Eliminate consing in sc-read-chars-ef 6 | 7 | - Make reader work with simple-streams 8 | 9 | - external format handling: load aliases, load formats, etc. 10 | 11 | - Handle writing beyond the end of a mapped-simple-stream properly 12 | 13 | - handle device-file-position for mapped streams 14 | 15 | - Test write-octets / read-octets handling of encapsulated streams 16 | 17 | - handle ansi-streams in write-octets / read-octets? 18 | 19 | - Implement socket-base-simple-stream and chunked transfer encoding. 20 | 21 | - Test string streams. 22 | 23 | - Make sure the code examples for stream encapsulation from Franz work 24 | 25 | - Test every single output function 26 | 27 | - Test character position (slot charpos) 28 | 29 | - make pathname work for simple-streams 30 | 31 | - test :abort argument to close (should revert to original file) 32 | 33 | -------------------------------------------------------------------------------- /contrib/sb-simple-streams/lp491087.txt: -------------------------------------------------------------------------------- 1 | 0123 2 | -------------------------------------------------------------------------------- /contrib/sb-simple-streams/sb-simple-streams.texinfo: -------------------------------------------------------------------------------- 1 | Simple streams are an extensible streams protocol that avoids some 2 | problems with Gray streams. 3 | 4 | Documentation about simple streams is available at: 5 | 6 | @uref{http://www.franz.com/support/documentation/6.2/doc/streams.htm} 7 | 8 | The implementation should be considered Alpha-quality; the basic 9 | framework is there, but many classes are just stubs at the moment. 10 | 11 | See @file{SYS:CONTRIB;SB-SIMPLE-STREAMS;SIMPLE-STREAM-TEST.LISP} for 12 | things that should work. 13 | 14 | Known differences to the ACL behaviour: 15 | 16 | @itemize 17 | 18 | @item 19 | @code{open} not return a simple-stream by default. This can be 20 | adjusted; see default-open-class in the file cl.lisp 21 | 22 | @item 23 | @code{write-vector} is unimplemented. 24 | 25 | @end itemize 26 | -------------------------------------------------------------------------------- /contrib/sb-sprof/.cvsignore: -------------------------------------------------------------------------------- 1 | test-passed -------------------------------------------------------------------------------- /contrib/sb-sprof/Makefile: -------------------------------------------------------------------------------- 1 | MODULE=sb-sprof 2 | include ../vanilla-module.mk 3 | 4 | test:: 5 | true 6 | -------------------------------------------------------------------------------- /contrib/sb-sprof/test.lisp: -------------------------------------------------------------------------------- 1 | (in-package :cl-user) 2 | (require :sb-sprof) 3 | 4 | #-(or win32 darwin) ;not yet 5 | (sb-sprof::test) 6 | #-(or win32 darwin) ;not yet 7 | (sb-sprof::consing-test) 8 | 9 | ;; For debugging purposes, print output for visual inspection to see if 10 | ;; the allocation sequence gets hit in the right places (i.e. not at all 11 | ;; in traditional builds, and everywhere if SB-SAFEPOINT-STRICTLY is 12 | ;; enabled.) 13 | (disassemble #'sb-sprof::consalot) 14 | -------------------------------------------------------------------------------- /contrib/vanilla-module.mk: -------------------------------------------------------------------------------- 1 | 2 | $(MODULE).fasl: $(MODULE).lisp ../../output/sbcl.core 3 | $(SBCL) --eval '(compile-file (format nil "SYS:CONTRIB;~:@(~A~);~:@(~A~).LISP" "$(MODULE)" "$(MODULE)"))' . 24 | -------------------------------------------------------------------------------- /doc/clean.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | (cd manual; sh clean.sh) 4 | -------------------------------------------------------------------------------- /doc/entities.inc: -------------------------------------------------------------------------------- 1 | 2 | AMOP"> 3 | ANSI"> 4 | CMU CL"> 5 | IEEE"> 6 | Python"> 7 | SBCL"> 8 | 9 | 10 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /doc/internals/.cvsignore: -------------------------------------------------------------------------------- 1 | *.aux 2 | *.cp 3 | *.cps 4 | *.fn 5 | *.fns 6 | *.info 7 | *.ky 8 | *.log 9 | *.pdf 10 | *.pg 11 | *.toc 12 | *.tp 13 | *.txt 14 | *.vr 15 | *.include 16 | -------------------------------------------------------------------------------- /doc/internals/Makefile: -------------------------------------------------------------------------------- 1 | ifeq ($(TEXI2PDF),) 2 | TEXI2PDF:=texi2dvi -p 3 | endif 4 | 5 | .PHONY: top clean html all 6 | 7 | all: sbcl-internals.pdf sbcl-internals.info 8 | 9 | top: 10 | sh make-top.sh 11 | 12 | info: top 13 | makeinfo sbcl-internals.texinfo 14 | 15 | %.eps: %.dot 16 | dot -Tps -Gsize="5,5" -Gratio=compress -Gconcentrate=true $< > $@ 17 | 18 | %.png: %.dot 19 | dot -Tpng -Gsize="5,5" -Gratio=compress -Gconcentrate=true $< > $@ 20 | 21 | %.txt: %.dot 22 | # FIXME. 23 | dot -Tcanon $< > $@ 24 | 25 | %.pdf: %.eps 26 | epstopdf $< > $@ 27 | 28 | sbcl-internals.pdf: top $(patsubst %.dot,%.pdf,$(wildcard *.dot)) *.texinfo 29 | $(TEXI2PDF) sbcl-internals.texinfo 30 | 31 | sbcl-internals.info: top $(patsubst %.dot,%.txt,$(wildcard *.dot)) *.texinfo 32 | 33 | html: html-stamp 34 | 35 | html-stamp: top $(patsubst %.dot,%.png,$(wildcard *.dot)) *.texinfo 36 | makeinfo --html sbcl-internals.texinfo 37 | # FIXME 38 | cp -f *.png sbcl-internals 39 | touch html-stamp 40 | clean: 41 | rm -rf *.include *.info *.pdf *~ *.cp *.fn *.ky *.log *.pg *.toc \ 42 | *.tp *.vr *.aux *.eps *.png *.dvi *.ps *.txt *.fns \ 43 | html-stamp sbcl-internals/ 44 | -------------------------------------------------------------------------------- /doc/internals/discriminating-functions.dot: -------------------------------------------------------------------------------- 1 | strict digraph dfun { 2 | 3 | mclimit=2.0 4 | 5 | edge [color=gray40] 6 | 7 | oneclass [label="one-class"] 8 | twoclass [label="two-class"] 9 | oneindex [label="one-index"] 10 | nn [label="n-n"] 11 | default [label="default-method-only"] 12 | nomethods [label="no-methods"] 13 | constant [label="constant-value"] 14 | 15 | subgraph class { 16 | 17 | edge [color=black] 18 | 19 | oneclass -> twoclass -> oneindex -> nn 20 | oneclass -> nn 21 | twoclass -> nn 22 | 23 | } 24 | 25 | // oneclass -> caching 26 | // oneclass -> checking 27 | // oneclass -> dispatch 28 | // twoclass -> caching 29 | // twoclass -> checking 30 | // twoclass -> dispatch 31 | // oneindex -> caching 32 | // oneindex -> checking 33 | // oneindex -> dispatch 34 | // nn -> caching 35 | // nn -> checking 36 | // nn -> dispatch 37 | 38 | subgraph class -> caching 39 | subgraph class -> checking 40 | subgraph class -> dispatch 41 | 42 | initial -> oneclass 43 | 44 | initial -> default 45 | initial -> nomethods 46 | initial -> constant 47 | 48 | initial -> caching 49 | initial -> checking -> caching 50 | initial -> dispatch 51 | checking -> dispatch 52 | 53 | } -------------------------------------------------------------------------------- /doc/internals/sbcl-internals.texinfo: -------------------------------------------------------------------------------- 1 | \input texinfo @c -*-texinfo-*- 2 | @c %**start of header 3 | @setfilename sbcl-internals.info 4 | @settitle SBCL Internals 5 | @c %**end of header 6 | 7 | @settitle SBCL Internals 8 | 9 | @c for install-info 10 | @dircategory Software development 11 | @direntry 12 | * sbcl-internals: (sbcl-internals). SBCL internal documentation 13 | @end direntry 14 | 15 | @copying 16 | @quotation 17 | This manual is part of the SBCL software system. See the 18 | @file{README} file for more information. 19 | 20 | This manual is in the public domain and is provided with absolutely no 21 | warranty. See the @file{COPYING} and @file{CREDITS} files for more 22 | information. 23 | @end quotation 24 | @end copying 25 | 26 | @titlepage 27 | 28 | @title SBCL Internals 29 | @c @author The CMUCL and SBCL teams 30 | 31 | @c The following two commands start the copyright page. 32 | @page 33 | @vskip 0pt plus 1filll 34 | @insertcopying 35 | 36 | @end titlepage 37 | 38 | @contents 39 | 40 | @ifnottex 41 | 42 | @node Top 43 | @comment node-name, next, previous, up 44 | @top SBCL Internals 45 | 46 | @insertcopying 47 | 48 | @include top-menu.include 49 | 50 | @end ifnottex 51 | 52 | @include top-include.include 53 | 54 | @bye 55 | -------------------------------------------------------------------------------- /doc/make-doc.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | . ../find-gnumake.sh 4 | find_gnumake 5 | 6 | (cd ./manual ; $GNUMAKE html pdf info) 7 | -------------------------------------------------------------------------------- /doc/manual/.cvsignore: -------------------------------------------------------------------------------- 1 | contrib-doc-list.texi-temp 2 | docstrings 3 | variables.texinfo 4 | *-stamp 5 | asdf 6 | sbcl 7 | *.aux 8 | *.cp 9 | *.cps 10 | *.dvi 11 | *.fn 12 | *.fns 13 | *.html 14 | *.info 15 | *.info-1 16 | *.info-2 17 | *.ky 18 | *.log 19 | *.pg 20 | *.texi-temp 21 | *.toc 22 | *.tp 23 | *.tps 24 | *.ps 25 | *.pdf 26 | *.vr 27 | *.vrs 28 | -------------------------------------------------------------------------------- /doc/manual/.gitignore: -------------------------------------------------------------------------------- 1 | *.aux 2 | *.cp 3 | *.cps 4 | *.fn 5 | *.fns 6 | *.ky 7 | *.log 8 | *.pg 9 | *.texi-temp 10 | *.toc 11 | *.tp 12 | *.tps 13 | *.vr 14 | *.vrs 15 | asdf.info* 16 | asdf.pdf 17 | asdf.ps 18 | asdf.texinfo 19 | asdf/ 20 | docstrings/ 21 | html-stamp 22 | sbcl.info* 23 | sbcl.pdf 24 | sbcl.ps 25 | sbcl/ 26 | tempfiles-stamp 27 | variables.texinfo 28 | -------------------------------------------------------------------------------- /doc/manual/TEXINFO-HINTS: -------------------------------------------------------------------------------- 1 | -*- text -*- 2 | 3 | Some hints for editing the manual files. Feel free to add anything 4 | that will save the next person some time. Thanks! 5 | 6 | 7 | - There's no need for Next, Prev, etc. pointers in @node lines: 8 | makeinfo will deduce these automatically when the line after @node 9 | contains a sectioning command like @section, @subsection. Hence, 10 | texinfo-multiple-files-update should not be used either. 11 | 12 | - Don't create or update Menus by hand; use C-c C-u C-a 13 | (texinfo-all-menus-update) instead. (Doesn't work in sbcl.texinfo, 14 | but this file is only changed when an entire chapter is added.) 15 | -------------------------------------------------------------------------------- /doc/manual/backmatter.texinfo: -------------------------------------------------------------------------------- 1 | @node Concept Index 2 | @comment node-name, next, previous, up 3 | @appendix Concept Index 4 | 5 | @printindex cp 6 | 7 | @node Function Index 8 | @comment node-name, next, previous, up 9 | @appendix Function Index 10 | 11 | @printindex fn 12 | 13 | @node Variable Index 14 | @comment node-name, next, previous, up 15 | @appendix Variable Index 16 | 17 | @printindex vr 18 | 19 | @node Type Index 20 | @comment node-name, next, previous, up 21 | @appendix Type Index 22 | 23 | @printindex tp 24 | 25 | @node Colophon 26 | @comment node-name, next, previous, up 27 | @unnumbered Colophon 28 | 29 | This manual is maintained in Texinfo, and automatically translated 30 | into other forms (e.g. HTML or pdf). If you're @emph{reading} this 31 | manual in one of these non-Texinfo translated forms, that's fine, but 32 | if you want to @emph{modify} this manual, you are strongly advised to 33 | seek out a Texinfo version and modify that instead of modifying a 34 | translated version. Even better might be to seek out @emph{the} 35 | Texinfo version (maintained at the time of this writing as part of the 36 | SBCL project at @uref{http://sbcl.sourceforge.net/}) and submit a 37 | patch. 38 | -------------------------------------------------------------------------------- /doc/manual/clean.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | . ../../find-gnumake.sh 4 | find_gnumake 5 | $GNUMAKE clean 6 | -------------------------------------------------------------------------------- /doc/manual/contrib-modules.texinfo: -------------------------------------------------------------------------------- 1 | @node Contributed Modules 2 | @comment node-name, next, previous, up 3 | @chapter Contributed Modules 4 | 5 | SBCL comes with a number of modules that are not part of the core 6 | system. These are loaded via @code{(require :@var{modulename})} 7 | (@pxref{Customization Hooks for Users}). This section contains 8 | documentation (or pointers to documentation) for some of the 9 | contributed modules. 10 | 11 | @menu 12 | * sb-aclrepl:: 13 | * sb-concurrency:: 14 | * sb-cover:: 15 | * sb-grovel:: 16 | * sb-md5:: 17 | * sb-posix:: 18 | * sb-queue:: 19 | * sb-rotate-byte:: 20 | @end menu 21 | 22 | @page 23 | @include sb-aclrepl/sb-aclrepl.texinfo 24 | 25 | @page 26 | @include sb-concurrency/sb-concurrency.texinfo 27 | 28 | @page 29 | @include sb-cover/sb-cover.texinfo 30 | 31 | @page 32 | @include sb-grovel/sb-grovel.texinfo 33 | 34 | @page 35 | @include sb-md5/sb-md5.texinfo 36 | 37 | @page 38 | @include sb-posix/sb-posix.texinfo 39 | 40 | @page 41 | @include sb-queue/sb-queue.texinfo 42 | 43 | @page 44 | @include sb-rotate-byte/sb-rotate-byte.texinfo 45 | 46 | 47 | -------------------------------------------------------------------------------- /doc/manual/package-locks-basic.texinfo: -------------------------------------------------------------------------------- 1 | @node Package Locks 2 | @comment node-name, next, previous, up 3 | @chapter Package Locks 4 | 5 | SBCL can be built with support for package locks to protect against 6 | unintentional modifications of packages. The full documentation for 7 | package locks is only built if package locks are enabled in the image 8 | the documentation was built from, 9 | 10 | Package locking support is currently not built by default. To build 11 | SBCL with package locking enabled add @code{:sb-package-locks} to 12 | target @code{*features*} as per instructions in the file 13 | @file{INSTALL}. 14 | -------------------------------------------------------------------------------- /doc/manual/profiling.texinfo: -------------------------------------------------------------------------------- 1 | @node Profiling 2 | @comment node-name, next, previous, up 3 | @chapter Profiling 4 | @cindex Profiling 5 | 6 | SBCL includes both a deterministic profiler, that can collect statistics 7 | on individual functions, and a more ``modern'' statistical profiler. 8 | 9 | Inlined functions do not appear in the results reported by either. 10 | 11 | @menu 12 | * Deterministic Profiler:: 13 | * Statistical Profiler:: 14 | @end menu 15 | 16 | @node Deterministic Profiler 17 | @comment node-name, next, previous, up 18 | @section Deterministic Profiler 19 | @cindex Profiling, deterministic 20 | 21 | The package @code{sb-profile} provides a classic, per-function-call 22 | profiler. 23 | 24 | @strong{NOTE}: When profiling code executed by multiple threads in 25 | parallel, the consing attributed to each function is inaccurate. 26 | 27 | @include macro-sb-profile-profile.texinfo 28 | @include macro-sb-profile-unprofile.texinfo 29 | @include fun-sb-profile-report.texinfo 30 | @include fun-sb-profile-reset.texinfo 31 | 32 | @node Statistical Profiler 33 | @comment node-name, next, previous, up 34 | @section Statistical Profiler 35 | @include sb-sprof/sb-sprof.texinfo 36 | -------------------------------------------------------------------------------- /doc/manual/style-multi.css: -------------------------------------------------------------------------------- 1 | .chapter { background-color:#d0e4fe; } 2 | .section { background-color:#d0e4fe; } 3 | .subsection { background-color:#d0e4fe; } 4 | .settitle { background-color:#d0e4fe; } 5 | .contents { border: 2px solid black; 6 | margin: 1cm 1cm 1cm 1cm; 7 | padding-left: 3mm; } 8 | body { padding-left: 3mm; } -------------------------------------------------------------------------------- /doc/manual/style-single.css: -------------------------------------------------------------------------------- 1 | .node { visibility:hidden; height: 0px; } 2 | .menu { visibility:hidden; height: 0px; } 3 | .chapter { background-color:#d0e4fe; } 4 | .section { background-color:#d0e4fe; } 5 | .subsection { background-color:#d0e4fe; } 6 | .settitle { background-color:#d0e4fe; } 7 | .contents { border: 2px solid black; 8 | margin: 1cm 1cm 1cm 1cm; 9 | padding-left: 3mm; } 10 | body { padding-left: 3mm; } -------------------------------------------------------------------------------- /doc/manual/texinfo-macros.texinfo: -------------------------------------------------------------------------------- 1 | @c Some plain TeX macrology to wrap text in \hbox{} only if the text 2 | @c contains no hyphens. 3 | @iftex 4 | @tex 5 | \newif\ifdash 6 | \long\def\dashp#1{\expandafter\setnext#1-\dashphelper} 7 | \long\def\setnext#1-{\futurelet\next\dashphelper} 8 | \long\def\dashphelper#1\dashphelper{ 9 | \ifx\dashphelper\next\dashfalse\else\dashtrue\fi 10 | } 11 | \def\lw#1{\leavevmode\dashp{#1}\ifdash#1\else\hbox{#1}\fi} 12 | @end tex 13 | @end iftex 14 | 15 | @c A Texinfo binding for the plain TeX above. Analogous to Texinfo's 16 | @c @w, but for Lisp symbols. AFAICT, the comment characters are 17 | @c necessary to prevent treating the newline as a space. 18 | @macro lw{word} 19 | @iftex 20 | @tex 21 | \\lw{\word\}% 22 | @end tex 23 | @end iftex 24 | @ifnottex 25 | \word\@c 26 | @end ifnottex 27 | @end macro 28 | 29 | @c Some index prettification helper macros, for tricking the texindex 30 | @c collation "engine" 31 | @macro earmuffs{name} 32 | *\name\* 33 | @end macro 34 | @macro setf{name} 35 | (setf \name\) 36 | @end macro 37 | @include docstrings/package-macros.texinfo 38 | -------------------------------------------------------------------------------- /doc/manual/variables.template: -------------------------------------------------------------------------------- 1 | @set VERSION @VERSION@ 2 | @set UPDATE-MONTH @MONTH@ 3 | -------------------------------------------------------------------------------- /find-gnumake.sh: -------------------------------------------------------------------------------- 1 | #!/bin/false 2 | # Not a shell script, but something intended to be sourced from shell scripts 3 | find_gnumake() { 4 | # the GNU dialect of "make" -- easier to find or port it than to 5 | # try to figure out how to port to the local dialect... 6 | if [ "$GNUMAKE" != "" ] ; then 7 | # The user is evidently trying to tell us something. 8 | GNUMAKE="$GNUMAKE" 9 | elif [ "GNU Make" = "`make -v 2>/dev/null | head -n 1 | cut -b 1-8`" ]; then 10 | GNUMAKE=make 11 | elif [ -x "`which gmake`" ] ; then 12 | # "gmake" is the preferred name in *BSD. 13 | GNUMAKE=gmake 14 | elif [ -x "`which gnumake`" ] ; then 15 | # MacOS X aka Darwin 16 | GNUMAKE=gnumake 17 | else 18 | echo "GNU Make not found. Try setting the environment variable GNUMAKE." 19 | exit 1 20 | fi 21 | export GNUMAKE 22 | #echo "//GNUMAKE=\"$GNUMAKE\"" 23 | } 24 | -------------------------------------------------------------------------------- /git/README: -------------------------------------------------------------------------------- 1 | SBCL Git Hooks 2 | 3 | These scripts live in /home/scm_git/s/sb/sbcl/sbcl.git/hooks on 4 | SourceForge, and have nothing to do with SBCL as such -- and 5 | everything to do with developer convenience and maintenance. 6 | 7 | To push updates there: 8 | 9 | ssh -t ,sbcl@shell.sourceforge.net create 10 | scp