diff --git a/.eggs/address-info.egg-info b/.eggs/address-info.egg-info new file mode 100644 index 0000000..620aac2 --- /dev/null +++ b/.eggs/address-info.egg-info @@ -0,0 +1,17 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/address-info.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/address-info.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/address-info.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/address-info.import.so") + (version "1.0.5") + (category net) + (synopsis "Network address information access") + (license "BSD") + (author "Thomas Chust") + (version "1.0.5") + (dependencies srfi-1) + (test-dependencies test) + (components + (extension + address-info + (cond-expand (windows (csc-options -L -lws2_32)) (else))))) diff --git a/.eggs/address-info.import.so b/.eggs/address-info.import.so new file mode 100755 index 0000000..c106745 Binary files /dev/null and b/.eggs/address-info.import.so differ diff --git a/.eggs/address-info.link b/.eggs/address-info.link new file mode 100644 index 0000000..edeba2d --- /dev/null +++ b/.eggs/address-info.link @@ -0,0 +1 @@ +(srfi-1) diff --git a/.eggs/address-info.o b/.eggs/address-info.o new file mode 100644 index 0000000..b6036f8 Binary files /dev/null and b/.eggs/address-info.o differ diff --git a/.eggs/address-info.so b/.eggs/address-info.so new file mode 100755 index 0000000..823c233 Binary files /dev/null and b/.eggs/address-info.so differ diff --git a/.eggs/base64.egg-info b/.eggs/base64.egg-info new file mode 100644 index 0000000..8f8caf1 --- /dev/null +++ b/.eggs/base64.egg-info @@ -0,0 +1,13 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/base64.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/base64.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/base64.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/base64.import.so") + (version "1.0") + (synopsis "Encoding and decoding of base64 strings") + (category parsing) + (license "BSD") + (dependencies srfi-13) + (test-dependencies test) + (author "James Bailey, Jim Ursetto") + (components (extension base64))) diff --git a/.eggs/base64.import.so b/.eggs/base64.import.so new file mode 100755 index 0000000..e2bd95b Binary files /dev/null and b/.eggs/base64.import.so differ diff --git a/.eggs/base64.link b/.eggs/base64.link new file mode 100644 index 0000000..f40be94 --- /dev/null +++ b/.eggs/base64.link @@ -0,0 +1 @@ +(srfi-13) diff --git a/.eggs/base64.o b/.eggs/base64.o new file mode 100644 index 0000000..71498b6 Binary files /dev/null and b/.eggs/base64.o differ diff --git a/.eggs/base64.so b/.eggs/base64.so new file mode 100755 index 0000000..0c20b75 Binary files /dev/null and b/.eggs/base64.so differ diff --git a/.eggs/chicken.base.import.so b/.eggs/chicken.base.import.so new file mode 100755 index 0000000..4babbc8 Binary files /dev/null and b/.eggs/chicken.base.import.so differ diff --git a/.eggs/chicken.bitwise.import.so b/.eggs/chicken.bitwise.import.so new file mode 100755 index 0000000..e8a78d1 Binary files /dev/null and b/.eggs/chicken.bitwise.import.so differ diff --git a/.eggs/chicken.blob.import.so b/.eggs/chicken.blob.import.so new file mode 100755 index 0000000..fd89744 Binary files /dev/null and b/.eggs/chicken.blob.import.so differ diff --git a/.eggs/chicken.compiler.user-pass.import.so b/.eggs/chicken.compiler.user-pass.import.so new file mode 100755 index 0000000..cfbc23b Binary files /dev/null and b/.eggs/chicken.compiler.user-pass.import.so differ diff --git a/.eggs/chicken.condition.import.so b/.eggs/chicken.condition.import.so new file mode 100755 index 0000000..ae931c8 Binary files /dev/null and b/.eggs/chicken.condition.import.so differ diff --git a/.eggs/chicken.continuation.import.so b/.eggs/chicken.continuation.import.so new file mode 100755 index 0000000..5dcf26b Binary files /dev/null and b/.eggs/chicken.continuation.import.so differ diff --git a/.eggs/chicken.csi.import.so b/.eggs/chicken.csi.import.so new file mode 100755 index 0000000..8e068cf Binary files /dev/null and b/.eggs/chicken.csi.import.so differ diff --git a/.eggs/chicken.errno.import.so b/.eggs/chicken.errno.import.so new file mode 100755 index 0000000..9fcf48c Binary files /dev/null and b/.eggs/chicken.errno.import.so differ diff --git a/.eggs/chicken.eval.import.so b/.eggs/chicken.eval.import.so new file mode 100755 index 0000000..461eadd Binary files /dev/null and b/.eggs/chicken.eval.import.so differ diff --git a/.eggs/chicken.file.import.so b/.eggs/chicken.file.import.so new file mode 100755 index 0000000..a2b23e3 Binary files /dev/null and b/.eggs/chicken.file.import.so differ diff --git a/.eggs/chicken.file.posix.import.so b/.eggs/chicken.file.posix.import.so new file mode 100755 index 0000000..8521130 Binary files /dev/null and b/.eggs/chicken.file.posix.import.so differ diff --git a/.eggs/chicken.fixnum.import.so b/.eggs/chicken.fixnum.import.so new file mode 100755 index 0000000..93fda67 Binary files /dev/null and b/.eggs/chicken.fixnum.import.so differ diff --git a/.eggs/chicken.flonum.import.so b/.eggs/chicken.flonum.import.so new file mode 100755 index 0000000..204033b Binary files /dev/null and b/.eggs/chicken.flonum.import.so differ diff --git a/.eggs/chicken.foreign.import.so b/.eggs/chicken.foreign.import.so new file mode 100755 index 0000000..fe42d7c Binary files /dev/null and b/.eggs/chicken.foreign.import.so differ diff --git a/.eggs/chicken.format.import.so b/.eggs/chicken.format.import.so new file mode 100755 index 0000000..b18d82f Binary files /dev/null and b/.eggs/chicken.format.import.so differ diff --git a/.eggs/chicken.gc.import.so b/.eggs/chicken.gc.import.so new file mode 100755 index 0000000..8a5b9a9 Binary files /dev/null and b/.eggs/chicken.gc.import.so differ diff --git a/.eggs/chicken.internal.import.so b/.eggs/chicken.internal.import.so new file mode 100755 index 0000000..435ac0a Binary files /dev/null and b/.eggs/chicken.internal.import.so differ diff --git a/.eggs/chicken.io.import.so b/.eggs/chicken.io.import.so new file mode 100755 index 0000000..5870602 Binary files /dev/null and b/.eggs/chicken.io.import.so differ diff --git a/.eggs/chicken.irregex.import.so b/.eggs/chicken.irregex.import.so new file mode 100755 index 0000000..d236dff Binary files /dev/null and b/.eggs/chicken.irregex.import.so differ diff --git a/.eggs/chicken.keyword.import.so b/.eggs/chicken.keyword.import.so new file mode 100755 index 0000000..c3fc040 Binary files /dev/null and b/.eggs/chicken.keyword.import.so differ diff --git a/.eggs/chicken.load.import.so b/.eggs/chicken.load.import.so new file mode 100755 index 0000000..d331813 Binary files /dev/null and b/.eggs/chicken.load.import.so differ diff --git a/.eggs/chicken.locative.import.so b/.eggs/chicken.locative.import.so new file mode 100755 index 0000000..c113d46 Binary files /dev/null and b/.eggs/chicken.locative.import.so differ diff --git a/.eggs/chicken.memory.import.so b/.eggs/chicken.memory.import.so new file mode 100755 index 0000000..6d12d82 Binary files /dev/null and b/.eggs/chicken.memory.import.so differ diff --git a/.eggs/chicken.memory.representation.import.so b/.eggs/chicken.memory.representation.import.so new file mode 100755 index 0000000..2132c76 Binary files /dev/null and b/.eggs/chicken.memory.representation.import.so differ diff --git a/.eggs/chicken.pathname.import.so b/.eggs/chicken.pathname.import.so new file mode 100755 index 0000000..efe14ed Binary files /dev/null and b/.eggs/chicken.pathname.import.so differ diff --git a/.eggs/chicken.platform.import.so b/.eggs/chicken.platform.import.so new file mode 100755 index 0000000..84a2c65 Binary files /dev/null and b/.eggs/chicken.platform.import.so differ diff --git a/.eggs/chicken.plist.import.so b/.eggs/chicken.plist.import.so new file mode 100755 index 0000000..76267f9 Binary files /dev/null and b/.eggs/chicken.plist.import.so differ diff --git a/.eggs/chicken.port.import.so b/.eggs/chicken.port.import.so new file mode 100755 index 0000000..e78b844 Binary files /dev/null and b/.eggs/chicken.port.import.so differ diff --git a/.eggs/chicken.pretty-print.import.so b/.eggs/chicken.pretty-print.import.so new file mode 100755 index 0000000..fb22497 Binary files /dev/null and b/.eggs/chicken.pretty-print.import.so differ diff --git a/.eggs/chicken.process-context.import.so b/.eggs/chicken.process-context.import.so new file mode 100755 index 0000000..8548e8e Binary files /dev/null and b/.eggs/chicken.process-context.import.so differ diff --git a/.eggs/chicken.process-context.posix.import.so b/.eggs/chicken.process-context.posix.import.so new file mode 100755 index 0000000..bf43b6a Binary files /dev/null and b/.eggs/chicken.process-context.posix.import.so differ diff --git a/.eggs/chicken.process.import.so b/.eggs/chicken.process.import.so new file mode 100755 index 0000000..181ac57 Binary files /dev/null and b/.eggs/chicken.process.import.so differ diff --git a/.eggs/chicken.process.signal.import.so b/.eggs/chicken.process.signal.import.so new file mode 100755 index 0000000..9a0a7e6 Binary files /dev/null and b/.eggs/chicken.process.signal.import.so differ diff --git a/.eggs/chicken.random.import.so b/.eggs/chicken.random.import.so new file mode 100755 index 0000000..e3b252d Binary files /dev/null and b/.eggs/chicken.random.import.so differ diff --git a/.eggs/chicken.read-syntax.import.so b/.eggs/chicken.read-syntax.import.so new file mode 100755 index 0000000..6f4c72e Binary files /dev/null and b/.eggs/chicken.read-syntax.import.so differ diff --git a/.eggs/chicken.repl.import.so b/.eggs/chicken.repl.import.so new file mode 100755 index 0000000..f77cc2b Binary files /dev/null and b/.eggs/chicken.repl.import.so differ diff --git a/.eggs/chicken.sort.import.so b/.eggs/chicken.sort.import.so new file mode 100755 index 0000000..e344b42 Binary files /dev/null and b/.eggs/chicken.sort.import.so differ diff --git a/.eggs/chicken.string.import.so b/.eggs/chicken.string.import.so new file mode 100755 index 0000000..69a5091 Binary files /dev/null and b/.eggs/chicken.string.import.so differ diff --git a/.eggs/chicken.syntax.import.so b/.eggs/chicken.syntax.import.so new file mode 100755 index 0000000..8e4834e Binary files /dev/null and b/.eggs/chicken.syntax.import.so differ diff --git a/.eggs/chicken.tcp.import.so b/.eggs/chicken.tcp.import.so new file mode 100755 index 0000000..d7a2703 Binary files /dev/null and b/.eggs/chicken.tcp.import.so differ diff --git a/.eggs/chicken.time.import.so b/.eggs/chicken.time.import.so new file mode 100755 index 0000000..b59ca9e Binary files /dev/null and b/.eggs/chicken.time.import.so differ diff --git a/.eggs/chicken.time.posix.import.so b/.eggs/chicken.time.posix.import.so new file mode 100755 index 0000000..6c19872 Binary files /dev/null and b/.eggs/chicken.time.posix.import.so differ diff --git a/.eggs/compile-file.egg-info b/.eggs/compile-file.egg-info new file mode 100644 index 0000000..b228538 --- /dev/null +++ b/.eggs/compile-file.egg-info @@ -0,0 +1,12 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/compile-file.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/compile-file.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/compile-file.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/compile-file.types" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/compile-file.import.so") + (version "1.3") + (synopsis "Programmatic compiler invocation") + (author "The CHICKEN Team") + (license "BSD") + (category misc) + (components (extension compile-file (types-file (predefined))))) diff --git a/.eggs/compile-file.import.so b/.eggs/compile-file.import.so new file mode 100755 index 0000000..eccb955 Binary files /dev/null and b/.eggs/compile-file.import.so differ diff --git a/.eggs/compile-file.link b/.eggs/compile-file.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/compile-file.link @@ -0,0 +1 @@ +() diff --git a/.eggs/compile-file.o b/.eggs/compile-file.o new file mode 100644 index 0000000..d5ccfa6 Binary files /dev/null and b/.eggs/compile-file.o differ diff --git a/.eggs/compile-file.so b/.eggs/compile-file.so new file mode 100755 index 0000000..4e3b794 Binary files /dev/null and b/.eggs/compile-file.so differ diff --git a/.eggs/compile-file.types b/.eggs/compile-file.types new file mode 100644 index 0000000..f2f8624 --- /dev/null +++ b/.eggs/compile-file.types @@ -0,0 +1,2 @@ +(compile-file#compile-file (#(procedure #:clean #:enforce) compile-file#compile-file (string #!rest) (or false string))) +(compile-file#compile-file-options (#(procedure #:clean #:enforce) compile-file#compile-file-options (#!optional (list-of string)) (list-of string))) diff --git a/.eggs/defstruct.egg-info b/.eggs/defstruct.egg-info new file mode 100644 index 0000000..02433f4 --- /dev/null +++ b/.eggs/defstruct.egg-info @@ -0,0 +1,13 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/defstruct.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/defstruct.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/defstruct.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/defstruct.import.so") + (version "2.0") + (synopsis "A more convenient form of define-record") + (author "Dorai Sitaram") + (category data) + (license "BSD") + (test-dependencies test) + (dependencies srfi-1) + (components (extension defstruct))) diff --git a/.eggs/defstruct.import.so b/.eggs/defstruct.import.so new file mode 100755 index 0000000..affc11d Binary files /dev/null and b/.eggs/defstruct.import.so differ diff --git a/.eggs/defstruct.link b/.eggs/defstruct.link new file mode 100644 index 0000000..edeba2d --- /dev/null +++ b/.eggs/defstruct.link @@ -0,0 +1 @@ +(srfi-1) diff --git a/.eggs/defstruct.o b/.eggs/defstruct.o new file mode 100644 index 0000000..6905883 Binary files /dev/null and b/.eggs/defstruct.o differ diff --git a/.eggs/defstruct.so b/.eggs/defstruct.so new file mode 100755 index 0000000..6f6643e Binary files /dev/null and b/.eggs/defstruct.so differ diff --git a/.eggs/http-client.egg-info b/.eggs/http-client.egg-info new file mode 100644 index 0000000..41e4c02 --- /dev/null +++ b/.eggs/http-client.egg-info @@ -0,0 +1,21 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/http-client.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/http-client.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/http-client.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/http-client.import.so") + (version "1.2.1") + (synopsis "High-level HTTP client library") + (author "Peter Bex") + (category net) + (license "BSD") + (dependencies + intarweb + uri-common + simple-md5 + sendfile + srfi-1 + srfi-13 + srfi-18 + srfi-69) + (test-dependencies test) + (components (extension http-client (csc-options "-O3")))) diff --git a/.eggs/http-client.import.so b/.eggs/http-client.import.so new file mode 100755 index 0000000..90cc811 Binary files /dev/null and b/.eggs/http-client.import.so differ diff --git a/.eggs/http-client.link b/.eggs/http-client.link new file mode 100644 index 0000000..6636401 --- /dev/null +++ b/.eggs/http-client.link @@ -0,0 +1 @@ +(sendfile simple-md5 uri-common intarweb srfi-69 srfi-18 srfi-13 srfi-1) diff --git a/.eggs/http-client.o b/.eggs/http-client.o new file mode 100644 index 0000000..652db7f Binary files /dev/null and b/.eggs/http-client.o differ diff --git a/.eggs/http-client.so b/.eggs/http-client.so new file mode 100755 index 0000000..37b31a6 Binary files /dev/null and b/.eggs/http-client.so differ diff --git a/.eggs/intarweb.egg-info b/.eggs/intarweb.egg-info new file mode 100644 index 0000000..9a28807 --- /dev/null +++ b/.eggs/intarweb.egg-info @@ -0,0 +1,17 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/intarweb.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/intarweb.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/intarweb.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/intarweb.import.so") + (version "2.0.2") + (synopsis "A more convenient HTTP library") + (author "Peter Bex") + (category web) + (license "BSD") + (dependencies srfi-1 srfi-13 srfi-14 defstruct uri-common base64) + (test-dependencies test) + (components + (extension + intarweb + (csc-options "-O3" "-d0") + (source-dependencies "intarweb.scm" "header-parsers.scm")))) diff --git a/.eggs/intarweb.import.so b/.eggs/intarweb.import.so new file mode 100755 index 0000000..3865709 Binary files /dev/null and b/.eggs/intarweb.import.so differ diff --git a/.eggs/intarweb.link b/.eggs/intarweb.link new file mode 100644 index 0000000..add2176 --- /dev/null +++ b/.eggs/intarweb.link @@ -0,0 +1 @@ +(defstruct uri-common base64 srfi-14 srfi-13 srfi-1) diff --git a/.eggs/intarweb.o b/.eggs/intarweb.o new file mode 100644 index 0000000..5d3131d Binary files /dev/null and b/.eggs/intarweb.o differ diff --git a/.eggs/intarweb.so b/.eggs/intarweb.so new file mode 100755 index 0000000..ec3e3bf Binary files /dev/null and b/.eggs/intarweb.so differ diff --git a/.eggs/iset.egg-info b/.eggs/iset.egg-info new file mode 100644 index 0000000..0d50faa --- /dev/null +++ b/.eggs/iset.egg-info @@ -0,0 +1,12 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/iset.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/iset.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/iset.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/iset.import.so") + (version "2.2") + (category data) + (synopsis "Integer sets") + (license "BSD") + (author "Alex Shinn") + (test-dependencies test) + (components (extension iset))) diff --git a/.eggs/iset.import.so b/.eggs/iset.import.so new file mode 100755 index 0000000..f14d6bd Binary files /dev/null and b/.eggs/iset.import.so differ diff --git a/.eggs/iset.link b/.eggs/iset.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/iset.link @@ -0,0 +1 @@ +() diff --git a/.eggs/iset.o b/.eggs/iset.o new file mode 100644 index 0000000..a924430 Binary files /dev/null and b/.eggs/iset.o differ diff --git a/.eggs/iset.so b/.eggs/iset.so new file mode 100755 index 0000000..48664ac Binary files /dev/null and b/.eggs/iset.so differ diff --git a/.eggs/matchable.egg-info b/.eggs/matchable.egg-info new file mode 100644 index 0000000..43a95c1 --- /dev/null +++ b/.eggs/matchable.egg-info @@ -0,0 +1,12 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/matchable.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/matchable.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/matchable.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/matchable.import.so") + (version "1.1") + (synopsis "Hygienic MATCH replacement") + (license "Public Domain") + (category lang-exts) + (author "Alex Shinn") + (test-dependencies test) + (components (extension matchable))) diff --git a/.eggs/matchable.import.so b/.eggs/matchable.import.so new file mode 100755 index 0000000..4981d04 Binary files /dev/null and b/.eggs/matchable.import.so differ diff --git a/.eggs/matchable.link b/.eggs/matchable.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/matchable.link @@ -0,0 +1 @@ +() diff --git a/.eggs/matchable.o b/.eggs/matchable.o new file mode 100644 index 0000000..620e288 Binary files /dev/null and b/.eggs/matchable.o differ diff --git a/.eggs/matchable.so b/.eggs/matchable.so new file mode 100755 index 0000000..923f5c0 Binary files /dev/null and b/.eggs/matchable.so differ diff --git a/.eggs/memory-mapped-files.egg-info b/.eggs/memory-mapped-files.egg-info new file mode 100644 index 0000000..b9cf373 --- /dev/null +++ b/.eggs/memory-mapped-files.egg-info @@ -0,0 +1,12 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/memory-mapped-files.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/memory-mapped-files.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/memory-mapped-files.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/memory-mapped-files.types" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/memory-mapped-files.import.so") + (version "0.4") + (synopsis "Memory-mapped file access for UNIX and Windows") + (category misc) + (license "BSD") + (author "The CHICKEN Team, Windows support by \"rivo\"") + (components (extension memory-mapped-files (types-file (predefined))))) diff --git a/.eggs/memory-mapped-files.import.so b/.eggs/memory-mapped-files.import.so new file mode 100755 index 0000000..2e93cf9 Binary files /dev/null and b/.eggs/memory-mapped-files.import.so differ diff --git a/.eggs/memory-mapped-files.link b/.eggs/memory-mapped-files.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/memory-mapped-files.link @@ -0,0 +1 @@ +() diff --git a/.eggs/memory-mapped-files.o b/.eggs/memory-mapped-files.o new file mode 100644 index 0000000..6354a0f Binary files /dev/null and b/.eggs/memory-mapped-files.o differ diff --git a/.eggs/memory-mapped-files.so b/.eggs/memory-mapped-files.so new file mode 100755 index 0000000..80fd7d8 Binary files /dev/null and b/.eggs/memory-mapped-files.so differ diff --git a/.eggs/memory-mapped-files.types b/.eggs/memory-mapped-files.types new file mode 100644 index 0000000..90de52f --- /dev/null +++ b/.eggs/memory-mapped-files.types @@ -0,0 +1,8 @@ +(memory-mapped-files#map-file-to-memory (#(procedure #:clean #:enforce) memory-mapped-files#map-file-to-memory (* fixnum fixnum fixnum fixnum #!optional fixnum) (struct mmap))) +(memory-mapped-files#map/anonymous fixnum) +(memory-mapped-files#map/file fixnum) +(memory-mapped-files#map/fixed fixnum) +(memory-mapped-files#map/private fixnum) +(memory-mapped-files#map/shared fixnum) +(memory-mapped-files#memory-mapped-file-pointer (#(procedure #:clean #:enforce) memory-mapped-files#memory-mapped-file-pointer ((struct mmap)) pointer)) +(memory-mapped-files#memory-mapped-file? (#(procedure #:clean #:predicate (struct mmap)) memory-mapped-files#memory-mapped-file? (*) boolean)) diff --git a/.eggs/modules.db b/.eggs/modules.db new file mode 100644 index 0000000..9a65cb7 --- /dev/null +++ b/.eggs/modules.db @@ -0,0 +1,1414 @@ +(* value scheme) +(* value r4rs) +(+ value scheme) +(+ value r4rs) +(- value scheme) +(- value r4rs) +(->string value chicken.string) +(/ value scheme) +(/ value r4rs) +(: syntax chicken.type) +(< value scheme) +(< value r4rs) +(<= value scheme) +(<= value r4rs) +(= value scheme) +(= value r4rs) +(> value scheme) +(> value r4rs) +(>= value scheme) +(>= value r4rs) +(abort value chicken.condition) +(abort value srfi-12) +(abs value scheme) +(abs value r4rs) +(absolute-pathname? value chicken.pathname) +(acos value scheme) +(acos value r4rs) +(add1 value chicken.base) +(address->pointer value chicken.memory) +(align-to-word value chicken.memory) +(alist-ref value chicken.base) +(alist-update value chicken.base) +(alist-update! value chicken.base) +(allocate value chicken.memory) +(and syntax r5rs-null) +(and syntax r4rs-null) +(and syntax scheme) +(and syntax r4rs) +(and-let* syntax chicken.base) +(and-let* syntax srfi-2) +(angle value scheme) +(angle value r4rs) +(append value scheme) +(append value r4rs) +(apply value scheme) +(apply value r4rs) +(argc+argv value chicken.process-context) +(argv value chicken.process-context) +(arithmetic-shift value chicken.bitwise) +(asin value scheme) +(asin value r4rs) +(assert syntax chicken.base) +(assoc value scheme) +(assoc value r4rs) +(assq value scheme) +(assq value r4rs) +(assume syntax chicken.type) +(assv value scheme) +(assv value r4rs) +(atan value scheme) +(atan value r4rs) +(atom? value chicken.base) +(begin syntax r5rs-null) +(begin syntax r4rs-null) +(begin syntax scheme) +(begin syntax r4rs) +(begin-for-syntax syntax chicken.syntax) +(bignum? value chicken.base) +(bit->boolean value chicken.bitwise) +(bitwise-and value chicken.bitwise) +(bitwise-ior value chicken.bitwise) +(bitwise-not value chicken.bitwise) +(bitwise-xor value chicken.bitwise) +(blob->f32vector value srfi-4) +(blob->f32vector/shared value srfi-4) +(blob->f64vector value srfi-4) +(blob->f64vector/shared value srfi-4) +(blob->s16vector value srfi-4) +(blob->s16vector/shared value srfi-4) +(blob->s32vector value srfi-4) +(blob->s32vector/shared value srfi-4) +(blob->s64vector value srfi-4) +(blob->s64vector/shared value srfi-4) +(blob->s8vector value srfi-4) +(blob->s8vector/shared value srfi-4) +(blob->string value chicken.blob) +(blob->u16vector value srfi-4) +(blob->u16vector/shared value srfi-4) +(blob->u32vector value srfi-4) +(blob->u32vector/shared value srfi-4) +(blob->u64vector value srfi-4) +(blob->u64vector/shared value srfi-4) +(blob->u8vector value srfi-4) +(blob->u8vector/shared value srfi-4) +(blob-size value chicken.blob) +(blob=? value chicken.blob) +(blob? value chicken.blob) +(block-device? value chicken.file.posix) +(block-ref value chicken.memory.representation) +(block-set! value chicken.memory.representation) +(boolean? value scheme) +(boolean? value r4rs) +(build-platform value chicken.platform) +(butlast value chicken.base) +(caaaar value scheme) +(caaaar value r4rs) +(caaadr value scheme) +(caaadr value r4rs) +(caaar value scheme) +(caaar value r4rs) +(caadar value scheme) +(caadar value r4rs) +(caaddr value scheme) +(caaddr value r4rs) +(caadr value scheme) +(caadr value r4rs) +(caar value scheme) +(caar value r4rs) +(cadaar value scheme) +(cadaar value r4rs) +(cadadr value scheme) +(cadadr value r4rs) +(cadar value scheme) +(cadar value r4rs) +(caddar value scheme) +(caddar value r4rs) +(cadddr value scheme) +(cadddr value r4rs) +(caddr value scheme) +(caddr value r4rs) +(cadr value scheme) +(cadr value r4rs) +(call-with-current-continuation value scheme) +(call-with-current-continuation value r4rs) +(call-with-input-file value scheme) +(call-with-input-file value r4rs) +(call-with-input-pipe value chicken.process) +(call-with-input-string value chicken.port) +(call-with-output-file value scheme) +(call-with-output-file value r4rs) +(call-with-output-pipe value chicken.process) +(call-with-output-string value chicken.port) +(call-with-values value scheme) +(call/cc value chicken.base) +(car value scheme) +(car value r4rs) +(case syntax r5rs-null) +(case syntax r4rs-null) +(case syntax scheme) +(case syntax r4rs) +(case-lambda syntax chicken.base) +(case-lambda syntax srfi-16) +(case-sensitive value chicken.base) +(cdaaar value scheme) +(cdaaar value r4rs) +(cdaadr value scheme) +(cdaadr value r4rs) +(cdaar value scheme) +(cdaar value r4rs) +(cdadar value scheme) +(cdadar value r4rs) +(cdaddr value scheme) +(cdaddr value r4rs) +(cdadr value scheme) +(cdadr value r4rs) +(cdar value scheme) +(cdar value r4rs) +(cddaar value scheme) +(cddaar value r4rs) +(cddadr value scheme) +(cddadr value r4rs) +(cddar value scheme) +(cddar value r4rs) +(cdddar value scheme) +(cdddar value r4rs) +(cddddr value scheme) +(cddddr value r4rs) +(cdddr value scheme) +(cdddr value r4rs) +(cddr value scheme) +(cddr value r4rs) +(cdr value scheme) +(cdr value r4rs) +(ceiling value scheme) +(ceiling value r4rs) +(change-directory value chicken.process-context) +(change-directory* value chicken.process-context.posix) +(char->integer value scheme) +(char->integer value r4rs) +(char-alphabetic? value scheme) +(char-alphabetic? value r4rs) +(char-ci<=? value scheme) +(char-ci<=? value r4rs) +(char-ci=? value scheme) +(char-ci>=? value r4rs) +(char-ci>? value scheme) +(char-ci>? value r4rs) +(char-downcase value scheme) +(char-downcase value r4rs) +(char-lower-case? value scheme) +(char-lower-case? value r4rs) +(char-name value chicken.base) +(char-numeric? value scheme) +(char-numeric? value r4rs) +(char-ready? value scheme) +(char-ready? value r4rs) +(char-upcase value scheme) +(char-upcase value r4rs) +(char-upper-case? value scheme) +(char-upper-case? value r4rs) +(char-whitespace? value scheme) +(char-whitespace? value r4rs) +(char<=? value scheme) +(char<=? value r4rs) +(char=? value scheme) +(char>=? value r4rs) +(char>? value scheme) +(char>? value r4rs) +(char? value scheme) +(char? value r4rs) +(character-device? value chicken.file.posix) +(chicken-home value chicken.platform) +(chicken-version value chicken.platform) +(chop value chicken.base) +(close-input-pipe value chicken.process) +(close-input-port value scheme) +(close-input-port value r4rs) +(close-output-pipe value chicken.process) +(close-output-port value scheme) +(close-output-port value r4rs) +(command-line-arguments value chicken.process-context) +(compiler-typecase syntax chicken.type) +(complement value chicken.base) +(complex? value scheme) +(complex? value r4rs) +(compose value chicken.base) +(compress value chicken.base) +(conc value chicken.string) +(cond syntax r5rs-null) +(cond syntax r4rs-null) +(cond syntax scheme) +(cond syntax r4rs) +(cond-expand syntax srfi-0) +(cond-expand syntax chicken.module) +(condition value chicken.condition) +(condition->list value chicken.condition) +(condition-case syntax chicken.condition) +(condition-predicate value chicken.condition) +(condition-predicate value srfi-12) +(condition-property-accessor value chicken.condition) +(condition-property-accessor value srfi-12) +(condition? value chicken.condition) +(condition? value srfi-12) +(conjoin value chicken.base) +(cons value scheme) +(cons value r4rs) +(constantly value chicken.base) +(continuation-capture value chicken.continuation) +(continuation-graft value chicken.continuation) +(continuation-return value chicken.continuation) +(continuation? value chicken.continuation) +(copy-file value chicken.file) +(copy-port value chicken.port) +(copy-read-table value chicken.read-syntax) +(cos value scheme) +(cos value r4rs) +(cplxnum? value chicken.base) +(cpu-time value chicken.time) +(create-directory value chicken.file) +(create-fifo value chicken.file.posix) +(create-pipe value chicken.process) +(create-session value chicken.process-context.posix) +(create-symbolic-link value chicken.file.posix) +(create-temporary-directory value chicken.file) +(create-temporary-file value chicken.file) +(current-directory value chicken.process-context) +(current-effective-group-id value chicken.process-context.posix) +(current-effective-user-id value chicken.process-context.posix) +(current-effective-user-name value chicken.process-context.posix) +(current-error-port value chicken.base) +(current-exception-handler value chicken.condition) +(current-exception-handler value srfi-12) +(current-gc-milliseconds value chicken.gc) +(current-group-id value chicken.process-context.posix) +(current-input-port value scheme) +(current-input-port value r4rs) +(current-milliseconds value chicken.time) +(current-module syntax chicken.module) +(current-output-port value scheme) +(current-output-port value r4rs) +(current-process-id value chicken.process-context.posix) +(current-process-milliseconds value chicken.time) +(current-read-table value chicken.read-syntax) +(current-seconds value chicken.time) +(current-user-id value chicken.process-context.posix) +(current-user-name value chicken.process-context.posix) +(cut syntax chicken.base) +(cut syntax srfi-26) +(cute syntax chicken.base) +(cute syntax srfi-26) +(declare syntax chicken.base) +(decompose-directory value chicken.pathname) +(decompose-pathname value chicken.pathname) +(define syntax r5rs-null) +(define syntax r4rs-null) +(define syntax scheme) +(define syntax r4rs) +(define-compiler-syntax syntax chicken.syntax) +(define-constant syntax chicken.base) +(define-external syntax chicken.foreign) +(define-for-syntax syntax chicken.syntax) +(define-foreign-type syntax chicken.foreign) +(define-foreign-variable syntax chicken.foreign) +(define-inline syntax chicken.base) +(define-interface syntax chicken.module) +(define-location syntax chicken.foreign) +(define-reader-ctor value chicken.read-syntax) +(define-reader-ctor value srfi-10) +(define-record syntax chicken.base) +(define-record-printer syntax chicken.base) +(define-record-type syntax chicken.base) +(define-record-type syntax srfi-9) +(define-specialization syntax chicken.type) +(define-syntax syntax r5rs-null) +(define-syntax syntax r4rs-null) +(define-syntax syntax scheme) +(define-syntax syntax r4rs) +(define-type syntax chicken.type) +(define-values syntax chicken.base) +(delay syntax r5rs-null) +(delay syntax r4rs-null) +(delay syntax scheme) +(delay syntax r4rs) +(delay-force syntax chicken.base) +(delete-directory value chicken.file) +(delete-file value chicken.file) +(delete-file* value chicken.file) +(denominator value scheme) +(denominator value r4rs) +(directory value chicken.file) +(directory-exists? value chicken.file) +(directory-null? value chicken.pathname) +(directory? value chicken.file.posix) +(disjoin value chicken.base) +(display value scheme) +(display value r4rs) +(do syntax r5rs-null) +(do syntax r4rs-null) +(do syntax scheme) +(do syntax r4rs) +(duplicate-fileno value chicken.file.posix) +(dynamic-load-libraries value chicken.load) +(dynamic-wind value scheme) +(each value chicken.base) +(editor-command value chicken.csi) +(emergency-exit value chicken.base) +(enable-warnings value chicken.base) +(eof-object? value scheme) +(eof-object? value r4rs) +(eq? value scheme) +(eq? value r4rs) +(equal=? value chicken.base) +(equal? value scheme) +(equal? value r4rs) +(eqv? value scheme) +(eqv? value r4rs) +(er-macro-transformer value chicken.syntax) +(errno value chicken.errno) +(errno/2big value chicken.errno) +(errno/acces value chicken.errno) +(errno/again value chicken.errno) +(errno/badf value chicken.errno) +(errno/busy value chicken.errno) +(errno/child value chicken.errno) +(errno/deadlk value chicken.errno) +(errno/dom value chicken.errno) +(errno/exist value chicken.errno) +(errno/fault value chicken.errno) +(errno/fbig value chicken.errno) +(errno/ilseq value chicken.errno) +(errno/intr value chicken.errno) +(errno/inval value chicken.errno) +(errno/io value chicken.errno) +(errno/isdir value chicken.errno) +(errno/mfile value chicken.errno) +(errno/mlink value chicken.errno) +(errno/nametoolong value chicken.errno) +(errno/nfile value chicken.errno) +(errno/nodev value chicken.errno) +(errno/noent value chicken.errno) +(errno/noexec value chicken.errno) +(errno/nolck value chicken.errno) +(errno/nomem value chicken.errno) +(errno/nospc value chicken.errno) +(errno/nosys value chicken.errno) +(errno/notdir value chicken.errno) +(errno/notempty value chicken.errno) +(errno/notty value chicken.errno) +(errno/nxio value chicken.errno) +(errno/perm value chicken.errno) +(errno/pipe value chicken.errno) +(errno/range value chicken.errno) +(errno/rofs value chicken.errno) +(errno/spipe value chicken.errno) +(errno/srch value chicken.errno) +(errno/wouldblock value chicken.errno) +(errno/xdev value chicken.errno) +(error value chicken.base) +(error value srfi-23) +(eval value scheme) +(eval-handler value chicken.eval) +(even? value scheme) +(even? value r4rs) +(exact->inexact value scheme) +(exact->inexact value r4rs) +(exact-integer-nth-root value chicken.base) +(exact-integer-sqrt value chicken.base) +(exact-integer? value chicken.base) +(exact? value scheme) +(exact? value r4rs) +(executable-pathname value chicken.process-context) +(exit value chicken.base) +(exit-handler value chicken.base) +(exp value scheme) +(exp value r4rs) +(expand value chicken.syntax) +(export syntax chicken.module) +(expt value scheme) +(expt value r4rs) +(extend-procedure value chicken.memory.representation) +(extended-procedure? value chicken.memory.representation) +(f32vector value srfi-4) +(f32vector->blob value srfi-4) +(f32vector->blob/shared value srfi-4) +(f32vector->list value srfi-4) +(f32vector-length value srfi-4) +(f32vector-ref value srfi-4) +(f32vector-set! value srfi-4) +(f32vector? value srfi-4) +(f64vector value srfi-4) +(f64vector->blob value srfi-4) +(f64vector->blob/shared value srfi-4) +(f64vector->list value srfi-4) +(f64vector-length value srfi-4) +(f64vector-ref value srfi-4) +(f64vector-set! value srfi-4) +(f64vector? value srfi-4) +(fcntl/dupfd value chicken.file.posix) +(fcntl/getfd value chicken.file.posix) +(fcntl/getfl value chicken.file.posix) +(fcntl/setfd value chicken.file.posix) +(fcntl/setfl value chicken.file.posix) +(feature? value chicken.platform) +(features value chicken.platform) +(fifo? value chicken.file.posix) +(file-access-time value chicken.file.posix) +(file-change-time value chicken.file.posix) +(file-close value chicken.file.posix) +(file-control value chicken.file.posix) +(file-creation-mode value chicken.file.posix) +(file-executable? value chicken.file) +(file-exists? value chicken.file) +(file-group value chicken.file.posix) +(file-link value chicken.file.posix) +(file-lock value chicken.file.posix) +(file-lock/blocking value chicken.file.posix) +(file-mkstemp value chicken.file.posix) +(file-modification-time value chicken.file.posix) +(file-open value chicken.file.posix) +(file-owner value chicken.file.posix) +(file-permissions value chicken.file.posix) +(file-position value chicken.file.posix) +(file-read value chicken.file.posix) +(file-readable? value chicken.file) +(file-select value chicken.file.posix) +(file-size value chicken.file.posix) +(file-stat value chicken.file.posix) +(file-test-lock value chicken.file.posix) +(file-truncate value chicken.file.posix) +(file-type value chicken.file.posix) +(file-unlock value chicken.file.posix) +(file-writable? value chicken.file) +(file-write value chicken.file.posix) +(fileno/stderr value chicken.file.posix) +(fileno/stdin value chicken.file.posix) +(fileno/stdout value chicken.file.posix) +(find-files value chicken.file) +(finite? value chicken.base) +(fixnum-bits value chicken.fixnum) +(fixnum-precision value chicken.fixnum) +(fixnum? value chicken.base) +(flatten value chicken.base) +(flip value chicken.base) +(flonum-decimal-precision value chicken.flonum) +(flonum-epsilon value chicken.flonum) +(flonum-maximum-decimal-exponent value chicken.flonum) +(flonum-maximum-exponent value chicken.flonum) +(flonum-minimum-decimal-exponent value chicken.flonum) +(flonum-minimum-exponent value chicken.flonum) +(flonum-precision value chicken.flonum) +(flonum-print-precision value chicken.flonum) +(flonum-radix value chicken.flonum) +(flonum? value chicken.base) +(floor value scheme) +(floor value r4rs) +(fluid-let syntax chicken.base) +(fluid-let syntax srfi-15) +(flush-output value chicken.base) +(foldl value chicken.base) +(foldr value chicken.base) +(for-each value scheme) +(for-each value r4rs) +(force value scheme) +(force value r4rs) +(force-finalizers value chicken.gc) +(foreign-code syntax chicken.foreign) +(foreign-declare syntax chicken.foreign) +(foreign-lambda syntax chicken.foreign) +(foreign-lambda* syntax chicken.foreign) +(foreign-primitive syntax chicken.foreign) +(foreign-safe-lambda syntax chicken.foreign) +(foreign-safe-lambda* syntax chicken.foreign) +(foreign-type-size syntax chicken.foreign) +(foreign-value syntax chicken.foreign) +(format value chicken.format) +(format value srfi-28) +(fp* value chicken.flonum) +(fp+ value chicken.flonum) +(fp- value chicken.flonum) +(fp/ value chicken.flonum) +(fp/? value chicken.flonum) +(fp< value chicken.flonum) +(fp<= value chicken.flonum) +(fp= value chicken.flonum) +(fp> value chicken.flonum) +(fp>= value chicken.flonum) +(fpabs value chicken.flonum) +(fpacos value chicken.flonum) +(fpasin value chicken.flonum) +(fpatan value chicken.flonum) +(fpatan2 value chicken.flonum) +(fpceiling value chicken.flonum) +(fpcos value chicken.flonum) +(fpexp value chicken.flonum) +(fpexpt value chicken.flonum) +(fpfloor value chicken.flonum) +(fpgcd value chicken.flonum) +(fpinteger? value chicken.flonum) +(fplog value chicken.flonum) +(fpmax value chicken.flonum) +(fpmin value chicken.flonum) +(fpneg value chicken.flonum) +(fprintf value chicken.format) +(fpround value chicken.flonum) +(fpsin value chicken.flonum) +(fpsqrt value chicken.flonum) +(fptan value chicken.flonum) +(fptruncate value chicken.flonum) +(free value chicken.memory) +(functor syntax chicken.module) +(fx* value chicken.fixnum) +(fx*? value chicken.fixnum) +(fx+ value chicken.fixnum) +(fx+? value chicken.fixnum) +(fx- value chicken.fixnum) +(fx-? value chicken.fixnum) +(fx/ value chicken.fixnum) +(fx/? value chicken.fixnum) +(fx< value chicken.fixnum) +(fx<= value chicken.fixnum) +(fx= value chicken.fixnum) +(fx> value chicken.fixnum) +(fx>= value chicken.fixnum) +(fxand value chicken.fixnum) +(fxeven? value chicken.fixnum) +(fxgcd value chicken.fixnum) +(fxior value chicken.fixnum) +(fxlen value chicken.fixnum) +(fxmax value chicken.fixnum) +(fxmin value chicken.fixnum) +(fxmod value chicken.fixnum) +(fxneg value chicken.fixnum) +(fxnot value chicken.fixnum) +(fxodd? value chicken.fixnum) +(fxrem value chicken.fixnum) +(fxshl value chicken.fixnum) +(fxshr value chicken.fixnum) +(fxxor value chicken.fixnum) +(gc value chicken.gc) +(gcd value scheme) +(gcd value r4rs) +(gensym value chicken.base) +(get value chicken.plist) +(get-call-chain value chicken.base) +(get-condition-property value chicken.condition) +(get-environment-variable value chicken.process-context) +(get-environment-variable value srfi-98) +(get-environment-variables value chicken.process-context) +(get-environment-variables value srfi-98) +(get-keyword value chicken.keyword) +(get-line-number value chicken.syntax) +(get-output-string value chicken.base) +(get-output-string value srfi-6) +(get-properties value chicken.plist) +(getter-with-setter value chicken.base) +(getter-with-setter value srfi-17) +(glob value chicken.file) +(glob->sre value chicken.irregex) +(handle-exceptions syntax chicken.condition) +(handle-exceptions syntax srfi-12) +(identity value chicken.base) +(if syntax r5rs-null) +(if syntax r4rs-null) +(if syntax scheme) +(if syntax r4rs) +(imag-part value scheme) +(imag-part value r4rs) +(implicit-exit-handler value chicken.base) +(import syntax chicken.module) +(import-for-syntax syntax chicken.module) +(import-syntax syntax chicken.module) +(import-syntax-for-syntax syntax chicken.module) +(include syntax chicken.base) +(include-relative syntax chicken.base) +(inexact->exact value scheme) +(inexact->exact value r4rs) +(inexact? value scheme) +(inexact? value r4rs) +(infinite? value chicken.base) +(input-port-open? value chicken.base) +(input-port? value scheme) +(input-port? value r4rs) +(installation-repository value chicken.platform) +(integer->char value scheme) +(integer->char value r4rs) +(integer-length value chicken.bitwise) +(integer? value scheme) +(integer? value r4rs) +(interaction-environment value scheme) +(interaction-environment value r4rs) +(intersperse value chicken.base) +(ir-macro-transformer value chicken.syntax) +(irregex value chicken.irregex) +(irregex-extract value chicken.irregex) +(irregex-fold value chicken.irregex) +(irregex-fold/chunked value chicken.irregex) +(irregex-match value chicken.irregex) +(irregex-match-data? value chicken.irregex) +(irregex-match-end-chunk value chicken.irregex) +(irregex-match-end-index value chicken.irregex) +(irregex-match-names value chicken.irregex) +(irregex-match-num-submatches value chicken.irregex) +(irregex-match-start-chunk value chicken.irregex) +(irregex-match-start-index value chicken.irregex) +(irregex-match-subchunk value chicken.irregex) +(irregex-match-substring value chicken.irregex) +(irregex-match-valid-index? value chicken.irregex) +(irregex-match/chunked value chicken.irregex) +(irregex-match? value chicken.irregex) +(irregex-names value chicken.irregex) +(irregex-num-submatches value chicken.irregex) +(irregex-opt value chicken.irregex) +(irregex-quote value chicken.irregex) +(irregex-replace value chicken.irregex) +(irregex-replace/all value chicken.irregex) +(irregex-search value chicken.irregex) +(irregex-search/chunked value chicken.irregex) +(irregex-split value chicken.irregex) +(irregex? value chicken.irregex) +(join value chicken.base) +(keyword->string value chicken.keyword) +(keyword->string value srfi-88) +(keyword-style value chicken.base) +(keyword? value chicken.keyword) +(keyword? value srfi-88) +(lambda syntax r5rs-null) +(lambda syntax r4rs-null) +(lambda syntax scheme) +(lambda syntax r4rs) +(lcm value scheme) +(lcm value r4rs) +(length value scheme) +(length value r4rs) +(let syntax r5rs-null) +(let syntax r4rs-null) +(let syntax scheme) +(let syntax r4rs) +(let* syntax r5rs-null) +(let* syntax r4rs-null) +(let* syntax scheme) +(let* syntax r4rs) +(let*-values syntax chicken.base) +(let*-values syntax srfi-11) +(let-compiler-syntax syntax chicken.syntax) +(let-location syntax chicken.foreign) +(let-optionals syntax chicken.base) +(let-optionals* syntax chicken.base) +(let-syntax syntax r5rs-null) +(let-syntax syntax r4rs-null) +(let-syntax syntax scheme) +(let-syntax syntax r4rs) +(let-values syntax chicken.base) +(let-values syntax srfi-11) +(letrec syntax r5rs-null) +(letrec syntax r4rs-null) +(letrec syntax scheme) +(letrec syntax r4rs) +(letrec* syntax chicken.base) +(letrec-syntax syntax r5rs-null) +(letrec-syntax syntax r4rs-null) +(letrec-syntax syntax scheme) +(letrec-syntax syntax r4rs) +(letrec-values syntax chicken.base) +(list value scheme) +(list value r4rs) +(list->f32vector value srfi-4) +(list->f64vector value srfi-4) +(list->s16vector value srfi-4) +(list->s32vector value srfi-4) +(list->s64vector value srfi-4) +(list->s8vector value srfi-4) +(list->string value scheme) +(list->string value r4rs) +(list->u16vector value srfi-4) +(list->u32vector value srfi-4) +(list->u64vector value srfi-4) +(list->u8vector value srfi-4) +(list->vector value scheme) +(list->vector value r4rs) +(list-of? value chicken.base) +(list-ref value scheme) +(list-ref value r4rs) +(list-tail value scheme) +(list-tail value r4rs) +(list? value scheme) +(list? value r4rs) +(load value scheme) +(load value r4rs) +(load-library value chicken.load) +(load-noisily value chicken.load) +(load-relative value chicken.load) +(load-verbose value chicken.load) +(local-time->seconds value chicken.time.posix) +(local-timezone-abbreviation value chicken.time.posix) +(location syntax chicken.foreign) +(locative->object value chicken.locative) +(locative-ref value chicken.locative) +(locative-set! value chicken.locative) +(locative? value chicken.locative) +(log value scheme) +(log value r4rs) +(machine-byte-order value chicken.platform) +(machine-type value chicken.platform) +(magnitude value scheme) +(magnitude value r4rs) +(make-absolute-pathname value chicken.pathname) +(make-bidirectional-port value chicken.port) +(make-blob value chicken.blob) +(make-broadcast-port value chicken.port) +(make-composite-condition value chicken.condition) +(make-composite-condition value srfi-12) +(make-concatenated-port value chicken.port) +(make-f32vector value srfi-4) +(make-f64vector value srfi-4) +(make-input-port value chicken.port) +(make-irregex-chunker value chicken.irregex) +(make-locative value chicken.locative) +(make-output-port value chicken.port) +(make-parameter value chicken.base) +(make-parameter value srfi-39) +(make-pathname value chicken.pathname) +(make-pointer-vector value chicken.memory) +(make-polar value scheme) +(make-polar value r4rs) +(make-promise value chicken.base) +(make-property-condition value chicken.condition) +(make-property-condition value srfi-12) +(make-record-instance value chicken.memory.representation) +(make-rectangular value scheme) +(make-rectangular value r4rs) +(make-s16vector value srfi-4) +(make-s32vector value srfi-4) +(make-s64vector value srfi-4) +(make-s8vector value srfi-4) +(make-string value scheme) +(make-string value r4rs) +(make-u16vector value srfi-4) +(make-u32vector value srfi-4) +(make-u64vector value srfi-4) +(make-u8vector value srfi-4) +(make-vector value scheme) +(make-vector value r4rs) +(make-weak-locative value chicken.locative) +(map value scheme) +(map value r4rs) +(max value scheme) +(max value r4rs) +(maximum-flonum value chicken.flonum) +(maybe-string->sre value chicken.irregex) +(member value scheme) +(member value r4rs) +(memory-statistics value chicken.gc) +(memq value scheme) +(memq value r4rs) +(memv value scheme) +(memv value r4rs) +(merge value chicken.sort) +(merge! value chicken.sort) +(min value scheme) +(min value r4rs) +(minimum-flonum value chicken.flonum) +(module syntax chicken.module) +(module-environment value chicken.eval) +(modulo value scheme) +(modulo value r4rs) +(most-negative-fixnum value chicken.fixnum) +(most-positive-fixnum value chicken.fixnum) +(move-file value chicken.file) +(move-memory! value chicken.memory) +(mutate-procedure! value chicken.memory.representation) +(nan? value chicken.base) +(negative? value scheme) +(negative? value r4rs) +(newline value scheme) +(newline value r4rs) +(normalize-pathname value chicken.pathname) +(not value scheme) +(not value r4rs) +(notice value chicken.base) +(nth-value syntax chicken.base) +(null-environment value scheme) +(null-environment value r4rs) +(null? value scheme) +(null? value r4rs) +(number->string value scheme) +(number->string value r4rs) +(number-of-bytes value chicken.memory.representation) +(number-of-slots value chicken.memory.representation) +(number-vector? value srfi-4) +(number? value scheme) +(number? value r4rs) +(numerator value scheme) +(numerator value r4rs) +(o value chicken.base) +(object->pointer value chicken.memory) +(object-become! value chicken.memory.representation) +(object-copy value chicken.memory.representation) +(odd? value scheme) +(odd? value r4rs) +(on-exit value chicken.base) +(open-input-file value scheme) +(open-input-file value r4rs) +(open-input-file* value chicken.file.posix) +(open-input-pipe value chicken.process) +(open-input-string value chicken.base) +(open-input-string value srfi-6) +(open-output-file value scheme) +(open-output-file value r4rs) +(open-output-file* value chicken.file.posix) +(open-output-pipe value chicken.process) +(open-output-string value chicken.base) +(open-output-string value srfi-6) +(open/append value chicken.file.posix) +(open/binary value chicken.file.posix) +(open/creat value chicken.file.posix) +(open/excl value chicken.file.posix) +(open/fsync value chicken.file.posix) +(open/noctty value chicken.file.posix) +(open/noinherit value chicken.file.posix) +(open/nonblock value chicken.file.posix) +(open/rdonly value chicken.file.posix) +(open/rdwr value chicken.file.posix) +(open/read value chicken.file.posix) +(open/sync value chicken.file.posix) +(open/text value chicken.file.posix) +(open/trunc value chicken.file.posix) +(open/write value chicken.file.posix) +(open/wronly value chicken.file.posix) +(optional syntax chicken.base) +(or syntax r5rs-null) +(or syntax r4rs-null) +(or syntax scheme) +(or syntax r4rs) +(output-port-open? value chicken.base) +(output-port? value scheme) +(output-port? value r4rs) +(pair? value scheme) +(pair? value r4rs) +(parameterize syntax chicken.base) +(parameterize syntax srfi-39) +(parent-process-id value chicken.process-context.posix) +(parentheses-synonyms value chicken.base) +(pathname-directory value chicken.pathname) +(pathname-extension value chicken.pathname) +(pathname-file value chicken.pathname) +(pathname-replace-directory value chicken.pathname) +(pathname-replace-extension value chicken.pathname) +(pathname-replace-file value chicken.pathname) +(pathname-strip-directory value chicken.pathname) +(pathname-strip-extension value chicken.pathname) +(peek-char value scheme) +(peek-char value r4rs) +(perm/irgrp value chicken.file.posix) +(perm/iroth value chicken.file.posix) +(perm/irusr value chicken.file.posix) +(perm/irwxg value chicken.file.posix) +(perm/irwxo value chicken.file.posix) +(perm/irwxu value chicken.file.posix) +(perm/isgid value chicken.file.posix) +(perm/isuid value chicken.file.posix) +(perm/isvtx value chicken.file.posix) +(perm/iwgrp value chicken.file.posix) +(perm/iwoth value chicken.file.posix) +(perm/iwusr value chicken.file.posix) +(perm/ixgrp value chicken.file.posix) +(perm/ixoth value chicken.file.posix) +(perm/ixusr value chicken.file.posix) +(pipe/buf value chicken.process) +(pointer+ value chicken.memory) +(pointer->address value chicken.memory) +(pointer->object value chicken.memory) +(pointer-f32-ref value chicken.memory) +(pointer-f32-set! value chicken.memory) +(pointer-f64-ref value chicken.memory) +(pointer-f64-set! value chicken.memory) +(pointer-like? value chicken.memory) +(pointer-s16-ref value chicken.memory) +(pointer-s16-set! value chicken.memory) +(pointer-s32-ref value chicken.memory) +(pointer-s32-set! value chicken.memory) +(pointer-s64-ref value chicken.memory) +(pointer-s64-set! value chicken.memory) +(pointer-s8-ref value chicken.memory) +(pointer-s8-set! value chicken.memory) +(pointer-tag value chicken.memory) +(pointer-u16-ref value chicken.memory) +(pointer-u16-set! value chicken.memory) +(pointer-u32-ref value chicken.memory) +(pointer-u32-set! value chicken.memory) +(pointer-u64-ref value chicken.memory) +(pointer-u64-set! value chicken.memory) +(pointer-u8-ref value chicken.memory) +(pointer-u8-set! value chicken.memory) +(pointer-vector value chicken.memory) +(pointer-vector-fill! value chicken.memory) +(pointer-vector-length value chicken.memory) +(pointer-vector-ref value chicken.memory) +(pointer-vector-set! value chicken.memory) +(pointer-vector? value chicken.memory) +(pointer=? value chicken.memory) +(pointer? value chicken.memory) +(port->fileno value chicken.file.posix) +(port-closed? value chicken.base) +(port-fold value chicken.port) +(port-for-each value chicken.port) +(port-map value chicken.port) +(port-name value chicken.port) +(port-position value chicken.port) +(port? value chicken.base) +(positive? value scheme) +(positive? value r4rs) +(pp value chicken.pretty-print) +(pretty-print value chicken.pretty-print) +(pretty-print-width value chicken.pretty-print) +(print value chicken.base) +(print* value chicken.base) +(print-call-chain value chicken.base) +(print-error-message value chicken.condition) +(printf value chicken.format) +(procedure-data value chicken.memory.representation) +(procedure-information value chicken.base) +(procedure? value scheme) +(procedure? value r4rs) +(process value chicken.process) +(process* value chicken.process) +(process-execute value chicken.process) +(process-fork value chicken.process) +(process-group-id value chicken.process-context.posix) +(process-run value chicken.process) +(process-signal value chicken.process) +(process-sleep value chicken.process) +(process-spawn value chicken.process) +(process-wait value chicken.process) +(program-name value chicken.process-context) +(promise? value chicken.base) +(provide value chicken.load) +(provided? value chicken.load) +(pseudo-random-integer value chicken.random) +(pseudo-random-real value chicken.random) +(put! value chicken.plist) +(qs value chicken.process) +(quasiquote syntax r5rs-null) +(quasiquote syntax r4rs-null) +(quasiquote syntax scheme) +(quasiquote syntax r4rs) +(quit value chicken.repl) +(quote syntax r5rs-null) +(quote syntax r4rs-null) +(quote syntax scheme) +(quote syntax r4rs) +(quotient value scheme) +(quotient value r4rs) +(quotient&modulo value chicken.base) +(quotient&remainder value chicken.base) +(random-bytes value chicken.random) +(rassoc value chicken.base) +(rational? value scheme) +(rational? value r4rs) +(rationalize value scheme) +(rationalize value r4rs) +(ratnum? value chicken.base) +(read value scheme) +(read value r4rs) +(read-buffered value chicken.io) +(read-byte value chicken.io) +(read-char value scheme) +(read-char value r4rs) +(read-line value chicken.io) +(read-lines value chicken.io) +(read-list value chicken.io) +(read-string value chicken.io) +(read-string! value chicken.io) +(read-symbolic-link value chicken.file.posix) +(read-token value chicken.io) +(read-u8vector value srfi-4) +(read-u8vector! value srfi-4) +(real-part value scheme) +(real-part value r4rs) +(real? value scheme) +(real? value r4rs) +(rec syntax chicken.base) +(rec syntax srfi-31) +(receive syntax chicken.base) +(receive syntax srfi-8) +(record->vector value chicken.memory.representation) +(record-instance-length value chicken.memory.representation) +(record-instance-slot value chicken.memory.representation) +(record-instance-slot-set! value chicken.memory.representation) +(record-instance-type value chicken.memory.representation) +(record-instance? value chicken.memory.representation) +(record-printer value chicken.base) +(reexport syntax chicken.module) +(register-feature! value chicken.platform) +(regular-file? value chicken.file.posix) +(release-number-vector value srfi-4) +(remainder value scheme) +(remainder value r4rs) +(remprop! value chicken.plist) +(rename-file value chicken.file) +(repl value chicken.repl) +(repl-prompt value chicken.repl) +(repository-path value chicken.platform) +(require value chicken.load) +(require-extension syntax chicken.base) +(require-extension syntax srfi-55) +(require-library syntax chicken.base) +(reset value chicken.repl) +(reset-handler value chicken.repl) +(return-to-host value chicken.platform) +(reverse value scheme) +(reverse value r4rs) +(reverse-list->string value chicken.string) +(reverse-string-append value chicken.string) +(round value scheme) +(round value r4rs) +(s16vector value srfi-4) +(s16vector->blob value srfi-4) +(s16vector->blob/shared value srfi-4) +(s16vector->list value srfi-4) +(s16vector-length value srfi-4) +(s16vector-ref value srfi-4) +(s16vector-set! value srfi-4) +(s16vector? value srfi-4) +(s32vector value srfi-4) +(s32vector->blob value srfi-4) +(s32vector->blob/shared value srfi-4) +(s32vector->list value srfi-4) +(s32vector-length value srfi-4) +(s32vector-ref value srfi-4) +(s32vector-set! value srfi-4) +(s32vector? value srfi-4) +(s64vector value srfi-4) +(s64vector->blob value srfi-4) +(s64vector->blob/shared value srfi-4) +(s64vector->list value srfi-4) +(s64vector-length value srfi-4) +(s64vector-ref value srfi-4) +(s64vector-set! value srfi-4) +(s64vector? value srfi-4) +(s8vector value srfi-4) +(s8vector->blob value srfi-4) +(s8vector->blob/shared value srfi-4) +(s8vector->list value srfi-4) +(s8vector-length value srfi-4) +(s8vector-ref value srfi-4) +(s8vector-set! value srfi-4) +(s8vector? value srfi-4) +(scheme-report-environment value scheme) +(scheme-report-environment value r4rs) +(seconds->local-time value chicken.time.posix) +(seconds->string value chicken.time.posix) +(seconds->utc-time value chicken.time.posix) +(seek/cur value chicken.file.posix) +(seek/end value chicken.file.posix) +(seek/set value chicken.file.posix) +(set! syntax srfi-17) +(set! syntax r5rs-null) +(set! syntax r4rs-null) +(set! syntax scheme) +(set! syntax r4rs) +(set!-values syntax chicken.base) +(set-alarm! value chicken.process.signal) +(set-buffering-mode! value chicken.port) +(set-car! value scheme) +(set-car! value r4rs) +(set-cdr! value scheme) +(set-cdr! value r4rs) +(set-describer! value chicken.csi) +(set-dynamic-load-mode! value chicken.load) +(set-environment-variable! value chicken.process-context) +(set-file-group! value chicken.file.posix) +(set-file-owner! value chicken.file.posix) +(set-file-permissions! value chicken.file.posix) +(set-file-position! value chicken.file.posix) +(set-file-times! value chicken.file.posix) +(set-finalizer! value chicken.gc) +(set-gc-report! value chicken.gc) +(set-parameterized-read-syntax! value chicken.read-syntax) +(set-port-name! value chicken.port) +(set-procedure-data! value chicken.memory.representation) +(set-pseudo-random-seed! value chicken.random) +(set-read-syntax! value chicken.read-syntax) +(set-record-printer! value chicken.base) +(set-root-directory! value chicken.process-context.posix) +(set-sharp-read-syntax! value chicken.read-syntax) +(set-signal-handler! value chicken.process.signal) +(set-signal-mask! value chicken.process.signal) +(setter value chicken.base) +(setter value srfi-17) +(signal value chicken.condition) +(signal value srfi-12) +(signal-handler value chicken.process.signal) +(signal-mask value chicken.process.signal) +(signal-mask! value chicken.process.signal) +(signal-masked? value chicken.process.signal) +(signal-unmask! value chicken.process.signal) +(signal/abrt value chicken.process.signal) +(signal/alrm value chicken.process.signal) +(signal/break value chicken.process.signal) +(signal/bus value chicken.process.signal) +(signal/chld value chicken.process.signal) +(signal/cont value chicken.process.signal) +(signal/fpe value chicken.process.signal) +(signal/hup value chicken.process.signal) +(signal/ill value chicken.process.signal) +(signal/int value chicken.process.signal) +(signal/io value chicken.process.signal) +(signal/kill value chicken.process.signal) +(signal/pipe value chicken.process.signal) +(signal/prof value chicken.process.signal) +(signal/quit value chicken.process.signal) +(signal/segv value chicken.process.signal) +(signal/stop value chicken.process.signal) +(signal/term value chicken.process.signal) +(signal/trap value chicken.process.signal) +(signal/tstp value chicken.process.signal) +(signal/urg value chicken.process.signal) +(signal/usr1 value chicken.process.signal) +(signal/usr2 value chicken.process.signal) +(signal/vtalrm value chicken.process.signal) +(signal/winch value chicken.process.signal) +(signal/xcpu value chicken.process.signal) +(signal/xfsz value chicken.process.signal) +(signals-list value chicken.process.signal) +(signum value chicken.base) +(sin value scheme) +(sin value r4rs) +(sleep value chicken.base) +(socket? value chicken.file.posix) +(software-type value chicken.platform) +(software-version value chicken.platform) +(sort value chicken.sort) +(sort! value chicken.sort) +(sorted? value chicken.sort) +(spawn/detach value chicken.process) +(spawn/nowait value chicken.process) +(spawn/nowaito value chicken.process) +(spawn/overlay value chicken.process) +(spawn/wait value chicken.process) +(sprintf value chicken.format) +(sqrt value scheme) +(sqrt value r4rs) +(sre->irregex value chicken.irregex) +(sre->string value chicken.irregex) +(string value scheme) +(string value r4rs) +(string->blob value chicken.blob) +(string->irregex value chicken.irregex) +(string->keyword value chicken.keyword) +(string->keyword value srfi-88) +(string->list value scheme) +(string->list value r4rs) +(string->number value scheme) +(string->number value r4rs) +(string->sre value chicken.irregex) +(string->symbol value scheme) +(string->symbol value r4rs) +(string->time value chicken.time.posix) +(string->uninterned-symbol value chicken.base) +(string-append value scheme) +(string-append value r4rs) +(string-chomp value chicken.string) +(string-chop value chicken.string) +(string-ci<=? value scheme) +(string-ci<=? value r4rs) +(string-ci=? value scheme) +(string-ci>=? value r4rs) +(string-ci>? value scheme) +(string-ci>? value r4rs) +(string-compare3 value chicken.string) +(string-compare3-ci value chicken.string) +(string-copy value scheme) +(string-copy value r4rs) +(string-fill! value scheme) +(string-fill! value r4rs) +(string-intersperse value chicken.string) +(string-length value scheme) +(string-length value r4rs) +(string-ref value scheme) +(string-ref value r4rs) +(string-set! value scheme) +(string-set! value r4rs) +(string-split value chicken.string) +(string-translate value chicken.string) +(string-translate* value chicken.string) +(string<=? value scheme) +(string<=? value r4rs) +(string=? value scheme) +(string>=? value r4rs) +(string>? value scheme) +(string>? value r4rs) +(string? value scheme) +(string? value r4rs) +(strip-syntax value chicken.syntax) +(sub1 value chicken.base) +(subf32vector value srfi-4) +(subf64vector value srfi-4) +(subs16vector value srfi-4) +(subs32vector value srfi-4) +(subs64vector value srfi-4) +(subs8vector value srfi-4) +(substring value scheme) +(substring value r4rs) +(substring-ci=? value chicken.string) +(substring-index value chicken.string) +(substring-index-ci value chicken.string) +(substring=? value chicken.string) +(subu16vector value srfi-4) +(subu32vector value srfi-4) +(subu64vector value srfi-4) +(subu8vector value srfi-4) +(subvector value chicken.base) +(symbol->string value scheme) +(symbol->string value r4rs) +(symbol-append value chicken.base) +(symbol-escape value chicken.base) +(symbol-plist value chicken.plist) +(symbol? value scheme) +(symbol? value r4rs) +(symbolic-link? value chicken.file.posix) +(syntax syntax chicken.syntax) +(syntax-error value chicken.syntax) +(syntax-rules syntax r5rs-null) +(syntax-rules syntax r4rs-null) +(syntax-rules syntax scheme) +(syntax-rules syntax r4rs) +(system value chicken.process) +(system* value chicken.process) +(system-cache-directory value chicken.platform) +(system-config-directory value chicken.platform) +(tag-pointer value chicken.memory) +(tagged-pointer? value chicken.memory) +(tail? value chicken.base) +(tan value scheme) +(tan value r4rs) +(tcp-abandon-port value chicken.tcp) +(tcp-accept value chicken.tcp) +(tcp-accept-ready? value chicken.tcp) +(tcp-accept-timeout value chicken.tcp) +(tcp-addresses value chicken.tcp) +(tcp-buffer-size value chicken.tcp) +(tcp-close value chicken.tcp) +(tcp-connect value chicken.tcp) +(tcp-connect-timeout value chicken.tcp) +(tcp-listen value chicken.tcp) +(tcp-listener-fileno value chicken.tcp) +(tcp-listener-port value chicken.tcp) +(tcp-listener? value chicken.tcp) +(tcp-port-numbers value chicken.tcp) +(tcp-read-timeout value chicken.tcp) +(tcp-write-timeout value chicken.tcp) +(terminal-name value chicken.port) +(terminal-port? value chicken.port) +(terminal-size value chicken.port) +(the syntax chicken.type) +(time syntax chicken.time) +(time->string value chicken.time.posix) +(toplevel-command value chicken.csi) +(topological-sort value chicken.sort) +(truncate value scheme) +(truncate value r4rs) +(u16vector value srfi-4) +(u16vector->blob value srfi-4) +(u16vector->blob/shared value srfi-4) +(u16vector->list value srfi-4) +(u16vector-length value srfi-4) +(u16vector-ref value srfi-4) +(u16vector-set! value srfi-4) +(u16vector? value srfi-4) +(u32vector value srfi-4) +(u32vector->blob value srfi-4) +(u32vector->blob/shared value srfi-4) +(u32vector->list value srfi-4) +(u32vector-length value srfi-4) +(u32vector-ref value srfi-4) +(u32vector-set! value srfi-4) +(u32vector? value srfi-4) +(u64vector value srfi-4) +(u64vector->blob value srfi-4) +(u64vector->blob/shared value srfi-4) +(u64vector->list value srfi-4) +(u64vector-length value srfi-4) +(u64vector-ref value srfi-4) +(u64vector-set! value srfi-4) +(u64vector? value srfi-4) +(u8vector value srfi-4) +(u8vector->blob value srfi-4) +(u8vector->blob/shared value srfi-4) +(u8vector->list value srfi-4) +(u8vector-length value srfi-4) +(u8vector-ref value srfi-4) +(u8vector-set! value srfi-4) +(u8vector? value srfi-4) +(unless syntax chicken.base) +(unregister-feature! value chicken.platform) +(unset-environment-variable! value chicken.process-context) +(user-information value chicken.process-context.posix) +(user-options-pass value chicken.compiler.user-pass) +(user-pass value chicken.compiler.user-pass) +(user-post-analysis-pass value chicken.compiler.user-pass) +(user-preprocessor-pass value chicken.compiler.user-pass) +(user-read-pass value chicken.compiler.user-pass) +(utc-time->seconds value chicken.time.posix) +(values value scheme) +(vector value scheme) +(vector value r4rs) +(vector->list value scheme) +(vector->list value r4rs) +(vector-copy! value chicken.base) +(vector-fill! value scheme) +(vector-fill! value r4rs) +(vector-length value scheme) +(vector-length value r4rs) +(vector-like? value chicken.memory.representation) +(vector-ref value scheme) +(vector-ref value r4rs) +(vector-resize value chicken.base) +(vector-set! value scheme) +(vector-set! value r4rs) +(vector? value scheme) +(vector? value r4rs) +(void value chicken.base) +(warning value chicken.base) +(when syntax chicken.base) +(with-error-output-to-port value chicken.port) +(with-error-output-to-string value chicken.port) +(with-exception-handler value chicken.condition) +(with-exception-handler value srfi-12) +(with-input-from-file value scheme) +(with-input-from-file value r4rs) +(with-input-from-pipe value chicken.process) +(with-input-from-port value chicken.port) +(with-input-from-string value chicken.port) +(with-output-to-file value scheme) +(with-output-to-file value r4rs) +(with-output-to-pipe value chicken.process) +(with-output-to-port value chicken.port) +(with-output-to-string value chicken.port) +(write value scheme) +(write value r4rs) +(write-byte value chicken.io) +(write-char value scheme) +(write-char value r4rs) +(write-line value chicken.io) +(write-string value chicken.io) +(write-u8vector value srfi-4) +(zero? value scheme) +(zero? value r4rs) diff --git a/.eggs/openssl.cipher.import.so b/.eggs/openssl.cipher.import.so new file mode 100755 index 0000000..e7ec71c Binary files /dev/null and b/.eggs/openssl.cipher.import.so differ diff --git a/.eggs/openssl.cipher.link b/.eggs/openssl.cipher.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/openssl.cipher.link @@ -0,0 +1 @@ +() diff --git a/.eggs/openssl.cipher.o b/.eggs/openssl.cipher.o new file mode 100644 index 0000000..d17fb03 Binary files /dev/null and b/.eggs/openssl.cipher.o differ diff --git a/.eggs/openssl.cipher.so b/.eggs/openssl.cipher.so new file mode 100755 index 0000000..d3c064a Binary files /dev/null and b/.eggs/openssl.cipher.so differ diff --git a/.eggs/openssl.digest.import.so b/.eggs/openssl.digest.import.so new file mode 100755 index 0000000..0b2b1f7 Binary files /dev/null and b/.eggs/openssl.digest.import.so differ diff --git a/.eggs/openssl.digest.link b/.eggs/openssl.digest.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/openssl.digest.link @@ -0,0 +1 @@ +() diff --git a/.eggs/openssl.digest.o b/.eggs/openssl.digest.o new file mode 100644 index 0000000..8da75d6 Binary files /dev/null and b/.eggs/openssl.digest.o differ diff --git a/.eggs/openssl.digest.so b/.eggs/openssl.digest.so new file mode 100755 index 0000000..697bd93 Binary files /dev/null and b/.eggs/openssl.digest.so differ diff --git a/.eggs/openssl.egg-info b/.eggs/openssl.egg-info new file mode 100644 index 0000000..41ecc25 --- /dev/null +++ b/.eggs/openssl.egg-info @@ -0,0 +1,45 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.cipher.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.cipher.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.cipher.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.cipher.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.digest.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.digest.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.digest.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.digest.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.random.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.random.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.random.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.random.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.socket.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.socket.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.socket.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.socket.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.version.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.version.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.version.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/openssl.version.import.so") + (version "2.2.4") + (synopsis "Bindings to the OpenSSL SSL/TLS library") + (author "Thomas Chust") + (maintainer "Vasilij Schneidermann") + (license "BSD") + (category net) + (dependencies srfi-1 srfi-13 srfi-18 address-info) + (test-dependencies http-client server-test spiffy test uri-common) + (foreign-dependencies "openssl-1.1.0") + (component-options (csc-options "-O3" "-d1")) + (components + (extension + openssl + (custom-build "build-openssl") + (component-dependencies openssl.socket)) + (extension openssl.cipher (custom-build "build-openssl")) + (extension openssl.digest (custom-build "build-openssl")) + (extension openssl.random (custom-build "build-openssl")) + (extension openssl.socket (custom-build "build-openssl")) + (extension openssl.version (custom-build "build-openssl")))) diff --git a/.eggs/openssl.import.so b/.eggs/openssl.import.so new file mode 100755 index 0000000..30170a4 Binary files /dev/null and b/.eggs/openssl.import.so differ diff --git a/.eggs/openssl.link b/.eggs/openssl.link new file mode 100644 index 0000000..57fb379 --- /dev/null +++ b/.eggs/openssl.link @@ -0,0 +1 @@ +(openssl.socket) diff --git a/.eggs/openssl.o b/.eggs/openssl.o new file mode 100644 index 0000000..f405148 Binary files /dev/null and b/.eggs/openssl.o differ diff --git a/.eggs/openssl.random.import.so b/.eggs/openssl.random.import.so new file mode 100755 index 0000000..38bd009 Binary files /dev/null and b/.eggs/openssl.random.import.so differ diff --git a/.eggs/openssl.random.link b/.eggs/openssl.random.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/openssl.random.link @@ -0,0 +1 @@ +() diff --git a/.eggs/openssl.random.o b/.eggs/openssl.random.o new file mode 100644 index 0000000..1cafbcc Binary files /dev/null and b/.eggs/openssl.random.o differ diff --git a/.eggs/openssl.random.so b/.eggs/openssl.random.so new file mode 100755 index 0000000..852888e Binary files /dev/null and b/.eggs/openssl.random.so differ diff --git a/.eggs/openssl.so b/.eggs/openssl.so new file mode 100755 index 0000000..4ed3068 Binary files /dev/null and b/.eggs/openssl.so differ diff --git a/.eggs/openssl.socket.import.so b/.eggs/openssl.socket.import.so new file mode 100755 index 0000000..6379b5d Binary files /dev/null and b/.eggs/openssl.socket.import.so differ diff --git a/.eggs/openssl.socket.link b/.eggs/openssl.socket.link new file mode 100644 index 0000000..cac1cb8 --- /dev/null +++ b/.eggs/openssl.socket.link @@ -0,0 +1 @@ +(address-info srfi-18 srfi-13 srfi-1) diff --git a/.eggs/openssl.socket.o b/.eggs/openssl.socket.o new file mode 100644 index 0000000..fe0f34f Binary files /dev/null and b/.eggs/openssl.socket.o differ diff --git a/.eggs/openssl.socket.so b/.eggs/openssl.socket.so new file mode 100755 index 0000000..0b39037 Binary files /dev/null and b/.eggs/openssl.socket.so differ diff --git a/.eggs/openssl.version.import.so b/.eggs/openssl.version.import.so new file mode 100755 index 0000000..cde8d30 Binary files /dev/null and b/.eggs/openssl.version.import.so differ diff --git a/.eggs/openssl.version.link b/.eggs/openssl.version.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/openssl.version.link @@ -0,0 +1 @@ +() diff --git a/.eggs/openssl.version.o b/.eggs/openssl.version.o new file mode 100644 index 0000000..ce4f3f0 Binary files /dev/null and b/.eggs/openssl.version.o differ diff --git a/.eggs/openssl.version.so b/.eggs/openssl.version.so new file mode 100755 index 0000000..430a262 Binary files /dev/null and b/.eggs/openssl.version.so differ diff --git a/.eggs/regex.egg-info b/.eggs/regex.egg-info new file mode 100644 index 0000000..d35c4ba --- /dev/null +++ b/.eggs/regex.egg-info @@ -0,0 +1,13 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/regex.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/regex.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/regex.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/regex.import.so") + (version "2.0") + (synopsis "Compatibility library for old regular expression API") + (version "2.0") + (category misc) + (license "BSD") + (author "felix winkelmann") + (maintainer "The CHICKEN team") + (components (extension regex))) diff --git a/.eggs/regex.import.so b/.eggs/regex.import.so new file mode 100755 index 0000000..69202d3 Binary files /dev/null and b/.eggs/regex.import.so differ diff --git a/.eggs/regex.link b/.eggs/regex.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/regex.link @@ -0,0 +1 @@ +() diff --git a/.eggs/regex.o b/.eggs/regex.o new file mode 100644 index 0000000..ce07eb2 Binary files /dev/null and b/.eggs/regex.o differ diff --git a/.eggs/regex.so b/.eggs/regex.so new file mode 100755 index 0000000..0e857ef Binary files /dev/null and b/.eggs/regex.so differ diff --git a/.eggs/sendfile.egg-info b/.eggs/sendfile.egg-info new file mode 100644 index 0000000..6f0c8d4 --- /dev/null +++ b/.eggs/sendfile.egg-info @@ -0,0 +1,33 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/sendfile.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/sendfile.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/sendfile.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/sendfile.import.so") + (version "1.8.3") + (license "BSD") + (category net) + (author "David Krentzlin") + (test-dependencies test simple-sha1 srfi-4 srfi-13 srfi-69) + (dependencies memory-mapped-files) + (synopsis "Sending a file over the network") + (components + (extension + sendfile + (custom-build "build-sendfile") + (source-dependencies + "feature-tests/madvise.c" + "feature-tests/mmap.c" + "feature-tests/posix-fadvise.c" + "feature-tests/sendfile-bsd.c" + "feature-tests/sendfile-linux.c" + "feature-tests/sendfile-macos.c" + "feature-tests/sendfile-sun.c" + "backward-compatibility.scm" + "backward-compatibility/copy-port.scm" + "backward-compatibility/pointer-offset.scm" + "strategies/mmap.scm" + "strategies/rw.scm" + "strategies/sendfile.bsd.scm" + "strategies/sendfile.linux.scm" + "strategies/sendfile.macos.scm" + "strategies/sendfile.solaris.scm")))) diff --git a/.eggs/sendfile.import.so b/.eggs/sendfile.import.so new file mode 100755 index 0000000..cf09574 Binary files /dev/null and b/.eggs/sendfile.import.so differ diff --git a/.eggs/sendfile.link b/.eggs/sendfile.link new file mode 100644 index 0000000..cc911d1 --- /dev/null +++ b/.eggs/sendfile.link @@ -0,0 +1 @@ +(memory-mapped-files) diff --git a/.eggs/sendfile.o b/.eggs/sendfile.o new file mode 100644 index 0000000..9e86816 Binary files /dev/null and b/.eggs/sendfile.o differ diff --git a/.eggs/sendfile.so b/.eggs/sendfile.so new file mode 100755 index 0000000..3fbeee0 Binary files /dev/null and b/.eggs/sendfile.so differ diff --git a/.eggs/server-test.egg-info b/.eggs/server-test.egg-info new file mode 100644 index 0000000..18a2e09 --- /dev/null +++ b/.eggs/server-test.egg-info @@ -0,0 +1,12 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/server-test.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/server-test.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/server-test.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/server-test.import.so") + (version "0.6") + (synopsis "Utilities to help testing servers") + (category testing) + (license "BSD") + (author "Mario Domenech Goulart") + (component-options (csc-options "-O3" "-d1")) + (components (extension server-test))) diff --git a/.eggs/server-test.import.so b/.eggs/server-test.import.so new file mode 100755 index 0000000..da11bf9 Binary files /dev/null and b/.eggs/server-test.import.so differ diff --git a/.eggs/server-test.link b/.eggs/server-test.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/server-test.link @@ -0,0 +1 @@ +() diff --git a/.eggs/server-test.o b/.eggs/server-test.o new file mode 100644 index 0000000..5c931e3 Binary files /dev/null and b/.eggs/server-test.o differ diff --git a/.eggs/server-test.so b/.eggs/server-test.so new file mode 100755 index 0000000..5b382fd Binary files /dev/null and b/.eggs/server-test.so differ diff --git a/.eggs/simple-directory-handler.import.so b/.eggs/simple-directory-handler.import.so new file mode 100755 index 0000000..35950ed Binary files /dev/null and b/.eggs/simple-directory-handler.import.so differ diff --git a/.eggs/simple-directory-handler.link b/.eggs/simple-directory-handler.link new file mode 100644 index 0000000..4135769 --- /dev/null +++ b/.eggs/simple-directory-handler.link @@ -0,0 +1 @@ +(srfi-14 uri-common spiffy intarweb srfi-1) diff --git a/.eggs/simple-directory-handler.o b/.eggs/simple-directory-handler.o new file mode 100644 index 0000000..f75c8b4 Binary files /dev/null and b/.eggs/simple-directory-handler.o differ diff --git a/.eggs/simple-directory-handler.so b/.eggs/simple-directory-handler.so new file mode 100755 index 0000000..b8ddcb1 Binary files /dev/null and b/.eggs/simple-directory-handler.so differ diff --git a/.eggs/simple-md5.egg-info b/.eggs/simple-md5.egg-info new file mode 100644 index 0000000..a5e2c07 --- /dev/null +++ b/.eggs/simple-md5.egg-info @@ -0,0 +1,14 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-md5.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-md5.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-md5.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-md5.import.so") + (version "0.1.1") + (synopsis "Computes MD5 (RFC1321) checksums") + (author "Colin Plumb, packaged for Chicken by Peter Bex") + (license "Public Domain") + (maintainer "Peter Bex") + (dependencies memory-mapped-files srfi-13) + (test-dependencies test) + (category crypt) + (components (extension simple-md5))) diff --git a/.eggs/simple-md5.import.so b/.eggs/simple-md5.import.so new file mode 100755 index 0000000..3f7c90f Binary files /dev/null and b/.eggs/simple-md5.import.so differ diff --git a/.eggs/simple-md5.link b/.eggs/simple-md5.link new file mode 100644 index 0000000..a852507 --- /dev/null +++ b/.eggs/simple-md5.link @@ -0,0 +1 @@ +(srfi-13 memory-mapped-files) diff --git a/.eggs/simple-md5.o b/.eggs/simple-md5.o new file mode 100644 index 0000000..0f08b1c Binary files /dev/null and b/.eggs/simple-md5.o differ diff --git a/.eggs/simple-md5.so b/.eggs/simple-md5.so new file mode 100755 index 0000000..f0336fc Binary files /dev/null and b/.eggs/simple-md5.so differ diff --git a/.eggs/simple-sha1.egg-info b/.eggs/simple-sha1.egg-info new file mode 100644 index 0000000..8c5286b --- /dev/null +++ b/.eggs/simple-sha1.egg-info @@ -0,0 +1,15 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-sha1.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-sha1.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-sha1.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-sha1.import.so") + (version "1.2") + (synopsis "A fast and simple SHA1 implementation with minimal dependencies") + (author "Steve Reid and felix winkelmann") + (license "Public Domain") + (maintainer "felix winkelmann") + (dependencies memory-mapped-files) + (test-dependencies test) + (category crypt) + (components + (extension simple-sha1 (source-dependencies "sha1.h" "sha1-base.c")))) diff --git a/.eggs/simple-sha1.import.so b/.eggs/simple-sha1.import.so new file mode 100755 index 0000000..f372e8a Binary files /dev/null and b/.eggs/simple-sha1.import.so differ diff --git a/.eggs/simple-sha1.link b/.eggs/simple-sha1.link new file mode 100644 index 0000000..cc911d1 --- /dev/null +++ b/.eggs/simple-sha1.link @@ -0,0 +1 @@ +(memory-mapped-files) diff --git a/.eggs/simple-sha1.o b/.eggs/simple-sha1.o new file mode 100644 index 0000000..666ec7a Binary files /dev/null and b/.eggs/simple-sha1.o differ diff --git a/.eggs/simple-sha1.so b/.eggs/simple-sha1.so new file mode 100755 index 0000000..3a2b5a6 Binary files /dev/null and b/.eggs/simple-sha1.so differ diff --git a/.eggs/spiffy.egg-info b/.eggs/spiffy.egg-info new file mode 100644 index 0000000..83dff72 --- /dev/null +++ b/.eggs/spiffy.egg-info @@ -0,0 +1,31 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/spiffy.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/spiffy.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/spiffy.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/spiffy.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-directory-handler.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-directory-handler.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-directory-handler.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/simple-directory-handler.import.so") + (version "6.3") + (synopsis "A small but powerful web server") + (author "Felix Winkelmann") + (maintainer "Peter Bex") + (category web) + (license "BSD") + (dependencies + intarweb + uri-common + uri-generic + sendfile + srfi-1 + srfi-13 + srfi-14 + srfi-18) + (test-dependencies test) + (components + (extension spiffy (csc-options "-O3")) + (extension + simple-directory-handler + (component-dependencies spiffy) + (csc-options "-O3")))) diff --git a/.eggs/spiffy.import.so b/.eggs/spiffy.import.so new file mode 100755 index 0000000..fd7b33c Binary files /dev/null and b/.eggs/spiffy.import.so differ diff --git a/.eggs/spiffy.link b/.eggs/spiffy.link new file mode 100644 index 0000000..29c5425 --- /dev/null +++ b/.eggs/spiffy.link @@ -0,0 +1 @@ +(intarweb sendfile uri-common srfi-18 srfi-14 srfi-13 srfi-1) diff --git a/.eggs/spiffy.o b/.eggs/spiffy.o new file mode 100644 index 0000000..a0295b8 Binary files /dev/null and b/.eggs/spiffy.o differ diff --git a/.eggs/spiffy.so b/.eggs/spiffy.so new file mode 100755 index 0000000..ff94e74 Binary files /dev/null and b/.eggs/spiffy.so differ diff --git a/.eggs/srfi-1.egg-info b/.eggs/srfi-1.egg-info new file mode 100644 index 0000000..b4e6c06 --- /dev/null +++ b/.eggs/srfi-1.egg-info @@ -0,0 +1,15 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-1.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-1.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-1.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-1.types" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-1.import.so") + (version "0.5.1") + (synopsis "SRFI-1 list library") + (author "Olin Shivers") + (maintainer "The CHICKEN Team") + (category data) + (test-dependencies test) + (license "BSD") + (components + (extension srfi-1 (csc-options "-O3" "-d0") (types-file (predefined))))) diff --git a/.eggs/srfi-1.import.so b/.eggs/srfi-1.import.so new file mode 100755 index 0000000..cfbcd58 Binary files /dev/null and b/.eggs/srfi-1.import.so differ diff --git a/.eggs/srfi-1.link b/.eggs/srfi-1.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/srfi-1.link @@ -0,0 +1 @@ +() diff --git a/.eggs/srfi-1.o b/.eggs/srfi-1.o new file mode 100644 index 0000000..fbaa3bd Binary files /dev/null and b/.eggs/srfi-1.o differ diff --git a/.eggs/srfi-1.so b/.eggs/srfi-1.so new file mode 100755 index 0000000..5b7fa04 Binary files /dev/null and b/.eggs/srfi-1.so differ diff --git a/.eggs/srfi-1.types b/.eggs/srfi-1.types new file mode 100644 index 0000000..a15e3ce --- /dev/null +++ b/.eggs/srfi-1.types @@ -0,0 +1,245 @@ +;; srfi-1 -*- Scheme -*- + +(srfi-1#alist-cons + (forall (a b c) (#(procedure #:pure) srfi-1#alist-cons (a b (list-of c)) + (pair (pair a b) (list-of c))))) +(srfi-1#alist-copy + (forall (a b) (#(procedure #:clean #:enforce) srfi-1#alist-copy + ((list-of (pair a b))) (list-of (pair a b))))) +(srfi-1#alist-delete + (forall (a b c) (#(procedure #:clean) srfi-1#alist-delete + (a (list-of (pair b c)) #!optional (procedure (a b) *)) + (list-of (pair b c))))) +(srfi-1#alist-delete! + (forall (a b c) (#(procedure) srfi-1#alist-delete! + (a (list-of (pair b c)) #!optional (procedure (a b) *)) + (list-of (pair b c))))) +(srfi-1#any (forall (a) (#(procedure #:enforce) srfi-1#any ((procedure (a #!rest) *) (list-of a) #!rest list) *))) +(srfi-1#append! (#(procedure #:enforce) srfi-1#append! (#!rest list) list)) + +(srfi-1#append-map + (forall (a b) (#(procedure #:enforce) srfi-1#append-map ((procedure (a #!rest) (list-of b)) (list-of a) #!rest list) + (list-of b)))) + +(srfi-1#append-map! + (forall (a b) (#(procedure #:enforce) srfi-1#append-map! ((procedure (a #!rest) (list-of b)) (list-of a) #!rest list) + (list-of b)))) + +(srfi-1#append-reverse (#(procedure #:clean #:enforce) srfi-1#append-reverse (list list) list)) +(srfi-1#append-reverse! (#(procedure #:enforce) srfi-1#append-reverse! (list list) list)) +(srfi-1#assoc + (forall (a b c) (#(procedure #:clean #:foldable) srfi-1#assoc + (a (list-of (pair b c)) #!optional (procedure (a b) *)) + (or false (pair b c)))) ; sic + ((* null) (let ((#(tmp) #(1))) '#f)) + (((or symbol procedure immediate) (list-of pair)) + (##core#inline "C_u_i_assq" #(1) #(2))) + ((* (list-of (pair (or symbol procedure immediate) *))) + (##core#inline "C_u_i_assq" #(1) #(2)))) + +(srfi-1#break (forall (a) (#(procedure #:enforce) srfi-1#break ((procedure (a) *) (list-of a)) (list-of a) (list-of a)))) +(srfi-1#break! (forall (a) (#(procedure #:enforce) srfi-1#break! ((procedure (a) *) (list-of a)) (list-of a) (list-of a)))) +(srfi-1#car+cdr (forall (a b) (#(procedure #:clean #:enforce) srfi-1#car+cdr ((pair a b)) a b))) +(srfi-1#circular-list (#(procedure #:clean) srfi-1#circular-list (#!rest) list)) + +(srfi-1#circular-list? (#(procedure #:clean #:foldable) srfi-1#circular-list? (*) boolean) + ((null) (let ((#(tmp) #(1))) '#f))) + +(srfi-1#concatenate (#(procedure #:clean #:enforce) srfi-1#concatenate ((list-of list)) list)) +(srfi-1#concatenate! (#(procedure #:enforce) srfi-1#concatenate! ((list-of list)) list)) +(srfi-1#cons* (forall (a) (#(procedure #:clean) srfi-1#cons* (a #!rest) (pair a *)))) +(srfi-1#count (forall (a) (#(procedure #:enforce) srfi-1#count ((procedure (a #!rest) *) (list-of a) #!rest list) fixnum))) +(srfi-1#delete (forall (a b) (#(procedure #:enforce) srfi-1#delete (a (list-of b) #!optional (procedure (a *) *)) (list-of b)))) +(srfi-1#delete! (forall (a b) (#(procedure #:enforce) srfi-1#delete! (a (list-of b) #!optional (procedure (a *) *)) (list-of b)))) + +(srfi-1#delete-duplicates + (forall (a) (#(procedure #:enforce) srfi-1#delete-duplicates ((list-of a) #!optional (procedure (a *) *)) (list-of a)))) + +(srfi-1#delete-duplicates! + (forall (a) (#(procedure #:enforce) srfi-1#delete-duplicates! ((list-of a) #!optional (procedure (a *) *)) (list-of a)))) + +(srfi-1#dotted-list? (#(procedure #:clean #:foldable) srfi-1#dotted-list? (*) boolean)) +(srfi-1#drop (forall (a) (#(procedure #:enforce) srfi-1#drop ((list-of a) fixnum) (list-of a)))) +(srfi-1#drop-right (forall (a) (#(procedure #:enforce) srfi-1#drop-right ((list-of a) fixnum) (list-of a)))) +(srfi-1#drop-right! (forall (a) (#(procedure #:enforce) srfi-1#drop-right! ((list-of a) fixnum) (list-of a)))) +(srfi-1#drop-while (forall (a) (#(procedure #:enforce) srfi-1#drop-while ((procedure (a) *) (list-of a)) (list-of a)))) +(srfi-1#eighth (#(procedure #:clean #:enforce #:foldable) srfi-1#eighth (pair) *)) + +(srfi-1#every + (forall (a) (#(procedure #:enforce) srfi-1#every ((procedure (a #!rest) *) (list-of a) #!rest list) *))) + +(srfi-1#fifth (#(procedure #:clean #:enforce #:foldable) srfi-1#fifth (pair) *)) +(srfi-1#filter (forall (a) (#(procedure #:enforce) srfi-1#filter ((procedure (a) *) (list-of a)) (list-of a)))) +(srfi-1#filter! (forall (a) (#(procedure #:enforce) srfi-1#filter! ((procedure (a) *) (list-of a)) (list-of a)))) + +(srfi-1#filter-map + (forall (a b) (#(procedure #:enforce) srfi-1#filter-map ((procedure (a #!rest) b) (list-of a) #!rest list) (list-of b)))) + +(srfi-1#find (forall (a) (#(procedure #:enforce) srfi-1#find ((procedure (a) *) (list-of a)) *))) +(srfi-1#find-tail (forall (a) (#(procedure #:enforce) srfi-1#find-tail ((procedure (a) *) (list-of a)) *))) + +(srfi-1#first (forall (a) (#(procedure #:clean #:enforce #:foldable) srfi-1#first ((pair a *)) a)) + ((pair) (##core#inline "C_u_i_car" #(1)))) + +(srfi-1#fold (#(procedure #:enforce) srfi-1#fold ((procedure (* #!rest) *) * #!rest list) *)) ;XXX +(srfi-1#fold-right (#(procedure #:enforce) srfi-1#fold-right ((procedure (* #!rest) *) * #!rest list) *)) ;XXX + +(srfi-1#fourth (forall (a) (#(procedure #:clean #:enforce #:foldable) srfi-1#fourth ((pair * (pair * (pair * (pair a *))))) a)) + (((pair * (pair * (pair * (pair * *))))) + (##core#inline "C_u_i_car" + (##core#inline "C_u_i_cdr" + (##core#inline "C_u_i_cdr" + (##core#inline "C_u_i_cdr" #(1))))))) + +(srfi-1#iota (#(procedure #:clean #:enforce) srfi-1#iota (fixnum #!optional fixnum fixnum) (list-of number))) +(srfi-1#last (#(procedure #:clean #:enforce #:foldable) srfi-1#last (pair) *)) +(srfi-1#last-pair (#(procedure #:clean #:enforce #:foldable) srfi-1#last-pair (pair) *)) +(srfi-1#length+ (#(procedure #:clean #:enforce #:foldable) srfi-1#length+ (list) *)) +(srfi-1#list-copy (forall (a) (#(procedure #:pure) srfi-1#list-copy (a) a))) +(srfi-1#list-index (forall (a) (#(procedure #:enforce) srfi-1#list-index ((procedure (a #!rest) *) (list-of a) #!rest list) *))) +(srfi-1#list-tabulate (forall (a) (#(procedure #:enforce) srfi-1#list-tabulate (fixnum (procedure (fixnum) a)) (list-of a)))) +(srfi-1#list= (#(procedure #:clean #:enforce) srfi-1#list= (#!optional (procedure (list list) *) #!rest list) boolean) + (() '#t) + ((procedure) (let ((#(tmp) #(1))) '#t))) + +(srfi-1#lset-adjoin + (forall (a) (#(procedure #:enforce) srfi-1#lset-adjoin ((procedure (a a) *) (list-of a) #!rest a) (list-of a))) + ((procedure list) (let ((#(tmp) #(1))) #(2)))) + +(srfi-1#lset-diff+intersection + (forall (a) + (#(procedure #:enforce) srfi-1#lset-diff+intersection ((procedure (a a) *) (list-of a) #!rest (list-of a)) + (list-of a) (list-of a))) + ((procedure list) (let ((#(tmp) #(1))) (##sys#values #(2) '())))) + +(srfi-1#lset-diff+intersection! + (forall (a) + (#(procedure #:enforce) srfi-1#lset-diff+intersection! ((procedure (a a) *) (list-of a) #!rest (list-of a)) + (list-of a) (list-of a))) + ((procedure list) (let ((#(tmp) #(1))) (##sys#values #(2) '())))) + +(srfi-1#lset-difference + (forall (a) (#(procedure #:enforce) srfi-1#lset-difference ((procedure (a a) *) (list-of a) #!rest (list-of a)) (list-of a))) + ((procedure list) (let ((#(tmp) #(1))) #(2)))) + +(srfi-1#lset-difference! + (forall (a) (#(procedure #:enforce) srfi-1#lset-difference! ((procedure (a a) *) (list-of a) #!rest (list-of a)) (list-of a))) + ((procedure list) (let ((#(tmp) #(1))) #(2)))) + +(srfi-1#lset-intersection + (forall (a) (#(procedure #:enforce) srfi-1#lset-intersection ((procedure (a a) *) (list-of a) #!rest (list-of a)) (list-of a))) + ((procedure list) (let ((#(tmp) #(1))) #(2)))) + +(srfi-1#lset-intersection! + (forall (a) (#(procedure #:enforce) srfi-1#lset-intersection! ((procedure (a a) *) (list-of a) #!rest (list-of a)) (list-of a))) + ((procedure list) (let ((#(tmp) #(1))) #(2)))) + +(srfi-1#lset-union + (forall (a) (#(procedure #:enforce) srfi-1#lset-union ((procedure (a a) *) #!rest (list-of a)) (list-of a))) + ((procedure) (let ((#(tmp) #(1))) '())) + ((procedure list) (let ((#(tmp) #(1))) #(2)))) + +(srfi-1#lset-union! + (forall (a) (#(procedure #:enforce) srfi-1#lset-union! ((procedure (a a) *) #!rest (list-of a)) (list-of a))) + ((procedure) (let ((#(tmp) #(1))) '())) + ((procedure list) (let ((#(tmp) #(1))) #(2)))) + +(srfi-1#lset-xor + (forall (a) (#(procedure #:enforce) srfi-1#lset-xor ((procedure (a a) *) #!rest (list-of a)) (list-of a))) + ((procedure) (let ((#(tmp) #(1))) '())) + ((procedure list) (let ((#(tmp) #(1))) #(2)))) + +(srfi-1#lset-xor! + (forall (a) (#(procedure #:enforce) srfi-1#lset-xor! ((procedure (a a) *) #!rest (list-of a)) (list-of a))) + ((procedure) (let ((#(tmp) #(1))) '())) + ((procedure list) (let ((#(tmp) #(1))) #(2)))) + +(srfi-1#lset<= + (forall (a) (#(procedure #:enforce) srfi-1#lset<= ((procedure (a a) *) #!rest (list-of a)) boolean)) + ((procedure) (let ((#(tmp) #(1))) '#t)) + ((procedure list) (let ((#(tmp1) #(1)) (#(tmp2) #(2))) '#t))) + +(srfi-1#lset= + (forall (a) (#(procedure #:enforce) srfi-1#lset= ((procedure (a a) *) #!rest (list-of a)) boolean)) + ((procedure) (let ((#(tmp) #(1))) '#t)) + ((procedure list) (let ((#(tmp1) #(1)) (#(tmp2) #(2))) '#t))) + +(srfi-1#make-list (forall (a) (#(procedure #:clean #:enforce) srfi-1#make-list (fixnum #!optional a) (list-of a)))) + +(srfi-1#map! + (forall (a b) (#(procedure #:enforce) srfi-1#map! ((procedure (a #!rest) b) (list-of a) #!rest list) (list-of b)))) + +(srfi-1#map-in-order + (forall + (a b) + (#(procedure #:enforce) srfi-1#map-in-order ((procedure (a #!rest) b) (list-of a) #!rest list) (list-of b)))) + +(srfi-1#member + (forall (a b) (#(procedure #:clean #:foldable) srfi-1#member + (a (list-of b) #!optional (procedure (a b) *)) ; sic + (or false (list-of b)))) + ((* null) (let ((#(tmp) #(1))) '#f)) + (((or symbol procedure immediate) list) + (##core#inline "C_u_i_memq" #(1) #(2))) + ((* (list-of (or symbol procedure immediate))) + (##core#inline "C_u_i_memq" #(1) #(2)))) + +(srfi-1#ninth (#(procedure #:clean #:enforce #:foldable) srfi-1#ninth (pair) *)) + +(srfi-1#not-pair? (#(procedure #:clean #:foldable) srfi-1#not-pair? (*) boolean) + ((pair) (let ((#(tmp) #(1))) '#f)) + (((not (or pair list))) (let ((#(tmp) #(1))) '#t))) + +(srfi-1#null-list? (#(procedure #:clean #:enforce #:foldable) srfi-1#null-list? (list) boolean) + ((pair) (let ((#(tmp) #(1))) '#f)) + ((list) (let ((#(tmp) #(1))) '#f)) + ((null) (let ((#(tmp) #(1))) '#t))) + +(srfi-1#pair-fold (#(procedure #:enforce) srfi-1#pair-fold (procedure * list #!rest list) *)) ;XXX do this +(srfi-1#pair-fold-right (#(procedure #:enforce) srfi-1#pair-fold-right (procedure * list #!rest list) *)) ;XXX +(srfi-1#pair-for-each (#(procedure #:enforce) srfi-1#pair-for-each ((procedure (#!rest) . *) list #!rest list) undefined)) ;XXX +(srfi-1#partition (forall (a) (#(procedure #:enforce) srfi-1#partition ((procedure (a) *) (list-of a)) (list-of a) (list-of a)))) +(srfi-1#partition! (forall (a) (#(procedure #:enforce) srfi-1#partition! ((procedure (a) *) (list-of a)) (list-of a) (list-of a)))) + +(srfi-1#proper-list? (#(procedure #:clean #:foldable) proper-list? (*) boolean) + ((null) (let ((#(tmp) #(1))) '#t))) + +(srfi-1#reduce (#(procedure #:enforce) srfi-1#reduce ((procedure (* *) *) * list) *)) ;XXX +(srfi-1#reduce-right (#(procedure #:enforce) srfi-1#reduce-right ((procedure (* *) *) * list) *)) ;XXX +(srfi-1#remove (forall (a) (#(procedure #:enforce) srfi-1#remove ((procedure (a) *) (list-of a)) (list-of a)))) +(srfi-1#remove! (forall (a) (#(procedure #:enforce) srfi-1#remove! ((procedure (a) *) (list-of a)) (list-of a)))) +(srfi-1#reverse! (forall (a) (#(procedure #:enforce) srfi-1#reverse! ((list-of a)) (list-of a)))) + +(srfi-1#second (forall (a) (#(procedure #:clean #:enforce #:foldable) srfi-1#second ((pair * (pair a *))) a)) + (((pair * (pair * *))) (##core#inline "C_u_i_car" (##core#inline "C_u_i_cdr" #(1))))) + +(srfi-1#seventh (#(procedure #:clean #:enforce #:foldable) srfi-1#seventh (pair) *)) +(srfi-1#sixth (#(procedure #:clean #:enforce #:foldable) srfi-1#sixth (pair) *)) +(srfi-1#span (forall (a) (#(procedure #:enforce) srfi-1#span ((procedure (a) *) (list-of a)) (list-of a) (list-of a)))) +(srfi-1#span! (forall (a) (#(procedure #:enforce) srfi-1#span! ((procedure (a) *) (list-of a)) (list-of a) (list-of a)))) +(srfi-1#split-at (forall (a) (#(procedure #:enforce) srfi-1#split-at ((list-of a) fixnum) (list-of a) (list-of a)))) +(srfi-1#split-at! (forall (a) (#(procedure #:enforce) srfi-1#split-at! ((list-of a) fixnum) (list-of a) (list-of a)))) +(srfi-1#take (forall (a) (#(procedure #:enforce) srfi-1#take ((list-of a) fixnum) (list-of a)))) +(srfi-1#take! (forall (a) (#(procedure #:enforce) srfi-1#take! ((list-of a) fixnum) (list-of a)))) +(srfi-1#take-right (forall (a) (#(procedure #:enforce) srfi-1#take-right ((list-of a) fixnum) (list-of a)))) +(srfi-1#take-while (forall (a) (#(procedure #:enforce) srfi-1#take-while ((procedure (a) *) (list-of a)) (list-of a)))) +(srfi-1#take-while! (forall (a) (#(procedure #:enforce) srfi-1#take-while! ((procedure (a) *) (list-of a)) (list-of a)))) +(srfi-1#tenth (#(procedure #:clean #:enforce #:foldable) srfi-1#tenth (pair) *)) + +(srfi-1#third (forall (a) (#(procedure #:clean #:enforce #:foldable) srfi-1#third ((pair * (pair * (pair a *)))) a)) + (((pair * (pair * (pair * *)))) + (##core#inline "C_u_i_car" + (##core#inline "C_u_i_cdr" (##core#inline "C_u_i_cdr" #(1)))))) + +(srfi-1#unfold (#(procedure #:enforce) srfi-1#unfold ((procedure (*) *) (procedure (*) *) (procedure (*) *) * #!optional (procedure (*) *)) *)) ;XXX +(srfi-1#unfold-right (#(procedure #:enforce) srfi-1#unfold-right ((procedure (*) *) (procedure (*) *) (procedure (*) *) * #!optional (procedure (*) *)) *)) ;XXX +(srfi-1#unzip1 (forall (a) (#(procedure #:clean #:enforce) srfi-1#unzip1 ((list-of (pair a *))) (list-of a)))) +(srfi-1#unzip2 (forall (a b) (#(procedure #:clean #:enforce) srfi-1#unzip2 ((list-of (pair a (pair b *)))) (list-of a) (list-of b)))) + +(srfi-1#unzip3 + (forall (a b c) (#(procedure #:clean #:enforce) srfi-1#unzip3 ((list-of (pair a (pair b (pair c *))))) (list-of a) (list-of b) (list-of c)))) + +(srfi-1#unzip4 (#(procedure #:clean #:enforce) srfi-1#unzip4 (list) list list list list)) ; yeah +(srfi-1#unzip5 (#(procedure #:clean #:enforce) srfi-1#unzip5 (list) list list list list list)) ; yeah, too +(srfi-1#xcons (forall (a b) (#(procedure #:pure) srfi-1#xcons (a b) (pair b a)))) +(srfi-1#zip (forall (a) (#(procedure #:clean #:enforce) srfi-1#zip ((list-of a) #!rest list) (list-of (pair a *))))) diff --git a/.eggs/srfi-13.egg-info b/.eggs/srfi-13.egg-info new file mode 100644 index 0000000..daa0ff4 --- /dev/null +++ b/.eggs/srfi-13.egg-info @@ -0,0 +1,16 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-13.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-13.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-13.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-13.types" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-13.import.so") + (version "0.3.2") + (synopsis "SRFI-13 string library") + (author "Olin Shivers") + (maintainer "The CHICKEN Team") + (category data) + (license "BSD") + (dependencies srfi-14) + (test-dependencies test) + (components + (extension srfi-13 (csc-options "-O3" "-d0") (types-file (predefined))))) diff --git a/.eggs/srfi-13.import.so b/.eggs/srfi-13.import.so new file mode 100755 index 0000000..5ef48e2 Binary files /dev/null and b/.eggs/srfi-13.import.so differ diff --git a/.eggs/srfi-13.link b/.eggs/srfi-13.link new file mode 100644 index 0000000..d6a07b6 --- /dev/null +++ b/.eggs/srfi-13.link @@ -0,0 +1 @@ +(srfi-14) diff --git a/.eggs/srfi-13.o b/.eggs/srfi-13.o new file mode 100644 index 0000000..e2e90e5 Binary files /dev/null and b/.eggs/srfi-13.o differ diff --git a/.eggs/srfi-13.so b/.eggs/srfi-13.so new file mode 100755 index 0000000..6e56365 Binary files /dev/null and b/.eggs/srfi-13.so differ diff --git a/.eggs/srfi-13.types b/.eggs/srfi-13.types new file mode 100644 index 0000000..d4c0f00 --- /dev/null +++ b/.eggs/srfi-13.types @@ -0,0 +1,172 @@ +(srfi-13#check-substring-spec (#(procedure #:clean #:enforce) srfi-13#check-substring-spec (* string fixnum fixnum) undefined)) +(srfi-13#kmp-step (#(procedure #:enforce) srfi-13#kmp-step (string vector char fixnum (procedure (char char) *) fixnum) fixnum)) +(srfi-13#make-kmp-restart-vector (#(procedure #:clean #:enforce) srfi-13#make-kmp-restart-vector (string #!optional (procedure (* *) *) fixnum fixnum) vector)) + +(srfi-13#string-any + (forall (a) + (#(procedure #:enforce) + srfi-13#string-any + ((or char (struct char-set) (procedure (char) a)) string #!optional fixnum fixnum) + (or boolean a)))) + +(srfi-13#string-append/shared (#(procedure #:clean #:enforce) srfi-13#string-append/shared (#!rest string) string) + ((string string) (##sys#string-append #(1) #(2)))) + +(srfi-13#string-ci< (#(procedure #:clean #:enforce) srfi-13#string-ci< (string string #!optional fixnum fixnum) boolean) + ((string string) (srfi-13#string-ci (#(procedure #:clean #:enforce) srfi-13#string-ci<> (string string #!optional fixnum fixnum) boolean) + ((string string) (not (##core#inline "C_i_string_ci_equal_p" #(1) #(2))))) + +(srfi-13#string-ci= (#(procedure #:clean #:enforce) srfi-13#string-ci= (string string #!optional fixnum fixnum) boolean) + ((string string) (##core#inline "C_i_string_ci_equal_p" #(1) #(2)))) + +(srfi-13#string-ci> (#(procedure #:clean #:enforce) srfi-13#string-ci> (string string #!optional fixnum fixnum) boolean) + ((string string) (srfi-13#string-ci>? #(1) #(2)))) + +(srfi-13#string-ci>= (#(procedure #:clean #:enforce) srfi-13#string-ci>= (string string #!optional fixnum fixnum) boolean) + ((string string) (srfi-13#string-ci>=? #(1) #(2)))) + +(srfi-13#string-compare (#(procedure #:enforce) srfi-13#string-compare (string string (procedure (fixnum) *) (procedure (fixnum) *) (procedure (fixnum) *) #!optional fixnum fixnum fixnum fixnum) *)) +(srfi-13#string-compare-ci (#(procedure #:enforce) srfi-13#string-compare (string string (procedure (fixnum) *) (procedure (fixnum) *) (procedure (fixnum) *) #!optional fixnum fixnum fixnum fixnum) *)) +(srfi-13#string-concatenate (#(procedure #:clean #:enforce) srfi-13#string-concatenate ((list-of string)) string)) +(srfi-13#string-concatenate-reverse (#(procedure #:clean #:enforce) srfi-13#string-concatenate-reverse ((list-of string) #!optional string fixnum) string)) +(srfi-13#string-concatenate-reverse/shared (#(procedure #:clean #:enforce) srfi-13#string-concatenate-reverse/shared ((list-of string) #!optional string fixnum) string)) +(srfi-13#string-concatenate/shared (#(procedure #:clean #:enforce) srfi-13#string-concatenate/shared ((list-of string)) string)) +(srfi-13#string-contains (#(procedure #:clean #:enforce) srfi-13#string-contains (string string #!optional fixnum fixnum fixnum fixnum) (or fixnum false))) +(srfi-13#string-contains-ci (#(procedure #:clean #:enforce) srfi-13#string-contains-ci (string string #!optional fixnum fixnum fixnum fixnum) (or fixnum false))) +(srfi-13#string-copy (#(procedure #:clean #:enforce) srfi-13#string-copy (string #!optional fixnum fixnum) string)) +(srfi-13#string-copy! (#(procedure #:clean #:enforce) srfi-13#string-copy! (string fixnum string #!optional fixnum fixnum) undefined)) +(srfi-13#string-count (#(procedure #:clean #:enforce) srfi-13#string-count (string * #!optional fixnum fixnum) fixnum)) +(srfi-13#string-delete (#(procedure #:clean #:enforce) srfi-13#string-delete (* string #!optional fixnum fixnum) string)) +(srfi-13#string-downcase (#(procedure #:clean #:enforce) srfi-13#string-downcase (string #!optional fixnum fixnum) string)) +(srfi-13#string-downcase! (#(procedure #:clean #:enforce) srfi-13#string-downcase! (string #!optional fixnum fixnum) string)) +(srfi-13#string-drop (#(procedure #:clean #:enforce) srfi-13#string-drop (string fixnum) string)) +(srfi-13#string-drop-right (#(procedure #:clean #:enforce) srfi-13#string-drop-right (string fixnum) string)) + +(srfi-13#string-every + (forall (a) + (#(procedure #:enforce) + srfi-13#string-every + ((or char (struct char-set) (procedure (char) a)) string #!optional fixnum fixnum) + (or boolean a)))) + +(srfi-13#string-fill! (#(procedure #:clean #:enforce) srfi-13#string-fill! (string char #!optional fixnum fixnum) string)) + +(srfi-13#string-filter + (#(procedure #:enforce) + srfi-13#string-filter + ((or char (struct char-set) (procedure (char) *)) string #!optional fixnum fixnum) + string)) + +(srfi-13#string-fold (#(procedure #:enforce) srfi-13#string-fold ((procedure (char *) *) * string #!optional fixnum fixnum) *)) ;XXX + +(srfi-13#string-fold-right (#(procedure #:enforce) srfi-13#string-fold-right ((procedure (char *) *) * string #!optional fixnum fixnum) *)) ;XXX +(srfi-13#string-for-each (#(procedure #:enforce) srfi-13#string-for-each ((procedure (char) . *) string #!optional fixnum fixnum) undefined)) +(srfi-13#string-for-each-index (#(procedure #:enforce) srfi-13#string-for-each-index ((procedure (fixnum) . *) string #!optional fixnum fixnum) undefined)) + +(srfi-13#string-index + (#(procedure #:enforce) + srfi-13#string-index + (string (or char (struct char-set) (procedure (char) *)) #!optional fixnum fixnum) + (or fixnum false))) + +(srfi-13#string-index-right + (#(procedure #:enforce) + srfi-13#string-index-right + (string (or char (struct char-set) (procedure (char) *)) #!optional fixnum fixnum) + (or fixnum false))) + +(srfi-13#string-join (#(procedure #:clean #:enforce) srfi-13#string-join (list #!optional string symbol) string)) +(srfi-13#string-kmp-partial-search (#(procedure #:enforce) srfi-13#string-kmp-partial-search (string vector string fixnum #!optional (procedure (char char) *) fixnum fixnum fixnum) fixnum)) +(srfi-13#string-map (#(procedure #:enforce) srfi-13#string-map ((procedure (char) char) string #!optional fixnum fixnum) string)) +(srfi-13#string-map! (#(procedure #:enforce) srfi-13#string-map! ((procedure (char) char) string #!optional fixnum fixnum) string)) + +(srfi-13#string-null? (#(procedure #:clean #:enforce) srfi-13#string-null? (string) boolean) + ((string) (##core#inline "C_zero_length_p" #(1)))) + +(srfi-13#string-pad (#(procedure #:clean #:enforce) srfi-13#string-pad (string fixnum #!optional char fixnum fixnum) string)) +(srfi-13#string-pad-right (#(procedure #:clean #:enforce) srfi-13#string-pad-right (string fixnum #!optional char fixnum fixnum) string)) +(srfi-13#string-parse-final-start+end (#(procedure #:enforce) srfi-13#string-parse-final-start+end (procedure string #!rest) . *)) +(srfi-13#string-parse-start+end (#(procedure #:enforce) srfi-13#string-parse-start+end (procedure string #!rest) . *)) +(srfi-13#string-prefix-ci? (#(procedure #:clean #:enforce) srfi-13#string-prefix-ci? (string string #!optional fixnum fixnum fixnum fixnum) boolean)) +(srfi-13#string-prefix-length (#(procedure #:clean #:enforce) srfi-13#string-prefix-length (string string #!optional fixnum fixnum fixnum fixnum) fixnum)) +(srfi-13#string-prefix-length-ci (#(procedure #:clean #:enforce) srfi-13#string-prefix-length-ci (string string #!optional fixnum fixnum fixnum fixnum) fixnum)) +(srfi-13#string-prefix? (#(procedure #:clean #:enforce) srfi-13#string-prefix? (string string #!optional fixnum fixnum fixnum fixnum) boolean)) +(srfi-13#string-replace (#(procedure #:clean #:enforce) srfi-13#string-replace (string string fixnum fixnum #!optional fixnum fixnum) string)) +(srfi-13#string-reverse (#(procedure #:clean #:enforce) srfi-13#string-reverse (string #!optional fixnum fixnum) string)) +(srfi-13#string-reverse! (#(procedure #:clean #:enforce) srfi-13#string-reverse! (string #!optional fixnum fixnum) string)) + +(srfi-13#string-skip + (#(procedure #:enforce) + srfi-13#string-skip + (string (or char (struct char-set) (procedure (char) *)) #!optional fixnum fixnum) + (or fixnum false))) + +(srfi-13#string-skip-right + (#(procedure #:enforce) + srfi-13#string-skip-right + (string (or char (struct char-set) (procedure (char) *)) #!optional fixnum fixnum) + (or fixnum false))) + +(srfi-13#string-suffix-ci? (#(procedure #:clean #:enforce) srfi-13#string-suffix-ci? (string string #!optional fixnum fixnum fixnum fixnum) boolean)) +(srfi-13#string-suffix-length (#(procedure #:clean #:enforce) srfi-13#string-suffix-length (string string #!optional fixnum fixnum fixnum fixnum) fixnum)) +(srfi-13#string-suffix-length-ci (#(procedure #:clean #:enforce) srfi-13#string-suffix-length-ci (string string #!optional fixnum fixnum fixnum fixnum) fixnum)) +(srfi-13#string-suffix? (#(procedure #:clean #:enforce) srfi-13#string-suffix? (string string #!optional fixnum fixnum fixnum fixnum) boolean)) +(srfi-13#string-tabulate (#(procedure #:enforce) srfi-13#string-tabulate ((procedure (fixnum) char) fixnum) string)) +(srfi-13#string-take (#(procedure #:clean #:enforce) srfi-13#string-take (string fixnum) string)) +(srfi-13#string-take-right (#(procedure #:clean #:enforce) srfi-13#string-take-right (string fixnum) string)) +(srfi-13#string-titlecase (#(procedure #:clean #:enforce) srfi-13#string-titlecase (string #!optional fixnum fixnum) string)) +(srfi-13#string-titlecase! (#(procedure #:clean #:enforce) srfi-13#string-titlecase! (string #!optional fixnum fixnum) string)) + +(srfi-13#string-tokenize + (#(procedure #:clean #:enforce) srfi-13#string-tokenize (string #!optional (struct char-set) fixnum fixnum) list)) + +(srfi-13#string-trim + (#(procedure #:enforce) + srfi-13#string-trim + (string #!optional (or char (struct char-set) (procedure (char) *)) fixnum fixnum) + string)) + +(srfi-13#string-trim-both + (#(procedure #:enforce) + srfi-13#string-trim-both + (string #!optional (or char (struct char-set) (procedure (char) *)) fixnum fixnum) + string)) + +(srfi-13#string-trim-right + (#(procedure #:enforce) + srfi-13#string-trim-right + (string #!optional (or char (struct char-set) (procedure (char) *)) fixnum fixnum) + string)) + +(srfi-13#string-unfold (#(procedure #:enforce) srfi-13#string-unfold (procedure procedure procedure * #!optional * procedure) string)) ;XXX +(srfi-13#string-unfold-right (#(procedure #:enforce) srfi-13#string-unfold-right (procedure procedure procedure * #!optional * procedure) string)) ;XXX +(srfi-13#string-upcase (#(procedure #:clean #:enforce) srfi-13#string-upcase (string #!optional fixnum fixnum) string)) +(srfi-13#string-upcase! (#(procedure #:clean #:enforce) srfi-13#string-upcase! (string #!optional fixnum fixnum) string)) +(srfi-13#string-xcopy! (#(procedure #:clean #:enforce) srfi-13#string-xcopy! (string string string fixnum #!optional fixnum fixnum fixnum) string)) + +(srfi-13#string< (#(procedure #:clean #:enforce) string< (string string #!optional fixnum fixnum fixnum fixnum) boolean) + ((string string) (scheme#string (#(procedure #:clean #:enforce) srfi-13#string<> (string string #!optional fixnum fixnum fixnum fixnum) boolean) + ((string string) (not (##core#inline "C_i_string_equal_p" #(1) #(2))))) + +(srfi-13#string= (#(procedure #:clean #:enforce) srfi-13#string= (string string #!optional fixnum fixnum fixnum fixnum) boolean) + ((string string) (##core#inline "C_i_string_equal_p" #(1) #(2)))) + +(srfi-13#string> (#(procedure #:clean #:enforce) srfi-13#string> (string string #!optional fixnum fixnum fixnum fixnum) boolean) + ((string string) (scheme#string>? #(1) #(2)))) + +(srfi-13#string>= (#(procedure #:clean #:enforce) srfi-13#string>= (string string #!optional fixnum fixnum fixnum fixnum) boolean) + ((string string) (scheme#string>=? #(1) #(2)))) + +(srfi-13#substring-spec-ok? (#(procedure #:clean #:enforce) srfi-13#substring-spec-ok? (string fixnum fixnum) boolean)) +(srfi-13#substring/shared (#(procedure #:clean #:enforce) srfi-13#substring/shared (string fixnum #!optional fixnum) string)) +(srfi-13#xsubstring (#(procedure #:clean #:enforce) srfi-13#xsubstring (string fixnum #!optional fixnum fixnum fixnum) string)) diff --git a/.eggs/srfi-14.egg-info b/.eggs/srfi-14.egg-info new file mode 100644 index 0000000..a78f05b --- /dev/null +++ b/.eggs/srfi-14.egg-info @@ -0,0 +1,14 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-14.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-14.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-14.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-14.types" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-14.import.so") + (version "0.2.1") + (synopsis "SRFI-14 character-sets library") + (author "Olin Shivers") + (maintainer "The CHICKEN Team") + (category data) + (license "BSD") + (components + (extension srfi-14 (types-file (predefined)) (csc-options "-O3" "-d0")))) diff --git a/.eggs/srfi-14.import.so b/.eggs/srfi-14.import.so new file mode 100755 index 0000000..fb20faf Binary files /dev/null and b/.eggs/srfi-14.import.so differ diff --git a/.eggs/srfi-14.link b/.eggs/srfi-14.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/srfi-14.link @@ -0,0 +1 @@ +() diff --git a/.eggs/srfi-14.o b/.eggs/srfi-14.o new file mode 100644 index 0000000..dff6ba1 Binary files /dev/null and b/.eggs/srfi-14.o differ diff --git a/.eggs/srfi-14.so b/.eggs/srfi-14.so new file mode 100755 index 0000000..2c7b96a Binary files /dev/null and b/.eggs/srfi-14.so differ diff --git a/.eggs/srfi-14.types b/.eggs/srfi-14.types new file mode 100644 index 0000000..485dbfd --- /dev/null +++ b/.eggs/srfi-14.types @@ -0,0 +1,74 @@ +(srfi-14#->char-set (procedure srfi-14#->char-set (*) (struct char-set)) + (((struct char-set)) #(1)) + ((string) (string->char-set #(1))) + ((char) (char-set #(1)))) + +(srfi-14#char-set (#(procedure #:enforce) srfi-14#char-set (#!rest char) (struct char-set))) +(srfi-14#char-set->list (#(procedure #:clean #:enforce) srfi-14#char-set->list ((struct char-set)) list)) +(srfi-14#char-set->string (#(procedure #:clean #:enforce) srfi-14#char-set->string ((struct char-set)) string)) +(srfi-14#char-set-adjoin (#(procedure #:clean #:enforce) srfi-14#char-set-adjoin ((struct char-set) #!rest char) (struct char-set))) +(srfi-14#char-set-adjoin! (#(procedure #:clean #:enforce) srfi-14#char-set-adjoin! ((struct char-set) #!rest char) (struct char-set))) +(srfi-14#char-set-any (#(procedure #:enforce) srfi-14#char-set-any ((procedure (char) *) (struct char-set)) *)) +(srfi-14#char-set-complement (#(procedure #:clean #:enforce) srfi-14#char-set-complement ((struct char-set)) (struct char-set))) +(srfi-14#char-set-complement! (#(procedure #:clean #:enforce) srfi-14#char-set-complement! ((struct char-set)) (struct char-set))) +(srfi-14#char-set-contains? (#(procedure #:clean #:enforce) srfi-14#char-set-contains? ((struct char-set) char) boolean)) +(srfi-14#char-set-copy (#(procedure #:clean #:enforce) srfi-14#char-set-copy ((struct char-set)) (struct char-set))) +(srfi-14#char-set-count (#(procedure #:clean #:enforce) srfi-14#char-set-count ((procedure (char) *) (struct char-set)) fixnum)) +(srfi-14#char-set-cursor (#(procedure #:clean #:enforce) srfi-14#char-set-cursor ((struct char-set)) fixnum)) +(srfi-14#char-set-cursor-next (#(procedure #:clean #:enforce) srfi-14#char-set-cursor-next ((struct char-set) fixnum) fixnum)) +(srfi-14#char-set-delete (#(procedure #:clean #:enforce) srfi-14#char-set-delete ((struct char-set) #!rest char) (struct char-set))) +(srfi-14#char-set-delete! (#(procedure #:clean #:enforce) srfi-14#char-set-delete! ((struct char-set) #!rest char) (struct char-set))) +(srfi-14#char-set-diff+intersection (#(procedure #:clean #:enforce) srfi-14#char-set-diff+intersection ((struct char-set) #!rest (struct char-set)) (struct char-set) (struct char-set))) +(srfi-14#char-set-diff+intersection! (#(procedure #:clean #:enforce) srfi-14#char-set-diff+intersection! ((struct char-set) #!rest (struct char-set)) (struct char-set) (struct char-set))) +(srfi-14#char-set-difference (#(procedure #:clean #:enforce) srfi-14#char-set-difference ((struct char-set) #!rest (struct char-set)) (struct char-set))) +(srfi-14#char-set-difference! (#(procedure #:clean #:enforce) srfi-14#char-set-difference! ((struct char-set) #!rest (struct char-set)) (struct char-set))) +(srfi-14#char-set-every (#(procedure #:enforce) srfi-14#char-set-every ((procedure (char) *) (struct char-set)) boolean)) +(srfi-14#char-set-filter (#(procedure #:enforce) srfi-14#char-set-filter ((procedure (char) *) (struct char-set) #!optional (struct char-set)) (struct char-set))) +(srfi-14#char-set-filter! (#(procedure #:enforce) srfi-14#char-set-filter! ((procedure (char) *) (struct char-set) #!optional (struct char-set)) (struct char-set))) +(srfi-14#char-set-fold (#(procedure #:enforce) srfi-14#char-set-fold ((procedure (char *) *) * (struct char-set)) *)) +(srfi-14#char-set-for-each (#(procedure #:enforce) srfi-14#char-set-for-each ((procedure (char) . *) (struct char-set)) undefined)) +(srfi-14#char-set-hash (#(procedure #:clean #:enforce) srfi-14#char-set-hash ((struct char-set) #!optional number) number)) +(srfi-14#char-set-intersection (#(procedure #:clean #:enforce) srfi-14#char-set-intersection (#!rest (struct char-set)) (struct char-set))) +(srfi-14#char-set-intersection! (#(procedure #:clean #:enforce) srfi-14#char-set-intersection! (#!rest (struct char-set)) (struct char-set))) +(srfi-14#char-set-map (#(procedure #:enforce) srfi-14#char-set-map ((procedure (char) char) (struct char-set)) (struct char-set))) +(srfi-14#char-set-ref (#(procedure #:clean #:enforce) srfi-14#char-set-ref ((struct char-set) fixnum) char)) +(srfi-14#char-set-size (#(procedure #:clean #:enforce) srfi-14#char-set-size ((struct char-set)) fixnum)) +(srfi-14#char-set-unfold (#(procedure #:enforce) srfi-14#char-set-unfold (procedure procedure procedure * #!optional (struct char-set)) (struct char-set))) +(srfi-14#char-set-unfold! (#(procedure #:enforce) srfi-14#char-set-unfold! (procedure procedure procedure * (struct char-set)) (struct char-set))) +(srfi-14#char-set-union (#(procedure #:clean #:enforce) srfi-14#char-set-union (#!rest (struct char-set)) (struct char-set))) +(srfi-14#char-set-union! (#(procedure #:clean #:enforce) srfi-14#char-set-union! (#!rest (struct char-set)) (struct char-set))) +(srfi-14#char-set-xor (#(procedure #:clean #:enforce) srfi-14#char-set-xor (#!rest (struct char-set)) (struct char-set))) +(srfi-14#char-set-xor! (#(procedure #:clean #:enforce) srfi-14#char-set-xor! (#!rest (struct char-set)) (struct char-set))) +(srfi-14#char-set:ascii (struct char-set)) +(srfi-14#char-set:blank (struct char-set)) +(srfi-14#char-set:digit (struct char-set)) +(srfi-14#char-set:empty (struct char-set)) +(srfi-14#char-set:full (struct char-set)) +(srfi-14#char-set:graphic (struct char-set)) +(srfi-14#char-set:hex-digit (struct char-set)) +(srfi-14#char-set:iso-control (struct char-set)) +(srfi-14#char-set:letter (struct char-set)) +(srfi-14#char-set:letter+digit (struct char-set)) +(srfi-14#char-set:lower-case (struct char-set)) +(srfi-14#char-set:printing (struct char-set)) +(srfi-14#char-set:punctuation (struct char-set)) +(srfi-14#char-set:symbol (struct char-set)) +(srfi-14#char-set:title-case (struct char-set)) +(srfi-14#char-set:upper-case (struct char-set)) +(srfi-14#char-set:whitespace (struct char-set)) + +(srfi-14#char-set= (#(procedure #:clean #:enforce) srfi-14#char-set= (#!rest (struct char-set)) boolean) + (() '#t) + (((struct char-set)) (let ((#(tmp) #(1))) '#t))) +(srfi-14#char-set<= (#(procedure #:clean #:enforce) srfi-14#char-set<= (#!rest (struct char-set)) boolean) + (() '#t) + (((struct char-set)) (let ((#(tmp) #(1))) '#t))) + +(srfi-14#char-set? (#(procedure #:pure #:predicate (struct char-set)) srfi-14#char-set? (*) boolean)) +(srfi-14#end-of-char-set? (#(procedure #:clean #:enforce) srfi-14#end-of-char-set? (fixnum) boolean)) +(srfi-14#list->char-set (#(procedure #:clean #:enforce) srfi-14#list->char-set ((list-of char) #!optional (struct char-set)) (struct char-set))) +(srfi-14#list->char-set! (#(procedure #:clean #:enforce) srfi-14#list->char-set! ((list-of char) #!optional (struct char-set)) (struct char-set))) +(srfi-14#string->char-set (#(procedure #:clean #:enforce) srfi-14#string->char-set (string #!optional (struct char-set)) (struct char-set))) +(srfi-14#string->char-set! (#(procedure #:clean #:enforce) srfi-14#string->char-set! (string #!optional (struct char-set)) (struct char-set))) +(srfi-14#ucs-range->char-set (#(procedure #:clean #:enforce) srfi-14#ucs-range->char-set (fixnum fixnum #!optional * (struct char-set)) (struct char-set))) +(srfi-14#ucs-range->char-set! (#(procedure #:clean #:enforce) srfi-14#ucs-range->char-set! (fixnum fixnum #!optional * (struct char-set)) (struct char-set))) diff --git a/.eggs/srfi-18.egg-info b/.eggs/srfi-18.egg-info new file mode 100644 index 0000000..4db6e27 --- /dev/null +++ b/.eggs/srfi-18.egg-info @@ -0,0 +1,19 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-18.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-18.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-18.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-18.types" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-18.import.so") + (version "0.1.6") + (synopsis "SRFI-18 thread library") + (author "The CHICKEN Team") + (maintainer "The CHICKEN Team") + (category hell) + (license "BSD") + (test-dependencies compile-file) + (components + (extension + srfi-18 + (custom-build "build-srfi-18") + (source-dependencies "srfi-18.scm" "srfi-18.types.in") + (types-file (predefined))))) diff --git a/.eggs/srfi-18.import.so b/.eggs/srfi-18.import.so new file mode 100755 index 0000000..1a6571e Binary files /dev/null and b/.eggs/srfi-18.import.so differ diff --git a/.eggs/srfi-18.link b/.eggs/srfi-18.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/srfi-18.link @@ -0,0 +1 @@ +() diff --git a/.eggs/srfi-18.o b/.eggs/srfi-18.o new file mode 100644 index 0000000..20172ad Binary files /dev/null and b/.eggs/srfi-18.o differ diff --git a/.eggs/srfi-18.so b/.eggs/srfi-18.so new file mode 100755 index 0000000..1d2f0c7 Binary files /dev/null and b/.eggs/srfi-18.so differ diff --git a/.eggs/srfi-18.types b/.eggs/srfi-18.types new file mode 100644 index 0000000..57842e5 --- /dev/null +++ b/.eggs/srfi-18.types @@ -0,0 +1,77 @@ + +(srfi-18#abandoned-mutex-exception? (#(procedure #:pure) abandoned-mutex-exception? (*) boolean)) +(srfi-18#condition-variable-broadcast! (#(procedure #:clean #:enforce) srfi-18#condition-variable-broadcast! ((struct condition-variable)) undefined)) +(srfi-18#condition-variable-name (#(procedure #:clean #:enforce) srfi-18#condition-variable-name ((struct condition-variable)) *)) +(srfi-18#condition-variable-signal! (#(procedure #:clean #:enforce) srfi-18#condition-variable-signal! ((struct condition-variable)) undefined)) +(srfi-18#condition-variable-specific (#(procedure #:clean #:enforce) srfi-18#condition-variable-specific ((struct condition-variable)) *)) +(srfi-18#condition-variable-specific-set! (#(procedure #:clean #:enforce) srfi-18#condition-variable-specific-set! ((struct condition-variable) *) undefined)) + +(srfi-18#condition-variable? (#(procedure #:pure #:predicate (struct condition-variable)) + srfi-18#condition-variable? (*) + boolean)) + +(srfi-18#current-thread (#(procedure #:clean) srfi-18#current-thread () (struct thread))) ;XXX + +(srfi-18#current-time (#(procedure #:clean) srfi-18#current-time () (struct time))) +(srfi-18#join-timeout-exception? (#(procedure #:pure) srfi-18#join-timeout-exception? (*) boolean)) +(srfi-18#make-condition-variable (#(procedure #:clean) srfi-18#make-condition-variable (#!optional *) (struct condition-variable))) +(srfi-18#make-mutex (#(procedure #:clean) srfi-18#make-mutex (#!optional *) (struct mutex))) +(srfi-18#make-thread (#(procedure #:clean #:enforce) srfi-18#make-thread ((procedure () . *) #!optional *) (struct thread))) +(srfi-18#mutex-lock! (#(procedure #:clean #:enforce) srfi-18#mutex-lock! ((struct mutex) #!optional (or false number (struct time)) (or false (struct thread))) boolean)) + +(srfi-18#mutex-name (#(procedure #:clean #:enforce) srfi-18#mutex-name ((struct mutex)) *) + (((struct mutex)) (##sys#slot #(1) '1))) + +(srfi-18#mutex-specific (#(procedure #:clean #:enforce) srfi-18#mutex-specific ((struct mutex)) *) + (((struct mutex)) (##sys#slot #(1) '6))) + +(srfi-18#mutex-specific-set! (#(procedure #:clean #:enforce) srfi-18#mutex-specific-set! ((struct mutex) *) undefined) + (((struct mutex) *) (##sys#setslot #(1) '6 #(2)))) + +(srfi-18#mutex-state (#(procedure #:clean #:enforce) srfi-18#mutex-state ((struct mutex)) (or symbol (struct thread)))) +(srfi-18#mutex-unlock! (#(procedure #:clean #:enforce) srfi-18#mutex-unlock! ((struct mutex) #!optional (struct condition-variable) *) undefined)) + +(srfi-18#mutex? (#(procedure #:pure #:predicate (struct mutex)) srfi-18#mutex? (*) boolean)) + +(srfi-18#raise (procedure srfi-18#raise (*) noreturn)) +(srfi-18#seconds->time (#(procedure #:clean #:enforce) srfi-18#seconds->time (number) (struct time))) +(srfi-18#terminated-thread-exception? (#(procedure #:pure) srfi-18#terminated-thread-exception? (*) boolean)) +(srfi-18#thread-join! (#(procedure #:clean #:enforce) srfi-18#thread-join! ((struct thread) #!optional * *) . *)) + +(srfi-18#thread-name (#(procedure #:clean #:enforce) srfi-18#thread-name ((struct thread)) *) + (((struct thread)) (##sys#slot #(1) '6))) + +(srfi-18#thread-quantum (#(procedure #:clean #:enforce) srfi-18#thread-quantum ((struct thread)) fixnum) + (((struct thread)) (##sys#slot #(1) '9))) + +(srfi-18#thread-quantum-set! (#(procedure #:clean #:enforce) srfi-18#thread-quantum-set! ((struct thread) fixnum) undefined)) +(srfi-18#thread-resume! (#(procedure #:clean #:enforce) srfi-18#thread-resume! ((struct thread)) undefined)) +(srfi-18#thread-signal! (#(procedure #:clean #:enforce) srfi-18#thread-signal! ((struct thread) *) undefined)) +(srfi-18#thread-sleep! (#(procedure #:clean) srfi-18#thread-sleep! (*) undefined)) + +(srfi-18#thread-specific (#(procedure #:clean #:enforce) srfi-18#thread-specific ((struct thread)) *) + (((struct thread)) (##sys#slot #(1) '10))) + +(srfi-18#thread-specific-set! (#(procedure #:clean #:enforce) srfi-18#thread-specific-set! ((struct thread) *) undefined) + (((struct thread) *) (##sys#setslot #(1) '10 #(2)))) + +(srfi-18#thread-start! (#(procedure #:enforce) srfi-18#thread-start! ((or (struct thread) (procedure () . *))) (struct thread))) + +(srfi-18#thread-state (#(procedure #:clean #:enforce) srfi-18#thread-state ((struct thread)) symbol) + (((struct thread)) (##sys#slot #(1) '3))) + +(srfi-18#thread-suspend! (#(procedure #:clean #:enforce) srfi-18#thread-suspend! ((struct thread)) undefined)) +(srfi-18#thread-terminate! (#(procedure #:clean #:enforce) srfi-18#thread-terminate! ((struct thread)) undefined)) +;; Added by the build script with keyword or symbol for 5.1 or 5.0 +;(srfi-18#thread-wait-for-i/o! (#(procedure #:clean #:enforce) srfi-18#thread-wait-for-i/o! (fixnum #!optional keyword) undefined)) +(srfi-18#thread-yield! (#(procedure #:clean) srfi-18#thread-yield! () undefined)) + +(srfi-18#thread? (#(procedure #:pure #:predicate (struct thread)) srfi-18#thread? (*) boolean)) + +(srfi-18#time->seconds (#(procedure #:clean #:enforce) srfi-18#time->seconds ((struct time)) number)) + +(srfi-18#time? (#(procedure #:pure #:predicate (struct time)) srfi-18#time? (*) boolean)) + +(srfi-18#uncaught-exception-reason (#(procedure #:clean #:enforce) srfi-18#uncaught-exception-reason ((struct condition)) *)) +(srfi-18#uncaught-exception? (#(procedure #:pure) srfi-18#uncaught-exception? (*) boolean)) +(srfi-18#thread-wait-for-i/o! (#(procedure #:clean #:enforce) srfi-18#thread-wait-for-i/o! (fixnum #!optional keyword) undefined)) diff --git a/.eggs/srfi-4.import.so b/.eggs/srfi-4.import.so new file mode 100755 index 0000000..d81304b Binary files /dev/null and b/.eggs/srfi-4.import.so differ diff --git a/.eggs/srfi-69.egg-info b/.eggs/srfi-69.egg-info new file mode 100644 index 0000000..0e669df --- /dev/null +++ b/.eggs/srfi-69.egg-info @@ -0,0 +1,14 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-69.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-69.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-69.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-69.types" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/srfi-69.import.so") + (version "0.4.3") + (synopsis "SRFI-69 hash-table library") + (author "The CHICKEN Team") + (maintainer "The CHICKEN Team") + (category data) + (license "BSD") + (components + (extension srfi-69 (csc-options "-O3" "-d0") (types-file (predefined))))) diff --git a/.eggs/srfi-69.import.so b/.eggs/srfi-69.import.so new file mode 100755 index 0000000..0508fba Binary files /dev/null and b/.eggs/srfi-69.import.so differ diff --git a/.eggs/srfi-69.link b/.eggs/srfi-69.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/srfi-69.link @@ -0,0 +1 @@ +() diff --git a/.eggs/srfi-69.o b/.eggs/srfi-69.o new file mode 100644 index 0000000..01579f3 Binary files /dev/null and b/.eggs/srfi-69.o differ diff --git a/.eggs/srfi-69.so b/.eggs/srfi-69.so new file mode 100755 index 0000000..69ec0ec Binary files /dev/null and b/.eggs/srfi-69.so differ diff --git a/.eggs/srfi-69.types b/.eggs/srfi-69.types new file mode 100644 index 0000000..8e3dc97 --- /dev/null +++ b/.eggs/srfi-69.types @@ -0,0 +1,66 @@ +(srfi-69#alist->hash-table (#(procedure #:clean #:enforce) srfi-69#alist->hash-table ((list-of pair) #!rest) (struct hash-table))) +(srfi-69#eq?-hash (#(procedure #:clean #:enforce) srfi-69#eq?-hash (* #!optional fixnum fixnum) fixnum)) +(srfi-69#equal?-hash (#(procedure #:clean #:enforce) srfi-69#equal?-hash (* #!optional fixnum fixnum) fixnum)) +(srfi-69#eqv?-hash (#(procedure #:clean #:enforce) srfi-69#eqv?-hash (* #!optional fixnum fixnum) fixnum)) +(srfi-69#hash (#(procedure #:pure #:enforce) srfi-69#hash (* #!optional fixnum fixnum) fixnum)) +(srfi-69#hash-by-identity (#(procedure #:pure #:enforce) srfi-69#hash-by-identity (* #!optional fixnum fixnum) fixnum)) +(srfi-69#hash-table->alist (#(procedure #:clean #:enforce) srfi-69#hash-table->alist ((struct hash-table)) (list-of pair))) +(srfi-69#hash-table-clear! (#(procedure #:clean #:enforce) srfi-69#hash-table-clear! ((struct hash-table)) undefined)) +(srfi-69#hash-table-copy (#(procedure #:clean #:enforce) srfi-69#hash-table-copy ((struct hash-table)) (struct hash-table))) +(srfi-69#hash-table-delete! (#(procedure #:clean #:enforce) srfi-69#hash-table-delete! ((struct hash-table) *) boolean)) +(srfi-69#hash-table-equivalence-function (#(procedure #:clean #:enforce) srfi-69#hash-table-equivalence-function ((struct hash-table)) (procedure (* *) *))) +(srfi-69#hash-table-exists? (#(procedure #:clean #:enforce) srfi-69#hash-table-exists? ((struct hash-table) *) boolean)) +(srfi-69#hash-table-fold (#(procedure #:enforce) srfi-69#hash-table-fold ((struct hash-table) (procedure (* * *) *) *) *)) +(srfi-69#hash-table-for-each (#(procedure #:enforce) srfi-69#hash-table-for-each ((struct hash-table) (procedure (* *) . *)) undefined)) + +(srfi-69#hash-table-has-initial? (#(procedure #:clean #:enforce) srfi-69#hash-table-has-initial? ((struct hash-table)) boolean) + (((struct hash-table)) (##sys#slot #(1) '9))) ;XXX might return other than #t + +(srfi-69#hash-table-hash-function (#(procedure #:clean #:enforce) srfi-69#hash-table-hash-function ((struct hash-table)) (procedure (* fixnum) fixnum)) + (((struct hash-table)) (##sys#slot #(1) '4))) + +(srfi-69#hash-table-initial (#(procedure #:clean #:enforce) srfi-69#hash-table-initial ((struct hash-table)) *)) +(srfi-69#hash-table-keys (#(procedure #:clean #:enforce) srfi-69#hash-table-keys ((struct hash-table)) list)) +(srfi-69#hash-table-map (#(procedure #:clean #:enforce) srfi-69#hash-table-map ((struct hash-table) (procedure (* *) *)) list)) + +(srfi-69#hash-table-max-load (#(procedure #:clean #:enforce) srfi-69#hash-table-max-load ((struct hash-table)) fixnum) + (((struct hash-table)) (##sys#slot #(1) '6))) + +(srfi-69#hash-table-merge (#(procedure #:clean #:enforce) srfi-69#hash-table-merge ((struct hash-table) (struct hash-table)) (struct hash-table))) +(srfi-69#hash-table-merge! (#(procedure #:clean #:enforce) srfi-69#hash-table-merge! ((struct hash-table) (struct hash-table)) (struct hash-table))) + +(srfi-69#hash-table-min-load (#(procedure #:clean #:enforce) srfi-69#hash-table-min-load ((struct hash-table)) fixnum) + (((struct hash-table)) (##sys#slot #(1) '5))) + +(srfi-69#hash-table-ref (#(procedure #:clean #:enforce) srfi-69#hash-table-ref ((struct hash-table) * #!optional (procedure () *)) *)) +(srfi-69#hash-table-ref/default (#(procedure #:clean #:enforce) srfi-69#hash-table-ref/default ((struct hash-table) * *) *)) +(srfi-69#hash-table-remove! (#(procedure #:clean #:enforce) srfi-69#hash-table-remove! ((struct hash-table) (procedure (* *) *)) undefined)) +(srfi-69#hash-table-set! (#(procedure #:clean #:enforce) srfi-69#hash-table-set! ((struct hash-table) * *) undefined)) + +(srfi-69#hash-table-size (#(procedure #:clean #:enforce) srfi-69#hash-table-size ((struct hash-table)) fixnum) + (((struct hash-table)) (##sys#slot #(1) '2))) + +(srfi-69#hash-table-update! (#(procedure #:enforce) srfi-69#hash-table-update! ((struct hash-table) * (procedure (*) *) #!optional (procedure () *)) *)) +(srfi-69#hash-table-update!/default (#(procedure #:clean #:enforce) srfi-69#hash-table-update!/default ((struct hash-table) * (procedure (*) *) *) *)) +(srfi-69#hash-table-values (#(procedure #:clean #:enforce) srfi-69#hash-table-values ((struct hash-table)) list)) +(srfi-69#hash-table-walk (#(procedure #:enforce) srfi-69#hash-table-walk ((struct hash-table) (procedure (* *) . *)) undefined)) + +(srfi-69#hash-table-weak-keys (#(procedure #:clean #:enforce) srfi-69#hash-table-weak-keys ((struct hash-table)) boolean) + (((struct hash-table)) (##sys#slot #(1) '7))) + +(srfi-69#hash-table-weak-values (#(procedure #:clean #:enforce) srfi-69#hash-table-weak-values ((struct hash-table)) boolean) + (((struct hash-table)) (##sys#slot #(1) '8))) + +(srfi-69#hash-table? (#(procedure #:pure #:predicate (struct hash-table)) srfi-69#hash-table? (*) boolean)) + +;;XXX if we want to hardcode hash-default-bound here, we could rewrite the 1-arg case... +; (applies to all hash-functions) +(srfi-69#keyword-hash (#(procedure #:clean #:enforce) srfi-69#keyword-hash (* #!optional fixnum fixnum) fixnum)) + +(srfi-69#make-hash-table (#(procedure #:clean #:enforce) srfi-69#make-hash-table (#!rest) (struct hash-table))) +(srfi-69#number-hash (#(procedure #:clean #:enforce) srfi-69#number-hash (fixnum #!optional fixnum fixnum) fixnum)) +(srfi-69#object-uid-hash (#(procedure #:clean #:enforce) srfi-69#object-uid-hash (* #!optional fixnum fixnum) fixnum)) +(srfi-69#symbol-hash (#(procedure #:clean #:enforce) srfi-69#symbol-hash (symbol #!optional fixnum fixnum) fixnum)) +(srfi-69#string-hash (#(procedure #:clean #:enforce) srfi-69#string-hash (string #!optional fixnum fixnum fixnum fixnum) number)) +(srfi-69#string-hash-ci (#(procedure #:clean #:enforce) srfi-69#string-hash-ci (string #!optional fixnum fixnum fixnum fixnum) number)) +(srfi-69#string-ci-hash (#(procedure #:clean #:enforce) srfi-69#string-ci-hash (string #!optional fixnum fixnum fixnum fixnum) number)) diff --git a/.eggs/test.egg-info b/.eggs/test.egg-info new file mode 100644 index 0000000..f8acae2 --- /dev/null +++ b/.eggs/test.egg-info @@ -0,0 +1,11 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/test.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/test.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/test.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/test.import.so") + (version "1.2") + (synopsis "Yet Another Testing Utility") + (license "BSD") + (category testing) + (author "Alex Shinn") + (components (extension test (source-dependencies "test-support.scm")))) diff --git a/.eggs/test.import.so b/.eggs/test.import.so new file mode 100755 index 0000000..9152727 Binary files /dev/null and b/.eggs/test.import.so differ diff --git a/.eggs/test.link b/.eggs/test.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/test.link @@ -0,0 +1 @@ +() diff --git a/.eggs/test.o b/.eggs/test.o new file mode 100644 index 0000000..77e75b9 Binary files /dev/null and b/.eggs/test.o differ diff --git a/.eggs/test.so b/.eggs/test.so new file mode 100755 index 0000000..ebed4ac Binary files /dev/null and b/.eggs/test.so differ diff --git a/.eggs/types.db b/.eggs/types.db new file mode 100644 index 0000000..922c07a --- /dev/null +++ b/.eggs/types.db @@ -0,0 +1,2360 @@ +;;;; types.db - Type-information for core library functions -*- Scheme -*- +; +; Copyright (c) 2009-2021, The CHICKEN Team +; All rights reserved. +; +; Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following +; conditions are met: +; +; Redistributions of source code must retain the above copyright notice, this list of conditions and the following +; disclaimer. +; 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. +; Neither the name of the author 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 HOLDERS 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. + + +;;; Notes: +; +; - numeric types are disjoint, "fixnum" or "float" will not match "number" in the +; rewrite rules +; - for a description of the type-specifier syntax, see "scrutinizer.scm" (top of file) +; - in templates, "#(INTEGER)" refers to the INTEGERth argument (starting from 1) +; - in templates, "#(INTEGER ...)" refers to the INTEGERth argument (starting from 1) and +; all remaining arguments +; - in templates "#(SYMBOL)" binds X to a temporary gensym'd variable, further references +; to "#(SYMBOL)" allow backreferences to this generated identifier +; - "#(procedure PROPERTY ...)" may be used in place of "procedure", properties are: +; #:clean - procedure does not modify state that might be used locally +; #:enforce - when procedure returns, arguments are of correct type +; #:foldable - procedure may be constant-folded +; #:predicate TYPE - procedure is a predicate on TYPE (implies #:foldable) +; #:pure - procedure has no side effects +; - "#:clean" means: will not invoke procedures that modify local variables and +; will not modify list or vector data held locally (note that I/O may invoke +; port handlers) +; - "#:pure" means: will not have side-effects; this is a bit of a lie, +; since arity-mismatch will for example always have a side effect. +; - "#:enforce" means: after return from this procedure, the argument is of +; the correct type (it would have signalled an error otherwise) +; - "#:foldable" means: when applied to constant arguments, direct calls +; to this procedure may be evaluated at compile time. + + +;; scheme + +(scheme#not (#(procedure #:pure #:foldable) scheme#not (*) boolean) + ((true) (false) (let ((#(tmp) #(1))) '#f)) + ((false) (true) (let ((#(tmp) #(1))) '#t)) + (((not boolean)) (false) (let ((#(tmp) #(1))) '#f))) + +(scheme#boolean? (#(procedure #:pure #:predicate boolean) scheme#boolean? (*) boolean)) + +(scheme#eq? (#(procedure #:pure #:foldable) scheme#eq? (* *) boolean)) + +(scheme#eqv? (#(procedure #:pure #:foldable) scheme#eqv? (* *) boolean) + (((or immediate symbol keyword) *) (scheme#eq? #(1) #(2))) + ((* (or immediate symbol keyword)) (scheme#eq? #(1) #(2))) + ((* *) (##core#inline "C_i_eqvp" #(1) #(2)))) + +(scheme#equal? (#(procedure #:pure #:foldable) scheme#equal? (* *) boolean) + (((or immediate symbol keyword) *) (scheme#eq? #(1) #(2))) + ((* (or immediate symbol keyword)) (scheme#eq? #(1) #(2))) + ((number number) (##core#inline "C_i_eqvp" #(1) #(2)))) + +(scheme#pair? (#(procedure #:pure #:predicate pair) scheme#pair? (*) boolean)) + +(scheme#cons (forall (a b) (#(procedure #:pure) scheme#cons (a b) (pair a b)))) + +(##sys#cons (forall (a b) (#(procedure #:pure) ##sys#cons (a b) (pair a b)))) + +(scheme#car (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#car ((pair a *)) a)) ((pair) (##core#inline "C_u_i_car" #(1)))) +(scheme#cdr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdr ((pair * a)) a)) ((pair) (##core#inline "C_u_i_cdr" #(1)))) + +(scheme#caar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#caar ((pair (pair a *) *)) a)) + (((pair (pair * *) *)) (##core#inline "C_u_i_car" (##core#inline "C_u_i_car" #(1))))) +(scheme#cadr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cadr ((pair * (pair a *))) a)) + (((pair * (pair * *))) (##core#inline "C_u_i_car" (##core#inline "C_u_i_cdr" #(1))))) +(scheme#cdar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdar ((pair (pair * a) *)) a)) + (((pair (pair * *) *)) (##core#inline "C_u_i_cdr" (##core#inline "C_u_i_car" #(1))))) +(scheme#cddr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cddr ((pair * (pair * a))) a)) + (((pair * (pair * *))) (##core#inline "C_u_i_cdr" (##core#inline "C_u_i_cdr" #(1))))) + +(scheme#caaar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#caaar ((pair (pair (pair a *) *) *)) a)) + (((pair (pair (pair * *) *) *)) + (##core#inline "C_u_i_car" + (##core#inline "C_u_i_car" (##core#inline "C_u_i_car" #(1)))))) + +(scheme#caadr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#caadr ((pair * (pair (pair a *) *))) a)) + (((pair * (pair (pair * *) *))) + (##core#inline "C_u_i_car" + (##core#inline "C_u_i_car" (##core#inline "C_u_i_cdr" #(1)))))) + +(scheme#cadar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cadar ((pair (pair * (pair a *)) *)) a)) + (((pair (pair * (pair * *)) *)) + (##core#inline "C_u_i_car" + (##core#inline "C_u_i_cdr" (##core#inline "C_u_i_car" #(1)))))) + +(scheme#caddr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#caddr ((pair * (pair * (pair a *)))) a)) + (((pair * (pair * (pair * *)))) + (##core#inline "C_u_i_car" + (##core#inline "C_u_i_cdr" (##core#inline "C_u_i_cdr" #(1)))))) + +(scheme#cdaar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdaar ((pair (pair (pair * a) *) *)) a)) + (((pair (pair (pair * *) *) *)) + (##core#inline "C_u_i_cdr" + (##core#inline "C_u_i_car" (##core#inline "C_u_i_car" #(1)))))) + +(scheme#cdadr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdadr ((pair * (pair (pair * a) *))) a)) + (((pair * (pair (pair * *) *))) + (##core#inline "C_u_i_cdr" + (##core#inline "C_u_i_car" (##core#inline "C_u_i_cdr" #(1)))))) + +(scheme#cddar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cddar ((pair (pair * (pair * a)) *)) a)) + (((pair (pair * (pair * *)) *)) + (##core#inline "C_u_i_cdr" + (##core#inline "C_u_i_cdr" (##core#inline "C_u_i_car" #(1)))))) + +(scheme#cdddr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdddr ((pair * (pair * (pair * a)))) a)) + (((pair * (pair * (pair * *)))) + (##core#inline "C_u_i_cdr" + (##core#inline "C_u_i_cdr" (##core#inline "C_u_i_cdr" #(1)))))) + +(scheme#caaaar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#caaaar ((pair (pair (pair (pair a *) *) *) *)) a))) +(scheme#caaadr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#caaadr ((pair * (pair (pair (pair a *) *) *))) a))) +(scheme#caadar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#caadar ((pair (pair * (pair (pair a *) *)) *)) a))) +(scheme#caaddr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#caaddr ((pair * (pair * (pair (pair a *) *)))) a))) +(scheme#cadaar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cadaar ((pair (pair (pair * (pair a *)) *) *)) a))) +(scheme#cadadr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cadadr ((pair * (pair (pair * (pair a *)) *))) a))) +(scheme#caddar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#caddar ((pair (pair * (pair * (pair a *))) *)) a))) +(scheme#cadddr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cadddr ((pair * (pair * (pair * (pair a *))))) a))) +(scheme#cdaaar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdaaar ((pair (pair (pair (pair * a) *) *) *)) a))) +(scheme#cdaadr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdaadr ((pair * (pair (pair (pair * a) *) *))) a))) +(scheme#cdadar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdadar ((pair (pair * (pair (pair * a) *)) *)) a))) +(scheme#cdaddr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdaddr ((pair * (pair * (pair (pair * a) *)))) a))) +(scheme#cddaar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cddaar ((pair (pair (pair * (pair * a)) *) *)) a))) +(scheme#cddadr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cddadr ((pair * (pair (pair * (pair * a)) *))) a))) +(scheme#cdddar (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cdddar ((pair (pair * (pair * (pair * a))) *)) a))) +(scheme#cddddr (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#cddddr ((pair * (pair * (pair * (pair * a))))) a))) + +(scheme#set-car! (#(procedure #:enforce) scheme#set-car! (pair *) undefined) + ((pair (or fixnum char boolean eof null undefined)) (##sys#setislot #(1) '0 #(2))) + ((pair *) (##sys#setslot #(1) '0 #(2)))) + +(scheme#set-cdr! (#(procedure #:enforce) scheme#set-cdr! (pair *) undefined) + ((pair (or fixnum char boolean eof null undefined)) (##sys#setislot #(1) '1 #(2))) + ((pair *) (##sys#setslot #(1) '1 #(2)))) + +(scheme#null? (#(procedure #:pure #:predicate null) scheme#null? (*) boolean)) +(scheme#list? (#(procedure #:pure #:predicate list) scheme#list? (*) boolean)) + +;; special cased (see scrutinizer.scm) +(scheme#list (#(procedure #:pure) scheme#list (#!rest) list)) +(##sys#list (#(procedure #:pure) ##sys#list (#!rest) list)) + +(scheme#length (#(procedure #:clean #:enforce #:foldable) scheme#length (list) fixnum) ; may loop + ((null) (let ((#(tmp) #(1))) '0)) + ((list) (##core#inline "C_u_i_length" #(1)))) + +(##sys#length (#(procedure #:clean #:enforce #:foldable) ##sys#length (list) fixnum) + ((null) (let ((#(tmp) #(1))) '0)) + ((list) (##core#inline "C_u_i_length" #(1)))) + +;; these are special cased (see scrutinizer.scm) +(scheme#list-tail (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#list-tail ((list-of a) fixnum) (list-of a)))) +(scheme#list-ref (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#list-ref ((list-of a) fixnum) a))) + +;; special cased (see scrutinizer.scm) +(scheme#append (#(procedure #:clean) scheme#append (#!rest *) *)) ; sic +(##sys#append (#(procedure #:clean) ##sys#append (#!rest *) *)) + +;; special cased (see scrutinizer.scm) +(scheme#reverse (forall (a) (#(procedure #:clean #:enforce) scheme#reverse ((list-of a)) (list-of a))) + ((null) (null) (let ((#(tmp) #(1))) '()))) + +(scheme#memq (forall (a b) (#(procedure #:clean #:foldable) scheme#memq (a (list-of b)) + (or false (pair a (list-of b))))) + ((* null) (let ((#(tmp) #(1))) '#f)) + ((* list) (##core#inline "C_u_i_memq" #(1) #(2)))) + +(scheme#memv (forall (a b) (#(procedure #:clean #:foldable) scheme#memv (a (list-of b)) + (or false (pair a (list-of b))))) + ((* null) (let ((#(tmp) #(1))) '#f)) + (((or symbol keyword procedure immediate) list) + (##core#inline "C_u_i_memq" #(1) #(2)))) + +(scheme#member (forall (a b) (#(procedure #:clean #:foldable) scheme#member (a (list-of b)) + (or false (pair a (list-of b))))) + ((* null) (let ((#(tmp) #(1))) '#f)) + (((or symbol keyword procedure immediate) list) + (##core#inline "C_u_i_memq" #(1) #(2))) + ((* (list-of (or symbol keyword procedure immediate))) + (##core#inline "C_u_i_memq" #(1) #(2)))) + +(scheme#assq (forall (a b c) (#(procedure #:clean #:foldable) scheme#assq + (a (list-of (pair b c))) + (or false (pair a c)))) + ((* null) (let ((#(tmp) #(1))) '#f)) + ((* (list-of pair)) (##core#inline "C_u_i_assq" #(1) #(2)))) + +(scheme#assv (forall (a b c) (#(procedure #:clean #:foldable) scheme#assv + (a (list-of (pair b c))) + (or false (pair a c)))) + ((* null) (let ((#(tmp) #(1))) '#f)) + (((or symbol keyword immediate procedure) (list-of pair)) + (##core#inline "C_u_i_assq" #(1) #(2))) + ((* (list-of (pair (or symbol keyword procedure immediate) *))) + (##core#inline "C_u_i_assq" #(1) #(2)))) + +(scheme#assoc (forall (a b c) (#(procedure #:clean #:foldable) scheme#assoc + (a (list-of (pair b c))) + (or false (pair a c)))) + ((* null) (let ((#(tmp) #(1))) '#f)) + (((or symbol keyword procedure immediate) (list-of pair)) + (##core#inline "C_u_i_assq" #(1) #(2))) + ((* (list-of (pair (or symbol keyword procedure immediate) *))) + (##core#inline "C_u_i_assq" #(1) #(2)))) + +(scheme#symbol? (#(procedure #:pure #:predicate symbol) scheme#symbol? (*) boolean)) + +(scheme#symbol->string (#(procedure #:clean #:enforce) scheme#symbol->string (symbol) string)) +(scheme#string->symbol (#(procedure #:clean #:enforce #:foldable) scheme#string->symbol (string) symbol)) + +(scheme#number? (#(procedure #:pure #:predicate number) scheme#number? (*) boolean)) + +;;XXX predicate? +(scheme#integer? (#(procedure #:pure #:foldable) scheme#integer? (*) boolean) + ((integer) (let ((#(tmp) #(1))) '#t)) + ((float) (##core#inline "C_u_i_fpintegerp" #(1))) + ((*) (##core#inline "C_i_integerp" #(1)))) + +(scheme#real? (#(procedure #:pure #:foldable) scheme#real? (*) boolean) + (((or fixnum float bignum ratnum)) (let ((#(tmp) #(1))) '#t)) + ((cplxnum) (let ((#(tmp) #(1))) '#f)) + ((*) (##core#inline "C_i_realp" #(1)))) +(scheme#complex? (#(procedure #:pure #:predicate number) scheme#complex? (*) boolean)) +(scheme#exact? (#(procedure #:clean #:enforce #:foldable) scheme#exact? (number) boolean) + (((or integer ratnum)) (let ((#(tmp) #(1))) '#t)) + ((float) (let ((#(tmp) #(1))) '#f))) +(scheme#inexact? (#(procedure #:clean #:enforce #:foldable) scheme#inexact? (number) boolean) + (((or integer ratnum)) (let ((#(tmp) #(1))) '#f)) + ((float) (let ((#(tmp) #(1))) '#t))) + +;;XXX predicate? +(scheme#rational? (#(procedure #:pure #:foldable) scheme#rational? (*) boolean) + (((or fixnum bignum ratnum)) (let ((#(tmp) #(1))) '#t)) + ((cplxnum) (let ((#(tmp) #(1))) '#f)) + ((float) (##core#inline "C_u_i_flonum_finitep" #(1))) + ((*) (##core#inline "C_i_rationalp" #(1)))) + +(scheme#zero? (#(procedure #:clean #:enforce #:foldable) scheme#zero? (number) boolean) + ((integer) (scheme#eq? #(1) '0)) + (((or cplxnum ratnum)) (let ((#(tmp) #(1))) '#f)) + ((number) (##core#inline "C_u_i_zerop2" #(1))) + ((*) (##core#inline "C_i_zerop" #(1)))) + +(scheme#odd? (#(procedure #:clean #:enforce #:foldable) scheme#odd? (number) boolean) + ((fixnum) (##core#inline "C_i_fixnumoddp" #(1))) + ((integer) (##core#inline "C_i_integer_oddp" #(1))) + ((*) (##core#inline "C_i_oddp" #(1)))) +(scheme#even? (#(procedure #:clean #:enforce #:foldable) scheme#even? (number) boolean) + ((fixnum) (##core#inline "C_i_fixnumevenp" #(1))) + ((integer) (##core#inline "C_i_integer_evenp" #(1))) + ((*) (##core#inline "C_i_evenp" #(1)))) + +(scheme#positive? (#(procedure #:clean #:enforce #:foldable) scheme#positive? (number) boolean) + ((fixnum) (##core#inline "C_i_fixnum_positivep" #(1))) + ((integer) (##core#inline "C_i_integer_positivep" #(1))) + ((*) (##core#inline "C_i_positivep" #(1)))) + +(scheme#negative? (#(procedure #:clean #:enforce #:foldable) scheme#negative? (number) boolean) + ((fixnum) (##core#inline "C_i_fixnum_negativep" #(1))) + ((integer) (##core#inline "C_i_integer_negativep" #(1))) + ((*) (##core#inline "C_i_negativep" #(1)))) + +(scheme#max (#(procedure #:clean #:enforce #:foldable) scheme#max (#!rest number) number) + ((fixnum fixnum) (fixnum) (chicken.fixnum#fxmax #(1) #(2))) + ((float float) (float) (##core#inline "C_i_flonum_max" #(1) #(2)))) + +(scheme#min (#(procedure #:clean #:enforce #:foldable) scheme#min (#!rest number) number) + ((fixnum fixnum) (fixnum) (chicken.fixnum#fxmin #(1) #(2))) + ((float float) (float) (##core#inline "C_i_flonum_min" #(1) #(2)))) + +(scheme#+ (#(procedure #:clean #:enforce #:foldable) scheme#+ (#!rest number) number) + (() (fixnum) '0) + ((fixnum) (fixnum) #(1)) + ((float) (float) #(1)) + ((integer) (integer) #(1)) + ((ratnum) (ratnum) #(1)) + ((cplxnum) (cplxnum) #(1)) + ((number) (number) #(1)) + ((float fixnum) (float) + (##core#inline_allocate + ("C_a_i_flonum_plus" 4) + #(1) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(2)))) + ((fixnum float) + (float) + (##core#inline_allocate + ("C_a_i_flonum_plus" 4) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(1)) + #(2))) + ((float float) (float) + (##core#inline_allocate ("C_a_i_flonum_plus" 4) #(1) #(2))) + ((fixnum fixnum) (integer) + (##core#inline_allocate ("C_a_i_fixnum_plus" 5) #(1) #(2))) + ((integer integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_plus" 5) #(1) #(2)))) + +(scheme#- (#(procedure #:clean #:enforce #:foldable) scheme#- (number #!rest number) number) + ((fixnum) (integer) (##core#inline_allocate ("C_a_i_fixnum_negate" 5) #(1))) + ((integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_negate" 5) #(1))) + ((float) (float) (##core#inline_allocate ("C_a_i_flonum_negate" 4) #(1))) + ((*) (*) (##core#inline_allocate ("C_s_a_i_negate" 29) #(1))) + ((float fixnum) (float) + (##core#inline_allocate + ("C_a_i_flonum_difference" 4) + #(1) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(2)))) + ((fixnum float) (float) + (##core#inline_allocate + ("C_a_i_flonum_difference" 4) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(1)) + #(2))) + ((float float) (float) + (##core#inline_allocate ("C_a_i_flonum_difference" 4) #(1) #(2))) + ((fixnum fixnum) (integer) + (##core#inline_allocate ("C_a_i_fixnum_difference" 5) #(1) #(2))) + ((integer integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_minus" 5) #(1) #(2)))) + +(scheme#* (#(procedure #:clean #:enforce #:foldable) scheme#* (#!rest number) number) + (() (fixnum) '1) + ((fixnum) (fixnum) #(1)) + ((float) (float) #(1)) + ((bignum) (bignum) #(1)) + ((integer) (integer) #(1)) + ((ratnum) (ratnum) #(1)) + ((cplxnum) (cplxnum) #(1)) + ((number) (number) #(1)) + ((float fixnum) (float) + (##core#inline_allocate + ("C_a_i_flonum_times" 4) + #(1) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(2)))) + ((fixnum float) (float) + (##core#inline_allocate + ("C_a_i_flonum_times" 4) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(1)) + #(2))) + ((float float) (float) + (##core#inline_allocate ("C_a_i_flonum_times" 4) #(1) #(2))) + ((fixnum fixnum) (integer) + (##core#inline_allocate ("C_a_i_fixnum_times" 5) #(1) #(2))) + ((integer integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_times" 5) #(1) #(2)))) + +(scheme#/ (#(procedure #:clean #:enforce #:foldable) scheme#/ (number #!rest number) number) + ((float fixnum) (float) + ;; This is the only checked one because the divisor is an exact value + (##core#inline_allocate + ("C_a_i_flonum_quotient_checked" 4) + #(1) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(2)))) + ((fixnum float) (float) + (##core#inline_allocate + ("C_a_i_flonum_quotient" 4) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(1)) + #(2))) + ((float float) (float) + (##core#inline_allocate ("C_a_i_flonum_quotient" 4) #(1) #(2))) + ((integer integer) ((or integer ratnum)) + (##sys#/-2 #(1) #(2))) + ((* *) (number) + (##sys#/-2 #(1) #(2)))) + +(scheme#= (#(procedure #:clean #:enforce #:foldable) scheme#= (#!rest number) boolean) + (() '#t) + ((number) (let ((#(tmp) #(1))) '#t)) + ((fixnum fixnum) (scheme#eq? #(1) #(2))) + ((float float) (##core#inline "C_flonum_equalp" #(1) #(2))) + ((integer integer) (##core#inline "C_i_integer_equalp" #(1) #(2)))) + +(scheme#> (#(procedure #:clean #:enforce #:foldable) scheme#> (#!rest number) boolean) + (() '#t) + ((number) (let ((#(tmp) #(1))) '#t)) + ((fixnum fixnum) (chicken.fixnum#fx> #(1) #(2))) + ((float float) (##core#inline "C_flonum_greaterp" #(1) #(2))) + ((integer integer) (##core#inline "C_i_integer_greaterp" #(1) #(2)))) + +(scheme#< (#(procedure #:clean #:enforce #:foldable) scheme#< (#!rest number) boolean) + (() '#t) + ((number) (let ((#(tmp) #(1))) '#t)) + ((fixnum fixnum) (chicken.fixnum#fx< #(1) #(2))) + ((integer integer) (##core#inline "C_i_integer_lessp" #(1) #(2))) + ((float float) (##core#inline "C_flonum_lessp" #(1) #(2)))) + +(scheme#>= (#(procedure #:clean #:enforce #:foldable) scheme#>= (#!rest number) boolean) + (() '#t) + ((number) (let ((#(tmp) #(1))) '#t)) + ((fixnum fixnum) (chicken.fixnum#fx>= #(1) #(2))) + ((integer integer) (##core#inline "C_i_integer_greater_or_equalp" #(1) #(2))) + ((float float) (##core#inline "C_flonum_greater_or_equal_p" #(1) #(2)))) + +(scheme#<= (#(procedure #:clean #:enforce #:foldable) scheme#<= (#!rest number) boolean) + (() '#t) + ((number) (let ((#(tmp) #(1))) '#t)) + ((fixnum fixnum) (chicken.fixnum#fx<= #(1) #(2))) + ((integer integer) (##core#inline "C_i_integer_less_or_equalp" #(1) #(2))) + ((float float) (##core#inline "C_flonum_less_or_equal_p" #(1) #(2)))) + +(scheme#quotient (#(procedure #:clean #:enforce #:foldable) scheme#quotient ((or integer float) (or integer float)) (or integer float)) + ;;XXX flonum/mixed case + ((float float) (float) + (##core#inline_allocate + ("C_a_i_flonum_actual_quotient_checked" 4) #(1) #(2))) + ((fixnum fixnum) (integer) + (##core#inline_allocate ("C_a_i_fixnum_quotient_checked" 5) + #(1) #(2))) + ((integer integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_quotient" 5) #(1) #(2)))) + +(scheme#remainder (#(procedure #:clean #:enforce #:foldable) scheme#remainder ((or integer float) (or integer float)) (or integer float)) + ((float float) (float) + (##core#inline_allocate + ("C_a_i_flonum_remainder_checked" 4) #(1) #(2))) + ;;XXX flonum/mixed case + ((fixnum fixnum) (fixnum) + (##core#inline "C_i_fixnum_remainder_checked" #(1) #(2))) + ((integer integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_remainder" 5) #(1) #(2)))) + +(scheme#modulo (#(procedure #:clean #:enforce #:foldable) scheme#modulo ((or integer float) (or integer float)) (or integer float)) + ((float float) (float) + (##core#inline_allocate + ("C_a_i_flonum_modulo_checked" 4) #(1) #(2))) + ;;XXX flonum/mixed case + ((fixnum fixnum) (fixnum) + (##core#inline "C_fixnum_modulo" #(1) #(2))) + ((integer integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_modulo" 5) #(1) #(2)))) + +(scheme#gcd (#(procedure #:clean #:enforce #:foldable) scheme#gcd (#!rest (or integer float)) (or integer float)) + (() '0) + ((fixnum fixnum) (fixnum) (chicken.fixnum#fxgcd #(1) #(2))) + ((float float) (float) (chicken.flonum#fpgcd #(1) #(2))) + ((integer integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_gcd" 5) #(1) #(2))) + ((* *) (##sys#gcd #(1) #(2)))) + +(##sys#gcd (#(procedure #:clean #:enforce #:foldable) ##sys#gcd (number number) number)) + +(scheme#lcm (#(procedure #:clean #:enforce #:foldable) scheme#lcm (#!rest number) number) + (() '1) + ((* *) (##sys#lcm #(1) #(2)))) + +(##sys#lcm (#(procedure #:clean #:enforce #:foldable) ##sys#lcm (number number) number)) + +(scheme#abs (#(procedure #:clean #:enforce #:foldable) scheme#abs (number) number) + ((fixnum) (integer) (##core#inline_allocate ("C_a_i_fixnum_abs" 5) #(1))) + ((float) (float) (##core#inline_allocate ("C_a_i_flonum_abs" 4) #(1))) + ((integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_abs" 5) #(1))) + ((*) (*) + (##core#inline_allocate ("C_s_a_i_abs" 7) #(1)))) + +(scheme#floor (#(procedure #:clean #:enforce #:foldable) scheme#floor ((or integer ratnum float)) (or integer ratnum float)) + ((fixnum) (fixnum) #(1)) + ((integer) (integer) #(1)) + ((float) (float) + (##core#inline_allocate ("C_a_i_flonum_floor" 4) #(1)))) + +(scheme#ceiling (#(procedure #:clean #:enforce #:foldable) scheme#ceiling ((or integer ratnum float)) (or integer ratnum float)) + ((fixnum) (fixnum) #(1)) + ((integer) (integer) #(1)) + ((float) (float) + (##core#inline_allocate ("C_a_i_flonum_ceiling" 4) #(1)))) + +(scheme#truncate (#(procedure #:clean #:enforce #:foldable) scheme#truncate ((or integer ratnum float)) (or integer ratnum float)) + ((fixnum) (fixnum) #(1)) + ((integer) (integer) #(1)) + ((float) (float) + (##core#inline_allocate ("C_a_i_flonum_truncate" 4) #(1)))) + +(scheme#round (#(procedure #:clean #:enforce #:foldable) scheme#round ((or integer ratnum float)) (or integer ratnum float)) + ((fixnum) (fixnum) #(1)) + ((integer) (integer) #(1)) + ((float) (float) + (##core#inline_allocate ("C_a_i_flonum_round_proper" 4) #(1)))) + +(scheme#exact->inexact (#(procedure #:clean #:enforce #:foldable) scheme#exact->inexact (number) (or float cplxnum)) + ((float) (float) #(1)) + ((fixnum) (float) (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(1))) + ((number) (##core#inline_allocate ("C_a_i_exact_to_inexact" 11) #(1)))) + +(scheme#inexact->exact (#(procedure #:clean #:enforce #:foldable) scheme#inexact->exact (number) (or integer ratnum)) + ((fixnum) (fixnum) #(1)) + ((integer) (integer) #(1)) + ((ratnum) (ratnum) #(1)) + (((or integer ratnum)) #(1))) + +(scheme#exp (#(procedure #:clean #:enforce #:foldable) scheme#exp (number) (or float cplxnum)) + ((float) (float) (##core#inline_allocate ("C_a_i_flonum_exp" 4) #(1)))) + +(scheme#log (#(procedure #:clean #:enforce #:foldable) scheme#log (number #!optional number) (or float cplxnum)) + ;; Unfortunately this doesn't work when the argument is negative + ;;((float) (float) (##core#inline_allocate ("C_a_i_flonum_log" 4) #(1))) + ((*) (##sys#log-1 #(1))) + ((* *) (##sys#/-2 (##sys#log-1 #(1)) (##sys#log-1 #(2))))) + +(scheme#expt (#(procedure #:clean #:enforce #:foldable) scheme#expt (number number) number) + ;; This breaks in some extreme edge cases... Worth disabling? + #;((float float) (float) + (##core#inline_allocate ("C_a_i_flonum_expt" 4) #(1) #(2))) + #;((float fixnum) (float) + (##core#inline_allocate ("C_a_i_flonum_expt" 4) + #(1) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(2)))) + #;((fixnum float) (float) + (##core#inline_allocate ("C_a_i_flonum_expt" 4) + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(1)) + #(2)))) + +(scheme#sqrt (#(procedure #:clean #:enforce #:foldable) scheme#sqrt (number) number) + ;; Unfortunately this doesn't work when the argument is negative + #;((float) (float) (##core#inline_allocate ("C_a_i_flonum_sqrt" 4) #(1)))) + +(scheme#sin (#(procedure #:clean #:enforce #:foldable) scheme#sin (number) (or float cplxnum)) + ((float) (float) (##core#inline_allocate ("C_a_i_flonum_sin" 4) #(1)))) + +(scheme#cos (#(procedure #:clean #:enforce #:foldable) scheme#cos (number) (or float cplxnum)) + ((float) (float) (##core#inline_allocate ("C_a_i_flonum_cos" 4) #(1)))) + +(scheme#tan (#(procedure #:clean #:enforce #:foldable) scheme#tan (number) (or float cplxnum)) + ((float) (float) (##core#inline_allocate ("C_a_i_flonum_tan" 4) #(1)))) + +(scheme#asin (#(procedure #:clean #:enforce #:foldable) scheme#asin (number) (or float cplxnum)) + ;; Unfortunately this doesn't work when the number is > 1.0 (returns compnum) + #;((float) (float) (##core#inline_allocate ("C_a_i_flonum_acos" 4) #(1)))) + +(scheme#acos (#(procedure #:clean #:enforce #:foldable) scheme#acos (number) (or float cplxnum)) + ;; Unfortunately this doesn't work when the number is > 1.0 (returns compnum) + #;((float) (float) (##core#inline_allocate ("C_a_i_flonum_acos" 4) #(1)))) + +(scheme#atan (#(procedure #:clean #:enforce #:foldable) scheme#atan (number #!optional number) (or float cplxnum)) + ((float) (float) (##core#inline_allocate ("C_a_i_flonum_atan" 4) #(1))) + ((float float) (float) + (##core#inline_allocate ("C_a_i_flonum_atan2" 4) #(1) #(2)))) + +(scheme#number->string (#(procedure #:clean #:enforce) scheme#number->string (number #!optional fixnum) string) + ((fixnum fixnum) (##sys#fixnum->string #(1) #(2))) + ((fixnum) (##sys#fixnum->string #(1) '10)) + ((integer fixnum) (##sys#integer->string #(1) #(2))) + ((integer) (##sys#integer->string #(1) '10)) + ((float fixnum) (##sys#flonum->string #(1) #(2))) + ((float) (##sys#flonum->string #(1) '10)) + ((* *) (##sys#number->string #(1) #(2))) + ((*) (##sys#number->string #(1) '10))) + +(##sys#fixnum->string (#(procedure #:clean #:enforce) ##sys#fixnum->string (fixnum fixnum) string)) +(##sys#integer->string (#(procedure #:clean #:enforce) ##sys#integer->string (integer fixnum) string)) +(##sys#flonum->string (#(procedure #:clean #:enforce) ##sys#flonum->string (float fixnum) string)) + +(scheme#string->number (#(procedure #:clean #:enforce #:foldable) scheme#string->number (string #!optional fixnum) + (or number false))) + +(scheme#char? (#(procedure #:pure #:predicate char) scheme#char? (*) boolean)) + +;; safe rewrites are already done by the optimizer +(scheme#char=? (#(procedure #:clean #:enforce #:foldable) scheme#char=? (char char) boolean) + ((char char) (##core#inline "C_u_i_char_equalp" #(1) #(2)))) +(scheme#char>? (#(procedure #:clean #:enforce #:foldable) scheme#char>? (char char) boolean) + ((char char) (##core#inline "C_u_i_char_greaterp" #(1) #(2)))) +(scheme#char=? (#(procedure #:clean #:enforce #:foldable) scheme#char>=? (char char) boolean) + ((char char) (##core#inline "C_u_i_char_greater_or_equal_p" #(1) #(2)))) +(scheme#char<=? (#(procedure #:clean #:enforce #:foldable) scheme#char<=? (char char) boolean) + ((char char) (##core#inline "C_u_i_char_less_or_equal_p" #(1) #(2)))) + +(scheme#char-ci=? (#(procedure #:clean #:enforce #:foldable) scheme#char-ci=? (char char) boolean)) +(scheme#char-ci? (#(procedure #:clean #:enforce #:foldable) scheme#char-ci>? (char char) boolean)) +(scheme#char-ci>=? (#(procedure #:clean #:enforce #:foldable) scheme#char-ci>=? (char char) boolean)) +(scheme#char-ci<=? (#(procedure #:clean #:enforce #:foldable) scheme#char-ci<=? (char char) boolean)) +(scheme#char-alphabetic? (#(procedure #:clean #:enforce #:foldable) scheme#char-alphabetic? (char) boolean)) +(scheme#char-whitespace? (#(procedure #:clean #:enforce #:foldable) scheme#char-whitespace? (char) boolean)) +(scheme#char-numeric? (#(procedure #:clean #:enforce #:foldable) scheme#char-numeric? (char) boolean)) +(scheme#char-upper-case? (#(procedure #:clean #:enforce #:foldable) scheme#char-upper-case? (char) boolean)) +(scheme#char-lower-case? (#(procedure #:clean #:enforce #:foldable) scheme#char-lower-case? (char) boolean)) +(scheme#char-upcase (#(procedure #:clean #:enforce #:foldable) scheme#char-upcase (char) char)) +(scheme#char-downcase (#(procedure #:clean #:enforce #:foldable) scheme#char-downcase (char) char)) + +(scheme#char->integer (#(procedure #:clean #:enforce #:foldable) scheme#char->integer (char) fixnum)) +(scheme#integer->char (#(procedure #:clean #:enforce #:foldable) scheme#integer->char (fixnum) char)) + +(scheme#string? (#(procedure #:pure #:predicate string) scheme#string? (*) boolean)) + +(scheme#string=? (#(procedure #:clean #:enforce #:foldable) scheme#string=? (string string) boolean) + ((string string) (##core#inline "C_u_i_string_equal_p" #(1) #(2)))) + +(scheme#string>? (#(procedure #:clean #:enforce #:foldable) scheme#string>? (string string) boolean)) +(scheme#string=? (#(procedure #:clean #:enforce #:foldable) scheme#string>=? (string string) boolean)) +(scheme#string<=? (#(procedure #:clean #:enforce #:foldable) scheme#string<=? (string string) boolean)) +(scheme#string-ci=? (#(procedure #:clean #:enforce #:foldable) scheme#string-ci=? (string string) boolean)) +(scheme#string-ci? (#(procedure #:clean #:enforce #:foldable) scheme#string-ci>? (string string) boolean)) +(scheme#string-ci>=? (#(procedure #:clean #:enforce #:foldable) scheme#string-ci>=? (string string) boolean)) +(scheme#string-ci<=? (#(procedure #:clean #:enforce #:foldable) scheme#string-ci<=? (string string) boolean)) + +(scheme#make-string (#(procedure #:clean #:enforce) scheme#make-string (fixnum #!optional char) string) + ((fixnum char) (##sys#make-string #(1) #(2))) + ((fixnum) (##sys#make-string #(1) '#\space))) + +(scheme#string-length (#(procedure #:clean #:enforce #:foldable) scheme#string-length (string) fixnum) + ((string) (##sys#size #(1)))) + +(scheme#string-ref (#(procedure #:clean #:enforce #:foldable) scheme#string-ref (string fixnum) char) + ((string fixnum) (##core#inline "C_i_string_ref" #(1) #(2)))) + +(scheme#string-set! (#(procedure #:enforce) scheme#string-set! (string fixnum char) undefined) + ((string fixnum char) (##core#inline "C_i_string_set" #(1) #(2) #(3)))) + +(scheme#string-append (#(procedure #:clean #:enforce) scheme#string-append (#!rest string) string) + ((string string) (##sys#string-append #(1) #(2)))) + +(scheme#string-copy (#(procedure #:clean #:enforce) scheme#string-copy (string) string)) + +(scheme#string->list (#(procedure #:clean #:enforce) scheme#string->list (string) (list-of char))) +(scheme#list->string (#(procedure #:clean #:enforce) scheme#list->string ((list-of char)) string)) +(scheme#substring (#(procedure #:clean #:enforce) scheme#substring (string fixnum #!optional fixnum) string)) +(scheme#string-fill! (#(procedure #:enforce) scheme#string-fill! (string char) string)) +(scheme#string (#(procedure #:clean #:enforce) scheme#string (#!rest char) string)) + +(scheme#vector? (#(procedure #:pure #:predicate vector) scheme#vector? (*) boolean)) + +;; special-cased (see scrutinizer.scm) +(scheme#make-vector (forall (a) (#(procedure #:clean #:enforce) scheme#make-vector (fixnum #!optional a) + (vector-of a)))) + +;; these are special cased (see scrutinizer.scm) +(scheme#vector-ref (forall (a) (#(procedure #:clean #:enforce #:foldable) scheme#vector-ref ((vector-of a) fixnum) a))) +(##sys#vector-ref (forall (a) (#(procedure #:clean #:enforce #:foldable) ##sys#vector-ref ((vector-of a) fixnum) a))) + +;; special-cased (see scrutinizer.scm) +(scheme#vector-set! (#(procedure #:enforce) scheme#vector-set! (vector fixnum *) undefined)) + +;; special cased (see scrutinizer.scm) +(scheme#vector (#(procedure #:pure) scheme#vector (#!rest) vector)) +(##sys#vector (#(procedure #:pure) ##sys#vector (#!rest) vector)) + +(scheme#vector-length (#(procedure #:clean #:enforce #:foldable) scheme#vector-length (vector) fixnum) + ((vector) (##sys#size #(1)))) +(##sys#vector-length (#(procedure #:clean #:enforce #:foldable) ##sys#vector-length (vector) fixnum) + ((vector) (##sys#size #(1)))) + +(scheme#vector->list (forall (a) (#(procedure #:clean #:enforce) scheme#vector->list ((vector-of a)) (list-of a)))) +(##sys#vector->list (forall (a) (#(procedure #:clean #:enforce) ##sys#vector->list ((vector-of a)) (list-of a)))) +(scheme#list->vector (forall (a) (#(procedure #:clean #:enforce) scheme#list->vector ((list-of a)) (vector-of a)))) +(##sys#list->vector (forall (a) (#(procedure #:clean #:enforce) ##sys#list->vector ((list-of a)) (vector-of a)))) +(scheme#vector-fill! (#(procedure #:enforce) scheme#vector-fill! (vector *) undefined)) + +(scheme#procedure? (#(procedure #:pure #:predicate procedure) scheme#procedure? (*) boolean)) + + +(scheme#map (forall (a b) (#(procedure #:enforce) scheme#map ((procedure (a #!rest) b) (list-of a) #!rest list) (list-of b)))) + +(scheme#for-each + (forall (a) (#(procedure #:enforce) scheme#for-each ((procedure (a #!rest) . *) (list-of a) #!rest list) undefined))) + +(scheme#apply (#(procedure #:enforce) scheme#apply (procedure #!rest) . *)) +(##sys#apply (#(procedure #:enforce) ##sys#apply (procedure #!rest) . *)) + +(scheme#force (procedure scheme#force (*) . *) + (((not (struct promise))) #(1))) + +(scheme#call-with-current-continuation + (#(procedure #:enforce) scheme#call-with-current-continuation + ((procedure (procedure) . *)) . *)) + +(scheme#input-port? (#(procedure #:pure #:predicate (refine (input) port)) scheme#input-port? (*) boolean)) +(scheme#output-port? (#(procedure #:pure #:predicate (refine (output) port)) scheme#output-port? (*) boolean)) + +(scheme#current-input-port + (#(procedure #:clean #:enforce) scheme#current-input-port + (#!optional input-port boolean boolean) input-port) + (() ##sys#standard-input) + (((refine (input) port)) + (let ((#(tmp1) #(1))) + (let ((#(tmp2) (set! ##sys#standard-input #(tmp1)))) + #(tmp1))))) + +(scheme#current-output-port + (#(procedure #:clean #:enforce) scheme#current-output-port + (#!optional output-port boolean boolean) output-port) + (() ##sys#standard-output) + (((refine (output) port)) + (let ((#(tmp1) #(1))) + (let ((#(tmp2) (set! ##sys#standard-output #(tmp1)))) + #(tmp1))))) + +(scheme#call-with-input-file + (procedure scheme#call-with-input-file + (string (procedure (input-port) . *) #!rest) . *)) + +(scheme#call-with-output-file + (procedure scheme#call-with-output-file + (string (procedure (output-port) . *) #!rest) . *)) + +(scheme#open-input-file (#(procedure #:clean #:enforce) scheme#open-input-file (string #!rest keyword) input-port)) +(scheme#open-output-file (#(procedure #:clean #:enforce) scheme#open-output-file (string #!rest keyword) output-port)) +(scheme#close-input-port (#(procedure #:enforce) scheme#close-input-port (input-port) undefined)) +(scheme#close-output-port (#(procedure #:enforce) scheme#close-output-port (output-port) undefined)) + +(scheme#read (#(procedure #:enforce) scheme#read (#!optional input-port) *)) + +(scheme#eof-object? (#(procedure #:pure #:predicate eof) scheme#eof-object? (*) boolean)) + +(scheme#read-char (#(procedure #:enforce) scheme#read-char (#!optional input-port) (or eof char))) +(scheme#peek-char (#(procedure #:enforce) scheme#peek-char (#!optional input-port) (or eof char))) + +(scheme#write (#(procedure #:enforce) scheme#write (* #!optional output-port) undefined)) +(scheme#display (#(procedure #:enforce) scheme#display (* #!optional output-port) undefined)) +(scheme#write-char (#(procedure #:enforce) scheme#write-char (char #!optional output-port) undefined)) + +;;XXX Yes, that would be nice, but the output-port may be closed +#;(##sys#write-char-0 + (#(procedure #:enforce) ##sys#write-char-0 (char output-port) undefined) + ((char output-port) + (let ((#(tmp) #(1))) + ((##sys#slot (##sys#slot #(tmp) '2) '2) #(tmp) #(2))))) + +(scheme#newline (#(procedure #:enforce) scheme#newline (#!optional output-port) undefined)) + +(scheme#with-input-from-file + (#(procedure #:enforce) scheme#with-input-from-file (string (procedure () . *) #!rest keyword) . *)) + +(scheme#with-output-to-file + (#(procedure #:enforce) scheme#with-output-to-file + (string (procedure () . *) #!rest keyword) . *)) + +(scheme#dynamic-wind + (#(procedure #:enforce) scheme#dynamic-wind + ((procedure () . *) (procedure () . *) (procedure () . *)) . *)) + +(scheme#values (#(procedure #:clean) scheme#values (#!rest values) . *)) +(##sys#values (#(procedure #:clean) ##sys#values (#!rest values) . *)) + +(scheme#call-with-values (#(procedure #:enforce) scheme#call-with-values + ((procedure () . *) procedure) . *) + (((procedure () *) *) (let ((#(tmp1) #(1))) + (let ((#(tmp2) #(2))) + (#(tmp2) (#(tmp1))))))) + +(##sys#call-with-values + (#(procedure #:enforce) ##sys#call-with-values ((procedure () . *) procedure) . *) + (((procedure () *) *) (let ((#(tmp1) #(1))) + (let ((#(tmp2) #(2))) + (#(tmp2) (#(tmp1))))))) + +(scheme#char-ready? (#(procedure #:enforce) scheme#char-ready? (#!optional input-port) boolean)) + +(scheme#real-part (#(procedure #:clean #:enforce #:foldable) scheme#real-part (number) (or integer float ratnum)) + (((or fixnum float bignum ratnum)) #(1)) + ((cplxnum) (##core#inline "C_u_i_cplxnum_real" #(1)))) + +(scheme#imag-part (#(procedure #:clean #:enforce #:foldable) scheme#imag-part (number) (or integer float ratnum)) + (((or fixnum bignum ratnum)) (let ((#(tmp) #(1))) '0)) + ((float) (let ((#(tmp) #(1))) '0.0)) + ((cplxnum) (##core#inline "C_u_i_cplxnum_imag" #(1)))) + +(scheme#magnitude (#(procedure #:clean #:enforce #:foldable) scheme#magnitude (number) number) + ((fixnum) (integer) (##core#inline_allocate ("C_a_i_fixnum_abs" 5) #(1))) + ((integer) (##core#inline_allocate ("C_s_a_u_i_integer_abs" 5) #(1))) + ((float) (float) (##core#inline_allocate ("C_a_i_flonum_abs" 4) #(1))) + (((or fixnum float bignum ratnum)) + (##core#inline_allocate ("C_s_a_i_abs" 7) #(1)))) + +(scheme#angle (#(procedure #:clean #:enforce #:foldable) scheme#angle (number) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_atan2" 4) '0.0 #(1))) + ((fixnum) (##core#inline_allocate + ("C_a_i_flonum_atan2" 4) + '0.0 + (##core#inline_allocate ("C_a_i_fix_to_flo" 4) #(1)))) + ((cplxnum) + (let ((#(tmp) #(1))) + (##core#inline_allocate + ("C_a_i_flonum_atan2" 4) + (##core#inline_allocate ("C_a_i_exact_to_inexact" 11) + (##core#inline "C_u_i_cplxnum_imag" #(tmp))) + (##core#inline_allocate ("C_a_i_exact_to_inexact" 11) + (##core#inline "C_u_i_cplxnum_real" #(tmp))))))) + +(scheme#numerator (#(procedure #:clean #:enforce #:foldable) scheme#numerator ((or float integer ratnum)) (or float integer)) + ((fixnum) (fixnum) #(1)) + ((bignum) (bignum) #(1)) + ((integer) (integer) #(1)) + ((ratnum) (integer) (##core#inline "C_u_i_ratnum_num" #(1)))) + +(scheme#denominator (#(procedure #:clean #:enforce #:foldable) scheme#denominator ((or float integer ratnum)) (or float integer)) + ((integer) (fixnum) (let ((#(tmp) #(1))) '1)) + ((ratnum) (integer) (##core#inline "C_u_i_ratnum_denom" #(1)))) + +(scheme#load (procedure scheme#load (string #!optional (procedure (*) . *)) undefined)) + +(scheme#eval (procedure scheme#eval (* #!optional (struct environment)) . *)) + +(scheme#scheme-report-environment + (#(procedure #:clean #:enforce) scheme#scheme-report-environment (#!optional fixnum) (struct environment))) + +(scheme#null-environment + (#(procedure #:clean #:enforce) scheme#null-environment (#!optional fixnum) (struct environment))) + +(scheme#interaction-environment + (#(procedure #:clean) scheme#interaction-environment () (struct environment))) + + + +;; eval + +(chicken.eval#module-environment + (#(procedure #:clean #:enforce) chicken.eval#module-environment ((or symbol (list-of (or symbol fixnum)))) (struct environment))) + + +;; base + +(chicken.base#add1 (#(procedure #:clean #:enforce #:foldable) chicken.base#add1 (number) number) + ((fixnum) (integer) + (##core#inline_allocate ("C_a_i_fixnum_plus" 5) #(1) '1)) + ((integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_plus" 5) #(1) '1)) + ((float) (float) + (##core#inline_allocate ("C_a_i_flonum_plus" 4) #(1) '1.0)) + ((*) (number) + (##core#inline_allocate ("C_s_a_i_plus" 29) #(1) '1))) + +(chicken.base#sub1 (#(procedure #:clean #:enforce #:foldable) chicken.base#sub1 (number) number) + ((fixnum) (integer) + (##core#inline_allocate ("C_a_i_fixnum_difference" 5) #(1) '1)) + ((integer) (integer) + (##core#inline_allocate ("C_s_a_u_i_integer_minus" 5) #(1) '1)) + ((float) (float) + (##core#inline_allocate ("C_a_i_flonum_difference" 4) #(1) '1.0)) + ((*) (number) + (##core#inline_allocate ("C_s_a_i_minus" 29) #(1) '1))) + +(chicken.base#subvector (forall (a) (#(procedure #:clean #:enforce) chicken.base#subvector ((vector-of a) fixnum #!optional fixnum) (vector-of a)))) +(chicken.base#vector-copy! (#(procedure #:enforce) chicken.base#vector-copy! (vector vector #!optional fixnum) undefined)) +(chicken.base#vector-resize + (forall (a b) (#(procedure #:clean #:enforce) chicken.base#vector-resize ((vector-of a) fixnum #!optional b) + (vector-of (or a b))))) + +(chicken.base#void (#(procedure #:pure) chicken.base#void (#!rest) undefined)) +(chicken.base#warning (procedure chicken.base#warning (* #!rest) undefined)) +(chicken.base#notice (procedure chicken.base#notice (* #!rest) undefined)) + +(chicken.base#exact-integer? (#(procedure #:pure #:foldable) chicken.base#exact-integer? (*) boolean) + ((integer) (let ((#(tmp) #(1))) '#t)) + (((not integer)) (let ((#(tmp) #(1))) '#f)) + ((*) (##core#inline "C_i_exact_integerp" #(1)))) +(chicken.base#exact-integer-nth-root (#(procedure #:clean #:enforce #:foldable) chicken.base#exact-integer-nth-root (integer integer) integer integer) + ((integer integer) (##sys#exact-integer-nth-root/loc 'exact-integer-nth-root #(1) #(2)))) + +(chicken.base#exact-integer-sqrt (#(procedure #:clean #:enforce #:foldable) chicken.base#exact-integer-sqrt (integer) integer integer) + ((integer) (##sys#exact-integer-sqrt #(1)))) + +(chicken.base#fixnum? (#(procedure #:pure #:predicate fixnum) chicken.base#fixnum? (*) boolean)) +(chicken.base#flonum? (#(procedure #:pure #:predicate float) chicken.base#flonum? (*) boolean)) +(chicken.base#bignum? (#(procedure #:pure #:predicate bignum) chicken.base#bignum? (*) boolean)) +(chicken.base#ratnum? (#(procedure #:pure #:predicate ratnum) chicken.base#ratnum? (*) boolean)) +(chicken.base#cplxnum? (#(procedure #:pure #:predicate cplxnum) chicken.base#cplxnum? (*) boolean)) + +(chicken.base#foldl (forall (a b) (#(procedure #:enforce) chicken.base#foldl ((procedure (a b) a) a (list-of b)) a))) +(chicken.base#foldr (forall (a b) (#(procedure #:enforce) chicken.base#foldr ((procedure (a b) b) b (list-of a)) b))) + +(chicken.base#nan? (#(procedure #:clean #:enforce #:foldable) chicken.base#nan? (number) boolean) + (((or integer ratnum)) (let ((#(tmp) #(1))) '#f)) + ((float) (##core#inline "C_u_i_flonum_nanp" #(1))) + ((*) (##core#inline "C_i_nanp" #(1)))) + +(chicken.base#infinite? (#(procedure #:clean #:enforce #:foldable) chicken.base#infinite? (number) boolean) + (((or integer ratnum)) (let ((#(tmp) #(1))) '#f)) + ((float) (##core#inline "C_u_i_flonum_infinitep" #(1))) + ((*) (##core#inline "C_i_infinitep" #(1)))) + +(chicken.base#finite? (#(procedure #:clean #:enforce #:foldable) chicken.base#finite? (number) boolean) + (((or integer ratnum)) (let ((#(tmp) #(1))) '#t)) + ((float) (##core#inline "C_u_i_flonum_finitep" #(1))) + ((*) (##core#inline "C_i_finitep" #(1)))) + +(chicken.base#get-call-chain (#(procedure #:clean #:enforce) chicken.base#get-call-chain (#!optional fixnum (struct thread)) (list-of vector))) +(chicken.base#print-call-chain (#(procedure #:clean #:enforce) chicken.base#print-call-chain (#!optional output-port fixnum * string) undefined)) + +(chicken.base#print (procedure chicken.base#print (#!rest *) undefined)) +(chicken.base#print* (procedure chicken.base#print* (#!rest) undefined)) +(chicken.base#procedure-information (#(procedure #:clean #:enforce) chicken.base#procedure-information (procedure) *)) +(chicken.base#promise? (#(procedure #:pure #:predicate (struct promise)) chicken.base#promise? (*) boolean)) + +(chicken.base#make-promise (#(procedure #:enforce) chicken.base#make-promise (*) (struct promise)) + (((struct promise)) #(1))) + +(chicken.base#call/cc (#(procedure #:enforce) chicken.base#call/cc ((procedure (*) . *)) . *)) + +(chicken.base#port? (#(procedure #:pure #:predicate port) chicken.base#port? (*) boolean)) + +(chicken.base#port-closed? + (#(procedure #:clean #:enforce) chicken.base#port-closed? (port) boolean) + ((port) (scheme#eq? (##sys#slot #(1) '8) '0))) + +(chicken.base#input-port-open? (#(procedure #:enforce) chicken.base#input-port-open? (input-port) boolean)) +(chicken.base#output-port-open? (#(procedure #:enforce) chicken.base#output-port-open? (output-port) boolean)) + +(chicken.base#get-output-string (#(procedure #:clean #:enforce) chicken.base#get-output-string (output-port) string)) +(chicken.base#open-input-string (#(procedure #:clean #:enforce) chicken.base#open-input-string (string #!rest) input-port)) +(chicken.base#open-output-string (#(procedure #:clean) chicken.base#open-output-string (#!rest) output-port)) + +(chicken.base#current-error-port + (#(procedure #:clean #:enforce) chicken.base#current-error-port (#!optional output-port boolean boolean) output-port) + ((output-port) (let ((#(tmp1) #(1))) + (let ((#(tmp2) (set! ##sys#standard-error #(tmp1)))) + #(tmp1)))) + (() ##sys#standard-error)) + +(chicken.base#flush-output (#(procedure #:enforce) chicken.base#flush-output (#!optional output-port) undefined)) + +(chicken.base#enable-warnings (#(procedure #:clean) chicken.base#enable-warnings (#!optional *) *)) + +(chicken.base#error (procedure chicken.base#error (* #!rest) noreturn)) +(chicken.base#equal=? (#(procedure #:clean #:foldable) chicken.base#equal=? (* *) boolean) + ((fixnum fixnum) (scheme#eq? #(1) #(2))) + (((or symbol keyword char eof null undefined) *) (scheme#eq? #(1) #(2))) + ((* (or symbol keyword char eof null undefined)) (scheme#eq? #(1) #(2))) + ((number number) (scheme#= #(1) #(2)))) + +(chicken.base#emergency-exit (procedure chicken.base#emergency-exit (#!optional fixnum) noreturn)) +(chicken.base#on-exit (#(procedure #:clean #:enforce) chicken.base#on-exit ((procedure () . *)) undefined)) +(chicken.base#implicit-exit-handler + (#(procedure #:clean #:enforce) chicken.base#implicit-exit-handler (#!optional (procedure () . *)) procedure)) + +(chicken.base#sleep (#(procedure #:clean #:enforce) chicken.base#sleep (fixnum) undefined)) + +(chicken.base#exit (procedure chicken.base#exit (#!optional fixnum) noreturn)) +(chicken.base#exit-handler (#(procedure #:clean #:enforce) chicken.base#exit-handler (#!optional (procedure (fixnum) . *)) procedure)) + +(chicken.base#gensym (#(procedure #:clean) chicken.base#gensym (#!optional (or string symbol)) symbol)) +(chicken.base#char-name (#(procedure #:clean #:enforce) chicken.base#char-name ((or char symbol) #!optional char) *)) ;XXX -> (or char symbol) ? + +(chicken.base#getter-with-setter + (#(procedure #:clean #:enforce) + chicken.base#getter-with-setter + ((procedure (#!rest) *) (procedure (* #!rest) . *) #!optional string) + procedure)) +(chicken.base#setter (#(procedure #:clean #:enforce) chicken.base#setter (procedure) procedure)) + +(chicken.base#signum (#(procedure #:clean #:enforce) chicken.base#signum (number) (or fixnum float cplxnum)) + ((fixnum) (fixnum) (##core#inline "C_i_fixnum_signum" #(1))) + ((integer) (fixnum) (##core#inline "C_u_i_integer_signum" #(1))) + ((float) (float) + (##core#inline_allocate ("C_a_u_i_flonum_signum" 4) #(1))) + ((ratnum) (fixnum) + (##core#inline "C_u_i_integer_signum" + (##core#inline "C_u_i_ratnum_num" #(1)))) + ((cplxnum) ((or float cplxnum)) (##sys#extended-signum #(1)))) + +(chicken.base#make-parameter (#(procedure #:clean #:enforce) chicken.base#make-parameter (* #!optional procedure) procedure)) +(chicken.base#string->uninterned-symbol (#(procedure #:clean #:enforce) chicken.base#string->uninterned-symbol (string) symbol)) +(chicken.base#symbol-append (#(procedure #:clean #:enforce #:foldable) chicken.base#symbol-append (#!rest symbol) symbol)) + +(chicken.base#case-sensitive (#(procedure #:clean) chicken.base#case-sensitive (#!optional *) *)) +(chicken.base#keyword-style (#(procedure #:clean) chicken.base#keyword-style (#!optional (or keyword false)) *)) +(chicken.base#parentheses-synonyms (#(procedure #:clean) chicken.base#parentheses-synonyms (#!optional *) *)) +(chicken.base#symbol-escape (#(procedure #:clean) chicken.base#symbol-escape (#!optional *) *)) + +(chicken.base#quotient&remainder (#(procedure #:clean #:enforce #:foldable) chicken.base#quotient&remainder ((or integer float) (or integer float)) (or integer float) (or integer float)) + ((float float) (float float) + (let ((#(tmp1) #(1))) + (let ((#(tmp2) #(2))) + (##sys#values + (##core#inline_allocate + ("C_a_i_flonum_actual_quotient_checked" 4) #(tmp1) #(tmp2)) + (##core#inline_allocate + ("C_a_i_flonum_remainder_checked" 4) #(tmp1) #(tmp2)))))) + ;;XXX flonum/mixed case + ((fixnum fixnum) (integer fixnum) + (let ((#(tmp1) #(1))) + (let ((#(tmp2) #(2))) + (##sys#values + (##core#inline_allocate ("C_a_i_fixnum_quotient_checked" 5) + #(tmp1) #(tmp2)) + (##core#inline + "C_i_fixnum_remainder_checked" #(tmp1) #(tmp2)))))) + ((integer integer) (integer integer) + ((##core#primitive "C_u_integer_quotient_and_remainder") #(1) #(2)))) + +;; TODO: Add nonspecializing type specific entries, to help flow analysis? +(chicken.base#quotient&modulo (#(procedure #:clean #:enforce #:foldable) chicken.base#quotient&modulo ((or integer float) (or integer float)) (or integer float) (or integer float))) + +(chicken.base#record-printer (#(procedure #:enforce) chicken.base#record-printer (symbol) (or false procedure))) +(chicken.base#set-record-printer! (#(procedure #:enforce) chicken.base#set-record-printer! (symbol procedure) undefined)) + +(chicken.base#alist-ref + (forall (a b c d) + (#(procedure #:clean #:foldable) chicken.base#alist-ref + (a (list-of (pair b c)) #!optional (procedure (a b) *) d) + (or false c d)))) +(chicken.base#alist-update! + (forall (a b c d) + (#(procedure) chicken.base#alist-update! + (a b (list-of (pair c d)) #!optional (procedure (a c) *)) + (list-of (pair c (or b d)))))) +(chicken.base#alist-update + (forall (a b c d) + (#(procedure #:clean) chicken.base#alist-update + (a b (list-of (pair c d)) #!optional (procedure (a c) *)) + (list-of (pair c (or b d)))))) + +(chicken.base#atom? (#(procedure #:pure #:foldable) chicken.base#atom? (*) boolean) + ((pair) (let ((#(tmp) #(1))) '#f)) + (((not (or pair list))) (let ((#(tmp) #(1))) '#t))) + +(chicken.base#butlast (forall (a) (#(procedure #:clean #:enforce) chicken.base#butlast ((pair a *)) (list-of a)))) +(chicken.base#chop (forall (a) (#(procedure #:clean #:enforce) chicken.base#chop ((list-of a) fixnum) (list-of a)))) +(chicken.base#complement (#(procedure #:clean #:enforce) chicken.base#complement ((procedure (#!rest) *)) (procedure (#!rest) boolean))) +(chicken.base#compose (#(procedure #:clean #:enforce) chicken.base#compose (#!rest procedure) procedure)) +(chicken.base#compress (forall (a) (#(procedure #:clean #:enforce) chicken.base#compress (list (list-of a)) (list-of a)))) +(chicken.base#conjoin (#(procedure #:clean #:enforce) chicken.base#conjoin (#!rest (procedure (*) *)) (procedure (*) *))) +(chicken.base#constantly (forall (a) (#(procedure #:pure) chicken.base#constantly (a) (procedure (#!rest) a)))) +(chicken.base#disjoin (#(procedure #:clean #:enforce) chicken.base#disjoin (#!rest (procedure (*) *)) (procedure (*) *))) +(chicken.base#each (#(procedure #:clean #:enforce) chicken.base#each (#!rest procedure) procedure)) +(chicken.base#flatten (#(procedure #:clean #:enforce) chicken.base#flatten (#!rest *) list)) +(chicken.base#flip (#(procedure #:clean #:enforce) chicken.base#flip ((procedure (* *) . *)) (procedure (* *) . *))) +(chicken.base#identity (forall (a) (#(procedure #:pure #:foldable) chicken.base#identity (a) a))) +(chicken.base#intersperse (#(procedure #:clean #:enforce) chicken.base#intersperse (list *) list)) +(chicken.base#join (#(procedure #:clean #:enforce) chicken.base#join ((list-of list) #!optional list) list)) +(chicken.base#list-of? (#(procedure #:clean #:enforce) chicken.base#list-of? ((procedure (*) *)) (procedure (list) boolean))) + +(chicken.base#o (#(procedure #:clean #:enforce) chicken.base#o (#!rest (procedure (*) *)) (procedure (*) *))) + +(chicken.base#rassoc + (forall (a b c) (#(procedure #:clean #:foldable) chicken.base#rassoc + (a (list-of (pair b c)) #!optional (procedure (a b) *)) + (or false (pair b c))))) +(chicken.base#tail? (#(procedure #:clean) chicken.base#tail? (* *) boolean)) + + +;; bitwise + +(chicken.bitwise#integer-length + (#(procedure #:clean #:enforce #:foldable) chicken.bitwise#integer-length (integer) fixnum) + ((fixnum) (##core#inline "C_i_fixnum_length" #(1))) + ((*) (##core#inline "C_i_integer_length" #(1)))) + +(chicken.bitwise#arithmetic-shift + (#(procedure #:clean #:enforce #:foldable) chicken.bitwise#arithmetic-shift (integer fixnum) integer)) + +(chicken.bitwise#bit->boolean + (#(procedure #:clean #:enforce #:foldable) chicken.bitwise#bit->boolean (integer integer) boolean) + ((fixnum fixnum) (##core#inline "C_i_fixnum_bit_to_bool" #(1) #(2)))) + +(chicken.bitwise#bitwise-and + (#(procedure #:clean #:enforce #:foldable) chicken.bitwise#bitwise-and (#!rest integer) integer) + (() '-1) + ((fixnum) (fixnum) #(1)) + ((integer) #(1)) + ((fixnum fixnum) (fixnum) (##core#inline "C_u_fixnum_and" #(1) #(2)))) + +(chicken.bitwise#bitwise-ior + (#(procedure #:clean #:enforce #:foldable) chicken.bitwise#bitwise-ior (#!rest integer) integer) + (() '0) + ((fixnum) (fixnum) #(1)) + ((integer) #(1)) + ((fixnum fixnum) (fixnum) (##core#inline "C_u_fixnum_or" #(1) #(2)))) + +(chicken.bitwise#bitwise-xor + (#(procedure #:clean #:enforce #:foldable) chicken.bitwise#bitwise-xor (#!rest integer) integer) + (() '0) + ((fixnum) (fixnum) #(1)) + ((integer) #(1)) + ((fixnum fixnum) (fixnum) (##core#inline "C_fixnum_xor" #(1) #(2)))) + +(chicken.bitwise#bitwise-not + (#(procedure #:clean #:enforce #:foldable) chicken.bitwise#bitwise-not (integer) integer)) + +;; blob + +(chicken.blob#blob? (#(procedure #:pure #:predicate blob) chicken.blob#blob? (*) boolean)) +(chicken.blob#blob=? (#(procedure #:clean #:enforce #:foldable) chicken.blob#blob=? (blob blob) boolean)) +(chicken.blob#blob-size (#(procedure #:clean #:enforce #:foldable) chicken.blob#blob-size (blob) fixnum) + ((blob) (##sys#size #(1)))) +(chicken.blob#blob->string (#(procedure #:clean #:enforce) chicken.blob#blob->string (blob) string)) +(chicken.blob#make-blob (#(procedure #:clean #:enforce) chicken.blob#make-blob (fixnum) blob) + ((fixnum) (##sys#make-blob #(1)))) +(chicken.blob#string->blob (#(procedure #:clean #:enforce) chicken.blob#string->blob (string) blob)) + +;; condition + +(chicken.condition#abort (procedure chicken.condition#abort (*) noreturn)) +(chicken.condition#condition (#(procedure #:clean #:enforce) chicken.condition#condition (list #!rest list) (struct condition))) +(chicken.condition#condition? (#(procedure #:pure #:predicate (struct condition)) chicken.condition#condition? (*) boolean)) +(chicken.condition#condition->list (#(procedure #:clean #:enforce) chicken.condition#condition->list ((struct condition)) (list-of pair))) +(chicken.condition#condition-predicate (#(procedure #:clean #:enforce) chicken.condition#condition-predicate (*) (procedure ((struct condition)) boolean))) +(chicken.condition#condition-property-accessor (#(procedure #:clean #:enforce) chicken.condition#condition-property-accessor (* * #!optional *) (procedure ((struct condition)) *))) + +(chicken.condition#current-exception-handler + (#(procedure #:clean #:enforce) chicken.condition#current-exception-handler (#!optional (procedure (*) noreturn) boolean boolean) procedure) + ((procedure) (let ((#(tmp1) #(1))) + (let ((#(tmp2) (set! ##sys#current-exception-handler #(tmp1)))) + #(tmp1)))) + (() ##sys#current-exception-handler)) +(chicken.condition#get-condition-property (#(procedure #:clean #:enforce) chicken.condition#get-condition-property ((struct condition) * * #!optional *) *)) +(chicken.condition#make-composite-condition (#(procedure #:clean #:enforce) chicken.condition#make-composite-condition (#!rest (struct condition)) (struct condition))) +(chicken.condition#make-property-condition (#(procedure #:clean #:enforce) chicken.condition#make-property-condition (* #!rest *) (struct condition))) +(chicken.condition#print-error-message (#(procedure #:clean #:enforce) chicken.condition#print-error-message (* #!optional output-port string) undefined)) +(chicken.condition#with-exception-handler (#(procedure #:enforce) chicken.condition#with-exception-handler ((procedure (*) . *) (procedure () . *)) . *)) +(chicken.condition#signal (procedure chicken.condition#signal (*) . *)) + +;; continuation + +(chicken.continuation#continuation-capture (#(procedure #:enforce) chicken.continuation#continuation-capture ((procedure ((struct continuation)) . *)) *)) +(chicken.continuation#continuation-graft (#(procedure #:clean #:enforce) chicken.continuation#continuation-graft ((struct continuation) (procedure () . *)) *)) +(chicken.continuation#continuation-return (#(procedure #:enforce) chicken.continuation#continuation-return ((struct continuation) #!rest) . *)) ;XXX make return type more specific? +(chicken.continuation#continuation? (#(procedure #:pure #:predicate (struct continuation)) chicken.continuation#continuation? (*) boolean)) + +;; read-syntax + +(chicken.read-syntax#copy-read-table (#(procedure #:clean #:enforce) chicken.read-syntax#copy-read-table ((struct read-table)) (struct read-table))) +(chicken.read-syntax#current-read-table + (#(procedure #:clean) chicken.read-syntax#current-read-table (#!optional (struct read-table)) (struct read-table))) +(chicken.read-syntax#define-reader-ctor (#(procedure #:clean #:enforce) chicken.read-syntax#define-reader-ctor (symbol procedure) undefined)) + +(chicken.read-syntax#set-parameterized-read-syntax! + (#(procedure #:clean #:enforce) chicken.read-syntax#set-parameterized-read-syntax! + ((or char symbol) (or false (procedure (input-port fixnum) . *))) + undefined)) + +(chicken.read-syntax#set-read-syntax! + (#(procedure #:clean #:enforce) chicken.read-syntax#set-read-syntax! + ((or char symbol) (or false (procedure (input-port) . *))) + undefined)) + +(chicken.read-syntax#set-sharp-read-syntax! + (#(procedure #:clean #:enforce) chicken.read-syntax#set-sharp-read-syntax! + ((or char symbol) (or false (procedure (input-port) . *))) undefined)) + + +;; time + +(chicken.time#cpu-time (#(procedure #:clean) chicken.time#cpu-time () fixnum fixnum)) +(chicken.time#current-seconds (#(procedure #:clean) chicken.time#current-seconds () integer)) +(chicken.time#current-milliseconds deprecated) +(chicken.time#current-process-milliseconds (#(procedure #:clean) chicken.time#current-process-milliseconds () integer)) + +(##sys#error (procedure ##sys#error (* #!rest) noreturn)) +(##sys#signal-hook (procedure ##sys#signal-hook (* #!rest) noreturn)) +(##sys#debug-mode? (procedure ##sys#debug-mode? () boolean) + (() (##core#inline "C_i_debug_modep"))) + + +;; flonum + +(chicken.flonum#flonum-decimal-precision fixnum) +(chicken.flonum#flonum-epsilon float) +(chicken.flonum#flonum-maximum-decimal-exponent fixnum) +(chicken.flonum#flonum-maximum-exponent fixnum) +(chicken.flonum#flonum-minimum-decimal-exponent fixnum) +(chicken.flonum#flonum-minimum-exponent fixnum) +(chicken.flonum#flonum-precision fixnum) +(chicken.flonum#flonum-print-precision (#(procedure #:clean #:enforce) chicken.flonum#flonum-print-precision (#!optional fixnum) fixnum)) +(chicken.flonum#flonum-radix fixnum) + +(chicken.flonum#fp- (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fp- (float float) float) + ((float float) (##core#inline_allocate ("C_a_i_flonum_difference" 4) #(1) #(2)) )) + +(chicken.flonum#fp* (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fp* (float float) float) + ((float float) (##core#inline_allocate ("C_a_i_flonum_times" 4) #(1) #(2)) )) + +(chicken.flonum#fp/ (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fp/ (float float) float) + ((float float) (##core#inline_allocate ("C_a_i_flonum_quotient" 4) #(1) #(2)) )) + +(chicken.flonum#fpgcd (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpgcd (float float) float) + ((float float) (##core#inline_allocate ("C_a_i_flonum_gcd" 4) #(1) #(2)) )) + +(chicken.flonum#fp+ (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fp+ (float float) float) + ((float float) (##core#inline_allocate ("C_a_i_flonum_plus" 4) #(1) #(2)) )) + +(chicken.flonum#fp< (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fp< (float float) boolean) + ((float float) (##core#inline "C_flonum_lessp" #(1) #(2)) )) + +(chicken.flonum#fp<= (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fp<= (float float) boolean) + ((float float) (##core#inline "C_flonum_less_or_equal_p" #(1) #(2)) )) + +(chicken.flonum#fp= (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fp= (float float) boolean) + ((float float) (##core#inline "C_flonum_equalp" #(1) #(2)) )) + +(chicken.flonum#fp> (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fp> (float float) boolean) + ((float float) (##core#inline "C_flonum_greaterp" #(1) #(2)) )) + +(chicken.flonum#fp>= (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fp>= (float float) boolean) + ((float float) (##core#inline "C_flonum_greater_or_equal_p" #(1) #(2)) )) + +(chicken.flonum#fpabs (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpabs (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_abs" 4) #(1) ))) + +(chicken.flonum#fpacos (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpacos (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_acos" 4) #(1) ))) + +(chicken.flonum#fpasin (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpasin (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_asin" 4) #(1) ))) + +(chicken.flonum#fpatan (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpatan (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_atan" 4) #(1) ))) + +(chicken.flonum#fpatan2 (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpatan2 (float float) float) + ((float float) (##core#inline_allocate ("C_a_i_flonum_atan2" 4) #(1) #(2)))) + +(chicken.flonum#fpceiling (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpceiling (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_ceiling" 4) #(1) ))) + +(chicken.flonum#fpcos (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpcos (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_cos" 4) #(1) ))) + +(chicken.flonum#fpexp (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpexp (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_exp" 4) #(1) ))) + +(chicken.flonum#fpexpt (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpexpt (float float) float) + ((float float) (##core#inline_allocate ("C_a_i_flonum_expt" 4) #(1) #(2)))) + +(chicken.flonum#fpfloor (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpfloor (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_floor" 4) #(1) ))) + +(chicken.flonum#fpinteger? (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpinteger? (float) boolean) + ((float) (##core#inline "C_u_i_fpintegerp" #(1) ))) + +(chicken.flonum#fplog (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fplog (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_log" 4) #(1) ))) + +(chicken.flonum#fpmax (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpmax (float float) float) + ((float float) (##core#inline "C_i_flonum_max" #(1) #(2)))) + +(chicken.flonum#fpmin (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpmin (float float) float) + ((float float) (##core#inline "C_i_flonum_min" #(1) #(2)))) + +(chicken.flonum#fpneg (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpneg (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_negate" 4) #(1) ))) + +(chicken.flonum#fpround (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpround (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_round" 4) #(1) ))) + +(chicken.flonum#fpsin (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpsin (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_sin" 4) #(1) ))) + +(chicken.flonum#fpsqrt (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fpsqrt (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_sqrt" 4) #(1) ))) + +(chicken.flonum#fptan (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fptan (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_tan" 4) #(1) ))) + +(chicken.flonum#fptruncate (#(procedure #:clean #:enforce #:foldable) chicken.flonum#fptruncate (float) float) + ((float) (##core#inline_allocate ("C_a_i_flonum_truncate" 4) #(1) ))) + +;; fixnum + +(chicken.fixnum#fixnum-bits fixnum) +(chicken.fixnum#fixnum-precision fixnum) + +;;XXX These aren't enforcing, and aren't foldable due to 32/64-bit issues +(chicken.fixnum#fx- (#(procedure #:clean) chicken.fixnum#fx- (fixnum fixnum) fixnum)) +(chicken.fixnum#fx* (#(procedure #:clean) chicken.fixnum#fx* (fixnum fixnum) fixnum)) +(chicken.fixnum#fx/ (#(procedure #:clean) chicken.fixnum#fx/ (fixnum fixnum) fixnum)) +(chicken.fixnum#fxgcd (#(procedure #:clean) chicken.fixnum#fxgcd (fixnum fixnum) fixnum)) +(chicken.fixnum#fx+ (#(procedure #:clean) chicken.fixnum#fx+ (fixnum fixnum) fixnum)) +(chicken.fixnum#fx< (#(procedure #:clean) chicken.fixnum#fx< (fixnum fixnum) boolean)) +(chicken.fixnum#fx<= (#(procedure #:clean) chicken.fixnum#fx<= (fixnum fixnum) boolean)) +(chicken.fixnum#fx= (#(procedure #:clean) chicken.fixnum#fx= (fixnum fixnum) boolean)) +(chicken.fixnum#fx> (#(procedure #:clean) chicken.fixnum#fx> (fixnum fixnum) boolean)) +(chicken.fixnum#fx>= (#(procedure #:clean) chicken.fixnum#fx>= (fixnum fixnum) boolean)) +(chicken.fixnum#fxand (#(procedure #:clean) chicken.fixnum#fxand (fixnum fixnum) fixnum)) +(chicken.fixnum#fxeven? (#(procedure #:clean) chicken.fixnum#fxeven? (fixnum) boolean)) +(chicken.fixnum#fxior (#(procedure #:clean) chicken.fixnum#fxior (fixnum fixnum) fixnum)) +(chicken.fixnum#fxmax (#(procedure #:clean) chicken.fixnum#fxmax (fixnum fixnum) fixnum)) +(chicken.fixnum#fxmin (#(procedure #:clean) chicken.fixnum#fxmin (fixnum fixnum) fixnum)) +(chicken.fixnum#fxmod (#(procedure #:clean) chicken.fixnum#fxmod (fixnum fixnum) fixnum)) +(chicken.fixnum#fxrem (#(procedure #:clean) chicken.fixnum#fxrem (fixnum fixnum) fixnum)) +(chicken.fixnum#fxneg (#(procedure #:clean) chicken.fixnum#fxneg (fixnum) fixnum)) +(chicken.fixnum#fxnot (#(procedure #:clean) chicken.fixnum#fxnot (fixnum) fixnum)) +(chicken.fixnum#fxodd? (#(procedure #:clean) chicken.fixnum#fxodd? (fixnum) boolean)) +(chicken.fixnum#fxshl (#(procedure #:clean) chicken.fixnum#fxshl (fixnum fixnum) fixnum)) +(chicken.fixnum#fxshr (#(procedure #:clean) chicken.fixnum#fxshr (fixnum fixnum) fixnum)) +(chicken.fixnum#fxxor (#(procedure #:clean) chicken.fixnum#fxxor (fixnum fixnum) fixnum)) +(chicken.fixnum#fxlen (#(procedure #:clean) chicken.fixnum#fxlen (fixnum) fixnum)) + +(chicken.fixnum#fx+? (#(procedure #:pure) chicken.fixnum#fx+? ((or fixnum false) (or fixnum false)) (or fixnum false))) +(chicken.fixnum#fx-? (#(procedure #:pure) chicken.fixnum#fx-? ((or fixnum false) (or fixnum false)) (or fixnum false))) +(chicken.fixnum#fx*? (#(procedure #:pure) chicken.fixnum#fx*? ((or fixnum false) (or fixnum false)) (or fixnum false))) +(chicken.fixnum#fx/? (#(procedure #:clean) chicken.fixnum#fx/? ((or fixnum false) (or fixnum false)) (or fixnum false))) + +;; keyword + +(chicken.keyword#get-keyword (#(procedure #:clean #:enforce) chicken.keyword#get-keyword (keyword list #!optional *) *)) +(chicken.keyword#keyword->string (#(procedure #:clean #:enforce) chicken.keyword#keyword->string (keyword) string)) +(chicken.keyword#keyword? (#(procedure #:pure #:predicate keyword) chicken.keyword#keyword? (*) boolean)) +(chicken.keyword#string->keyword (#(procedure #:clean #:enforce) chicken.keyword#string->keyword (string) keyword)) + +;; load + +(chicken.load#dynamic-load-libraries + (#(procedure #:clean) chicken.load#dynamic-load-libraries (#!optional (list-of string)) (list-of string))) +(chicken.load#load-library (#(procedure #:enforce) chicken.load#load-library (symbol #!optional string) undefined)) +(chicken.load#load-noisily (procedure chicken.load#load-noisily (string #!rest) undefined)) +(chicken.load#load-relative (#(procedure #:enforce) chicken.load#load-relative (string #!optional (procedure (*) . *)) undefined)) +(chicken.load#load-verbose (#(procedure #:clean) chicken.load#load-verbose (#!optional *) *)) +(chicken.load#provide (#(procedure #:clean #:enforce) chicken.load#provide (#!rest symbol) undefined)) +(chicken.load#provided? (#(procedure #:clean #:enforce) chicken.load#provided? (#!rest symbol) boolean)) +(chicken.load#require (#(procedure #:clean) chicken.load#require (#!rest symbol) undefined)) +(chicken.load#set-dynamic-load-mode! (#(procedure #:clean #:enforce) chicken.load#set-dynamic-load-mode! ((or symbol (list-of symbol))) undefined)) +(chicken.load#find-file (#(procedure #:clean) chicken.load#find-file (string (or (list-of string) string)) (or string false))) + +;; platform + +(chicken.platform#build-platform (#(procedure #:pure) chicken.platform#build-platform () symbol)) +(chicken.platform#chicken-version (#(procedure #:pure) chicken.platform#chicken-version (#!optional *) string)) +(chicken.platform#chicken-home (#(procedure #:clean) chicken.platform#chicken-home () string)) +(chicken.platform#feature? (#(procedure #:clean) chicken.platform#feature? (#!rest (or keyword symbol string)) boolean)) +(chicken.platform#features (#(procedure #:clean) chicken.platform#features () (list-of keyword))) +(chicken.platform#software-type (#(procedure #:pure) chicken.platform#software-type () symbol)) +(chicken.platform#software-version (#(procedure #:pure) chicken.platform#software-version () symbol)) +(chicken.platform#register-feature! (#(procedure #:clean #:enforce) chicken.platform#register-feature! (#!rest (or keyword symbol string)) undefined)) +(chicken.platform#unregister-feature! (#(procedure #:clean #:enforce) chicken.platform#unregister-feature! (#!rest (or keyword symbol string)) undefined)) +(chicken.platform#machine-byte-order (#(procedure #:pure) chicken.platform#machine-byte-order () symbol)) +(chicken.platform#machine-type (#(procedure #:pure) chicken.platform#machine-type () symbol)) +(chicken.platform#repository-path (#(procedure #:clean) chicken.platform#repository-path (#!optional *) *)) +(chicken.platform#installation-repository (#(procedure #:clean) chicken.platform#installation-repository (#!optional *) *)) +(chicken.platform#return-to-host (procedure chicken.platform#return-to-host () . *)) +(chicken.platform#system-config-directory (#(procedure #:clean) chicken.platform#system-config-directory () (or string false))) +(chicken.platform#system-cache-directory (#(procedure #:clean) chicken.platform#system-cache-directory () (or string false))) + +;; plist + +(chicken.plist#get (#(procedure #:clean #:enforce) chicken.plist#get (symbol symbol #!optional *) *) + ((symbol symbol *) (##core#inline "C_i_getprop" #(1) #(2) #(3)))) +(chicken.plist#get-properties (#(procedure #:clean #:enforce) chicken.plist#get-properties (symbol list) symbol * list)) +(chicken.plist#put! (#(procedure #:clean #:enforce) chicken.plist#put! (symbol symbol *) undefined) + ((symbol symbol *) + (##core#inline_allocate ("C_a_i_putprop" 8) #(1) #(2) #(3)))) +(chicken.plist#remprop! (#(procedure #:clean #:enforce) chicken.plist#remprop! (symbol symbol) undefined)) +(chicken.plist#symbol-plist (#(procedure #:clean #:enforce) chicken.plist#symbol-plist (symbol) list) + ((symbol) (##sys#slot #(1) '2))) + +(chicken.flonum#maximum-flonum float) +(chicken.flonum#minimum-flonum float) +(chicken.fixnum#most-negative-fixnum fixnum) +(chicken.fixnum#most-positive-fixnum fixnum) + +;; gc + +(chicken.gc#current-gc-milliseconds (#(procedure #:clean) chicken.gc#current-gc-milliseconds () integer)) +(chicken.gc#force-finalizers (procedure chicken.gc#force-finalizers () undefined)) +(chicken.gc#gc (#(procedure #:clean) chicken.gc#gc (#!optional *) fixnum)) +(chicken.gc#memory-statistics (#(procedure #:clean) chicken.gc#memory-statistics () (vector-of fixnum))) +(chicken.gc#set-finalizer! (#(procedure #:clean #:enforce) chicken.gc#set-finalizer! (* (procedure (*) . *)) *)) +(chicken.gc#set-gc-report! (#(procedure #:clean) chicken.gc#set-gc-report! (*) undefined)) + +(chicken.repl#repl (#(procedure #:enforce) chicken.repl#repl (#!optional (procedure (*) . *)) undefined)) +(chicken.repl#repl-prompt (#(procedure #:clean #:enforce) chicken.repl#repl-prompt (#!optional (procedure () string)) procedure)) +(chicken.repl#reset (procedure chicken.repl#reset () noreturn)) +(chicken.repl#reset-handler (#(procedure #:clean #:enforce) chicken.repl#reset-handler (#!optional (procedure () . *)) procedure)) +(chicken.repl#quit (procedure chicken.repl#quit (#!optional *) noreturn)) + + +(##sys#void (#(procedure #:pure) void (#!rest) undefined)) + +;; chicken (internal) + +(##sys#foreign-char-argument (#(procedure #:clean #:enforce) ##sys#foreign-char-argument (char) char) + ((char) #(1))) +(##sys#foreign-fixnum-argument (#(procedure #:clean #:enforce) ##sys#foreign-fixnum-argument (fixnum) fixnum) + ((fixnum) #(1))) +(##sys#foreign-flonum-argument (#(procedure #:clean #:enforce) ##sys#foreign-flonum-argument (number) number) + ((float) #(1))) +(##sys#foreign-string-argument (#(procedure #:clean #:enforce) ##sys#foreign-string-argument (string) string) + ((string) #(1))) +(##sys#foreign-symbol-argument (#(procedure #:clean #:enforce) ##sys#foreign-symbol-argument (symbol) symbol) + ((symbol) #(1))) +(##sys#foreign-pointer-argument (forall ((p (or locative pointer))) + (#(procedure #:clean #:enforce) ##sys#foreign-pointer-argument (p) p)) + ((pointer) (pointer) #(1)) + ((locative) (locative) #(1))) + +(##sys#check-blob (#(procedure #:clean #:enforce) ##sys#check-blob (blob #!optional *) *) + ((blob) (let ((#(tmp) #(1))) '#t)) + ((blob *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-pair (#(procedure #:clean #:enforce) ##sys#check-pair (pair #!optional *) *) + ((pair) (let ((#(tmp) #(1))) '#t)) + ((pair *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-list (#(procedure #:clean #:enforce) ##sys#check-list (list #!optional *) *) + (((or null pair list)) (let ((#(tmp) #(1))) '#t)) + (((or null pair list) *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-string (#(procedure #:clean #:enforce) ##sys#check-string (string #!optional *) *) + ((string) (let ((#(tmp) #(1))) '#t)) + ((string) * (let ((#(tmp) #(1))) '#t))) +(##sys#check-number (#(procedure #:clean #:enforce) ##sys#check-number (number #!optional *) *) + ((number) (let ((#(tmp) #(1))) '#t)) + ((number *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-exact (#(procedure #:clean #:enforce) ##sys#check-exact (fixnum #!optional *) *) + ((fixnum) (let ((#(tmp) #(1))) '#t)) + ((fixnum *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-inexact (#(procedure #:clean #:enforce) ##sys#check-inexact (float #!optional *) *) + ((float) (let ((#(tmp) #(1))) '#t)) + ((float *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-symbol (#(procedure #:clean #:enforce) ##sys#check-symbol (symbol #!optional *) *) + ((symbol) (let ((#(tmp) #(1))) '#t)) + ((symbol *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-vector (#(procedure #:clean #:enforce) ##sys#check-vector (vector #!optional *) *) + ((vector) (let ((#(tmp) #(1))) '#t)) + ((vector *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-char (#(procedure #:clean #:enforce) ##sys#check-char (char #!optional *) *) + ((char) (let ((#(tmp) #(1))) '#t)) + ((char *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-boolean (#(procedure #:clean #:enforce) ##sys#check-boolean (boolean #!optional *) *) + ((boolean) (let ((#(tmp) #(1))) '#t)) + ((boolean *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-locative (#(procedure #:clean #:enforce) ##sys#check-locative (locative #!optional *) *) + ((locative) (let ((#(tmp) #(1))) '#t)) + ((locative *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-closure (#(procedure #:clean #:enforce) ##sys#check-closure (procedure #!optional *) *) + ((procedure) (let ((#(tmp) #(1))) '#t)) + ((procedure *) (let ((#(tmp) #(1))) '#t))) +(##sys#check-keyword (#(procedure #:clean #:enforce) ##sys#check-keyword (keyword #!optional *) *) + ((keyword) (let ((#(tmp) #(1))) '#t)) + ((keyword *) (let ((#(tmp) #(1))) '#t))) + +(##sys#check-port + (#(procedure #:clean #:enforce) ##sys#check-port ((or input-port output-port) #!optional *) *) + (((or (refine (input) port) (refine (output) port))) (let ((#(tmp) #(1))) '#t)) + (((or (refine (input) port) (refine (output) port)) *) (let ((#(tmp) #(1))) '#t))) + +(##sys#check-input-port + (#(procedure #:clean #:enforce) ##sys#check-input-port (input-port * #!optional *) *) + ((* *) (##core#inline "C_i_check_port" #(1) '1 #(2))) + ((* * *) (##core#inline "C_i_check_port_2" #(1) '1 #(2) #(3)))) + +(##sys#check-output-port + (#(procedure #:clean #:enforce) ##sys#check-output-port (output-port * #!optional *) *) + ((* *) (##core#inline "C_i_check_port" #(1) '2 #(2))) + ((* * *) (##core#inline "C_i_check_port_2" #(1) '2 #(2) #(3)))) + +(##sys#check-open-port + (#(procedure #:clean #:enforce) ##sys#check-open-port ((or input-port output-port) #!optional *) *) + ((*) (##core#inline "C_i_check_port" #(1) '0 '#t)) + ((* *) (##core#inline "C_i_check_port_2" #(1) '0 '#t #(2)))) + +(##sys#slot (#(procedure #:enforce) ##sys#slot (* fixnum) *)) + +(##sys#setslot (#(procedure #:enforce) ##sys#setslot (* fixnum *) *) + #;((* fixnum immediate) (##sys#setislot #(1) #(2) #(3)))) ; too dangerous + +(##sys#size (#(procedure #:pure #:foldable) ##sys#size (*) fixnum)) + +(##sys#standard-input input-port) +(##sys#standard-output output-port) +(##sys#standard-error output-port) + +(##sys#provide (procedure ##sys#provide (symbol) boolean) + ((symbol) (##core#inline_allocate ("C_a_i_provide" 8) #(1)))) + +(##sys#provided? (procedure ##sys#provided? (symbol) boolean) + ((symbol) (##core#inline "C_i_providedp" #(1)))) + +;; string + +(chicken.string#->string (procedure chicken.string#->string (*) string) + ((string) #(1))) + +(chicken.string#conc (procedure chicken.string#conc (#!rest) string)) + +(chicken.string#string-chomp (#(procedure #:clean #:enforce) chicken.string#string-chomp (string #!optional string) string)) +(chicken.string#string-chop (#(procedure #:clean #:enforce) chicken.string#string-chop (string fixnum) (list-of string))) +(chicken.string#string-compare3 (#(procedure #:clean #:enforce) chicken.string#string-compare3 (string string) fixnum)) +(chicken.string#string-compare3-ci (#(procedure #:clean #:enforce) chicken.string#string-compare3-ci (string string) fixnum)) +(chicken.string#string-intersperse (#(procedure #:clean #:enforce) chicken.string#string-intersperse ((list-of string) #!optional string) string)) +(chicken.string#string-split (#(procedure #:clean #:enforce) chicken.string#string-split (string #!optional string *) (list-of string))) +(chicken.string#string-translate (#(procedure #:clean #:enforce) chicken.string#string-translate (string * #!optional *) string)) +(chicken.string#string-translate* (#(procedure #:clean #:enforce) chicken.string#string-translate* (string (list-of (pair string string))) string)) + +(chicken.string#substring=? (#(procedure #:clean #:enforce #:foldable) chicken.string#substring=? (string string #!optional fixnum fixnum fixnum) boolean)) +(chicken.string#substring-ci=? (#(procedure #:clean #:enforce #:foldable) chicken.string#substring-ci=? (string string #!optional fixnum fixnum fixnum) boolean)) +(chicken.string#substring-index (#(procedure #:clean #:enforce #:foldable) chicken.string#substring-index (string string #!optional fixnum) (or false fixnum)) + ((* *) (##sys#substring-index #(1) #(2) '0)) + ((* * *) (##sys#substring-index #(1) #(2) #(3)))) +(chicken.string#substring-index-ci (#(procedure #:clean #:enforce #:foldable) chicken.string#substring-index-ci (string string #!optional fixnum) (or false fixnum)) + ((* *) (##sys#substring-index-ci #(1) #(2) '0)) + ((* * *) (##sys#substring-index-ci #(1) #(2) #(3)))) + +(chicken.string#reverse-list->string (#(procedure #:clean #:enforce) chicken.string#reverse-list->string ((list-of char)) string)) +(chicken.string#reverse-string-append (#(procedure #:clean #:enforce) chicken.string#reverse-string-append ((list-of string)) string)) + +(##sys#substring-index + (#(procedure #:clean #:enforce #:foldable) ##sys#substring-index + (string string fixnum) + (or false fixnum))) + +(##sys#substring-index-ci + (#(procedure #:clean #:enforce #:foldable) ##sys#substring-index-ci + (string string fixnum) + (or false fixnum))) + +;; io + +(chicken.io#read-list (#(procedure #:enforce) chicken.io#read-list (#!optional input-port (procedure (input-port) *) fixnum) list)) +(chicken.io#read-buffered (#(procedure #:enforce) chicken.io#read-buffered (#!optional input-port) string)) +(chicken.io#read-byte (#(procedure #:enforce) chicken.io#read-byte (#!optional input-port) *)) +(chicken.io#read-line (#(procedure #:enforce) chicken.io#read-line (#!optional input-port (or false fixnum)) (or eof string))) +(chicken.io#read-lines (#(procedure #:enforce) chicken.io#read-lines (#!optional input-port fixnum) (list-of string))) +(chicken.io#read-string (#(procedure #:enforce) chicken.io#read-string (#!optional (or fixnum false) input-port) (or string eof))) +(chicken.io#read-string! (#(procedure #:enforce) chicken.io#read-string! ((or fixnum false) string #!optional input-port fixnum) fixnum)) +(chicken.io#read-token (#(procedure #:enforce) chicken.io#read-token ((procedure (char) *) #!optional input-port) string)) +(chicken.io#write-byte (#(procedure #:enforce) chicken.io#write-byte (fixnum #!optional output-port) undefined)) +(chicken.io#write-line (#(procedure #:enforce) chicken.io#write-line (string #!optional output-port) undefined)) +(chicken.io#write-string (#(procedure #:enforce) chicken.io#write-string (string #!optional * output-port) undefined)) + +;; pretty-print + +(chicken.pretty-print#pp (#(procedure #:enforce) chicken.pretty-print#pp (* #!optional output-port) undefined)) +(chicken.pretty-print#pretty-print (#(procedure #:enforce) chicken.pretty-print#pretty-print (* #!optional output-port) undefined)) +(chicken.pretty-print#pretty-print-width (#(procedure #:clean) chicken.pretty-print#pretty-print-width (#!optional fixnum) *)) + +;; format + +(chicken.format#format (procedure chicken.format#format (#!rest) *)) +(chicken.format#fprintf (#(procedure #:enforce) chicken.format#fprintf (output-port string #!rest) undefined)) +(chicken.format#printf (#(procedure #:enforce) chicken.format#printf (string #!rest) undefined)) +(chicken.format#sprintf (#(procedure #:enforce #:foldable) chicken.format#sprintf (string #!rest) string)) + +;; random + +(chicken.random#pseudo-random-integer (#(procedure #:clean #:enforce) chicken.random#pseudo-random-integer (integer) integer) + ((fixnum) (##core#inline "C_random_fixnum" #(1)))) +(chicken.random#pseudo-random-real (#(procedure #:clean #:enforce) chicken.random#pseudo-random-real () float)) +(chicken.random#set-pseudo-random-seed! (#(procedure #:clean #:enforce) chicken.random#set-pseudo-random-seed! ((or blob string) #!optional fixnum) undefined)) +(chicken.random#random-bytes (#(procedure #:clean #:enforce) chicken.random#random-bytes (#!optional * fixnum) *)) + +;; file + +(chicken.file#directory (#(procedure #:clean #:enforce) chicken.file#directory (#!optional string *) (list-of string))) +(chicken.file#create-directory (#(procedure #:clean #:enforce) chicken.file#create-directory (string #!optional *) string)) +(chicken.file#create-temporary-directory (#(procedure #:clean #:enforce) chicken.file#create-temporary-directory () string)) +(chicken.file#create-temporary-file (#(procedure #:clean #:enforce) chicken.file#create-temporary-file (#!optional string) string)) +(chicken.file#delete-directory (#(procedure #:clean #:enforce) chicken.file#delete-directory (string #!optional *) string)) +(chicken.file#delete-file (#(procedure #:clean #:enforce) chicken.file#delete-file (string) string)) +(chicken.file#delete-file* (#(procedure #:clean #:enforce) chicken.file#delete-file* (string) *)) +(chicken.file#directory-exists? (#(procedure #:clean #:enforce) chicken.file#directory-exists? (string) (or false string))) +(chicken.file#file-exists? (#(procedure #:clean #:enforce) chicken.file#file-exists? (string) (or false string))) +(chicken.file#find-files (#(procedure #:enforce) chicken.file#find-files (string #!rest) list)) +(chicken.file#glob (#(procedure #:clean #:enforce) chicken.file#glob (#!rest string) list)) +(chicken.file#copy-file (#(procedure #:clean #:enforce) chicken.file#copy-file (string string #!optional * fixnum) fixnum)) +(chicken.file#move-file (#(procedure #:clean #:enforce) chicken.file#move-file (string string #!optional * fixnum) fixnum)) +(chicken.file#rename-file (#(procedure #:clean #:enforce) chicken.file#rename-file (string string #!optional *) string)) +(chicken.file#file-readable? (#(procedure #:clean #:enforce) chicken.file#file-readable? (string) boolean)) +(chicken.file#file-writable? (#(procedure #:clean #:enforce) chicken.file#file-writable? (string) boolean)) +(chicken.file#file-executable? (#(procedure #:clean #:enforce) chicken.file#file-executable? (string) boolean)) + + +;; pathname + +(chicken.pathname#absolute-pathname? (#(procedure #:clean #:enforce) chicken.pathname#absolute-pathname? (string) boolean)) +(chicken.pathname#decompose-directory (#(procedure #:clean #:enforce) chicken.pathname#decompose-directory (string) * * *)) +(chicken.pathname#decompose-pathname (#(procedure #:clean #:enforce) chicken.pathname#decompose-pathname (string) * * *)) +(chicken.pathname#directory-null? (#(procedure #:clean #:enforce) chicken.pathname#directory-null? (string) boolean)) +(chicken.pathname#make-absolute-pathname (#(procedure #:clean #:enforce) chicken.pathname#make-absolute-pathname (* #!optional string string) string)) +(chicken.pathname#make-pathname (#(procedure #:clean #:enforce) chicken.pathname#make-pathname ((or string (list-of string) false) #!optional (or string false) (or string false)) string)) +(chicken.pathname#normalize-pathname (#(procedure #:clean #:enforce) chicken.pathname#normalize-pathname (string #!optional symbol) string)) +(chicken.pathname#pathname-directory (#(procedure #:clean #:enforce) chicken.pathname#pathname-directory (string) *)) +(chicken.pathname#pathname-extension (#(procedure #:clean #:enforce) chicken.pathname#pathname-extension (string) *)) +(chicken.pathname#pathname-file (#(procedure #:clean #:enforce) chicken.pathname#pathname-file (string) *)) +(chicken.pathname#pathname-replace-directory (#(procedure #:clean #:enforce) chicken.pathname#pathname-replace-directory (string string) string)) +(chicken.pathname#pathname-replace-extension (#(procedure #:clean #:enforce) chicken.pathname#pathname-replace-extension (string string) string)) +(chicken.pathname#pathname-replace-file (#(procedure #:clean #:enforce) chicken.pathname#pathname-replace-file (string string) string)) +(chicken.pathname#pathname-strip-directory (#(procedure #:clean #:enforce) chicken.pathname#pathname-strip-directory (string) string)) +(chicken.pathname#pathname-strip-extension (#(procedure #:clean #:enforce) chicken.pathname#pathname-strip-extension (string) string)) + +;; irregex + +(chicken.irregex#irregex (#(procedure #:clean) chicken.irregex#irregex (#!rest) (struct regexp))) + +;; Both of these DFA accessors return either #f or a DFA vector. +;; TODO: Should we spec out the entire DFA type layout? It's plenty complex, so we don't +;; want to be specifying this for all procedures accepting a DFA! +;; A DFA looks like a vector of lists; +;; the car of each list is a number (for init-state), false or an alist; +;; the cdr is a list of alists, which contains a char (or vector) and two alists +;; These alists have types themselves, of course... +(chicken.irregex#irregex-dfa (#(procedure #:clean #:enforce) chicken.irregex#irregex-dfa ((struct regexp)) (or false vector)) + (((struct regexp)) (##sys#slot #(1) '1))) + +(chicken.irregex#irregex-dfa/search (#(procedure #:clean #:enforce) chicken.irregex#irregex-dfa/search ((struct regexp)) (or false vector)) + (((struct regexp)) (##sys#slot #(1) '2))) + +;; Procedure type returned by irregex-nfa is a matcher type (it is misnamed) +;; which is another complex procedure type. +(chicken.irregex#irregex-nfa (#(procedure #:clean #:enforce) chicken.irregex#irregex-nfa ((struct regexp)) (or false procedure)) + (((struct regexp)) (##sys#slot #(1) '3))) + +(chicken.irregex#irregex-flags (#(procedure #:clean #:enforce) chicken.irregex#irregex-flags ((struct regexp)) fixnum) + (((struct regexp)) (##sys#slot #(1) '4))) + +(chicken.irregex#irregex-num-submatches (#(procedure #:clean #:enforce) chicken.irregex#irregex-num-submatches ((struct regexp)) + fixnum) + (((struct regexp)) (##sys#slot #(1) '5))) + +(chicken.irregex#irregex-lengths (#(procedure #:clean #:enforce) chicken.irregex#irregex-lengths ((struct regexp)) + (vector-of (or false pair))) + (((struct regexp)) (##sys#slot #(1) '6))) + +;; XXX: Submatch names ought to be symbols according to the docs, but this is +;; not enforced anywhere, so we can't assume it in the return type here. +(chicken.irregex#irregex-names (#(procedure #:clean #:enforce) chicken.irregex#irregex-names ((struct regexp)) + (list-of (pair * fixnum))) + (((struct regexp)) (##sys#slot #(1) '7))) + +;; XXX: specialize these? (how?) +(chicken.irregex#irregex-extract (#(procedure #:clean #:enforce) chicken.irregex#irregex-extract (* string #!optional fixnum fixnum) + (list-of string))) +(chicken.irregex#irregex-split (#(procedure #:clean #:enforce) chicken.irregex#irregex-split (* string #!optional fixnum fixnum) + (list-of string))) + +(chicken.irregex#irregex-fold (forall (a) (#(procedure #:enforce) chicken.irregex#irregex-fold (* (procedure (fixnum (struct regexp-match) a) a) a string #!optional (procedure (fixnum *) *) fixnum fixnum) a))) +;; XXX TODO: chunker is a plain vector +(chicken.irregex#irregex-fold/chunked (forall (a c) (#(procedure #:enforce) chicken.irregex#irregex-fold/chunked (* (procedure (c fixnum (struct regexp-match) a) a) a vector c #!optional (procedure (c fixnum a) a) fixnum fixnum) a))) +(chicken.irregex#irregex-reset-matches! (procedure chicken.irregex#irregex-reset-matches! ((struct regexp-match)) + (struct regexp-match))) + +;; A silly procedure, but at least we can "inline" it like this +(chicken.irregex#irregex-match? (#(procedure #:clean #:enforce) chicken.irregex#irregex-match? (* string #!optional fixnum fixnum) boolean) + ((* string) (if (chicken.irregex#irregex-match #(1) #(2)) '#t '#f)) + ((* string fixnum) (if (chicken.irregex#irregex-match #(1) #(2) #(3)) '#t '#f)) + ((* string fixnum fixnum) (if (chicken.irregex#irregex-match #(1) #(2) #(3) #(4)) '#t '#f))) +;; These two return #f or a match object +(chicken.irregex#irregex-match (#(procedure #:clean #:enforce) chicken.irregex#irregex-match (* string #!optional fixnum fixnum) + (or false (struct regexp-match)))) +;; XXX chunker is a plain vector +;; Not marked clean because we don't know what chunker procedures will do +(chicken.irregex#irregex-match/chunked (#(procedure #:enforce) chicken.irregex#irregex-match/chunked (* vector * #!optional fixnum) + (or false (struct regexp-match)))) + +(chicken.irregex#irregex-match-data? (#(procedure #:pure #:predicate (struct regexp-match)) chicken.irregex#irregex-match-data? (*) boolean)) + +(chicken.irregex#irregex-match-end-index (#(procedure #:clean #:enforce) chicken.irregex#irregex-match-end-index ((struct regexp-match) #!optional *) fixnum)) +(chicken.irregex#irregex-match-end-chunk (#(procedure #:clean #:enforce) chicken.irregex#irregex-match-end-chunk ((struct regexp-match) #!optional *) *)) +(chicken.irregex#irregex-match-start-index (#(procedure #:clean #:enforce) chicken.irregex#irregex-match-start-index ((struct regexp-match) #!optional *) fixnum)) +(chicken.irregex#irregex-match-start-chunk (#(procedure #:clean #:enforce) chicken.irregex#irregex-match-start-chunk ((struct regexp-match) #!optional *) *)) +(chicken.irregex#irregex-match-substring (#(procedure #:clean #:enforce) chicken.irregex#irregex-match-substring ((struct regexp-match) #!optional *) *)) +(chicken.irregex#irregex-match-subchunk (#(procedure #:clean #:enforce) chicken.irregex#irregex-match-subchunk ((struct regexp-match) #!optional *) *)) + +(chicken.irregex#irregex-match-names (#(procedure #:clean #:enforce) chicken.irregex#irregex-match-names ((struct regexp-match)) list) + (((struct regexp-match)) (##sys#slot #(1) '2))) + +(chicken.irregex#irregex-match-num-submatches (#(procedure #:enforce) chicken.irregex#irregex-match-num-submatches ((struct regexp-match)) fixnum) + (((struct regexp-match)) + (chicken.fixnum#fx- (chicken.fixnum#fx/ (##sys#size (##sys#slot #(1) '1)) '4) '2))) + +(chicken.irregex#irregex-new-matches (procedure chicken.irregex#irregex-new-matches (*) *)) ; really only for internal use.. +(chicken.irregex#irregex-opt (#(procedure #:clean #:enforce) chicken.irregex#irregex-opt (list) *)) +(chicken.irregex#irregex-quote (#(procedure #:clean #:enforce) chicken.irregex#irregex-quote (string) string)) + +(chicken.irregex#irregex-replace (#(procedure #:enforce) chicken.irregex#irregex-replace (* string #!rest) string)) +(chicken.irregex#irregex-replace/all (#(procedure #:enforce) chicken.irregex#irregex-replace/all (* string #!rest) string)) +;; Returns a list of strings, but *only* when all user-procedures do +(chicken.irregex#irregex-apply-match (procedure ((struct regexp-match) list) list)) ; internal use + +;; These return #f or a match object +(chicken.irregex#irregex-search (#(procedure #:clean #:enforce) chicken.irregex#irregex-search (* string #!optional fixnum fixnum) + (or false (struct regexp-match)))) +;; XXX chunker is a plain vector +(chicken.irregex#irregex-search/chunked (#(procedure #:enforce) chicken.irregex#irregex-search/chunked (* vector * #!optional fixnum *) + (or false (struct regexp-match)))) +(chicken.irregex#irregex-search/matches (#(procedure #:enforce) chicken.irregex#irregex-search/matches (* vector * * fixnum (struct regexp-match)) + (or false (struct regexp-match)))) +(chicken.irregex#irregex-match-valid-index? + (#(procedure #:clean #:enforce) chicken.irregex#irregex-match-valid-index? ((struct regexp-match) *) boolean)) + +(chicken.irregex#irregex? (#(procedure #:pure #:predicate (struct regexp)) chicken.irregex#irregex? (*) boolean)) + +(chicken.irregex#make-irregex-chunker + (#(procedure #:enforce) chicken.irregex#make-irregex-chunker + ((procedure (*) *) + (procedure (*) *) + #!optional + (procedure (*) *) + (procedure (*) *) + (procedure (* fixnum * fixnum) string) + (procedure (* fixnum * fixnum) *)) + *)) +(chicken.irregex#maybe-string->sre (#(procedure #:clean) chicken.irregex#maybe-string->sre (*) *)) +(chicken.irregex#sre->irregex (#(procedure #:clean) chicken.irregex#sre->irregex (#!rest) *)) +(chicken.irregex#string->irregex (#(procedure #:clean #:enforce) chicken.irregex#string->irregex (string #!rest) *)) +(chicken.irregex#string->sre (#(procedure #:clean #:enforce) chicken.irregex#string->sre (string #!rest) *)) +(chicken.irregex#glob->sre (#(procedure #:clean #:enforce) chicken.irregex#glob->sre (string) (pair symbol *))) + + +;; memory + +(chicken.memory#allocate (#(procedure #:clean #:enforce) chicken.memory#allocate (fixnum) (or false pointer))) +(chicken.memory#free (#(procedure #:clean #:enforce) chicken.memory#free (pointer) undefined)) + +(chicken.memory#address->pointer (#(procedure #:clean #:enforce) chicken.memory#address->pointer (fixnum) pointer) + ((fixnum) (##sys#address->pointer #(1)))) + +(chicken.memory#pointer->address (#(procedure #:clean #:enforce) chicken.memory#pointer->address ((or pointer procedure port locative)) integer) + ((pointer) (##sys#pointer->address #(1)))) + +(chicken.memory#align-to-word (#(procedure #:clean) chicken.memory#align-to-word ((or number pointer locative procedure port)) (or pointer number))) + +(chicken.memory#move-memory! (#(procedure #:enforce) chicken.memory#move-memory! (* * #!optional fixnum fixnum fixnum) *)) + +(chicken.memory#object->pointer (#(procedure #:clean) chicken.memory#object->pointer (*) *)) +(chicken.memory#pointer->object (#(procedure #:clean #:enforce) chicken.memory#pointer->object (pointer) *) + ((pointer) (##core#inline "C_pointer_to_object" #(1)))) + +(chicken.memory#pointer+ (#(procedure #:clean #:enforce) chicken.memory#pointer+ ((or pointer procedure port locative) fixnum) pointer)) +(chicken.memory#pointer? (#(procedure #:clean #:predicate pointer) chicken.memory#pointer? (*) boolean)) +(chicken.memory#pointer=? (#(procedure #:clean #:enforce) chicken.memory#pointer=? ((or pointer locative procedure port) + (or pointer locative procedure port)) boolean) + ((pointer pointer) (##core#inline "C_pointer_eqp" #(1) #(2)))) +(chicken.memory#pointer-like? (#(procedure #:pure #:predicate (or pointer locative procedure port)) chicken.memory#pointer-like? (*) boolean) + (((or pointer locative procedure port)) (let ((#(tmp) #(1))) '#t))) + +(chicken.memory#make-pointer-vector (#(procedure #:clean #:enforce) chicken.memory#make-pointer-vector (fixnum #!optional (or pointer false)) pointer-vector)) +(chicken.memory#pointer-vector (#(procedure #:clean #:enforce) chicken.memory#pointer-vector (#!rest pointer-vector) boolean)) +(chicken.memory#pointer-vector? (#(procedure #:pure #:predicate pointer-vector) chicken.memory#pointer-vector? (*) boolean)) +(chicken.memory#pointer-vector-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-vector-ref (pointer-vector fixnum) (or pointer false))) +(chicken.memory#pointer-vector-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-vector-set! (pointer-vector fixnum (or pointer false)) undefined)) +(chicken.memory#pointer-vector-fill! (#(procedure #:clean #:enforce) chicken.memory#pointer-vector-fill! (pointer-vector (or pointer false)) undefined)) +(chicken.memory#pointer-vector-length (#(procedure #:clean #:enforce) chicken.memory#pointer-vector-length (pointer-vector) fixnum) + ((pointer-vector) (##sys#slot #(1) '1))) + +(chicken.memory#pointer-f32-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-f32-ref (pointer) number)) +(chicken.memory#pointer-f32-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-f32-set! (pointer number) undefined)) +(chicken.memory#pointer-f64-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-f64-ref (pointer) number)) +(chicken.memory#pointer-f64-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-f64-set! (pointer number) undefined)) + +(chicken.memory#pointer-s16-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-s16-ref (pointer) fixnum)) +(chicken.memory#pointer-s16-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-s16-set! (pointer fixnum) undefined)) +(chicken.memory#pointer-s32-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-s32-ref (pointer) integer)) +(chicken.memory#pointer-s32-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-s32-set! (pointer integer) undefined)) +(chicken.memory#pointer-s64-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-s64-ref (pointer) integer)) +(chicken.memory#pointer-s64-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-s64-set! (pointer integer) undefined)) +(chicken.memory#pointer-s8-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-s8-ref (pointer) fixnum)) +(chicken.memory#pointer-s8-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-s8-set! (pointer fixnum) undefined)) + +(chicken.memory#pointer-u16-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-u16-ref (pointer) fixnum)) +(chicken.memory#pointer-u16-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-u16-set! (pointer fixnum) undefined)) +(chicken.memory#pointer-u32-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-u32-ref (pointer) integer)) +(chicken.memory#pointer-u32-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-u32-set! (pointer integer) undefined)) +(chicken.memory#pointer-u64-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-u64-ref (pointer) integer)) +(chicken.memory#pointer-u64-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-u64-set! (pointer integer) undefined)) +(chicken.memory#pointer-u8-ref (#(procedure #:clean #:enforce) chicken.memory#pointer-u8-ref (pointer) fixnum)) +(chicken.memory#pointer-u8-set! (#(procedure #:clean #:enforce) chicken.memory#pointer-u8-set! (pointer fixnum) undefined)) + +(chicken.memory#tag-pointer (#(procedure #:clean #:enforce) chicken.memory#tag-pointer (pointer *) pointer)) +(chicken.memory#tagged-pointer? (#(procedure #:clean #:enforce) chicken.memory#tagged-pointer? (* #!optional *) boolean)) +(chicken.memory#pointer-tag (#(procedure #:clean #:enforce) chicken.memory#pointer-tag ((or pointer locative procedure port)) *) + (((or locative procedure port)) (let ((#(tmp) #(1))) '#f))) + + +;; memory.representation + +(chicken.memory.representation#block-ref (#(procedure #:clean #:enforce) chicken.memory.representation#block-ref (* fixnum) *)) +(chicken.memory.representation#block-set! (#(procedure #:enforce) chicken.memory.representation#block-set! (* fixnum *) *)) +(chicken.memory.representation#extend-procedure (#(procedure #:clean #:enforce) chicken.memory.representation#extend-procedure (procedure *) procedure)) +(chicken.memory.representation#extended-procedure? (#(procedure #:clean) chicken.memory.representation#extended-procedure (*) boolean)) + +(chicken.memory.representation#mutate-procedure! + (#(procedure #:enforce) chicken.memory.representation#mutate-procedure! (procedure (procedure (procedure) . *)) procedure)) + +(chicken.memory.representation#number-of-bytes (#(procedure #:clean) chicken.memory.representation#number-of-bytes (*) fixnum) + (((or blob string)) (##sys#size #(1))) + (((or port procedure symbol keyword pair vector locative float pointer-vector)) + ;; would be applicable to all structure types, but we can't specify + ;; "(struct *)" (yet) + (##core#inline "C_bytes" (##sys#size #(1))))) + +(chicken.memory.representation#number-of-slots (#(procedure #:clean #:foldable) chicken.memory.representation#number-of-slots (*) fixnum) + (((or vector symbol keyword pair)) (##sys#size #(1)))) + +(chicken.memory.representation#object-become! (procedure chicken.memory.representation#object-become! (list) *)) +(chicken.memory.representation#object-copy (#(procedure #:clean) chicken.memory.representation#object-copy (*) *)) +(chicken.memory.representation#procedure-data (#(procedure #:clean #:enforce) chicken.memory.representation#procedure-data (procedure) *)) +(chicken.memory.representation#record->vector (#(procedure #:clean) chicken.memory.representation#record->vector (*) vector)) + +(chicken.memory.representation#make-record-instance (#(procedure #:clean) chicken.memory.representation#make-record-instance (symbol #!rest) *)) +(chicken.memory.representation#record-instance? (#(procedure #:clean) chicken.memory.representation#record-instance? (* #!optional symbol) boolean) + ((* symbol) (##sys#structure? #(1) #(2))) + ((*) (let ((#(tmp) #(1))) + (if (##sys#immediate? #(tmp)) + '#f + (##sys#generic-structure? #(tmp)))))) + +(chicken.memory.representation#record-instance-length (#(procedure #:clean) chicken.memory.representation#record-instance-length (*) fixnum)) +(chicken.memory.representation#record-instance-slot (#(procedure #:clean #:enforce) chicken.memory.representation#record-instance-slot (* fixnum) *)) +(chicken.memory.representation#record-instance-slot-set! (#(procedure #:clean #:enforce) chicken.memory.representation#record-instance-slot-set! (* fixnum *) undefined)) +(chicken.memory.representation#record-instance-type (#(procedure #:clean) chicken.memory.representation#record-instance-type (*) *)) +(chicken.memory.representation#set-procedure-data! (#(procedure #:clean #:enforce) chicken.memory.representation#set-procedure-data! (procedure *) undefined)) + +;; locative + +(chicken.locative#locative->object (#(procedure #:clean #:enforce) chicken.locative#locative->object (locative) *)) +(chicken.locative#locative-ref (#(procedure #:clean #:enforce) chicken.locative#locative-ref (locative) *) + ((locative) (##core#inline_allocate ("C_a_i_locative_ref" 6) #(1)))) +(chicken.locative#locative-set! (#(procedure #:enforce) chicken.locative#locative-set! (locative *) *)) +(chicken.locative#locative? (#(procedure #:pure #:predicate locative) chicken.locative#locative? (*) boolean)) +(chicken.locative#make-locative (#(procedure #:clean #:enforce) chicken.locative#make-locative (* #!optional fixnum) locative)) +(chicken.locative#make-weak-locative (#(procedure #:clean #:enforce) chicken.locative#make-weak-locative (* #!optional fixnum) locative)) + +;; port + +(chicken.port#call-with-input-string (#(procedure #:enforce) chicken.port#call-with-input-string (string (procedure (input-port) . *)) . *)) +(chicken.port#call-with-output-string (#(procedure #:enforce) chicken.port#call-with-output-string ((procedure (output-port) . *)) string)) +(chicken.port#copy-port (#(procedure #:enforce) chicken.port#copy-port (* * #!optional (procedure (*) *) (procedure (* output-port) *)) undefined)) +(chicken.port#make-input-port (#(procedure #:clean #:enforce) chicken.port#make-input-port ((procedure () (or char eof)) (procedure () *) (procedure () . *) #!optional * * * *) input-port)) +(chicken.port#make-output-port (#(procedure #:clean #:enforce) chicken.port#make-output-port ((procedure (string) . *) (procedure () . *) #!optional (procedure () . *)) output-port)) +(chicken.port#port-for-each (#(procedure #:enforce) chicken.port#port-for-each ((procedure (*) *) (procedure () . *)) undefined)) + +(chicken.port#port-map + (forall (a b) (#(procedure #:enforce) chicken.port#port-map ((procedure (a) b) (procedure () a)) (list-of b)))) + +(chicken.port#port-fold (#(procedure #:enforce) chicken.port#port-fold ((procedure (* *) *) * (procedure () *)) *)) +(chicken.port#port-position (#(procedure #:clean #:enforce) chicken.port#port-position (#!optional port) fixnum fixnum)) +(chicken.port#make-bidirectional-port (#(procedure #:clean #:enforce) chicken.port#make-bidirectional-port (input-port output-port) (refine (input output) port))) +(chicken.port#make-broadcast-port (#(procedure #:clean #:enforce) chicken.port#make-broadcast-port (#!rest output-port) output-port)) +(chicken.port#make-concatenated-port (#(procedure #:clean #:enforce) chicken.port#make-concatenated-port (port #!rest input-port) input-port)) +(chicken.port#set-buffering-mode! (#(procedure #:clean #:enforce) chicken.port#set-buffering-mode! (port keyword #!optional fixnum) undefined)) +(chicken.port#with-error-output-to-port (#(procedure #:enforce) chicken.port#with-error-output-to-port (output-port (procedure () . *)) . *)) +(chicken.port#with-input-from-port (#(procedure #:enforce) chicken.port#with-input-from-port (input-port (procedure () . *)) . *)) +(chicken.port#with-input-from-string (#(procedure #:enforce) chicken.port#with-input-from-string (string (procedure () . *)) . *)) +(chicken.port#with-output-to-port (#(procedure #:enforce) chicken.port#with-output-to-port (output-port (procedure () . *)) . *)) +(chicken.port#with-output-to-string (#(procedure #:enforce) chicken.port#with-output-to-string ((procedure () . *)) string)) +(chicken.port#with-error-output-to-string (#(procedure #:enforce) chicken.port#with-error-output-to-string ((procedure () . *)) string)) + +(chicken.port#port-name + (#(procedure #:clean #:enforce) chicken.port#port-name (#!optional port) *) + ((port) (##sys#slot #(1) '3))) + +(chicken.port#set-port-name! + (#(procedure #:clean #:enforce) chicken.port#set-port-name! (port string) undefined) + ((port string) (##sys#setslot #(1) '3 #(2)))) + +(chicken.port#terminal-name (#(procedure #:clean #:enforce) chicken.port#terminal-name (port) string)) +(chicken.port#terminal-port? (#(procedure #:clean #:enforce) chicken.port#terminal-port? (port) boolean)) +(chicken.port#terminal-size (#(procedure #:clean #:enforce) chicken.port#terminal-size (port) fixnum fixnum)) + +;; errno + +(chicken.errno#errno (#(procedure #:clean) chicken.errno#errno () fixnum)) +(chicken.errno#errno/2big fixnum) +(chicken.errno#errno/acces fixnum) +(chicken.errno#errno/again fixnum) +(chicken.errno#errno/badf fixnum) +(chicken.errno#errno/busy fixnum) +(chicken.errno#errno/child fixnum) +(chicken.errno#errno/deadlk fixnum) +(chicken.errno#errno/dom fixnum) +(chicken.errno#errno/exist fixnum) +(chicken.errno#errno/fault fixnum) +(chicken.errno#errno/fbig fixnum) +(chicken.errno#errno/ilseq fixnum) +(chicken.errno#errno/intr fixnum) +(chicken.errno#errno/inval fixnum) +(chicken.errno#errno/io fixnum) +(chicken.errno#errno/isdir fixnum) +(chicken.errno#errno/mfile fixnum) +(chicken.errno#errno/mlink fixnum) +(chicken.errno#errno/nametoolong fixnum) +(chicken.errno#errno/nfile fixnum) +(chicken.errno#errno/nodev fixnum) +(chicken.errno#errno/noent fixnum) +(chicken.errno#errno/noexec fixnum) +(chicken.errno#errno/nolck fixnum) +(chicken.errno#errno/nomem fixnum) +(chicken.errno#errno/nospc fixnum) +(chicken.errno#errno/nosys fixnum) +(chicken.errno#errno/notdir fixnum) +(chicken.errno#errno/notempty fixnum) +(chicken.errno#errno/notty fixnum) +(chicken.errno#errno/nxio fixnum) +(chicken.errno#errno/perm fixnum) +(chicken.errno#errno/pipe fixnum) +(chicken.errno#errno/range fixnum) +(chicken.errno#errno/rofs fixnum) +(chicken.errno#errno/spipe fixnum) +(chicken.errno#errno/srch fixnum) +(chicken.errno#errno/wouldblock fixnum) +(chicken.errno#errno/xdev fixnum) + +;; process-context + +(chicken.process-context#argc+argv (#(procedure #:clean) chicken.process-context#argc+argv () fixnum pointer)) +(chicken.process-context#argv (#(procedure #:clean) chicken.process-context#argv () (list-of string))) +(chicken.process-context#change-directory (#(procedure #:clean #:enforce) chicken.process-context#change-directory (string) string)) +(chicken.process-context#command-line-arguments (#(procedure #:clean) chicken.process-context#command-line-arguments (#!optional (list-of string)) (list-of string))) +(chicken.process-context#current-directory (#(procedure #:clean #:enforce) chicken.process-context#current-directory () string)) +(chicken.process-context#executable-pathname (#(procedure #:pure) chicken.process-context#executable-pathname () (or string false))) +(chicken.process-context#get-environment-variable (#(procedure #:clean #:enforce) chicken.process-context#get-environment-variable (string) *)) +(chicken.process-context#get-environment-variables (#(procedure #:clean) chicken.process-context#get-environment-variables () (list-of (pair string string)))) +(chicken.process-context#program-name (#(procedure #:clean #:enforce) chicken.process-context#program-name (#!optional string) string)) +(chicken.process-context#set-environment-variable! (#(procedure #:clean #:enforce) chicken.process-context#set-environment-variable! (string string) undefined)) +(chicken.process-context#unset-environment-variable! (#(procedure #:clean #:enforce) chicken.process-context#unset-environment-variable! (string) undefined)) + +;; process-context.posix + +(chicken.process-context.posix#change-directory* (#(procedure #:clean #:enforce) chicken.process-context.posix#change-directory* (fixnum) fixnum)) +(chicken.process-context.posix#create-session (#(procedure #:clean) chicken.process-context.posix#create-session () fixnum)) + +(chicken.process-context.posix#current-effective-group-id (#(procedure #:clean) chicken.process-context.posix#current-effective-group-id () fixnum)) +(chicken.process-context.posix#current-effective-user-id (#(procedure #:clean) chicken.process-context.posix#current-effective-user-id () fixnum)) +(chicken.process-context.posix#current-effective-user-name (#(procedure #:clean) chicken.process-context.posix#current-effective-user-name () string)) +(chicken.process-context.posix#current-group-id (#(procedure #:clean) chicken.process-context.posix#current-group-id () fixnum)) +(chicken.process-context.posix#current-user-id (#(procedure #:clean) chicken.process-context.posix#current-user-id () fixnum)) +(chicken.process-context.posix#current-user-name (#(procedure #:clean) chicken.process-context.posix#current-user-name () string)) +(chicken.process-context.posix#current-process-id (#(procedure #:clean) chicken.process-context.posix#current-process-id () fixnum)) +(chicken.process-context.posix#parent-process-id (#(procedure #:clean) chicken.process-context.posix#parent-process-id () fixnum)) + +(chicken.process-context.posix#process-group-id (#(procedure #:clean #:enforce) chicken.process-context.posix#process-group-id () fixnum)) +(chicken.process-context.posix#set-root-directory! (#(procedure #:clean #:enforce) chicken.process-context.posix#set-root-directory! (string) undefined)) +(chicken.process-context.posix#user-information (#(procedure #:clean #:enforce) chicken.process-context.posix#user-information ((or string fixnum) #!optional *) *)) + + +;; file.posix + +(chicken.file.posix#create-fifo (#(procedure #:clean #:enforce) chicken.file.posix#create-fifo (string #!optional fixnum) undefined)) +(chicken.file.posix#create-symbolic-link (#(procedure #:clean #:enforce) chicken.file.posix#create-symbolic-link (string string) undefined)) +(chicken.file.posix#read-symbolic-link (#(procedure #:clean #:enforce) chicken.file.posix#read-symbolic-link (string #!optional boolean) string)) +(chicken.file.posix#duplicate-fileno (#(procedure #:clean #:enforce) chicken.file.posix#duplicate-fileno (fixnum #!optional fixnum) fixnum)) + +(chicken.file.posix#fcntl/dupfd fixnum) +(chicken.file.posix#fcntl/getfd fixnum) +(chicken.file.posix#fcntl/getfl fixnum) +(chicken.file.posix#fcntl/setfd fixnum) +(chicken.file.posix#fcntl/setfl fixnum) + +(chicken.file.posix#file-access-time (#(procedure #:clean #:enforce) chicken.file.posix#file-access-time ((or string port fixnum)) integer)) +(chicken.file.posix#file-change-time (#(procedure #:clean #:enforce) chicken.file.posix#file-change-time ((or string port fixnum)) integer)) +(chicken.file.posix#file-modification-time (#(procedure #:clean #:enforce) chicken.file.posix#file-modification-time ((or string fixnum port)) integer)) +(chicken.file.posix#file-close (#(procedure #:clean #:enforce) chicken.file.posix#file-close (fixnum) undefined)) +(chicken.file.posix#file-control (#(procedure #:clean #:enforce) chicken.file.posix#file-control (fixnum fixnum #!optional fixnum) fixnum)) +(chicken.file.posix#file-creation-mode (#(procedure #:clean #:enforce) chicken.file.posix#file-creation-mode (#!optional fixnum) fixnum)) +(chicken.file.posix#file-group (#(procedure #:clean #:enforce) chicken.file.posix#file-owner ((or string fixnum port)) fixnum)) +(chicken.file.posix#file-link (#(procedure #:clean #:enforce) chicken.file.posix#file-link (string string) undefined)) +(chicken.file.posix#file-lock (#(procedure #:clean #:enforce) chicken.file.posix#file-lock (port #!optional fixnum integer) (struct lock))) +(chicken.file.posix#file-lock/blocking (#(procedure #:clean #:enforce) chicken.file.posix#file-lock/blocking (port #!optional fixnum integer) (struct lock))) +(chicken.file.posix#file-mkstemp (#(procedure #:clean #:enforce) chicken.file.posix#file-mkstemp (string) fixnum string)) +(chicken.file.posix#file-open (#(procedure #:clean #:enforce) chicken.file.posix#file-open (string fixnum #!optional fixnum) fixnum)) +(chicken.file.posix#file-owner (#(procedure #:clean #:enforce) chicken.file.posix#file-owner ((or string fixnum port)) fixnum)) +(chicken.file.posix#file-permissions (#(procedure #:clean #:enforce) chicken.file.posix#file-permissions ((or string fixnum port)) fixnum)) +(chicken.file.posix#file-position (#(procedure #:clean #:enforce) chicken.file.posix#file-position ((or port fixnum)) integer)) +(chicken.file.posix#file-read (#(procedure #:clean #:enforce) chicken.file.posix#file-read (fixnum fixnum #!optional *) list)) +(chicken.file.posix#file-select (#(procedure #:clean #:enforce) chicken.file.posix#file-select ((or (list-of fixnum) fixnum false) (or (list-of fixnum) fixnum false) #!optional fixnum) * *)) +(chicken.file.posix#file-size (#(procedure #:clean #:enforce) chicken.file.posix#file-size ((or string fixnum port)) integer)) +(chicken.file.posix#file-stat (#(procedure #:clean #:enforce) chicken.file.posix#file-stat ((or string fixnum port) #!optional *) (vector-of integer))) +(chicken.file.posix#file-test-lock (#(procedure #:clean #:enforce) chicken.file.posix#file-test-lock (port #!optional fixnum *) boolean)) +(chicken.file.posix#file-truncate (#(procedure #:clean #:enforce) chicken.file.posix#file-truncate ((or string fixnum output-port) integer) undefined)) +(chicken.file.posix#file-unlock (#(procedure #:clean #:enforce) chicken.file.posix#file-unlock ((struct lock)) undefined)) +(chicken.file.posix#file-write (#(procedure #:clean #:enforce) chicken.file.posix#file-write (fixnum * #!optional fixnum) fixnum)) +(chicken.file.posix#file-type (#(procedure #:clean #:enforce) chicken.file.posix#file-type ((or string fixnum port) #!optional * *) symbol)) + +(chicken.file.posix#block-device? (#(procedure #:clean #:enforce) chicken.file.posix#block-device? ((or string fixnum port)) boolean)) +(chicken.file.posix#character-device? (#(procedure #:clean #:enforce) chicken.file.posix#character-device? ((or string fixnum port)) boolean)) +(chicken.file.posix#directory? (#(procedure #:clean #:enforce) chicken.file.posix#directory? ((or string fixnum port)) boolean)) +(chicken.file.posix#fifo? (#(procedure #:clean #:enforce) chicken.file.posix#fifo? ((or string fixnum port)) boolean)) +(chicken.file.posix#regular-file? (#(procedure #:clean #:enforce) chicken.file.posix#regular-file? ((or string fixnum port)) boolean)) +(chicken.file.posix#socket? (#(procedure #:clean #:enforce) chicken.file.posix#socket? ((or string fixnum port)) boolean)) +(chicken.file.posix#symbolic-link? (#(procedure #:clean #:enforce) chicken.file.posix#symbolic-link? ((or string fixnum port)) boolean)) + +(chicken.file.posix#fileno/stderr fixnum) +(chicken.file.posix#fileno/stdin fixnum) +(chicken.file.posix#fileno/stdout fixnum) + +(chicken.file.posix#open-input-file* (#(procedure #:clean #:enforce) chicken.file.posix#open-input-file* (fixnum #!optional keyword) input-port)) +(chicken.file.posix#open-output-file* (#(procedure #:clean #:enforce) chicken.file.posix#open-output-file* (fixnum #!optional keyword) output-port)) + +(chicken.file.posix#open/append fixnum) +(chicken.file.posix#open/binary fixnum) +(chicken.file.posix#open/creat fixnum) +(chicken.file.posix#open/excl fixnum) +(chicken.file.posix#open/fsync fixnum) +(chicken.file.posix#open/noctty fixnum) +(chicken.file.posix#open/noinherit fixnum) +(chicken.file.posix#open/nonblock fixnum) +(chicken.file.posix#open/rdonly fixnum) +(chicken.file.posix#open/rdwr fixnum) +(chicken.file.posix#open/read fixnum) +(chicken.file.posix#open/sync fixnum) +(chicken.file.posix#open/text fixnum) +(chicken.file.posix#open/trunc fixnum) +(chicken.file.posix#open/write fixnum) +(chicken.file.posix#open/wronly fixnum) + +(chicken.file.posix#perm/irgrp fixnum) +(chicken.file.posix#perm/iroth fixnum) +(chicken.file.posix#perm/irusr fixnum) +(chicken.file.posix#perm/irwxg fixnum) +(chicken.file.posix#perm/irwxo fixnum) +(chicken.file.posix#perm/irwxu fixnum) +(chicken.file.posix#perm/isgid fixnum) +(chicken.file.posix#perm/isuid fixnum) +(chicken.file.posix#perm/isvtx fixnum) +(chicken.file.posix#perm/iwgrp fixnum) +(chicken.file.posix#perm/iwoth fixnum) +(chicken.file.posix#perm/iwusr fixnum) +(chicken.file.posix#perm/ixgrp fixnum) +(chicken.file.posix#perm/ixoth fixnum) +(chicken.file.posix#perm/ixusr fixnum) + +(chicken.file.posix#port->fileno (#(procedure #:clean #:enforce) chicken.file.posix#port->fileno (port) fixnum)) + +(chicken.file.posix#seek/cur fixnum) +(chicken.file.posix#seek/end fixnum) +(chicken.file.posix#seek/set fixnum) + +(chicken.file.posix#set-file-group! (#(procedure #:clean #:enforce) chicken.file.posix#set-file-group! ((or string fixnum port) fixnum) undefined)) +(chicken.file.posix#set-file-owner! (#(procedure #:clean #:enforce) chicken.file.posix#set-file-owner! ((or string fixnum port) fixnum) undefined)) +(chicken.file.posix#set-file-permissions! (#(procedure #:clean #:enforce) chicken.file.posix#set-file-permissions! ((or string fixnum port) fixnum) undefined)) +(chicken.file.posix#set-file-position! (#(procedure #:clean #:enforce) chicken.file.posix#set-file-position! ((or port fixnum) integer #!optional fixnum) undefined)) +(chicken.file.posix#set-file-times! (#(procedure #:clean #:enforce) chicken.file.posix#set-file-times! (string #!optional (or false integer) (or false integer)) undefined)) + + +;; time.posix + +(chicken.time.posix#seconds->local-time (#(procedure #:clean #:enforce) chicken.time.posix#seconds->local-time (#!optional integer) (vector fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum boolean fixnum))) +(chicken.time.posix#seconds->string (#(procedure #:clean #:enforce) chicken.time.posix#seconds->string (#!optional integer) string)) +(chicken.time.posix#seconds->utc-time (#(procedure #:clean #:enforce) chicken.time.posix#seconds->utc-time (#!optional integer) (vector fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum boolean fixnum))) +(chicken.time.posix#utc-time->seconds (#(procedure #:clean #:enforce) chicken.time.posix#utc-time->seconds ((vector fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum boolean fixnum)) integer)) +(chicken.time.posix#local-time->seconds (#(procedure #:clean #:enforce) chicken.time.posix#local-time->seconds ((vector fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum boolean fixnum)) integer)) +(chicken.time.posix#local-timezone-abbreviation (#(procedure #:clean) chicken.time.posix#local-timezone-abbreviation () string)) +(chicken.time.posix#string->time (#(procedure #:clean #:enforce) chicken.time.posix#string->time (string #!optional string) (vector fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum boolean fixnum))) +(chicken.time.posix#time->string (#(procedure #:clean #:enforce) chicken.time.posix#time->string ((vector fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum boolean fixnum) #!optional string) string)) + +;; process + +(chicken.process#process-execute + (#(procedure #:clean #:enforce) chicken.process#process-execute (string #!optional (list-of string) (list-of (pair string string)) fixnum) noreturn)) +(chicken.process#process-fork (#(procedure #:enforce) chicken.process#process-fork (#!optional (or (procedure () . *) false) *) fixnum)) +(chicken.process#qs (#(procedure #:clean #:enforce) chicken.process#qs (string #!optional symbol) string)) +(chicken.process#process-run (#(procedure #:clean #:enforce) chicken.process#process-run (string #!optional (list-of string)) fixnum)) +(chicken.process#process-signal (#(procedure #:clean #:enforce) chicken.process#process-signal (fixnum #!optional fixnum) undefined)) +(chicken.process#process-spawn + (#(procedure #:clean #:enforce) chicken.process#process-spawn (fixnum string #!optional (list-of string) (list-of (pair string string)) boolean) fixnum)) +(chicken.process#system (#(procedure #:clean #:enforce) chicken.process#system (string) fixnum)) +(chicken.process#system* (#(procedure #:clean #:enforce) chicken.process#system* (string) undefined)) +(chicken.process#process (#(procedure #:clean #:enforce) chicken.process#process (string #!optional (list-of string) (list-of (pair string string)) boolean) input-port output-port fixnum)) +(chicken.process#process* (#(procedure #:clean #:enforce) chicken.process#process* (string #!optional (list-of string) (list-of (pair string string)) boolean) input-port output-port fixnum *)) +(chicken.process#process-wait (#(procedure #:clean #:enforce) chicken.process#process-wait (#!optional fixnum *) fixnum fixnum fixnum)) +(chicken.process#process-sleep (#(procedure #:clean #:enforce) chicken.process#process-sleep (fixnum) fixnum)) +(chicken.process#call-with-input-pipe (#(procedure #:enforce) chicken.process#call-with-input-pipe (string (procedure (input-port) . *) #!optional keyword) . *)) +(chicken.process#call-with-output-pipe (#(procedure #:enforce) chicken.process#call-with-output-pipe (string (procedure (input-port) . *) #!optional keyword) . *)) +(chicken.process#close-input-pipe (#(procedure #:clean #:enforce) chicken.process#close-input-pipe (input-port) fixnum)) +(chicken.process#close-output-pipe (#(procedure #:clean #:enforce) chicken.process#close-output-pipe (output-port) fixnum)) +(chicken.process#create-pipe (procedure chicken.process#create-pipe (#!optional fixnum) fixnum fixnum)) +(chicken.process#open-input-pipe (#(procedure #:clean #:enforce) chicken.process#open-input-pipe (string #!optional keyword) input-port)) +(chicken.process#open-output-pipe (#(procedure #:clean #:enforce) chicken.process#open-output-pipe (string #!optional keyword) output-port)) +(chicken.process#with-input-from-pipe (#(procedure #:enforce) chicken.process#with-input-from-pipe (string (procedure () . *) #!optional keyword) . *)) +(chicken.process#with-output-to-pipe (#(procedure #:enforce) chicken.process#with-output-to-pipe (string (procedure () . *) #!optional keyword) . *)) + +(chicken.process#pipe/buf fixnum) +(chicken.process#spawn/overlay fixnum) +(chicken.process#spawn/wait fixnum) +(chicken.process#spawn/nowait fixnum) +(chicken.process#spawn/nowaito fixnum) +(chicken.process#spawn/detach fixnum) + + +;; process.signal + +(chicken.process.signal#set-alarm! (#(procedure #:clean #:enforce) chicken.process#set-alarm! (integer) integer)) +(chicken.process.signal#set-signal-handler! (#(procedure #:clean #:enforce) chicken.process.signal#set-signal-handler! (fixnum (or false (procedure (fixnum) . *))) undefined)) +(chicken.process.signal#set-signal-mask! (#(procedure #:clean #:enforce) chicken.process.signal#set-signal-mask! ((list-of fixnum)) undefined)) +(chicken.process.signal#signal-handler (#(procedure #:clean #:enforce) chicken.process.signal#signal-handler (fixnum) (or false (procedure (fixnum) . *)))) +(chicken.process.signal#signal-mask (#(procedure #:clean) chicken.process.signal#signal-mask () fixnum)) +(chicken.process.signal#signal-mask! (#(procedure #:clean #:enforce) chicken.process.signal#signal-mask! (fixnum) undefined)) +(chicken.process.signal#signal-masked? (#(procedure #:clean #:enforce) chicken.process.signal#signal-masked? (fixnum) boolean)) +(chicken.process.signal#signal-unmask! (#(procedure #:clean #:enforce) chicken.process.signal#signal-unmask! (fixnum) undefined)) + +(chicken.process.signal#signal/abrt fixnum) +(chicken.process.signal#signal/alrm fixnum) +(chicken.process.signal#signal/chld fixnum) +(chicken.process.signal#signal/cont fixnum) +(chicken.process.signal#signal/fpe fixnum) +(chicken.process.signal#signal/hup fixnum) +(chicken.process.signal#signal/ill fixnum) +(chicken.process.signal#signal/int fixnum) +(chicken.process.signal#signal/io fixnum) +(chicken.process.signal#signal/bus fixnum) +(chicken.process.signal#signal/kill fixnum) +(chicken.process.signal#signal/pipe fixnum) +(chicken.process.signal#signal/prof fixnum) +(chicken.process.signal#signal/quit fixnum) +(chicken.process.signal#signal/segv fixnum) +(chicken.process.signal#signal/stop fixnum) +(chicken.process.signal#signal/term fixnum) +(chicken.process.signal#signal/trap fixnum) +(chicken.process.signal#signal/tstp fixnum) +(chicken.process.signal#signal/urg fixnum) +(chicken.process.signal#signal/usr1 fixnum) +(chicken.process.signal#signal/usr2 fixnum) +(chicken.process.signal#signal/vtalrm fixnum) +(chicken.process.signal#signal/winch fixnum) +(chicken.process.signal#signal/xcpu fixnum) +(chicken.process.signal#signal/xfsz fixnum) +(chicken.process.signal#signals-list (list-of fixnum)) + + +;; sort + +(chicken.sort#merge + (forall (e) + (#(procedure #:enforce) chicken.sort#merge ((list-of e) (list-of e) (procedure (e e) *)) (list-of e)))) + +(chicken.sort#merge! + (forall (e) + (#(procedure #:enforce) chicken.sort#merge! ((list-of e) (list-of e) (procedure (e e) *)) (list-of e)))) + +(chicken.sort#sort + (forall (e (s (or (vector-of e) (list-of e)))) + (#(procedure #:enforce) + chicken.sort#sort + (s (procedure (e e) *)) + s))) + +(chicken.sort#sort! + (forall (e (s (or (vector-of e) (list-of e)))) + (#(procedure #:enforce) + chicken.sort#sort! + (s (procedure (e e) *)) + s))) + +(chicken.sort#sorted? (#(procedure #:enforce) chicken.sort#sorted? ((or list vector) (procedure (* *) *)) boolean)) +(chicken.sort#topological-sort (#(procedure #:enforce) chicken.sort#topological-sort ((list-of list) (procedure (* *) *)) list)) + + +;; srfi-4 + +(srfi-4#blob->f32vector (#(procedure #:clean #:enforce) srfi-4#blob->f32vector (blob) (struct f32vector))) +(srfi-4#blob->f32vector/shared (#(procedure #:clean #:enforce) srfi-4#blob->f32vector/shared (blob) (struct f32vector))) +(srfi-4#blob->f64vector (#(procedure #:clean #:enforce) srfi-4#blob->f64vector (blob) (struct f64vector))) +(srfi-4#blob->f64vector/shared (#(procedure #:clean #:enforce) srfi-4#blob->f64vector/shared (blob) (struct f64vector))) +(srfi-4#blob->s16vector (#(procedure #:clean #:enforce) srfi-4#blob->s16vector (blob) (struct s16vector))) +(srfi-4#blob->s16vector/shared (#(procedure #:clean #:enforce) srfi-4#blob->s16vector/shared (blob) (struct s16vector))) +(srfi-4#blob->s32vector (#(procedure #:clean #:enforce) srfi-4#blob->s32vector (blob) (struct s32vector))) +(srfi-4#blob->s32vector/shared (#(procedure #:clean #:enforce) srfi-4#blob->s32vector/shared (blob) (struct s32vector))) +(srfi-4#blob->s8vector (#(procedure #:clean #:enforce) srfi-4#blob->s8vector (blob) (struct s8vector))) +(srfi-4#blob->s8vector/shared (#(procedure #:clean #:enforce) srfi-4#blob->s8vector/shared (blob) (struct s8vector))) +(srfi-4#blob->u16vector (#(procedure #:clean #:enforce) srfi-4#blob->u16vector (blob) (struct u16vector))) +(srfi-4#blob->u16vector/shared (#(procedure #:clean #:enforce) srfi-4#blob->u16vector/shared (blob) (struct u16vector))) +(srfi-4#blob->u32vector (#(procedure #:clean #:enforce) srfi-4#blob->u32vector (blob) (struct u32vector))) +(srfi-4#blob->u32vector/shared (#(procedure #:clean #:enforce) srfi-4#blob->u32vector/shared (blob) (struct u32vector))) +(srfi-4#blob->u64vector (#(procedure #:clean #:enforce) srfi-4#blob->u64vector (blob) (struct u64vector))) +(srfi-4#blob->u64vector/shared (#(procedure #:clean #:enforce) srfi-4#blob->u64vector/shared (blob) (struct u64vector))) +(srfi-4#blob->u8vector (#(procedure #:clean #:enforce) blob->u8vector (blob) (struct u8vector))) +(srfi-4#blob->u8vector/shared (#(procedure #:clean #:enforce) srfi-4#blob->u8vector/shared (blob) (struct u8vector))) +(srfi-4#f32vector (#(procedure #:clean #:enforce) srfi-4#f32vector (#!rest (or integer float)) (struct f32vector))) +(srfi-4#f32vector->blob (#(procedure #:clean #:enforce) srfi-4#f32vector->blob ((struct f32vector)) blob)) +(srfi-4#f32vector->blob/shared (#(procedure #:clean #:enforce) srfi-4#f32vector->blob/shared ((struct f32vector)) blob)) +(srfi-4#f32vector->list (#(procedure #:clean #:enforce) srfi-4#f32vector->list ((struct f32vector)) (list-of float))) + +(srfi-4#f32vector-length (#(procedure #:clean #:enforce) srfi-4#f32vector-length ((struct f32vector)) fixnum) + (((struct f32vector)) (##core#inline "C_u_i_32vector_length" #(1)))) + +(srfi-4#f32vector-ref (#(procedure #:clean #:enforce) srfi-4#f32vector-ref ((struct f32vector) fixnum) float)) +(srfi-4#f32vector-set! (#(procedure #:clean #:enforce) srfi-4#f32vector-set! ((struct f32vector) fixnum (or integer float)) undefined)) + +(srfi-4#f32vector? (#(procedure #:pure #:predicate (struct f32vector)) srfi-4#f32vector? (*) boolean)) + +(srfi-4#f64vector (#(procedure #:clean #:enforce) srfi-4#f64vector (#!rest (or integer float)) (struct f64vector))) +(srfi-4#f64vector->blob (#(procedure #:clean #:enforce) srfi-4#f64vector->blob ((struct f64vector)) blob)) +(srfi-4#f64vector->blob/shared (#(procedure #:clean #:enforce) srfi-4#f64vector->blob/shared ((struct f64vector)) blob)) +(srfi-4#f64vector->list (#(procedure #:clean #:enforce) srfi-4#f64vector->list ((struct f64vector)) (list-of float))) + +(srfi-4#f64vector-length (#(procedure #:clean #:enforce) srfi-4#f64vector-length ((struct f64vector)) fixnum) + (((struct f64vector)) (##core#inline "C_u_i_64vector_length" #(1)))) + +(srfi-4#f64vector-ref (#(procedure #:clean #:enforce) srfi-4#f64vector-ref ((struct f64vector) fixnum) float)) +(srfi-4#f64vector-set! (#(procedure #:clean #:enforce) srfi-4#f64vector-set! ((struct f64vector) fixnum (or integer float)) undefined)) + +(srfi-4#f64vector? (#(procedure #:pure #:predicate (struct f64vector)) srfi-4#f64vector? (*) boolean)) + +(srfi-4#list->f32vector (#(procedure #:clean #:enforce) srfi-4#list->f32vector ((list-of (or float integer))) (struct f32vector))) +(srfi-4#list->f64vector (#(procedure #:clean #:enforce) srfi-4#list->f64vector ((list-of (or float integer))) (struct f64vector))) +(srfi-4#list->s16vector (#(procedure #:clean #:enforce) srfi-4#list->s16vector ((list-of fixnum)) (struct s16vector))) +(srfi-4#list->s32vector (#(procedure #:clean #:enforce) srfi-4#list->s32vector ((list-of integer)) (struct s32vector))) +(srfi-4#list->s8vector (#(procedure #:clean #:enforce) srfi-4#list->s8vector ((list-of fixnum)) (struct s8vector))) +(srfi-4#list->u16vector (#(procedure #:clean #:enforce) srfi-4#list->u16vector ((list-of fixnum)) (struct u16vector))) +(srfi-4#list->u32vector (#(procedure #:clean #:enforce) srfi-4#list->u32vector ((list-of integer)) (struct u32vector))) +(srfi-4#list->u64vector (#(procedure #:clean #:enforce) srfi-4#list->u64vector ((list-of integer)) (struct u64vector))) +(srfi-4#list->u8vector (#(procedure #:clean #:enforce) srfi-4#list->u8vector ((list-of fixnum)) (struct u8vector))) +(srfi-4#make-f32vector (#(procedure #:clean #:enforce) srfi-4#make-f32vector (fixnum #!optional (or integer float false) boolean boolean) (struct f32vector))) +(srfi-4#make-f64vector (#(procedure #:clean #:enforce) srfi-4#make-f64vector (fixnum #!optional (or integer float false) boolean) (struct f64vector))) +(srfi-4#make-s16vector (#(procedure #:clean #:enforce) srfi-4#make-s16vector (fixnum #!optional (or fixnum false) boolean boolean) (struct s16vector))) +(srfi-4#make-s32vector (#(procedure #:clean #:enforce) srfi-4#make-s32vector (fixnum #!optional (or integer false) boolean boolean) (struct s32vector))) +(srfi-4#make-s8vector (#(procedure #:clean #:enforce) srfi-4#make-s8vector (fixnum #!optional (or fixnum false) boolean boolean) (struct s8vector))) +(srfi-4#make-u16vector (#(procedure #:clean #:enforce) srfi-4#make-u16vector (fixnum #!optional (or fixnum false) boolean boolean) (struct u16vector))) +(srfi-4#make-u32vector (#(procedure #:clean #:enforce) srfi-4#make-u32vector (fixnum #!optional (or integer false) boolean boolean) (struct u32vector))) +(srfi-4#make-u64vector (#(procedure #:clean #:enforce) srfi-4#make-u64vector (fixnum #!optional (or integer false) boolean boolean) (struct u64vector))) +(srfi-4#make-u8vector (#(procedure #:clean #:enforce) srfi-4#make-u8vector (fixnum #!optional (or fixnum false) boolean boolean) (struct u8vector))) +(srfi-4#read-u8vector (#(procedure #:enforce) srfi-4#read-u8vector (#!optional (or fixnum false) input-port) (or (struct u8vector) eof))) +(srfi-4#read-u8vector! (#(procedure #:enforce) srfi-4#read-u8vector! ((or fixnum false) (struct u8vector) #!optional input-port fixnum) integer)) +(srfi-4#release-number-vector (procedure srfi-4#release-number-vector (*) undefined)) +(srfi-4#s16vector (#(procedure #:clean #:enforce) srfi-4#s16vector (#!rest fixnum) (struct s16vector))) +(srfi-4#s16vector->blob (#(procedure #:clean #:enforce) srfi-4#s16vector->blob ((struct s16vector)) blob)) +(srfi-4#s16vector->blob/shared (#(procedure #:clean #:enforce) srfi-4#s16vector->blob/shared ((struct s16vector)) blob)) +(srfi-4#s16vector->list (#(procedure #:clean #:enforce) srfi-4#s16vector->list ((struct s16vector)) (list-of fixnum))) + +(srfi-4#s16vector-length (#(procedure #:clean #:enforce) srfi-4#s16vector-length ((struct s16vector)) fixnum) + (((struct s16vector)) (##core#inline "C_u_i_16vector_length" #(1)))) + +(srfi-4#s16vector-ref (#(procedure #:clean #:enforce) srfi-4#s16vector-ref ((struct s16vector) fixnum) fixnum)) +(srfi-4#s16vector-set! (#(procedure #:clean #:enforce) srfi-4#s16vector-set! ((struct s16vector) fixnum fixnum) undefined)) + +(srfi-4#s16vector? (#(procedure #:pure #:predicate (struct s16vector)) srfi-4#s16vector? (*) boolean)) + +(srfi-4#s32vector (#(procedure #:clean #:enforce) srfi-4#s32vector (#!rest integer) (struct s32vector))) +(srfi-4#s32vector->blob (#(procedure #:clean #:enforce) srfi-4#s32vector->blob ((struct s32vector)) blob)) +(srfi-4#s32vector->blob/shared (#(procedure #:clean #:enforce) srfi-4#s32vector->blob/shared ((struct s32vector)) blob)) +(srfi-4#s32vector->list (#(procedure #:clean #:enforce) srfi-4#s32vector->list ((struct s32vector)) (list-of integer))) + +(srfi-4#s32vector-length (#(procedure #:clean #:enforce) srfi-4#s32vector-length ((struct s32vector)) fixnum) + (((struct s32vector)) (##core#inline "C_u_i_32vector_length" #(1)))) + +(srfi-4#s32vector-ref (#(procedure #:clean #:enforce) srfi-4#s32vector-ref ((struct s32vector) fixnum) integer)) +(srfi-4#s32vector-set! (#(procedure #:clean #:enforce) srfi-4#s32vector-set! ((struct s32vector) fixnum integer) undefined)) + +(srfi-4#s32vector? (#(procedure #:pure #:predicate (struct s32vector)) srfi-4#s32vector? (*) boolean)) + +(srfi-4#s8vector (#(procedure #:clean #:enforce) srfi-4#s8vector (#!rest fixnum) (struct s8vector))) +(srfi-4#s8vector->blob (#(procedure #:clean #:enforce) srfi-4#s8vector->blob ((struct s8vector)) blob)) +(srfi-4#s8vector->blob/shared (#(procedure #:clean #:enforce) srfi-4#s8vector->blob/shared ((struct s8vector)) blob)) +(srfi-4#s8vector->list (#(procedure #:clean #:enforce) srfi-4#s8vector->list ((struct s8vector)) (list-of fixnum))) + +(srfi-4#s8vector-length (#(procedure #:clean #:enforce) srfi-4#s8vector-length ((struct s8vector)) fixnum) + (((struct s8vector)) (##core#inline "C_u_i_8vector_length" #(1)))) + +(srfi-4#s8vector-ref (#(procedure #:clean #:enforce) srfi-4#s8vector-ref ((struct s8vector) fixnum) fixnum)) +(srfi-4#s8vector-set! (#(procedure #:clean #:enforce) srfi-4#s8vector-set! ((struct s8vector) fixnum fixnum) undefined)) + +(srfi-4#s8vector? (#(procedure #:pure #:predicate (struct s8vector)) srfi-4#s8vector? (*) boolean)) + +(srfi-4#subf32vector (#(procedure #:clean #:enforce) srfi-4#subf32vector ((struct f32vector) fixnum fixnum) (struct f32vector))) +(srfi-4#subf64vector (#(procedure #:clean #:enforce) srfi-4#subf64vector ((struct f64vector) fixnum fixnum) (struct f64vector))) +(srfi-4#subs16vector (#(procedure #:clean #:enforce) srfi-4#subs16vector ((struct s16vector) fixnum fixnum) (struct s16vector))) +(srfi-4#subs32vector (#(procedure #:clean #:enforce) srfi-4#subs32vector ((struct s32vector) fixnum fixnum) (struct s32vector))) +(srfi-4#subs8vector (#(procedure #:clean #:enforce) srfi-4#subs8vector ((struct s8vector) fixnum fixnum) (struct s8vector))) +(srfi-4#subu16vector (#(procedure #:clean #:enforce) srfi-4#subu16vector ((struct u16vector) fixnum fixnum) (struct u16vector))) +(srfi-4#subu32vector (#(procedure #:clean #:enforce) srfi-4#subu32vector ((struct u32vector) fixnum fixnum) (struct u32vector))) +(srfi-4#subu64vector (#(procedure #:clean #:enforce) srfi-4#subu64vector ((struct u64vector) fixnum fixnum) (struct u64vector))) +(srfi-4#subu8vector (#(procedure #:clean #:enforce) srfi-4#subu8vector ((struct u8vector) fixnum fixnum) (struct u8vector))) +(srfi-4#u16vector (#(procedure #:clean #:enforce) srfi-4#u16vector (#!rest fixnum) (struct u16vector))) +(srfi-4#u16vector->blob (#(procedure #:clean #:enforce) srfi-4#u16vector->blob ((struct u16vector)) blob)) +(srfi-4#u16vector->blob/shared (#(procedure #:clean #:enforce) srfi-4#u16vector->blob/shared ((struct u16vector)) blob)) +(srfi-4#u16vector->list (#(procedure #:clean #:enforce) srfi-4#u16vector->list ((struct u16vector)) (list-of fixnum))) + +(srfi-4#u16vector-length (#(procedure #:clean #:enforce) srfi-4#u16vector-length ((struct u16vector)) fixnum) + (((struct u16vector)) (##core#inline "C_u_i_16vector_length" #(1)))) + +(srfi-4#u16vector-ref (#(procedure #:clean #:enforce) srfi-4#u16vector-ref ((struct u16vector) fixnum) fixnum)) +(srfi-4#u16vector-set! (#(procedure #:clean #:enforce) srfi-4#u16vector-set! ((struct u16vector) fixnum fixnum) undefined)) + +(srfi-4#u16vector? (#(procedure #:pure #:predicate (struct u16vector)) srfi-4#u16vector? (*) boolean)) + +(srfi-4#u32vector (#(procedure #:clean #:enforce) srfi-4#u32vector (#!rest integer) (struct u32vector))) +(srfi-4#u32vector->blob (#(procedure #:clean #:enforce) srfi-4#u32vector->blob ((struct u32vector)) blob)) +(srfi-4#u32vector->blob/shared (#(procedure #:clean #:enforce) srfi-4#u32vector->blob/shared ((struct u32vector)) blob)) +(srfi-4#u32vector->list (#(procedure #:clean #:enforce) srfi-4#u32vector->list ((struct u32vector)) (list-of integer))) + +(srfi-4#u32vector-length (#(procedure #:clean #:enforce) srfi-4#u32vector-length ((struct u32vector)) fixnum) + (((struct u32vector)) (##core#inline "C_u_i_32vector_length" #(1)))) + +(srfi-4#u32vector-ref (#(procedure #:clean #:enforce) srfi-4#u32vector-ref ((struct u32vector) fixnum) integer)) +(srfi-4#u32vector-set! (#(procedure #:clean #:enforce) srfi-4#u32vector-set! ((struct u32vector) fixnum integer) undefined)) + +(srfi-4#u32vector? (#(procedure #:pure #:predicate (struct u32vector)) srfi-4#u32vector? (*) boolean)) + +(srfi-4#u64vector (#(procedure #:clean #:enforce) srfi-4#u64vector (#!rest integer) (struct u64vector))) +(srfi-4#u64vector->blob (#(procedure #:clean #:enforce) srfi-4#u64vector->blob ((struct u64vector)) blob)) +(srfi-4#u64vector->blob/shared (#(procedure #:clean #:enforce) srfi-4#u64vector->blob/shared ((struct u64vector)) blob)) +(srfi-4#u64vector->list (#(procedure #:clean #:enforce) srfi-4#u64vector->list ((struct u64vector)) (list-of integer))) + +(srfi-4#u64vector-length (#(procedure #:clean #:enforce) srfi-4#u64vector-length ((struct u64vector)) fixnum) + (((struct u64vector)) (##core#inline "C_u_i_64vector_length" #(1)))) + +(srfi-4#u64vector-ref (#(procedure #:clean #:enforce) srfi-4#u64vector-ref ((struct u64vector) fixnum) integer)) +(srfi-4#u64vector-set! (#(procedure #:clean #:enforce) srfi-4#u64vector-set! ((struct u64vector) fixnum integer) undefined)) + +(srfi-4#u64vector? (#(procedure #:pure #:predicate (struct u64vector)) srfi-4#u64vector? (*) boolean)) + +(srfi-4#u8vector (#(procedure #:clean #:enforce) srfi-4#u8vector (#!rest fixnum) (struct u8vector))) +(srfi-4#u8vector->blob (#(procedure #:clean #:enforce) srfi-4#u8vector->blob ((struct u8vector)) blob)) +(srfi-4#u8vector->blob/shared (#(procedure #:clean #:enforce) srfi-4#u8vector->blob/shared ((struct u8vector)) blob)) +(srfi-4#u8vector->list (#(procedure #:clean #:enforce) srfi-4#u8vector->list ((struct u8vector)) (list-of fixnum))) + +(srfi-4#u8vector-length (#(procedure #:clean #:enforce) srfi-4#u8vector-length ((struct u8vector)) fixnum) + (((struct u8vector)) (##core#inline "C_u_i_8vector_length" #(1)))) + +(srfi-4#u8vector-ref (#(procedure #:clean #:enforce) srfi-4#u8vector-ref ((struct u8vector) fixnum) fixnum)) +(srfi-4#u8vector-set! (#(procedure #:clean #:enforce) srfi-4#u8vector-set! ((struct u8vector) fixnum fixnum) undefined)) + +(srfi-4#u8vector? (#(procedure #:pure #:predicate (struct u8vector)) srfi-4#u8vector? (*) boolean)) + +(srfi-4#write-u8vector (#(procedure #:enforce) srfi-4#write-u8vector ((struct u8vector) #!optional output-port fixnum fixnum) undefined)) + +(srfi-4#number-vector? (#(procedure #:pure #:predicate (or (struct u8vector) (struct u16vector) (struct s8vector) (struct s16vector) (struct u32vector) (struct s32vector) (struct u64vector) (struct s64vector) (struct f32vector) (struct f64vector))) srfi-4#number-vector? (*) boolean)) +(##sys#srfi-4-vector? (#(procedure #:pure #:predicate (or (struct u8vector) (struct u16vector) (struct s8vector) (struct s16vector) (struct u32vector) (struct s32vector) (struct u64vector) (struct s64vector) (struct f32vector) (struct f64vector))) ##sys#srfi-4-vector? (*) boolean)) + +;; syntax + +(chicken.syntax#er-macro-transformer + (#(procedure #:clean #:enforce) + chicken.syntax#er-macro-transformer + ((procedure (* (procedure (*) *) (procedure (* *) *)) *)) + (struct transformer))) +(chicken.syntax#expand (procedure chicken.syntax#expand (* #!optional list) *)) +(chicken.syntax#ir-macro-transformer + (#(procedure #:clean #:enforce) + chicken.syntax#ir-macro-transformer + ((procedure (* (procedure (*) *) (procedure (* *) *)) *)) + (struct transformer))) +(chicken.syntax#strip-syntax (#(procedure #:clean) chicken.syntax#strip-syntax (*) *)) +(chicken.syntax#syntax-error (procedure chicken.syntax#syntax-error (* #!rest) noreturn)) + +;; tcp + +(chicken.tcp#tcp-abandon-port (#(procedure #:clean #:enforce) chicken.tcp#tcp-abandon-port (port) undefined)) +(chicken.tcp#tcp-accept (#(procedure #:clean #:enforce) chicken.tcp#tcp-accept ((struct tcp-listener)) input-port output-port)) +(chicken.tcp#tcp-accept-ready? (#(procedure #:clean #:enforce) chicken.tcp#tcp-accept-ready? ((struct tcp-listener)) boolean)) +(chicken.tcp#tcp-accept-timeout (#(procedure #:clean #:enforce) chicken.tcp#tcp-accept-timeout (#!optional (or false integer)) (or false integer))) +(chicken.tcp#tcp-addresses (#(procedure #:clean #:enforce) chicken.tcp#tcp-addresses (port) string string)) +(chicken.tcp#tcp-buffer-size (#(procedure #:clean #:enforce) chicken.tcp#tcp-buffer-size (#!optional (or false fixnum)) (or false fixnum))) +(chicken.tcp#tcp-close (#(procedure #:clean #:enforce) chicken.tcp#tcp-close ((struct tcp-listener)) undefined)) +(chicken.tcp#tcp-connect (#(procedure #:clean #:enforce) chicken.tcp#tcp-connect (string #!optional fixnum) input-port output-port)) +(chicken.tcp#tcp-connect-timeout (#(procedure #:clean #:enforce) chicken.tcp#tcp-connect-timeout (#!optional (or false integer)) (or false integer))) +(chicken.tcp#tcp-listen (#(procedure #:clean #:enforce) chicken.tcp#tcp-listen (fixnum #!optional fixnum *) (struct tcp-listener))) + +(chicken.tcp#tcp-listener-fileno (#(procedure #:clean #:enforce) chicken.tcp#tcp-listener-fileno ((struct tcp-listener)) fixnum) + (((struct tcp-listener)) (##sys#slot #(1) '1))) + +(chicken.tcp#tcp-listener-port (#(procedure #:clean #:enforce) chicken.tcp#tcp-listener-port ((struct tcp-listener)) fixnum)) + +(chicken.tcp#tcp-listener? (#(procedure #:clean #:predicate (struct tcp-listener)) chicken.tcp#tcp-listener? (*) boolean)) + +(chicken.tcp#tcp-port-numbers (#(procedure #:clean #:enforce) chicken.tcp#tcp-port-numbers (port) fixnum fixnum)) +(chicken.tcp#tcp-read-timeout (#(procedure #:clean #:enforce) chicken.tcp#tcp-read-timeout (#!optional (or false integer)) (or false integer))) +(chicken.tcp#tcp-write-timeout (#(procedure #:clean #:enforce) chicken.tcp#tcp-write-timeout (#!optional (or false integer)) (or false integer))) diff --git a/.eggs/unicode-char-sets.import.so b/.eggs/unicode-char-sets.import.so new file mode 100755 index 0000000..02e04e8 Binary files /dev/null and b/.eggs/unicode-char-sets.import.so differ diff --git a/.eggs/unicode-char-sets.link b/.eggs/unicode-char-sets.link new file mode 100644 index 0000000..c246a8f --- /dev/null +++ b/.eggs/unicode-char-sets.link @@ -0,0 +1 @@ +(iset) diff --git a/.eggs/unicode-char-sets.o b/.eggs/unicode-char-sets.o new file mode 100644 index 0000000..6a6dc2a Binary files /dev/null and b/.eggs/unicode-char-sets.o differ diff --git a/.eggs/unicode-char-sets.so b/.eggs/unicode-char-sets.so new file mode 100755 index 0000000..8ada523 Binary files /dev/null and b/.eggs/unicode-char-sets.so differ diff --git a/.eggs/uri-common.egg-info b/.eggs/uri-common.egg-info new file mode 100644 index 0000000..b3ec5ff --- /dev/null +++ b/.eggs/uri-common.egg-info @@ -0,0 +1,13 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/uri-common.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/uri-common.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/uri-common.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/uri-common.import.so") + (version "2.0") + (synopsis "Parser for common URI schemes") + (author "Peter Bex") + (license "BSD") + (category web) + (dependencies uri-generic defstruct matchable srfi-1 srfi-13 srfi-14) + (test-dependencies test) + (components (extension uri-common))) diff --git a/.eggs/uri-common.import.so b/.eggs/uri-common.import.so new file mode 100755 index 0000000..fd15631 Binary files /dev/null and b/.eggs/uri-common.import.so differ diff --git a/.eggs/uri-common.link b/.eggs/uri-common.link new file mode 100644 index 0000000..065843b --- /dev/null +++ b/.eggs/uri-common.link @@ -0,0 +1 @@ +(uri-generic matchable defstruct srfi-14 srfi-13 srfi-1) diff --git a/.eggs/uri-common.o b/.eggs/uri-common.o new file mode 100644 index 0000000..e3400e8 Binary files /dev/null and b/.eggs/uri-common.o differ diff --git a/.eggs/uri-common.so b/.eggs/uri-common.so new file mode 100755 index 0000000..920bd05 Binary files /dev/null and b/.eggs/uri-common.so differ diff --git a/.eggs/uri-generic.egg-info b/.eggs/uri-generic.egg-info new file mode 100644 index 0000000..e4bff56 --- /dev/null +++ b/.eggs/uri-generic.egg-info @@ -0,0 +1,13 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/uri-generic.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/uri-generic.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/uri-generic.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/uri-generic.import.so") + (version "3.3") + (license "BSD") + (category web) + (dependencies matchable srfi-1 srfi-14) + (test-dependencies test) + (author "Ivan Raikov, Peter Bex, Seth Alves") + (synopsis "URI generic syntax (RFC 3986) parsing and manipulation.") + (components (extension uri-generic))) diff --git a/.eggs/uri-generic.import.so b/.eggs/uri-generic.import.so new file mode 100755 index 0000000..de736e5 Binary files /dev/null and b/.eggs/uri-generic.import.so differ diff --git a/.eggs/uri-generic.link b/.eggs/uri-generic.link new file mode 100644 index 0000000..4ccf20e --- /dev/null +++ b/.eggs/uri-generic.link @@ -0,0 +1 @@ +(matchable srfi-14 srfi-1) diff --git a/.eggs/uri-generic.o b/.eggs/uri-generic.o new file mode 100644 index 0000000..1923fdf Binary files /dev/null and b/.eggs/uri-generic.o differ diff --git a/.eggs/uri-generic.so b/.eggs/uri-generic.so new file mode 100755 index 0000000..a4fa8e4 Binary files /dev/null and b/.eggs/uri-generic.so differ diff --git a/.eggs/utf8-case-map.import.so b/.eggs/utf8-case-map.import.so new file mode 100755 index 0000000..fe56b29 Binary files /dev/null and b/.eggs/utf8-case-map.import.so differ diff --git a/.eggs/utf8-case-map.link b/.eggs/utf8-case-map.link new file mode 100644 index 0000000..0fd7118 --- /dev/null +++ b/.eggs/utf8-case-map.link @@ -0,0 +1 @@ +(unicode-char-sets utf8-srfi-14 utf8-lolevel) diff --git a/.eggs/utf8-case-map.o b/.eggs/utf8-case-map.o new file mode 100644 index 0000000..72bdc3b Binary files /dev/null and b/.eggs/utf8-case-map.o differ diff --git a/.eggs/utf8-case-map.so b/.eggs/utf8-case-map.so new file mode 100755 index 0000000..c8475eb Binary files /dev/null and b/.eggs/utf8-case-map.so differ diff --git a/.eggs/utf8-lolevel.import.so b/.eggs/utf8-lolevel.import.so new file mode 100755 index 0000000..dd4ff66 Binary files /dev/null and b/.eggs/utf8-lolevel.import.so differ diff --git a/.eggs/utf8-lolevel.link b/.eggs/utf8-lolevel.link new file mode 100644 index 0000000..6a452c1 --- /dev/null +++ b/.eggs/utf8-lolevel.link @@ -0,0 +1 @@ +() diff --git a/.eggs/utf8-lolevel.o b/.eggs/utf8-lolevel.o new file mode 100644 index 0000000..a995823 Binary files /dev/null and b/.eggs/utf8-lolevel.o differ diff --git a/.eggs/utf8-lolevel.so b/.eggs/utf8-lolevel.so new file mode 100755 index 0000000..4d78691 Binary files /dev/null and b/.eggs/utf8-lolevel.so differ diff --git a/.eggs/utf8-srfi-13.import.so b/.eggs/utf8-srfi-13.import.so new file mode 100755 index 0000000..2a4a946 Binary files /dev/null and b/.eggs/utf8-srfi-13.import.so differ diff --git a/.eggs/utf8-srfi-13.link b/.eggs/utf8-srfi-13.link new file mode 100644 index 0000000..b538404 --- /dev/null +++ b/.eggs/utf8-srfi-13.link @@ -0,0 +1 @@ +(utf8-case-map iset utf8-srfi-14 utf8-lolevel srfi-69) diff --git a/.eggs/utf8-srfi-13.o b/.eggs/utf8-srfi-13.o new file mode 100644 index 0000000..6f0c94b Binary files /dev/null and b/.eggs/utf8-srfi-13.o differ diff --git a/.eggs/utf8-srfi-13.so b/.eggs/utf8-srfi-13.so new file mode 100755 index 0000000..a1021eb Binary files /dev/null and b/.eggs/utf8-srfi-13.so differ diff --git a/.eggs/utf8-srfi-14.import.so b/.eggs/utf8-srfi-14.import.so new file mode 100755 index 0000000..3ff8dc3 Binary files /dev/null and b/.eggs/utf8-srfi-14.import.so differ diff --git a/.eggs/utf8-srfi-14.link b/.eggs/utf8-srfi-14.link new file mode 100644 index 0000000..7eef682 --- /dev/null +++ b/.eggs/utf8-srfi-14.link @@ -0,0 +1 @@ +(srfi-69 utf8-lolevel iset) diff --git a/.eggs/utf8-srfi-14.o b/.eggs/utf8-srfi-14.o new file mode 100644 index 0000000..33c8958 Binary files /dev/null and b/.eggs/utf8-srfi-14.o differ diff --git a/.eggs/utf8-srfi-14.so b/.eggs/utf8-srfi-14.so new file mode 100755 index 0000000..0fccc83 Binary files /dev/null and b/.eggs/utf8-srfi-14.so differ diff --git a/.eggs/utf8.egg-info b/.eggs/utf8.egg-info new file mode 100644 index 0000000..9fb0034 --- /dev/null +++ b/.eggs/utf8.egg-info @@ -0,0 +1,44 @@ +((installed-files + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-lolevel.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-lolevel.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-lolevel.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-lolevel.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-srfi-14.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-srfi-14.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-srfi-14.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-srfi-14.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/unicode-char-sets.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/unicode-char-sets.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/unicode-char-sets.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/unicode-char-sets.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-case-map.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-case-map.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-case-map.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-case-map.import.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-srfi-13.o" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-srfi-13.link" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-srfi-13.so" + "/home/arne/dev/wtf.nein.seizethemeans/.eggs/utf8-srfi-13.import.so") + (version "3.6.3") + (synopsis "Unicode support") + (category parsing) + (dependencies srfi-69 iset regex) + (test-dependencies test) + (license "BSD") + (author "Alex Shinn") + (component-options (csc-options "-fixnum-arithmetic" "-inline" "-local")) + (components + (extension utf8-lolevel (csc-options "-O3" "-d0")) + (extension utf8 (component-dependencies utf8-lolevel)) + (extension utf8-srfi-14 (component-dependencies utf8-lolevel)) + (extension unicode-char-sets) + (extension + utf8-case-map + (component-dependencies utf8-lolevel utf8-srfi-14 unicode-char-sets)) + (extension + utf8-srfi-13 + (component-dependencies utf8-lolevel utf8-srfi-14 utf8-case-map)))) diff --git a/.eggs/utf8.import.so b/.eggs/utf8.import.so new file mode 100755 index 0000000..27154c0 Binary files /dev/null and b/.eggs/utf8.import.so differ diff --git a/.eggs/utf8.link b/.eggs/utf8.link new file mode 100644 index 0000000..8245c98 --- /dev/null +++ b/.eggs/utf8.link @@ -0,0 +1 @@ +(utf8-lolevel regex) diff --git a/.eggs/utf8.o b/.eggs/utf8.o new file mode 100644 index 0000000..a300da3 Binary files /dev/null and b/.eggs/utf8.o differ diff --git a/.eggs/utf8.so b/.eggs/utf8.so new file mode 100755 index 0000000..36223b4 Binary files /dev/null and b/.eggs/utf8.so differ