diff options
-rw-r--r-- | doc/guile-api.alist | 3201 |
1 files changed, 3201 insertions, 0 deletions
diff --git a/doc/guile-api.alist b/doc/guile-api.alist new file mode 100644 index 000000000..c1a6c46e1 --- /dev/null +++ b/doc/guile-api.alist @@ -0,0 +1,3201 @@ +;; Generated Fri Feb 15 13:35:09 PST 2002 by guile-scripts/scan-api -- do not edit! +;; guile: /home/ttn/build/.gnu/guile-core/pre-inst-guile . +;; sofile: libguile/.libs/libguile.so.10.0.0 + +( +(scheme +($abs "#<primitive-procedure") +($acos "#<primitive-procedure") +($acosh "#<primitive-procedure") +($asin "#<primitive-procedure") +($asinh "#<primitive-procedure") +($atan "#<primitive-procedure") +($atan2 "#<primitive-procedure") +($atanh "#<primitive-procedure") +($cos "#<primitive-procedure") +($cosh "#<primitive-procedure") +($exp "#<primitive-procedure") +($expt "#<primitive-procedure") +($log "#<primitive-procedure") +($sin "#<primitive-procedure") +($sinh "#<primitive-procedure") +($sqrt "#<primitive-procedure") +($tan "#<primitive-procedure") +($tanh "#<primitive-procedure") +(%cond-expand-features "") +(%cond-expand-table "") +(%deliver-signals "#<primitive-procedure") +(%get-pre-modules-obarray "#<primitive-procedure") +(%guile-build-info "") +(%init-goops-builtins "#<primitive-procedure") +(%init-rdelim-builtins "#<primitive-procedure") +(%init-rw-builtins "#<primitive-procedure") +(%library-dir "#<primitive-procedure") +(%load-announce "#<procedure") +(%load-extensions "") +(%load-hook "#<procedure") +(%load-path "") +(%load-verbosely "") +(%make-void-port "#<primitive-procedure") +(%module-public-interface "") +(%module-public-interface "") +(%nil "") +(%package-data-dir "#<primitive-procedure") +(%print-module "#<procedure") +(%print-values "#<primitive-procedure") +(%search-load-path "#<primitive-procedure") +(%site-dir "#<primitive-procedure") +(* "#<primitive-procedure") +(*features* "") +(*null-device* "") +(*random-state* "") +(*unspecified* "") +(+ "#<primitive-procedure") +(- "#<primitive-procedure") +(->bool "#<procedure") +(/ "#<primitive-procedure") +(1+ "#<procedure") +(1- "#<procedure") +(< "#<primitive-procedure") +(<= "#<primitive-procedure") +(<class> "") +(<entity> "") +(<operator-class> "") +(= "#<primitive-procedure") +(> "#<primitive-procedure") +(>= "#<primitive-procedure") +(@apply "") +(@bind "") +(@call-with-current-continuation "") +(@call-with-values "") +(@fop "") +(AF_INET "") +(AF_INET6 "") +(AF_UNIX "") +(AF_UNSPEC "") +(E2BIG "") +(EACCES "") +(EADDRINUSE "") +(EADDRNOTAVAIL "") +(EADV "") +(EAFNOSUPPORT "") +(EAGAIN "") +(EALREADY "") +(EBADE "") +(EBADF "") +(EBADFD "") +(EBADMSG "") +(EBADR "") +(EBADRQC "") +(EBADSLT "") +(EBFONT "") +(EBUSY "") +(ECHILD "") +(ECHRNG "") +(ECOMM "") +(ECONNABORTED "") +(ECONNREFUSED "") +(ECONNRESET "") +(EDEADLK "") +(EDEADLOCK "") +(EDESTADDRREQ "") +(EDOM "") +(EDOTDOT "") +(EDQUOT "") +(EEXIST "") +(EFAULT "") +(EFBIG "") +(EHOSTDOWN "") +(EHOSTUNREACH "") +(EIDRM "") +(EILSEQ "") +(EINPROGRESS "") +(EINTR "") +(EINVAL "") +(EIO "") +(EISCONN "") +(EISDIR "") +(EISNAM "") +(EL2HLT "") +(EL2NSYNC "") +(EL3HLT "") +(EL3RST "") +(ELIBACC "") +(ELIBBAD "") +(ELIBEXEC "") +(ELIBMAX "") +(ELIBSCN "") +(ELNRNG "") +(ELOOP "") +(EMFILE "") +(EMLINK "") +(EMSGSIZE "") +(EMULTIHOP "") +(ENAMETOOLONG "") +(ENAVAIL "") +(ENETDOWN "") +(ENETRESET "") +(ENETUNREACH "") +(ENFILE "") +(ENOANO "") +(ENOBUFS "") +(ENOCSI "") +(ENODATA "") +(ENODEV "") +(ENOENT "") +(ENOEXEC "") +(ENOLCK "") +(ENOLINK "") +(ENOMEM "") +(ENOMSG "") +(ENONET "") +(ENOPKG "") +(ENOPROTOOPT "") +(ENOSPC "") +(ENOSR "") +(ENOSTR "") +(ENOSYS "") +(ENOTBLK "") +(ENOTCONN "") +(ENOTDIR "") +(ENOTEMPTY "") +(ENOTNAM "") +(ENOTSOCK "") +(ENOTTY "") +(ENOTUNIQ "") +(ENXIO "") +(EOPNOTSUPP "") +(EOVERFLOW "") +(EPERM "") +(EPFNOSUPPORT "") +(EPIPE "") +(EPROTO "") +(EPROTONOSUPPORT "") +(EPROTOTYPE "") +(ERANGE "") +(EREMCHG "") +(EREMOTE "") +(EREMOTEIO "") +(ERESTART "") +(EROFS "") +(ESHUTDOWN "") +(ESOCKTNOSUPPORT "") +(ESPIPE "") +(ESRCH "") +(ESRMNT "") +(ESTALE "") +(ESTRPIPE "") +(ETIME "") +(ETIMEDOUT "") +(ETOOMANYREFS "") +(ETXTBSY "") +(EUCLEAN "") +(EUNATCH "") +(EUSERS "") +(EWOULDBLOCK "") +(EXDEV "") +(EXFULL "") +(FD_CLOEXEC "") +(F_DUPFD "") +(F_GETFD "") +(F_GETFL "") +(F_GETOWN "") +(F_OK "") +(F_SETFD "") +(F_SETFL "") +(F_SETOWN "") +(INADDR_ANY "") +(INADDR_BROADCAST "") +(INADDR_LOOPBACK "") +(INADDR_NONE "") +(ITIMER_PROF "") +(ITIMER_REAL "") +(ITIMER_VIRTUAL "") +(LC_ALL "") +(LC_COLLATE "") +(LC_CTYPE "") +(LC_MESSAGES "") +(LC_MONETARY "") +(LC_NUMERIC "") +(LC_TIME "") +(LOCK_EX "") +(LOCK_NB "") +(LOCK_SH "") +(LOCK_UN "") +(MSG_DONTROUTE "") +(MSG_OOB "") +(MSG_PEEK "") +(NSIG "") +(OPEN_BOTH "") +(OPEN_READ "") +(OPEN_WRITE "") +(O_APPEND "") +(O_CREAT "") +(O_EXCL "") +(O_NDELAY "") +(O_NOCTTY "") +(O_NONBLOCK "") +(O_RDONLY "") +(O_RDWR "") +(O_SYNC "") +(O_TRUNC "") +(O_WRONLY "") +(PF_INET "") +(PF_INET6 "") +(PF_UNIX "") +(PF_UNSPEC "") +(PIPE_BUF "") +(PRIO_PGRP "") +(PRIO_PROCESS "") +(PRIO_USER "") +(R_OK "") +(SA_NOCLDSTOP "") +(SA_RESTART "") +(SEEK_CUR "") +(SEEK_END "") +(SEEK_SET "") +(SIGABRT "") +(SIGALRM "") +(SIGBUS "") +(SIGCHLD "") +(SIGCLD "") +(SIGCONT "") +(SIGFPE "") +(SIGHUP "") +(SIGILL "") +(SIGINT "") +(SIGIO "") +(SIGIOT "") +(SIGKILL "") +(SIGPIPE "") +(SIGPOLL "") +(SIGPROF "") +(SIGPWR "") +(SIGQUIT "") +(SIGSEGV "") +(SIGSTKFLT "") +(SIGSTOP "") +(SIGTERM "") +(SIGTRAP "") +(SIGTSTP "") +(SIGTTIN "") +(SIGTTOU "") +(SIGUNUSED "") +(SIGURG "") +(SIGUSR1 "") +(SIGUSR2 "") +(SIGVTALRM "") +(SIGWINCH "") +(SIGXCPU "") +(SIGXFSZ "") +(SIG_DFL "") +(SIG_IGN "") +(SOCK_DGRAM "") +(SOCK_RAW "") +(SOCK_STREAM "") +(SOL_IP "") +(SOL_SOCKET "") +(SO_BROADCAST "") +(SO_DEBUG "") +(SO_DONTROUTE "") +(SO_ERROR "") +(SO_KEEPALIVE "") +(SO_LINGER "") +(SO_NO_CHECK "") +(SO_OOBINLINE "") +(SO_PRIORITY "") +(SO_RCVBUF "") +(SO_REUSEADDR "") +(SO_SNDBUF "") +(SO_TYPE "") +(WAIT_ANY "") +(WAIT_MYPGRP "") +(WNOHANG "") +(WUNTRACED "") +(W_OK "") +(X_OK "") +(_IOFBF "") +(_IOLBF "") +(_IONBF "") +(abort-hook "") +(abs "#<primitive-procedure") +(accept "#<primitive-procedure") +(access? "#<primitive-procedure") +(acons "#<primitive-procedure") +(acos "#<procedure") +(acosh "#<procedure") +(add-hook! "#<primitive-procedure") +(after-backtrace-hook "") +(after-error-hook "") +(after-eval-hook "") +(after-gc-hook "") +(after-print-hook "") +(after-read-hook "") +(alarm "#<primitive-procedure") +(and "") +(and-map "#<procedure") +(and=> "#<procedure") +(angle "#<primitive-procedure") +(app "") +(append "#<primitive-procedure") +(append! "#<primitive-procedure") +(apply "#<procedure") +(apply-to-args "#<procedure") +(apply:nconc2last "#<primitive-procedure") +(array->list "#<primitive-procedure") +(array-contents "#<primitive-procedure") +(array-copy! "#<primitive-procedure") +(array-copy-in-order! "#<primitive-procedure") +(array-dimensions "#<primitive-procedure") +(array-equal? "#<primitive-procedure") +(array-fill! "#<primitive-procedure") +(array-for-each "#<primitive-procedure") +(array-in-bounds? "#<primitive-procedure") +(array-index-map! "#<primitive-procedure") +(array-map! "#<primitive-procedure") +(array-map-in-order! "#<primitive-procedure") +(array-prototype "#<primitive-procedure") +(array-rank "#<primitive-procedure") +(array-ref "#<primitive-procedure") +(array-set! "#<primitive-procedure") +(array-shape "#<procedure") +(array? "#<primitive-procedure") +(ash "#<primitive-procedure") +(asin "#<procedure") +(asinh "#<procedure") +(assert-defmacro?! "#<procedure") +(assert-load-verbosity "#<procedure") +(assert-repl-print-unspecified "#<procedure") +(assert-repl-silence "#<procedure") +(assert-repl-verbosity "#<procedure") +(assoc "#<primitive-procedure") +(assoc-ref "#<primitive-procedure") +(assoc-remove! "#<primitive-procedure") +(assoc-set! "#<primitive-procedure") +(assq "#<primitive-procedure") +(assq-ref "#<primitive-procedure") +(assq-remove! "#<primitive-procedure") +(assq-set! "#<primitive-procedure") +(assv "#<primitive-procedure") +(assv-ref "#<primitive-procedure") +(assv-remove! "#<primitive-procedure") +(assv-set! "#<primitive-procedure") +(async "#<primitive-procedure") +(async-mark "#<primitive-procedure") +(atan "#<procedure") +(atanh "#<procedure") +(autoload-done! "#<procedure") +(autoload-done-or-in-progress? "#<procedure") +(autoload-in-progress! "#<procedure") +(autoloads-done "") +(autoloads-in-progress "") +(backtrace "#<primitive-procedure") +(bad-throw "#<procedure") +(basename "#<primitive-procedure") +(basic-load "#<procedure") +(batch-mode? "#<procedure") +(beautify-user-module! "#<procedure") +(before-backtrace-hook "") +(before-error-hook "") +(before-eval-hook "") +(before-print-hook "") +(before-read-hook "") +(before-signal-stack "") +(begin "") +(begin-deprecated "") +(bind "#<primitive-procedure") +(bit-count "#<primitive-procedure") +(bit-count* "#<primitive-procedure") +(bit-extract "#<primitive-procedure") +(bit-invert! "#<primitive-procedure") +(bit-position "#<primitive-procedure") +(bit-set*! "#<primitive-procedure") +(boolean? "#<primitive-procedure") +(caaaar "#<primitive-procedure") +(caaadr "#<primitive-procedure") +(caaar "#<primitive-procedure") +(caadar "#<primitive-procedure") +(caaddr "#<primitive-procedure") +(caadr "#<primitive-procedure") +(caar "#<primitive-procedure") +(cadaar "#<primitive-procedure") +(cadadr "#<primitive-procedure") +(cadar "#<primitive-procedure") +(caddar "#<primitive-procedure") +(cadddr "#<primitive-procedure") +(caddr "#<primitive-procedure") +(cadr "#<primitive-procedure") +(call-with-current-continuation "#<procedure") +(call-with-dynamic-root "#<primitive-procedure") +(call-with-input-file "#<procedure") +(call-with-input-string "#<primitive-procedure") +(call-with-new-thread "#<primitive-procedure") +(call-with-output-file "#<procedure") +(call-with-output-string "#<primitive-procedure") +(call-with-values "#<procedure") +(car "#<primitive-procedure") +(case "") +(catch "#<primitive-procedure") +(cdaaar "#<primitive-procedure") +(cdaadr "#<primitive-procedure") +(cdaar "#<primitive-procedure") +(cdadar "#<primitive-procedure") +(cdaddr "#<primitive-procedure") +(cdadr "#<primitive-procedure") +(cdar "#<primitive-procedure") +(cddaar "#<primitive-procedure") +(cddadr "#<primitive-procedure") +(cddar "#<primitive-procedure") +(cdddar "#<primitive-procedure") +(cddddr "#<primitive-procedure") +(cdddr "#<primitive-procedure") +(cddr "#<primitive-procedure") +(cdr "#<primitive-procedure") +(ceiling "#<primitive-procedure") +(char->integer "#<primitive-procedure") +(char-alphabetic? "#<primitive-procedure") +(char-ci<=? "#<primitive-procedure") +(char-ci<? "#<primitive-procedure") +(char-ci=? "#<primitive-procedure") +(char-ci>=? "#<primitive-procedure") +(char-ci>? "#<primitive-procedure") +(char-code-limit "") +(char-downcase "#<primitive-procedure") +(char-is-both? "#<primitive-procedure") +(char-lower-case? "#<primitive-procedure") +(char-numeric? "#<primitive-procedure") +(char-ready? "#<primitive-procedure") +(char-upcase "#<primitive-procedure") +(char-upper-case? "#<primitive-procedure") +(char-whitespace? "#<primitive-procedure") +(char<=? "#<primitive-procedure") +(char<? "#<primitive-procedure") +(char=? "#<primitive-procedure") +(char>=? "#<primitive-procedure") +(char>? "#<primitive-procedure") +(char? "#<primitive-procedure") +(chdir "#<primitive-procedure") +(chmod "#<primitive-procedure") +(chown "#<primitive-procedure") +(chroot "#<primitive-procedure") +(class-of "#<primitive-procedure") +(close "#<primitive-procedure") +(close-fdes "#<primitive-procedure") +(close-input-port "#<primitive-procedure") +(close-io-port "#<primitive-procedure") +(close-output-port "#<primitive-procedure") +(close-port "#<primitive-procedure") +(closedir "#<primitive-procedure") +(closure? "#<primitive-procedure") +(collect "") +(command-line "#<procedure") +(compile-define-module-args "#<procedure") +(compile-interface-spec "#<procedure") +(complex? "#<primitive-procedure") +(cond "") +(cond-expand "") +(cond-expand-provide "#<procedure") +(connect "#<primitive-procedure") +(cons "#<primitive-procedure") +(cons* "#<primitive-procedure") +(cons-source "#<primitive-procedure") +(copy-file "#<primitive-procedure") +(copy-random-state "#<primitive-procedure") +(copy-tree "#<primitive-procedure") +(cos "#<procedure") +(cosh "#<procedure") +(crypt "#<primitive-procedure") +(ctermid "#<primitive-procedure") +(current-error-port "#<primitive-procedure") +(current-input-port "#<primitive-procedure") +(current-load-port "#<primitive-procedure") +(current-module "#<primitive-procedure") +(current-output-port "#<primitive-procedure") +(current-time "#<primitive-procedure") +(cuserid "#<primitive-procedure") +(debug-disable "#<procedure") +(debug-enable "#<procedure") +(debug-object? "#<primitive-procedure") +(debug-options "#<procedure") +(debug-options-interface "#<primitive-procedure") +(debug-set! "") +(default-lazy-handler "#<procedure") +(define "") +(define-macro "") +(define-module "") +(define-option-interface "") +(define-private "") +(define-public "") +(define-syntax-macro "") +(defined? "#<primitive-procedure") +(defmacro "") +(defmacro-public "") +(defmacro-transformer "#<procedure") +(defmacro:syntax-transformer "#<procedure") +(defmacro:transformer "#<procedure") +(defmacro? "#<procedure") +(delay "") +(delete "#<primitive-procedure") +(delete! "#<primitive-procedure") +(delete-file "#<primitive-procedure") +(delete1! "#<primitive-procedure") +(delq "#<primitive-procedure") +(delq! "#<primitive-procedure") +(delq1! "#<primitive-procedure") +(delv "#<primitive-procedure") +(delv! "#<primitive-procedure") +(delv1! "#<primitive-procedure") +(destroy-guardian! "#<primitive-procedure") +(dimensions->uniform-array "#<primitive-procedure") +(directory-stream? "#<primitive-procedure") +(dirname "#<primitive-procedure") +(display "#<primitive-procedure") +(display-application "#<primitive-procedure") +(display-backtrace "#<primitive-procedure") +(display-error "#<primitive-procedure") +(display-usage-report "#<procedure") +(do "") +(doubly-weak-hash-table? "#<primitive-procedure") +(drain-input "#<primitive-procedure") +(dup "#<procedure") +(dup->fdes "#<primitive-procedure") +(dup->inport "#<procedure") +(dup->outport "#<procedure") +(dup->port "#<procedure") +(dup2 "#<primitive-procedure") +(duplicate-port "#<procedure") +(dynamic-args-call "#<primitive-procedure") +(dynamic-call "#<primitive-procedure") +(dynamic-func "#<primitive-procedure") +(dynamic-link "#<primitive-procedure") +(dynamic-object? "#<primitive-procedure") +(dynamic-root "#<primitive-procedure") +(dynamic-unlink "#<primitive-procedure") +(dynamic-wind "#<primitive-procedure") +(enclose-array "#<primitive-procedure") +(endgrent "#<procedure") +(endhostent "#<procedure") +(endnetent "#<procedure") +(endprotoent "#<procedure") +(endpwent "#<procedure") +(endservent "#<procedure") +(entity? "#<primitive-procedure") +(env-module "#<primitive-procedure") +(environ "#<primitive-procedure") +(environment-bound? "#<primitive-procedure") +(environment-cell "#<primitive-procedure") +(environment-define "#<primitive-procedure") +(environment-fold "#<primitive-procedure") +(environment-module "#<procedure") +(environment-observe "#<primitive-procedure") +(environment-observe-weak "#<primitive-procedure") +(environment-ref "#<primitive-procedure") +(environment-set! "#<primitive-procedure") +(environment-undefine "#<primitive-procedure") +(environment-unobserve "#<primitive-procedure") +(environment? "#<primitive-procedure") +(eof-object? "#<primitive-procedure") +(eq? "#<primitive-procedure") +(equal? "#<primitive-procedure") +(eqv? "#<primitive-procedure") +(error "#<procedure") +(error-catching-loop "#<procedure") +(error-catching-repl "#<procedure") +(eval "#<primitive-procedure") +(eval-case "") +(eval-disable "#<procedure") +(eval-enable "#<procedure") +(eval-environment-imported "#<primitive-procedure") +(eval-environment-local "#<primitive-procedure") +(eval-environment-set-imported! "#<primitive-procedure") +(eval-environment-set-local! "#<primitive-procedure") +(eval-environment? "#<primitive-procedure") +(eval-options "#<procedure") +(eval-options-interface "#<primitive-procedure") +(eval-set! "") +(eval-string "#<primitive-procedure") +(evaluator-traps-interface "#<primitive-procedure") +(even? "#<primitive-procedure") +(exact->inexact "#<primitive-procedure") +(exact? "#<primitive-procedure") +(execl "#<primitive-procedure") +(execle "#<primitive-procedure") +(execlp "#<primitive-procedure") +(exit "#<procedure") +(exit-hook "") +(exp "#<procedure") +(export "") +(export-environment-private "#<primitive-procedure") +(export-environment-set-private! "#<primitive-procedure") +(export-environment-set-signature! "#<primitive-procedure") +(export-environment-signature "#<primitive-procedure") +(export-environment? "#<primitive-procedure") +(export-syntax "") +(expt "#<procedure") +(false-if-exception "") +(fcntl "#<primitive-procedure") +(fdes->inport "#<procedure") +(fdes->outport "#<procedure") +(fdes->ports "#<primitive-procedure") +(fdopen "#<primitive-procedure") +(feature? "#<procedure") +(file-exists? "#<procedure") +(file-is-directory? "#<procedure") +(file-port? "#<primitive-procedure") +(file-position "#<procedure") +(file-set-position "#<procedure") +(fileno "#<primitive-procedure") +(flock "#<primitive-procedure") +(floor "#<primitive-procedure") +(fluid-ref "#<primitive-procedure") +(fluid-set! "#<primitive-procedure") +(fluid? "#<primitive-procedure") +(flush-all-ports "#<primitive-procedure") +(for-each "#<primitive-procedure") +(for-next-option "#<procedure") +(force "#<primitive-procedure") +(force-output "#<primitive-procedure") +(format "#<primitive-procedure") +(frame-arguments "#<primitive-procedure") +(frame-evaluating-args? "#<primitive-procedure") +(frame-next "#<primitive-procedure") +(frame-number "#<primitive-procedure") +(frame-overflow? "#<primitive-procedure") +(frame-previous "#<primitive-procedure") +(frame-procedure "#<primitive-procedure") +(frame-procedure? "#<primitive-procedure") +(frame-real? "#<primitive-procedure") +(frame-source "#<primitive-procedure") +(frame? "#<primitive-procedure") +(fsync "#<primitive-procedure") +(ftell "#<primitive-procedure") +(gc "#<primitive-procedure") +(gc-run-time "#<procedure") +(gc-stats "#<primitive-procedure") +(gcd "#<primitive-procedure") +(gensym "#<primitive-procedure") +(get-internal-real-time "#<primitive-procedure") +(get-internal-run-time "#<primitive-procedure") +(get-option "#<procedure") +(get-output-string "#<primitive-procedure") +(get-print-state "#<primitive-procedure") +(getcwd "#<primitive-procedure") +(getegid "#<primitive-procedure") +(getenv "#<primitive-procedure") +(geteuid "#<primitive-procedure") +(getgid "#<primitive-procedure") +(getgr "#<primitive-procedure") +(getgrent "#<procedure") +(getgrgid "#<procedure") +(getgrnam "#<procedure") +(getgroups "#<primitive-procedure") +(gethost "#<primitive-procedure") +(gethostbyaddr "#<procedure") +(gethostbyname "#<procedure") +(gethostent "#<procedure") +(gethostname "#<primitive-procedure") +(getitimer "#<primitive-procedure") +(getlogin "#<primitive-procedure") +(getnet "#<primitive-procedure") +(getnetbyaddr "#<procedure") +(getnetbyname "#<procedure") +(getnetent "#<procedure") +(getpass "#<primitive-procedure") +(getpeername "#<primitive-procedure") +(getpgrp "#<primitive-procedure") +(getpid "#<primitive-procedure") +(getppid "#<primitive-procedure") +(getpriority "#<primitive-procedure") +(getproto "#<primitive-procedure") +(getprotobyname "#<procedure") +(getprotobynumber "#<procedure") +(getprotoent "#<procedure") +(getpw "#<primitive-procedure") +(getpwent "#<procedure") +(getpwnam "#<procedure") +(getpwuid "#<procedure") +(getserv "#<primitive-procedure") +(getservbyname "#<procedure") +(getservbyport "#<procedure") +(getservent "#<procedure") +(getsockname "#<primitive-procedure") +(getsockopt "#<primitive-procedure") +(gettimeofday "#<primitive-procedure") +(getuid "#<primitive-procedure") +(gmtime "#<primitive-procedure") +(group:gid "#<procedure") +(group:mem "#<procedure") +(group:name "#<procedure") +(group:passwd "#<procedure") +(guardian-destroyed? "#<primitive-procedure") +(guardian-greedy? "#<primitive-procedure") +(handle-system-error "#<procedure") +(has-shown-backtrace-hint? "") +(has-shown-debugger-hint? "") +(has-suffix? "#<procedure") +(hash "#<primitive-procedure") +(hash-create-handle! "#<primitive-procedure") +(hash-fold "#<primitive-procedure") +(hash-get-handle "#<primitive-procedure") +(hash-ref "#<primitive-procedure") +(hash-remove! "#<primitive-procedure") +(hash-set! "#<primitive-procedure") +(hashq "#<primitive-procedure") +(hashq-create-handle! "#<primitive-procedure") +(hashq-get-handle "#<primitive-procedure") +(hashq-ref "#<primitive-procedure") +(hashq-remove! "#<primitive-procedure") +(hashq-set! "#<primitive-procedure") +(hashv "#<primitive-procedure") +(hashv-create-handle! "#<primitive-procedure") +(hashv-get-handle "#<primitive-procedure") +(hashv-ref "#<primitive-procedure") +(hashv-remove! "#<primitive-procedure") +(hashv-set! "#<primitive-procedure") +(hashx-create-handle! "#<primitive-procedure") +(hashx-get-handle "#<primitive-procedure") +(hashx-ref "#<primitive-procedure") +(hashx-set! "#<primitive-procedure") +(hook->list "#<primitive-procedure") +(hook-empty? "#<primitive-procedure") +(hook? "#<primitive-procedure") +(hostent:addr-list "#<procedure") +(hostent:addrtype "#<procedure") +(hostent:aliases "#<procedure") +(hostent:length "#<procedure") +(hostent:name "#<procedure") +(htonl "#<primitive-procedure") +(htons "#<primitive-procedure") +(identity "#<procedure") +(if "") +(imag-part "#<primitive-procedure") +(import-environment-imports "#<primitive-procedure") +(import-environment-set-imports! "#<primitive-procedure") +(import-environment? "#<primitive-procedure") +(in-vicinity "#<procedure") +(include-deprecated-features "#<primitive-procedure") +(inet-aton "#<primitive-procedure") +(inet-lnaof "#<primitive-procedure") +(inet-makeaddr "#<primitive-procedure") +(inet-netof "#<primitive-procedure") +(inet-ntoa "#<primitive-procedure") +(inet-ntop "#<primitive-procedure") +(inet-pton "#<primitive-procedure") +(inexact->exact "#<primitive-procedure") +(inexact? "#<primitive-procedure") +(inherit-print-state "#<procedure") +(input-port? "#<primitive-procedure") +(integer->char "#<primitive-procedure") +(integer-expt "#<primitive-procedure") +(integer-length "#<primitive-procedure") +(integer? "#<primitive-procedure") +(interaction-environment "#<primitive-procedure") +(internal-time-units-per-second "") +(iota "#<procedure") +(ipow-by-squaring "#<procedure") +(isatty? "#<primitive-procedure") +(issue-deprecation-warning "#<primitive-procedure") +(join-thread "#<primitive-procedure") +(keyword->symbol "#<procedure") +(keyword-dash-symbol "#<primitive-procedure") +(keyword-like-symbol->keyword "#<procedure") +(keyword? "#<primitive-procedure") +(kill "#<primitive-procedure") +(kw-arg-ref "#<procedure") +(lambda "") +(last-pair "#<primitive-procedure") +(last-stack-frame "#<primitive-procedure") +(lazy-catch "#<primitive-procedure") +(lazy-handler-dispatch "#<procedure") +(lcm "#<primitive-procedure") +(leaf-environment? "#<primitive-procedure") +(length "#<primitive-procedure") +(let "") +(let* "") +(letrec "") +(link "#<primitive-procedure") +(list "#<primitive-procedure") +(list->array "#<procedure") +(list->string "#<primitive-procedure") +(list->symbol "#<procedure") +(list->uniform-array "#<primitive-procedure") +(list->uniform-vector "#<procedure") +(list->vector "#<primitive-procedure") +(list->weak-vector "#<primitive-procedure") +(list-cdr-ref "#<primitive-procedure") +(list-cdr-set! "#<primitive-procedure") +(list-copy "#<primitive-procedure") +(list-head "#<primitive-procedure") +(list-index "#<procedure") +(list-ref "#<primitive-procedure") +(list-set! "#<primitive-procedure") +(list-tail "#<primitive-procedure") +(list? "#<primitive-procedure") +(listen "#<primitive-procedure") +(load "#<procedure") +(load-compiled "") +(load-emacs-interface "#<procedure") +(load-extension "#<primitive-procedure") +(load-from-path "#<procedure") +(load-module "#<procedure") +(load-user-init "#<procedure") +(local-define "#<procedure") +(local-eval "#<primitive-procedure") +(local-ref "#<procedure") +(local-remove "#<procedure") +(local-set! "#<procedure") +(localtime "#<primitive-procedure") +(lock-mutex "#<primitive-procedure") +(log "#<procedure") +(log10 "#<procedure") +(logand "#<primitive-procedure") +(logbit? "#<primitive-procedure") +(logcount "#<primitive-procedure") +(logior "#<primitive-procedure") +(lognot "#<primitive-procedure") +(logtest "#<primitive-procedure") +(logxor "#<primitive-procedure") +(lstat "#<primitive-procedure") +(macro-name "#<primitive-procedure") +(macro-table "") +(macro-transformer "#<primitive-procedure") +(macro-type "#<primitive-procedure") +(macro? "#<primitive-procedure") +(macroexpand "#<procedure") +(macroexpand-1 "#<procedure") +(magnitude "#<primitive-procedure") +(major-version "#<primitive-procedure") +(make-arbiter "#<primitive-procedure") +(make-array "#<procedure") +(make-autoload-interface "#<procedure") +(make-class-object "#<primitive-procedure") +(make-condition-variable "#<primitive-procedure") +(make-doubly-weak-hash-table "#<primitive-procedure") +(make-eval-environment "#<primitive-procedure") +(make-export-environment "#<primitive-procedure") +(make-fluid "#<primitive-procedure") +(make-guardian "#<primitive-procedure") +(make-hash-table "#<procedure") +(make-hook "#<primitive-procedure") +(make-import-environment "#<primitive-procedure") +(make-keyword-from-dash-symbol "#<primitive-procedure") +(make-leaf-environment "#<primitive-procedure") +(make-list "#<procedure") +(make-module "#<procedure") +(make-modules-in "#<procedure") +(make-mutex "#<primitive-procedure") +(make-object-property "#<procedure") +(make-polar "#<primitive-procedure") +(make-procedure-with-setter "#<primitive-procedure") +(make-record-type "#<procedure") +(make-rectangular "#<primitive-procedure") +(make-regexp "#<primitive-procedure") +(make-root-module "#<procedure") +(make-scm-module "#<procedure") +(make-shared-array "#<primitive-procedure") +(make-soft-port "#<primitive-procedure") +(make-stack "#<primitive-procedure") +(make-string "#<primitive-procedure") +(make-struct "#<primitive-procedure") +(make-struct-layout "#<primitive-procedure") +(make-subclass-object "#<primitive-procedure") +(make-symbol "#<primitive-procedure") +(make-undefined-variable "#<primitive-procedure") +(make-uniform-array "#<procedure") +(make-uniform-vector "#<primitive-procedure") +(make-variable "#<primitive-procedure") +(make-vector "#<primitive-procedure") +(make-vtable-vtable "#<primitive-procedure") +(make-weak-key-hash-table "#<primitive-procedure") +(make-weak-value-hash-table "#<primitive-procedure") +(make-weak-vector "#<primitive-procedure") +(map "#<primitive-procedure") +(map-in-order "#<primitive-procedure") +(mask-signals "#<primitive-procedure") +(max "#<primitive-procedure") +(member "#<primitive-procedure") +(memoized-environment "#<primitive-procedure") +(memoized? "#<primitive-procedure") +(memq "#<primitive-procedure") +(memv "#<primitive-procedure") +(merge "#<primitive-procedure") +(merge! "#<primitive-procedure") +(micro-version "#<primitive-procedure") +(min "#<primitive-procedure") +(minor-version "#<primitive-procedure") +(mkdir "#<primitive-procedure") +(mknod "#<primitive-procedure") +(mkstemp! "#<primitive-procedure") +(mktime "#<primitive-procedure") +(module-add! "#<procedure") +(module-binder "#<procedure") +(module-bound? "#<procedure") +(module-clear! "#<procedure") +(module-constructor "#<procedure") +(module-define! "#<procedure") +(module-defined? "#<procedure") +(module-ensure-local-variable! "#<procedure") +(module-eval-closure "#<procedure") +(module-export! "#<procedure") +(module-for-each "#<procedure") +(module-kind "#<procedure") +(module-local-variable "#<procedure") +(module-locally-bound? "#<procedure") +(module-make-local-var! "#<procedure") +(module-map "#<procedure") +(module-modified "#<procedure") +(module-name "#<procedure") +(module-obarray "#<procedure") +(module-obarray-get-handle "#<procedure") +(module-obarray-ref "#<procedure") +(module-obarray-remove! "#<procedure") +(module-obarray-set! "#<procedure") +(module-observe "#<procedure") +(module-observe-weak "#<procedure") +(module-observer-id "#<procedure") +(module-observers "#<procedure") +(module-public-interface "#<procedure") +(module-re-export! "#<procedure") +(module-ref "#<procedure") +(module-remove! "#<procedure") +(module-search "#<procedure") +(module-set! "#<procedure") +(module-symbol-binding "#<procedure") +(module-symbol-interned? "#<procedure") +(module-symbol-local-binding "#<procedure") +(module-symbol-locally-interned? "#<procedure") +(module-transformer "#<procedure") +(module-type "") +(module-unobserve "#<procedure") +(module-use! "#<procedure") +(module-uses "#<procedure") +(module-variable "#<procedure") +(module-weak-observers "#<procedure") +(module? "#<procedure") +(modulo "#<primitive-procedure") +(most-negative-fixnum "") +(most-positive-fixnum "") +(move->fdes "#<procedure") +(named-module-use! "#<procedure") +(negative? "#<primitive-procedure") +(nested-define! "#<procedure") +(nested-ref "#<procedure") +(nested-remove! "#<procedure") +(nested-set! "#<procedure") +(netent:addrtype "#<procedure") +(netent:aliases "#<procedure") +(netent:name "#<procedure") +(netent:net "#<procedure") +(newline "#<primitive-procedure") +(nice "#<primitive-procedure") +(nil-cond "") +(noop "#<primitive-procedure") +(not "#<primitive-procedure") +(ntohl "#<primitive-procedure") +(ntohs "#<primitive-procedure") +(null? "#<primitive-procedure") +(number->string "#<primitive-procedure") +(number? "#<primitive-procedure") +(object->string "#<primitive-procedure") +(object-address "#<primitive-procedure") +(object-properties "#<primitive-procedure") +(object-property "#<primitive-procedure") +(odd? "#<primitive-procedure") +(open "#<primitive-procedure") +(open-fdes "#<primitive-procedure") +(open-file "#<primitive-procedure") +(open-input-file "#<procedure") +(open-input-string "#<primitive-procedure") +(open-io-file "#<procedure") +(open-output-file "#<procedure") +(open-output-string "#<primitive-procedure") +(opendir "#<primitive-procedure") +(operator? "#<primitive-procedure") +(or "") +(or-map "#<procedure") +(output-port? "#<primitive-procedure") +(pair? "#<primitive-procedure") +(parse-path "#<primitive-procedure") +(passwd:dir "#<procedure") +(passwd:gecos "#<procedure") +(passwd:gid "#<procedure") +(passwd:name "#<procedure") +(passwd:passwd "#<procedure") +(passwd:shell "#<procedure") +(passwd:uid "#<procedure") +(pause "#<primitive-procedure") +(peek "#<procedure") +(peek-char "#<primitive-procedure") +(pipe "#<primitive-procedure") +(pk "#<procedure") +(port->fdes "#<procedure") +(port-closed? "#<primitive-procedure") +(port-column "#<primitive-procedure") +(port-filename "#<primitive-procedure") +(port-for-each "#<primitive-procedure") +(port-line "#<primitive-procedure") +(port-mode "#<primitive-procedure") +(port-revealed "#<primitive-procedure") +(port-with-print-state "#<primitive-procedure") +(port? "#<primitive-procedure") +(positive? "#<primitive-procedure") +(primitive-eval "#<primitive-procedure") +(primitive-exit "#<primitive-procedure") +(primitive-fork "#<primitive-procedure") +(primitive-load "#<primitive-procedure") +(primitive-load-path "#<primitive-procedure") +(primitive-macro? "#<procedure") +(primitive-make-property "#<primitive-procedure") +(primitive-move->fdes "#<primitive-procedure") +(primitive-property-del! "#<primitive-procedure") +(primitive-property-ref "#<primitive-procedure") +(primitive-property-set! "#<primitive-procedure") +(print-disable "#<procedure") +(print-enable "#<procedure") +(print-options "#<procedure") +(print-options-interface "#<primitive-procedure") +(print-set! "") +(procedure "#<primitive-procedure") +(procedure->macro "#<primitive-procedure") +(procedure->memoizing-macro "#<primitive-procedure") +(procedure->syntax "#<primitive-procedure") +(procedure-documentation "#<primitive-procedure") +(procedure-environment "#<primitive-procedure") +(procedure-name "#<primitive-procedure") +(procedure-properties "#<primitive-procedure") +(procedure-property "#<primitive-procedure") +(procedure-source "#<primitive-procedure") +(procedure-with-setter? "#<primitive-procedure") +(procedure? "#<primitive-procedure") +(process-define-module "#<procedure") +(process-use-modules "#<procedure") +(program-arguments "#<primitive-procedure") +(promise? "#<primitive-procedure") +(protoent:aliases "#<procedure") +(protoent:name "#<procedure") +(protoent:proto "#<procedure") +(provide "#<procedure") +(provided? "#<procedure") +(purify-module! "#<procedure") +(putenv "#<primitive-procedure") +(quasiquote "") +(quit "#<procedure") +(quote "") +(quotient "#<primitive-procedure") +(raise "#<primitive-procedure") +(random "#<primitive-procedure") +(random:exp "#<primitive-procedure") +(random:hollow-sphere! "#<primitive-procedure") +(random:normal "#<primitive-procedure") +(random:normal-vector! "#<primitive-procedure") +(random:solid-sphere! "#<primitive-procedure") +(random:uniform "#<primitive-procedure") +(rational? "#<primitive-procedure") +(re-export "") +(re-export-syntax "") +(read "#<primitive-procedure") +(read-char "#<primitive-procedure") +(read-disable "#<procedure") +(read-enable "#<procedure") +(read-eval? "") +(read-hash-extend "#<primitive-procedure") +(read-hash-procedures "") +(read-options "#<procedure") +(read-options-interface "#<primitive-procedure") +(read-set! "") +(read:array "#<procedure") +(read:uniform-vector "#<procedure") +(readdir "#<primitive-procedure") +(readlink "#<primitive-procedure") +(real-part "#<primitive-procedure") +(real? "#<primitive-procedure") +(record-accessor "#<procedure") +(record-constructor "#<procedure") +(record-modifier "#<procedure") +(record-predicate "#<procedure") +(record-type-descriptor "#<procedure") +(record-type-fields "#<procedure") +(record-type-name "#<procedure") +(record-type-vtable "") +(record-type? "#<procedure") +(record? "#<procedure") +(recv! "#<primitive-procedure") +(recvfrom! "#<primitive-procedure") +(redirect-port "#<primitive-procedure") +(regexp-exec "#<primitive-procedure") +(regexp/basic "") +(regexp/extended "") +(regexp/icase "") +(regexp/newline "") +(regexp/notbol "") +(regexp/noteol "") +(regexp? "#<primitive-procedure") +(release-arbiter "#<primitive-procedure") +(release-port-handle "#<procedure") +(remainder "#<primitive-procedure") +(remove-hook! "#<primitive-procedure") +(rename-file "#<primitive-procedure") +(repl "#<procedure") +(repl-reader "#<procedure") +(reset-hook! "#<primitive-procedure") +(resolve-interface "#<procedure") +(resolve-module "#<procedure") +(restore-signals "#<primitive-procedure") +(restricted-vector-sort! "#<primitive-procedure") +(reverse "#<primitive-procedure") +(reverse! "#<primitive-procedure") +(rewinddir "#<primitive-procedure") +(rmdir "#<primitive-procedure") +(round "#<primitive-procedure") +(run-asyncs "#<primitive-procedure") +(run-hook "#<primitive-procedure") +(save-module-excursion "#<procedure") +(save-stack "#<procedure") +(scheme-file-suffix "#<procedure") +(scm-error "#<primitive-procedure") +(scm-repl-print-unspecified "") +(scm-repl-prompt "") +(scm-repl-silent "") +(scm-repl-verbose "") +(scm-style-repl "#<procedure") +(search-path "#<primitive-procedure") +(seed->random-state "#<primitive-procedure") +(seek "#<primitive-procedure") +(select "#<primitive-procedure") +(send "#<primitive-procedure") +(sendto "#<primitive-procedure") +(servent:aliases "#<procedure") +(servent:name "#<procedure") +(servent:port "#<procedure") +(servent:proto "#<procedure") +(set! "") +(set-autoloaded! "#<procedure") +(set-batch-mode?! "#<procedure") +(set-car! "#<primitive-procedure") +(set-cdr! "#<primitive-procedure") +(set-current-error-port "#<primitive-procedure") +(set-current-input-port "#<primitive-procedure") +(set-current-module "#<primitive-procedure") +(set-current-output-port "#<primitive-procedure") +(set-defmacro-transformer! "#<procedure") +(set-module-binder! "#<procedure") +(set-module-eval-closure! "#<procedure") +(set-module-kind! "#<procedure") +(set-module-name! "#<procedure") +(set-module-obarray! "#<procedure") +(set-module-observer-id! "#<procedure") +(set-module-observers! "#<procedure") +(set-module-public-interface! "#<procedure") +(set-module-transformer! "#<procedure") +(set-module-uses! "#<procedure") +(set-object-procedure! "#<primitive-procedure") +(set-object-properties! "#<primitive-procedure") +(set-object-property! "#<primitive-procedure") +(set-port-column! "#<primitive-procedure") +(set-port-filename! "#<primitive-procedure") +(set-port-line! "#<primitive-procedure") +(set-port-revealed! "#<primitive-procedure") +(set-procedure-properties! "#<primitive-procedure") +(set-procedure-property! "#<primitive-procedure") +(set-repl-prompt! "#<procedure") +(set-source-properties! "#<primitive-procedure") +(set-source-property! "#<primitive-procedure") +(set-struct-vtable-name! "#<primitive-procedure") +(set-symbol-property! "#<procedure") +(set-system-module! "#<procedure") +(set-tm:gmtoff "#<procedure") +(set-tm:hour "#<procedure") +(set-tm:isdst "#<procedure") +(set-tm:mday "#<procedure") +(set-tm:min "#<procedure") +(set-tm:mon "#<procedure") +(set-tm:sec "#<procedure") +(set-tm:wday "#<procedure") +(set-tm:yday "#<procedure") +(set-tm:year "#<procedure") +(set-tm:zone "#<procedure") +(setegid "#<primitive-procedure") +(setenv "#<procedure") +(seteuid "#<primitive-procedure") +(setgid "#<primitive-procedure") +(setgr "#<primitive-procedure") +(setgrent "#<procedure") +(sethost "#<primitive-procedure") +(sethostent "#<procedure") +(sethostname "#<primitive-procedure") +(setitimer "#<primitive-procedure") +(setlocale "#<primitive-procedure") +(setnet "#<primitive-procedure") +(setnetent "#<procedure") +(setpgid "#<primitive-procedure") +(setpriority "#<primitive-procedure") +(setproto "#<primitive-procedure") +(setprotoent "#<procedure") +(setpw "#<primitive-procedure") +(setpwent "#<procedure") +(setserv "#<primitive-procedure") +(setservent "#<procedure") +(setsid "#<primitive-procedure") +(setsockopt "#<primitive-procedure") +(setter "#<primitive-procedure") +(setuid "#<primitive-procedure") +(setvbuf "#<primitive-procedure") +(shared-array-increments "#<primitive-procedure") +(shared-array-offset "#<primitive-procedure") +(shared-array-root "#<primitive-procedure") +(shutdown "#<primitive-procedure") +(sigaction "#<primitive-procedure") +(signal-condition-variable "#<primitive-procedure") +(signal-handlers "") +(simple-format "#<primitive-procedure") +(sin "#<procedure") +(single-active-thread? "#<primitive-procedure") +(sinh "#<procedure") +(sleep "#<primitive-procedure") +(sloppy-assoc "#<primitive-procedure") +(sloppy-assq "#<primitive-procedure") +(sloppy-assv "#<primitive-procedure") +(sockaddr:addr "#<procedure") +(sockaddr:fam "#<procedure") +(sockaddr:path "#<procedure") +(sockaddr:port "#<procedure") +(socket "#<primitive-procedure") +(socketpair "#<primitive-procedure") +(sort "#<primitive-procedure") +(sort! "#<primitive-procedure") +(sort-list "#<primitive-procedure") +(sort-list! "#<primitive-procedure") +(sorted? "#<primitive-procedure") +(source-properties "#<primitive-procedure") +(source-property "#<primitive-procedure") +(source-whash "") +(sqrt "#<procedure") +(stable-sort "#<primitive-procedure") +(stable-sort! "#<primitive-procedure") +(stack-id "#<primitive-procedure") +(stack-length "#<primitive-procedure") +(stack-ref "#<primitive-procedure") +(stack-saved? "") +(stack? "#<primitive-procedure") +(standard-eval-closure "#<primitive-procedure") +(standard-interface-eval-closure "#<primitive-procedure") +(start-stack "") +(stat "#<primitive-procedure") +(stat:atime "#<procedure") +(stat:blksize "#<procedure") +(stat:blocks "#<procedure") +(stat:ctime "#<procedure") +(stat:dev "#<procedure") +(stat:gid "#<procedure") +(stat:ino "#<procedure") +(stat:mode "#<procedure") +(stat:mtime "#<procedure") +(stat:nlink "#<procedure") +(stat:perms "#<procedure") +(stat:rdev "#<procedure") +(stat:size "#<procedure") +(stat:type "#<procedure") +(stat:uid "#<procedure") +(status:exit-val "#<primitive-procedure") +(status:stop-sig "#<primitive-procedure") +(status:term-sig "#<primitive-procedure") +(strerror "#<primitive-procedure") +(strftime "#<primitive-procedure") +(string "#<primitive-procedure") +(string->list "#<primitive-procedure") +(string->number "#<primitive-procedure") +(string->symbol "#<primitive-procedure") +(string-append "#<primitive-procedure") +(string-capitalize "#<primitive-procedure") +(string-capitalize! "#<primitive-procedure") +(string-ci->symbol "#<primitive-procedure") +(string-ci<=? "#<primitive-procedure") +(string-ci<? "#<primitive-procedure") +(string-ci=? "#<primitive-procedure") +(string-ci>=? "#<primitive-procedure") +(string-ci>? "#<primitive-procedure") +(string-copy "#<primitive-procedure") +(string-downcase "#<primitive-procedure") +(string-downcase! "#<primitive-procedure") +(string-fill! "#<primitive-procedure") +(string-index "#<primitive-procedure") +(string-length "#<primitive-procedure") +(string-null? "#<primitive-procedure") +(string-ref "#<primitive-procedure") +(string-rindex "#<primitive-procedure") +(string-set! "#<primitive-procedure") +(string-split "#<primitive-procedure") +(string-upcase "#<primitive-procedure") +(string-upcase! "#<primitive-procedure") +(string<=? "#<primitive-procedure") +(string<? "#<primitive-procedure") +(string=? "#<primitive-procedure") +(string>=? "#<primitive-procedure") +(string>? "#<primitive-procedure") +(string? "#<primitive-procedure") +(strptime "#<primitive-procedure") +(struct-layout "#<procedure") +(struct-ref "#<primitive-procedure") +(struct-set! "#<primitive-procedure") +(struct-vtable "#<primitive-procedure") +(struct-vtable-name "#<primitive-procedure") +(struct-vtable-tag "#<primitive-procedure") +(struct-vtable? "#<primitive-procedure") +(struct? "#<primitive-procedure") +(substring "#<primitive-procedure") +(substring-fill! "#<primitive-procedure") +(substring-move! "#<primitive-procedure") +(symbol "#<procedure") +(symbol->keyword "#<procedure") +(symbol->string "#<primitive-procedure") +(symbol-append "#<procedure") +(symbol-fref "#<primitive-procedure") +(symbol-fset! "#<primitive-procedure") +(symbol-hash "#<primitive-procedure") +(symbol-interned? "#<primitive-procedure") +(symbol-pref "#<primitive-procedure") +(symbol-prefix-proc "#<procedure") +(symbol-property "#<procedure") +(symbol-property-remove! "#<procedure") +(symbol-pset! "#<primitive-procedure") +(symbol? "#<primitive-procedure") +(symlink "#<primitive-procedure") +(sync "#<primitive-procedure") +(system "#<primitive-procedure") +(system-async "#<primitive-procedure") +(system-async-mark "#<primitive-procedure") +(system-error-errno "#<procedure") +(tan "#<procedure") +(tanh "#<procedure") +(tcgetpgrp "#<primitive-procedure") +(tcsetpgrp "#<primitive-procedure") +(the-environment "") +(the-eof-object "") +(the-last-stack "") +(the-root-environment "") +(the-root-module "") +(the-scm-module "") +(throw "#<primitive-procedure") +(thunk? "#<primitive-procedure") +(times "#<primitive-procedure") +(tm:gmtoff "#<procedure") +(tm:hour "#<procedure") +(tm:isdst "#<procedure") +(tm:mday "#<procedure") +(tm:min "#<procedure") +(tm:mon "#<procedure") +(tm:sec "#<procedure") +(tm:wday "#<procedure") +(tm:yday "#<procedure") +(tm:year "#<procedure") +(tm:zone "#<procedure") +(tmpnam "#<primitive-procedure") +(tms:clock "#<procedure") +(tms:cstime "#<procedure") +(tms:cutime "#<procedure") +(tms:stime "#<procedure") +(tms:utime "#<procedure") +(top-repl "#<procedure") +(transform-usage-lambda "#<procedure") +(transpose-array "#<primitive-procedure") +(trap-disable "#<procedure") +(trap-enable "#<procedure") +(trap-set! "") +(traps "#<procedure") +(truncate "#<primitive-procedure") +(truncate-file "#<primitive-procedure") +(try-arbiter "#<primitive-procedure") +(try-load-module "#<procedure") +(try-module-autoload "#<procedure") +(ttyname "#<primitive-procedure") +(turn-on-debugging "#<procedure") +(tzset "#<primitive-procedure") +(umask "#<primitive-procedure") +(uname "#<primitive-procedure") +(undefine "") +(uniform-array-read! "#<primitive-procedure") +(uniform-array-set1! "#<primitive-procedure") +(uniform-array-write "#<primitive-procedure") +(uniform-vector-fill! "#<primitive-procedure") +(uniform-vector-length "#<primitive-procedure") +(uniform-vector-read! "#<primitive-procedure") +(uniform-vector-ref "#<primitive-procedure") +(uniform-vector-set! "#<procedure") +(uniform-vector-write "#<primitive-procedure") +(uniform-vector? "#<primitive-procedure") +(unlock-mutex "#<primitive-procedure") +(unmask-signals "#<primitive-procedure") +(unmemoize "#<primitive-procedure") +(unread-char "#<primitive-procedure") +(unread-string "#<primitive-procedure") +(unspecified? "#<procedure") +(use-emacs-interface "") +(use-modules "") +(use-srfis "#<procedure") +(use-syntax "") +(using-readline? "#<procedure-with-setter>") +(usleep "#<primitive-procedure") +(utime "#<primitive-procedure") +(utsname:machine "#<procedure") +(utsname:nodename "#<procedure") +(utsname:release "#<procedure") +(utsname:sysname "#<procedure") +(utsname:version "#<procedure") +(valid-object-procedure? "#<primitive-procedure") +(values "#<primitive-procedure") +(variable-bound? "#<primitive-procedure") +(variable-ref "#<primitive-procedure") +(variable-set! "#<primitive-procedure") +(variable? "#<primitive-procedure") +(vector "#<primitive-procedure") +(vector->list "#<primitive-procedure") +(vector-fill! "#<primitive-procedure") +(vector-length "#<primitive-procedure") +(vector-move-left! "#<primitive-procedure") +(vector-move-right! "#<primitive-procedure") +(vector-ref "#<primitive-procedure") +(vector-set! "#<primitive-procedure") +(vector? "#<primitive-procedure") +(version "#<primitive-procedure") +(vtable-index-layout "") +(vtable-index-printer "") +(vtable-index-vtable "") +(vtable-offset-user "") +(wait-condition-variable "#<primitive-procedure") +(waitpid "#<primitive-procedure") +(warn "#<procedure") +(weak-key-hash-table? "#<primitive-procedure") +(weak-value-hash-table? "#<primitive-procedure") +(weak-vector "#<primitive-procedure") +(weak-vector? "#<primitive-procedure") +(while "") +(with-error-to-file "#<procedure") +(with-error-to-port "#<procedure") +(with-error-to-string "#<procedure") +(with-fluids "") +(with-fluids* "#<primitive-procedure") +(with-input-from-file "#<procedure") +(with-input-from-port "#<procedure") +(with-input-from-string "#<procedure") +(with-output-to-file "#<procedure") +(with-output-to-port "#<procedure") +(with-output-to-string "#<procedure") +(with-traps "#<primitive-procedure") +(write "#<primitive-procedure") +(write-char "#<primitive-procedure") +(xformer-table "") +(yield "#<primitive-procedure") +(zero? "#<primitive-procedure") +) ;; end of scheme +(C +(collisionp B) +(coop_abort T) +(coop_condition_variable_destroy T) +(coop_condition_variable_init T) +(coop_condition_variable_signal T) +(coop_condition_variable_timed_wait_mutex T) +(coop_condition_variable_wait_mutex T) +(coop_create T) +(coop_getspecific T) +(coop_global_allq B) +(coop_global_curr B) +(coop_global_runq B) +(coop_global_sleepq B) +(coop_init T) +(coop_join T) +(coop_key_create T) +(coop_key_delete T) +(coop_mutex_destroy T) +(coop_mutex_init T) +(coop_mutex_lock T) +(coop_mutex_trylock T) +(coop_mutex_unlock T) +(coop_new_condition_variable_init T) +(coop_new_mutex_init T) +(coop_next_runnable_thread T) +(coop_qget T) +(coop_qput T) +(coop_setspecific T) +(coop_sleephelp T) +(coop_start T) +(coop_timeout_qinsert T) +(coop_tmp_queue B) +(coop_wait_for_runnable_thread T) +(coop_wait_for_runnable_thread_now T) +(coop_yield T) +(gdb_binding T) +(gdb_eval T) +(gdb_language D) +(gdb_maybe_valid_type_p T) +(gdb_options D) +(gdb_output B) +(gdb_output_length B) +(gdb_print T) +(gdb_read T) +(gdb_result B) +(gexceptfds B) +(gh_append T) +(gh_append2 T) +(gh_append3 T) +(gh_append4 T) +(gh_apply T) +(gh_bool2scm T) +(gh_boolean_p T) +(gh_caaar T) +(gh_caadr T) +(gh_caar T) +(gh_cadar T) +(gh_caddr T) +(gh_cadr T) +(gh_call0 T) +(gh_call1 T) +(gh_call2 T) +(gh_call3 T) +(gh_car T) +(gh_catch T) +(gh_cdaar T) +(gh_cdadr T) +(gh_cdar T) +(gh_cddar T) +(gh_cdddr T) +(gh_cddr T) +(gh_cdr T) +(gh_char2scm T) +(gh_char_p T) +(gh_chars2byvect T) +(gh_cons T) +(gh_define T) +(gh_display T) +(gh_double2scm T) +(gh_doubles2dvect T) +(gh_doubles2scm T) +(gh_enter T) +(gh_eq_p T) +(gh_equal_p T) +(gh_eqv_p T) +(gh_eval_file T) +(gh_eval_file_with_catch T) +(gh_eval_file_with_standard_handler T) +(gh_eval_str T) +(gh_eval_str_with_catch T) +(gh_eval_str_with_stack_saving_handler T) +(gh_eval_str_with_standard_handler T) +(gh_exact_p T) +(gh_floats2fvect T) +(gh_get_substr T) +(gh_inexact_p T) +(gh_int2scm T) +(gh_ints2scm T) +(gh_length T) +(gh_list_p T) +(gh_long2scm T) +(gh_longs2ivect T) +(gh_lookup T) +(gh_make_vector T) +(gh_module_lookup T) +(gh_new_procedure T) +(gh_new_procedure0_0 T) +(gh_new_procedure0_1 T) +(gh_new_procedure0_2 T) +(gh_new_procedure1_0 T) +(gh_new_procedure1_1 T) +(gh_new_procedure1_2 T) +(gh_new_procedure2_0 T) +(gh_new_procedure2_1 T) +(gh_new_procedure2_2 T) +(gh_new_procedure3_0 T) +(gh_new_procedure4_0 T) +(gh_new_procedure5_0 T) +(gh_newline T) +(gh_null_p T) +(gh_number_p T) +(gh_pair_p T) +(gh_procedure_p T) +(gh_repl T) +(gh_scm2bool T) +(gh_scm2char T) +(gh_scm2chars T) +(gh_scm2double T) +(gh_scm2doubles T) +(gh_scm2floats T) +(gh_scm2int T) +(gh_scm2long T) +(gh_scm2longs T) +(gh_scm2newstr T) +(gh_scm2shorts T) +(gh_scm2ulong T) +(gh_set_car_x T) +(gh_set_cdr_x T) +(gh_set_substr T) +(gh_shorts2svect T) +(gh_standard_handler T) +(gh_str02scm T) +(gh_str2scm T) +(gh_string_equal_p T) +(gh_string_p T) +(gh_symbol2newstr T) +(gh_symbol2scm T) +(gh_symbol_p T) +(gh_ulong2scm T) +(gh_ulongs2uvect T) +(gh_uniform_vector_length T) +(gh_uniform_vector_ref T) +(gh_vector_length T) +(gh_vector_p T) +(gh_vector_ref T) +(gh_vector_set_x T) +(gh_write T) +(gnfds B) +(greadfds B) +(gwritefds B) +(issued_msgs B) +(rexceptfds B) +(rreadfds B) +(rwritefds B) +(scm_I_am_dead B) +(scm_abs T) +(scm_accept T) +(scm_access T) +(scm_accessor_method_slot_definition T) +(scm_acons T) +(scm_acosh T) +(scm_add_feature T) +(scm_add_hook_x T) +(scm_add_method T) +(scm_add_slot T) +(scm_add_to_port_table T) +(scm_addbig T) +(scm_after_gc_c_hook B) +(scm_after_gc_hook B) +(scm_after_sweep_c_hook B) +(scm_aind T) +(scm_alarm T) +(scm_alloc_struct T) +(scm_allocate_string T) +(scm_angle T) +(scm_append T) +(scm_append_x T) +(scm_apply T) +(scm_apply_0 T) +(scm_apply_1 T) +(scm_apply_2 T) +(scm_apply_3 T) +(scm_apply_generic T) +(scm_apply_with_dynamic_root T) +(scm_arg_type_key B) +(scm_args_number_key B) +(scm_array_contents T) +(scm_array_copy_x T) +(scm_array_dimensions T) +(scm_array_equal_p T) +(scm_array_fill_int T) +(scm_array_fill_x T) +(scm_array_for_each T) +(scm_array_identity T) +(scm_array_in_bounds_p T) +(scm_array_index_map_x T) +(scm_array_map_x T) +(scm_array_p T) +(scm_array_prototype T) +(scm_array_rank T) +(scm_array_set_x T) +(scm_ash T) +(scm_asinh T) +(scm_assoc T) +(scm_assoc_ref T) +(scm_assoc_remove_x T) +(scm_assoc_set_x T) +(scm_assq T) +(scm_assq_ref T) +(scm_assq_remove_x T) +(scm_assq_set_x T) +(scm_assv T) +(scm_assv_ref T) +(scm_assv_remove_x T) +(scm_assv_set_x T) +(scm_async T) +(scm_async_click T) +(scm_async_mark T) +(scm_asyncs_pending_p D) +(scm_atanh T) +(scm_backtrace T) +(scm_badargsp T) +(scm_basename T) +(scm_basic_basic_make_class T) +(scm_basic_make_class T) +(scm_before_gc_c_hook B) +(scm_before_mark_c_hook B) +(scm_before_sweep_c_hook B) +(scm_big_and T) +(scm_big_ior T) +(scm_big_test T) +(scm_big_xor T) +(scm_bigcomp T) +(scm_bigequal T) +(scm_bigprint T) +(scm_bind T) +(scm_bit_count T) +(scm_bit_count_star T) +(scm_bit_extract T) +(scm_bit_invert_x T) +(scm_bit_position T) +(scm_bit_set_star_x T) +(scm_block_gc D) +(scm_body_thunk T) +(scm_boolean_p T) +(scm_boot_guile T) +(scm_boot_guile_1_live D) +(scm_c_call_with_current_module T) +(scm_c_chars2byvect T) +(scm_c_chars2scm T) +(scm_c_default_rstate T) +(scm_c_define T) +(scm_c_define_gsubr T) +(scm_c_define_gsubr_with_generic T) +(scm_c_define_module T) +(scm_c_define_subr T) +(scm_c_define_subr_with_generic T) +(scm_c_doubles2dvect T) +(scm_c_doubles2scm T) +(scm_c_environment_cell T) +(scm_c_environment_fold T) +(scm_c_environment_observe T) +(scm_c_environment_ref T) +(scm_c_eval_string T) +(scm_c_exp1 T) +(scm_c_export T) +(scm_c_floats2fvect T) +(scm_c_floats2scm T) +(scm_c_get_internal_run_time T) +(scm_c_hook_add T) +(scm_c_hook_init T) +(scm_c_hook_remove T) +(scm_c_hook_run T) +(scm_c_ints2ivect T) +(scm_c_ints2scm T) +(scm_c_issue_deprecation_warning T) +(scm_c_load_extension T) +(scm_c_longs2ivect T) +(scm_c_longs2scm T) +(scm_c_lookup T) +(scm_c_make_gsubr T) +(scm_c_make_gsubr_with_generic T) +(scm_c_make_hash_table T) +(scm_c_make_keyword T) +(scm_c_make_rstate T) +(scm_c_make_subr T) +(scm_c_make_subr_with_generic T) +(scm_c_make_vector T) +(scm_c_memq T) +(scm_c_module_define T) +(scm_c_module_lookup T) +(scm_c_normal01 T) +(scm_c_primitive_load T) +(scm_c_primitive_load_path T) +(scm_c_random T) +(scm_c_random_bignum T) +(scm_c_read T) +(scm_c_read_string T) +(scm_c_register_extension T) +(scm_c_resolve_module T) +(scm_c_run_hook T) +(scm_c_scm2chars T) +(scm_c_scm2doubles T) +(scm_c_scm2floats T) +(scm_c_scm2ints T) +(scm_c_scm2longs T) +(scm_c_scm2shorts T) +(scm_c_shorts2scm T) +(scm_c_shorts2svect T) +(scm_c_string2str T) +(scm_c_substring2str T) +(scm_c_symbol2str T) +(scm_c_uints2uvect T) +(scm_c_ulongs2uvect T) +(scm_c_uniform01 T) +(scm_c_use_module T) +(scm_c_with_fluid T) +(scm_c_with_fluids T) +(scm_c_write T) +(scm_call_0 T) +(scm_call_1 T) +(scm_call_2 T) +(scm_call_3 T) +(scm_call_4 T) +(scm_call_generic_0 T) +(scm_call_generic_1 T) +(scm_call_generic_2 T) +(scm_call_generic_3 T) +(scm_call_with_dynamic_root T) +(scm_call_with_input_string T) +(scm_call_with_new_thread T) +(scm_call_with_output_string T) +(scm_casei_streq T) +(scm_catch T) +(scm_cellp T) +(scm_cells_allocated D) +(scm_ceval T) +(scm_ceval_ptr B) +(scm_change_object_class T) +(scm_char_alphabetic_p T) +(scm_char_ci_eq_p T) +(scm_char_ci_geq_p T) +(scm_char_ci_gr_p T) +(scm_char_ci_leq_p T) +(scm_char_ci_less_p T) +(scm_char_downcase T) +(scm_char_eq_p T) +(scm_char_geq_p T) +(scm_char_gr_p T) +(scm_char_is_both_p T) +(scm_char_leq_p T) +(scm_char_less_p T) +(scm_char_lower_case_p T) +(scm_char_numeric_p T) +(scm_char_p T) +(scm_char_ready_p T) +(scm_char_to_integer T) +(scm_char_upcase T) +(scm_char_upper_case_p T) +(scm_char_whitespace_p T) +(scm_charnames D) +(scm_charnums R) +(scm_chdir T) +(scm_check_apply_p B) +(scm_check_entry_p B) +(scm_check_exit_p B) +(scm_chmod T) +(scm_chown T) +(scm_chroot T) +(scm_class_accessor B) +(scm_class_boolean B) +(scm_class_char B) +(scm_class_class B) +(scm_class_complex B) +(scm_class_direct_methods T) +(scm_class_direct_slots T) +(scm_class_direct_subclasses T) +(scm_class_direct_supers T) +(scm_class_double B) +(scm_class_entity B) +(scm_class_entity_class B) +(scm_class_entity_with_setter B) +(scm_class_environment T) +(scm_class_float B) +(scm_class_foreign_class B) +(scm_class_foreign_object B) +(scm_class_foreign_slot B) +(scm_class_generic B) +(scm_class_generic_with_setter B) +(scm_class_input_output_port B) +(scm_class_input_port B) +(scm_class_int B) +(scm_class_integer B) +(scm_class_keyword B) +(scm_class_list B) +(scm_class_method B) +(scm_class_name T) +(scm_class_null B) +(scm_class_number B) +(scm_class_object B) +(scm_class_of T) +(scm_class_opaque B) +(scm_class_operator_class B) +(scm_class_operator_with_setter_class B) +(scm_class_output_port B) +(scm_class_pair B) +(scm_class_port B) +(scm_class_precedence_list T) +(scm_class_primitive_generic B) +(scm_class_procedure B) +(scm_class_procedure_class B) +(scm_class_procedure_with_setter B) +(scm_class_protected B) +(scm_class_protected_opaque B) +(scm_class_protected_read_only B) +(scm_class_read_only B) +(scm_class_real B) +(scm_class_scm B) +(scm_class_self B) +(scm_class_simple_method B) +(scm_class_slots T) +(scm_class_string B) +(scm_class_symbol B) +(scm_class_top B) +(scm_class_unknown B) +(scm_class_vector B) +(scm_close T) +(scm_close_fdes T) +(scm_close_input_port T) +(scm_close_output_port T) +(scm_close_port T) +(scm_closedir T) +(scm_closure T) +(scm_closure_p T) +(scm_compile_shell_switches T) +(scm_complex_equalp T) +(scm_components B) +(scm_compute_applicable_methods T) +(scm_connect T) +(scm_cons T) +(scm_cons2 T) +(scm_cons_source T) +(scm_cons_star T) +(scm_copy_big_dec T) +(scm_copy_file T) +(scm_copy_fluids T) +(scm_copy_random_state T) +(scm_copy_smaller T) +(scm_copy_tree T) +(scm_count_argv T) +(scm_critical_section_mutex B) +(scm_crypt T) +(scm_ctermid T) +(scm_current_error_port T) +(scm_current_input_port T) +(scm_current_load_port T) +(scm_current_module T) +(scm_current_module_lookup_closure T) +(scm_current_module_transformer T) +(scm_current_output_port T) +(scm_current_time T) +(scm_cuserid T) +(scm_cvref T) +(scm_dapply T) +(scm_dblprec B) +(scm_debug_eframe_size B) +(scm_debug_mode B) +(scm_debug_object_p T) +(scm_debug_options T) +(scm_debug_opts D) +(scm_default_init_heap_size_1 D) +(scm_default_init_heap_size_2 D) +(scm_default_max_segment_size D) +(scm_default_min_yield_1 D) +(scm_default_min_yield_2 D) +(scm_define T) +(scm_definedp T) +(scm_delete T) +(scm_delete1_x T) +(scm_delete_file T) +(scm_delete_x T) +(scm_delq T) +(scm_delq1_x T) +(scm_delq_x T) +(scm_delv T) +(scm_delv1_x T) +(scm_delv_x T) +(scm_deprecated_newcell T) +(scm_deprecated_newcell2 T) +(scm_destroy_guardian_x T) +(scm_deval T) +(scm_difference T) +(scm_dimensions_to_uniform_array T) +(scm_directory_stream_p T) +(scm_dirname T) +(scm_display T) +(scm_display_application T) +(scm_display_backtrace T) +(scm_display_error T) +(scm_display_error_message T) +(scm_divbigdig T) +(scm_divide T) +(scm_done_free T) +(scm_done_malloc T) +(scm_dot_string B) +(scm_double2num T) +(scm_doubly_weak_hash_table_p T) +(scm_dowinds T) +(scm_downcase T) +(scm_drain_input T) +(scm_dup2 T) +(scm_dup_to_fdes T) +(scm_dynamic_args_call T) +(scm_dynamic_call T) +(scm_dynamic_func T) +(scm_dynamic_link T) +(scm_dynamic_object_p T) +(scm_dynamic_root T) +(scm_dynamic_unlink T) +(scm_dynamic_wind T) +(scm_enable_primitive_generic_x T) +(scm_enclose_array T) +(scm_end_input T) +(scm_ensure_accessor T) +(scm_entity_p T) +(scm_env_module T) +(scm_env_top_level T) +(scm_environ T) +(scm_environment_bound_p T) +(scm_environment_cell T) +(scm_environment_define T) +(scm_environment_fold T) +(scm_environment_observe T) +(scm_environment_observe_weak T) +(scm_environment_p T) +(scm_environment_ref T) +(scm_environment_set_x T) +(scm_environment_undefine T) +(scm_environment_unobserve T) +(scm_environments_prehistory T) +(scm_eof_object_p T) +(scm_eq_p T) +(scm_equal_p T) +(scm_eqv_p T) +(scm_error T) +(scm_error_environment_immutable_binding T) +(scm_error_environment_immutable_location T) +(scm_error_environment_unbound T) +(scm_error_num_args_subr T) +(scm_error_revive_threads T) +(scm_error_scm T) +(scm_eval T) +(scm_eval_args T) +(scm_eval_body T) +(scm_eval_car T) +(scm_eval_closure_lookup T) +(scm_eval_environment_imported T) +(scm_eval_environment_local T) +(scm_eval_environment_p T) +(scm_eval_environment_set_imported_x T) +(scm_eval_environment_set_local_x T) +(scm_eval_options_interface T) +(scm_eval_opts D) +(scm_eval_stack B) +(scm_eval_string T) +(scm_eval_x T) +(scm_evaluator_trap_table D) +(scm_evaluator_traps T) +(scm_even_p T) +(scm_evict_ports T) +(scm_exact_p T) +(scm_exact_to_inexact T) +(scm_execl T) +(scm_execle T) +(scm_execlp T) +(scm_exit_status T) +(scm_expmem D) +(scm_export_environment_p T) +(scm_export_environment_private T) +(scm_export_environment_set_private_x T) +(scm_export_environment_set_signature_x T) +(scm_export_environment_signature T) +(scm_f_apply B) +(scm_f_gsubr_apply B) +(scm_fcntl T) +(scm_fdes_to_port T) +(scm_fdes_to_ports T) +(scm_fdopen T) +(scm_file_port_p T) +(scm_fileno T) +(scm_fill_input T) +(scm_find_executable T) +(scm_find_method T) +(scm_finish_srcprop T) +(scm_float2num T) +(scm_flock T) +(scm_fluid_p T) +(scm_fluid_ref T) +(scm_fluid_set_x T) +(scm_flush T) +(scm_flush_all_ports T) +(scm_flush_ws T) +(scm_for_each T) +(scm_force T) +(scm_force_output T) +(scm_fork T) +(scm_frame_arguments T) +(scm_frame_evaluating_args_p T) +(scm_frame_next T) +(scm_frame_number T) +(scm_frame_overflow_p T) +(scm_frame_p T) +(scm_frame_previous T) +(scm_frame_procedure T) +(scm_frame_procedure_p T) +(scm_frame_real_p T) +(scm_frame_source T) +(scm_free0 T) +(scm_free_print_state T) +(scm_free_subr_entry T) +(scm_freelist D) +(scm_freelist2 D) +(scm_fsync T) +(scm_ftell T) +(scm_gc T) +(scm_gc_cells_collected B) +(scm_gc_cells_marked_acc D) +(scm_gc_cells_swept D) +(scm_gc_cells_swept_acc D) +(scm_gc_for_newcell T) +(scm_gc_heap_lock D) +(scm_gc_malloc_collected B) +(scm_gc_mark T) +(scm_gc_mark_dependencies T) +(scm_gc_mark_time_taken D) +(scm_gc_ports_collected B) +(scm_gc_protect_object T) +(scm_gc_register_root T) +(scm_gc_register_roots T) +(scm_gc_running_p D) +(scm_gc_stats T) +(scm_gc_sweep T) +(scm_gc_sweep_time_taken D) +(scm_gc_time_taken D) +(scm_gc_times D) +(scm_gc_unprotect_object T) +(scm_gc_unregister_root T) +(scm_gc_unregister_roots T) +(scm_gc_yield B) +(scm_gcd T) +(scm_generic_capability_p T) +(scm_generic_function_methods T) +(scm_generic_function_name T) +(scm_gensym T) +(scm_geq_p T) +(scm_get_internal_real_time T) +(scm_get_internal_run_time T) +(scm_get_keyword T) +(scm_get_meta_args T) +(scm_get_one_zombie T) +(scm_get_output_string T) +(scm_get_pre_modules_obarray T) +(scm_get_print_state T) +(scm_get_stack_base T) +(scm_getc T) +(scm_getcwd T) +(scm_getegid T) +(scm_getenv T) +(scm_geteuid T) +(scm_getgid T) +(scm_getgrgid T) +(scm_getgroups T) +(scm_gethost T) +(scm_gethostname T) +(scm_getitimer T) +(scm_getlogin T) +(scm_getnet T) +(scm_getpass T) +(scm_getpeername T) +(scm_getpgrp T) +(scm_getpid T) +(scm_getppid T) +(scm_getpriority T) +(scm_getproto T) +(scm_getpwuid T) +(scm_getserv T) +(scm_getsockname T) +(scm_getsockopt T) +(scm_gettimeofday T) +(scm_getuid T) +(scm_gmtime T) +(scm_gr_p T) +(scm_grow_tok_buf T) +(scm_gsubr_apply T) +(scm_guard T) +(scm_guardian_destroyed_p T) +(scm_guardian_greedy_p T) +(scm_handle_by_message T) +(scm_handle_by_message_noexit T) +(scm_handle_by_proc T) +(scm_handle_by_proc_catching_all T) +(scm_handle_by_throw T) +(scm_hash T) +(scm_hash_create_handle_x T) +(scm_hash_fn_create_handle_x T) +(scm_hash_fn_get_handle T) +(scm_hash_fn_ref T) +(scm_hash_fn_remove_x T) +(scm_hash_fn_set_x T) +(scm_hash_fold T) +(scm_hash_get_handle T) +(scm_hash_ref T) +(scm_hash_remove_x T) +(scm_hash_set_x T) +(scm_hasher T) +(scm_hashq T) +(scm_hashq_create_handle_x T) +(scm_hashq_get_handle T) +(scm_hashq_ref T) +(scm_hashq_remove_x T) +(scm_hashq_set_x T) +(scm_hashv T) +(scm_hashv_create_handle_x T) +(scm_hashv_get_handle T) +(scm_hashv_ref T) +(scm_hashv_remove_x T) +(scm_hashv_set_x T) +(scm_hashx_create_handle_x T) +(scm_hashx_get_handle T) +(scm_hashx_ref T) +(scm_hashx_remove_x T) +(scm_hashx_set_x T) +(scm_heap_org B) +(scm_heap_table D) +(scm_hook_empty_p T) +(scm_hook_p T) +(scm_hook_to_list T) +(scm_htonl T) +(scm_htons T) +(scm_i_adjbig T) +(scm_i_big2dbl T) +(scm_i_big2inum T) +(scm_i_copy_rstate T) +(scm_i_copybig T) +(scm_i_dbl2big T) +(scm_i_display_error T) +(scm_i_dummy B) +(scm_i_eval T) +(scm_i_eval_x T) +(scm_i_get_keyword T) +(scm_i_init_rstate T) +(scm_i_int2big T) +(scm_i_long2big T) +(scm_i_long_long2big T) +(scm_i_make_class_object T) +(scm_i_mem2number T) +(scm_i_mkbig T) +(scm_i_normbig T) +(scm_i_procedure_arity T) +(scm_i_ptrdiff2big T) +(scm_i_short2big T) +(scm_i_size2big T) +(scm_i_uint2big T) +(scm_i_ulong2big T) +(scm_i_ulong_long2big T) +(scm_i_uniform32 T) +(scm_i_ushort2big T) +(scm_i_variable_print T) +(scm_ice_9_already_loaded D) +(scm_igc T) +(scm_ihash T) +(scm_ihashq T) +(scm_ihashv T) +(scm_iint2str T) +(scm_ilength T) +(scm_ilookup T) +(scm_imag_part T) +(scm_import_environment_imports T) +(scm_import_environment_p T) +(scm_import_environment_set_imports_x T) +(scm_include_deprecated_features T) +(scm_inet_aton T) +(scm_inet_makeaddr T) +(scm_inet_netof T) +(scm_inet_ntoa T) +(scm_inet_ntop T) +(scm_inet_pton T) +(scm_inexact_p T) +(scm_inexact_to_exact T) +(scm_init_alist T) +(scm_init_arbiters T) +(scm_init_async T) +(scm_init_backtrace T) +(scm_init_boolean T) +(scm_init_chars T) +(scm_init_continuations T) +(scm_init_debug T) +(scm_init_deprecation T) +(scm_init_dynamic_linking T) +(scm_init_dynwind T) +(scm_init_environments T) +(scm_init_eq T) +(scm_init_error T) +(scm_init_eval T) +(scm_init_evalext T) +(scm_init_extensions T) +(scm_init_feature T) +(scm_init_filesys T) +(scm_init_fluids T) +(scm_init_fports T) +(scm_init_gc T) +(scm_init_gdbint T) +(scm_init_goops T) +(scm_init_goops_builtins T) +(scm_init_gsubr T) +(scm_init_guardians T) +(scm_init_guile T) +(scm_init_hash T) +(scm_init_hashtab T) +(scm_init_hooks T) +(scm_init_ioext T) +(scm_init_iselect T) +(scm_init_keywords T) +(scm_init_lang T) +(scm_init_list T) +(scm_init_load T) +(scm_init_load_path T) +(scm_init_macros T) +(scm_init_mallocs T) +(scm_init_modules T) +(scm_init_net_db T) +(scm_init_numbers T) +(scm_init_objects T) +(scm_init_objprop T) +(scm_init_options T) +(scm_init_opts T) +(scm_init_pairs T) +(scm_init_ports T) +(scm_init_posix T) +(scm_init_print T) +(scm_init_procprop T) +(scm_init_procs T) +(scm_init_properties T) +(scm_init_ramap T) +(scm_init_random T) +(scm_init_rdelim T) +(scm_init_rdelim_builtins T) +(scm_init_read T) +(scm_init_regex_posix T) +(scm_init_root T) +(scm_init_rw T) +(scm_init_rw_builtins T) +(scm_init_scmsigs T) +(scm_init_script T) +(scm_init_simpos T) +(scm_init_socket T) +(scm_init_sort T) +(scm_init_srcprop T) +(scm_init_stackchk T) +(scm_init_stacks T) +(scm_init_stime T) +(scm_init_storage T) +(scm_init_strings T) +(scm_init_strop T) +(scm_init_strorder T) +(scm_init_strports T) +(scm_init_struct T) +(scm_init_subr_table T) +(scm_init_symbols T) +(scm_init_threads T) +(scm_init_throw T) +(scm_init_unif T) +(scm_init_values T) +(scm_init_variable T) +(scm_init_vectors T) +(scm_init_version T) +(scm_init_vports T) +(scm_init_weaks T) +(scm_initialized_p D) +(scm_input_port_p T) +(scm_instance_p T) +(scm_int2num T) +(scm_integer_expt T) +(scm_integer_length T) +(scm_integer_p T) +(scm_integer_to_char T) +(scm_interaction_environment T) +(scm_internal_catch T) +(scm_internal_cwdr T) +(scm_internal_dynamic_wind T) +(scm_internal_hash_fold T) +(scm_internal_lazy_catch T) +(scm_internal_parse_path T) +(scm_internal_select T) +(scm_internal_stack_catch T) +(scm_intprint T) +(scm_ints_disabled D) +(scm_iprin1 T) +(scm_iprlist T) +(scm_ipruk T) +(scm_isatty_p T) +(scm_issue_deprecation_warning T) +(scm_istr2bve T) +(scm_isymnames D) +(scm_ithrow T) +(scm_join_thread T) +(scm_keyword_dash_symbol T) +(scm_keyword_p T) +(scm_kill T) +(scm_last_pair T) +(scm_last_stack_frame T) +(scm_lazy_catch T) +(scm_lcm T) +(scm_leaf_environment_p T) +(scm_length T) +(scm_leq_p T) +(scm_less_p T) +(scm_lfwrite T) +(scm_link T) +(scm_list T) +(scm_list_1 T) +(scm_list_2 T) +(scm_list_3 T) +(scm_list_4 T) +(scm_list_5 T) +(scm_list_cdr_set_x T) +(scm_list_copy T) +(scm_list_head T) +(scm_list_n T) +(scm_list_p T) +(scm_list_ref T) +(scm_list_set_x T) +(scm_list_tail T) +(scm_list_to_uniform_array T) +(scm_listen T) +(scm_listofnullstr B) +(scm_lnaof T) +(scm_load_extension T) +(scm_load_goops T) +(scm_load_startup_files T) +(scm_local_eval T) +(scm_localtime T) +(scm_lock_mutex T) +(scm_logand T) +(scm_logbit_p T) +(scm_logcount T) +(scm_logior T) +(scm_lognot T) +(scm_logtest T) +(scm_logxor T) +(scm_long2num T) +(scm_long_long2num T) +(scm_lookup T) +(scm_lookup_closure_module T) +(scm_lookupcar T) +(scm_lreadparen T) +(scm_lreadr T) +(scm_lreadrecparen T) +(scm_lstat T) +(scm_m_and T) +(scm_m_apply T) +(scm_m_at_call_with_values T) +(scm_m_atbind T) +(scm_m_atdispatch T) +(scm_m_atfop T) +(scm_m_atslot_ref T) +(scm_m_atslot_set_x T) +(scm_m_begin T) +(scm_m_case T) +(scm_m_cond T) +(scm_m_cont T) +(scm_m_define T) +(scm_m_delay T) +(scm_m_do T) +(scm_m_expand_body T) +(scm_m_generalized_set_x T) +(scm_m_if T) +(scm_m_lambda T) +(scm_m_let T) +(scm_m_letrec T) +(scm_m_letstar T) +(scm_m_nil_cond T) +(scm_m_or T) +(scm_m_quasiquote T) +(scm_m_quote T) +(scm_m_set_x T) +(scm_m_undefine T) +(scm_macro_name T) +(scm_macro_p T) +(scm_macro_transformer T) +(scm_macro_type T) +(scm_macroexp T) +(scm_magnitude T) +(scm_major_version T) +(scm_makacro T) +(scm_makcclo T) +(scm_make T) +(scm_make_arbiter T) +(scm_make_class T) +(scm_make_class_object T) +(scm_make_complex T) +(scm_make_condition_variable T) +(scm_make_continuation T) +(scm_make_debugobj T) +(scm_make_doubly_weak_hash_table T) +(scm_make_environment T) +(scm_make_eval_environment T) +(scm_make_export_environment T) +(scm_make_extended_class T) +(scm_make_fluid T) +(scm_make_foreign_object T) +(scm_make_guardian T) +(scm_make_hook T) +(scm_make_import_environment T) +(scm_make_initial_fluids T) +(scm_make_keyword_from_dash_symbol T) +(scm_make_leaf_environment T) +(scm_make_memoized T) +(scm_make_method_cache T) +(scm_make_mutex T) +(scm_make_polar T) +(scm_make_port_classes T) +(scm_make_port_type T) +(scm_make_print_state T) +(scm_make_procedure_with_setter T) +(scm_make_ra T) +(scm_make_real T) +(scm_make_rectangular T) +(scm_make_regexp T) +(scm_make_root T) +(scm_make_shared_array T) +(scm_make_smob T) +(scm_make_smob_type T) +(scm_make_soft_port T) +(scm_make_srcprops T) +(scm_make_stack T) +(scm_make_string T) +(scm_make_struct T) +(scm_make_struct_layout T) +(scm_make_subclass_object T) +(scm_make_symbol T) +(scm_make_synt T) +(scm_make_undefined_variable T) +(scm_make_uve T) +(scm_make_variable T) +(scm_make_vector T) +(scm_make_vtable_vtable T) +(scm_make_weak_key_hash_table T) +(scm_make_weak_value_hash_table T) +(scm_make_weak_vector T) +(scm_makfrom0str T) +(scm_makfrom0str_opt T) +(scm_makfromstrs T) +(scm_makmacro T) +(scm_makmmacro T) +(scm_makprom T) +(scm_malloc_obj T) +(scm_mallocated D) +(scm_map T) +(scm_mark0 T) +(scm_mark_locations T) +(scm_mark_subr_table T) +(scm_markcdr T) +(scm_markstream T) +(scm_mask_ints D) +(scm_mask_signals T) +(scm_masktab B) +(scm_master_freelist D) +(scm_master_freelist2 D) +(scm_max T) +(scm_max_segment_size B) +(scm_mcache_compute_cmethod T) +(scm_mcache_lookup_cmethod T) +(scm_mem2string T) +(scm_mem2symbol T) +(scm_mem2uninterned_symbol T) +(scm_member T) +(scm_memoize_method T) +(scm_memoized_environment T) +(scm_memoized_p T) +(scm_memory_alloc_key B) +(scm_memory_error T) +(scm_memq T) +(scm_memv T) +(scm_merge T) +(scm_merge_x T) +(scm_metaclass_operator B) +(scm_metaclass_standard B) +(scm_method_generic_function T) +(scm_method_procedure T) +(scm_method_specializers T) +(scm_micro_version T) +(scm_min T) +(scm_minor_version T) +(scm_misc_error T) +(scm_misc_error_key B) +(scm_mkdir T) +(scm_mknod T) +(scm_mkstemp T) +(scm_mkstrport T) +(scm_mktime T) +(scm_mode_bits T) +(scm_module_define T) +(scm_module_goops B) +(scm_module_lookup T) +(scm_module_lookup_closure T) +(scm_module_reverse_lookup T) +(scm_module_system_booted_p D) +(scm_module_tag B) +(scm_module_transformer T) +(scm_modules_prehistory T) +(scm_modulo T) +(scm_mtrigger B) +(scm_mulbig T) +(scm_must_free T) +(scm_must_malloc T) +(scm_must_realloc T) +(scm_must_strdup T) +(scm_must_strndup T) +(scm_n_charnames D) +(scm_n_heap_segs D) +(scm_nconc2last T) +(scm_negative_p T) +(scm_newline T) +(scm_nice T) +(scm_no_applicable_method B) +(scm_noop T) +(scm_not T) +(scm_ntohl T) +(scm_ntohs T) +(scm_null_p T) +(scm_num2dbl T) +(scm_num2double T) +(scm_num2float T) +(scm_num2int T) +(scm_num2long T) +(scm_num2long_long T) +(scm_num2ptrdiff T) +(scm_num2short T) +(scm_num2size T) +(scm_num2uint T) +(scm_num2ulong T) +(scm_num2ulong_long T) +(scm_num2ushort T) +(scm_num_eq_p T) +(scm_num_overflow T) +(scm_num_overflow_key B) +(scm_number_p T) +(scm_number_to_string T) +(scm_numptob B) +(scm_numsmob B) +(scm_object_address T) +(scm_object_properties T) +(scm_object_property T) +(scm_object_to_string T) +(scm_odd_p T) +(scm_open T) +(scm_open_fdes T) +(scm_open_file T) +(scm_open_input_string T) +(scm_open_output_string T) +(scm_opendir T) +(scm_operator_p T) +(scm_options T) +(scm_out_of_range T) +(scm_out_of_range_key B) +(scm_out_of_range_pos T) +(scm_output_port_p T) +(scm_pair_p T) +(scm_parse_path T) +(scm_pause T) +(scm_peek_char T) +(scm_permanent_object T) +(scm_pipe T) +(scm_port_class D) +(scm_port_closed_p T) +(scm_port_column T) +(scm_port_filename T) +(scm_port_for_each T) +(scm_port_line T) +(scm_port_mode T) +(scm_port_non_buffer T) +(scm_port_p T) +(scm_port_print T) +(scm_port_revealed T) +(scm_port_table B) +(scm_port_table_room D) +(scm_port_table_size D) +(scm_port_with_print_state T) +(scm_ports_prehistory T) +(scm_positive_p T) +(scm_pre_modules_obarray B) +(scm_primitive_eval T) +(scm_primitive_eval_x T) +(scm_primitive_exit T) +(scm_primitive_generic_generic T) +(scm_primitive_load T) +(scm_primitive_load_path T) +(scm_primitive_make_property T) +(scm_primitive_move_to_fdes T) +(scm_primitive_property_del_x T) +(scm_primitive_property_ref T) +(scm_primitive_property_set_x T) +(scm_prin1 T) +(scm_print_carefully_p B) +(scm_print_complex T) +(scm_print_options T) +(scm_print_opts D) +(scm_print_port_mode T) +(scm_print_real T) +(scm_print_state_vtable D) +(scm_print_struct T) +(scm_print_symbol_name T) +(scm_printer_apply T) +(scm_procedure T) +(scm_procedure_documentation T) +(scm_procedure_environment T) +(scm_procedure_name T) +(scm_procedure_p T) +(scm_procedure_properties T) +(scm_procedure_property T) +(scm_procedure_source T) +(scm_procedure_with_setter_p T) +(scm_product T) +(scm_program_arguments T) +(scm_promise_p T) +(scm_pseudolong T) +(scm_ptobs B) +(scm_ptrdiff2num T) +(scm_putc T) +(scm_putenv T) +(scm_puts T) +(scm_quotient T) +(scm_ra2contig T) +(scm_ra_difference T) +(scm_ra_divide T) +(scm_ra_eqp T) +(scm_ra_greqp T) +(scm_ra_grp T) +(scm_ra_leqp T) +(scm_ra_lessp T) +(scm_ra_matchp T) +(scm_ra_product T) +(scm_ra_set_contp T) +(scm_ra_sum T) +(scm_raequal T) +(scm_raise T) +(scm_ramapc T) +(scm_random T) +(scm_random_exp T) +(scm_random_hollow_sphere_x T) +(scm_random_normal T) +(scm_random_normal_vector_x T) +(scm_random_solid_sphere_x T) +(scm_random_uniform T) +(scm_raprin1 T) +(scm_read T) +(scm_read_char T) +(scm_read_delimited_x T) +(scm_read_hash_extend T) +(scm_read_line T) +(scm_read_options T) +(scm_read_opts D) +(scm_read_string_x_partial T) +(scm_read_token T) +(scm_readdir T) +(scm_readlink T) +(scm_real_equalp T) +(scm_real_p T) +(scm_real_part T) +(scm_recv T) +(scm_recvfrom T) +(scm_redirect_port T) +(scm_regexp_exec T) +(scm_regexp_p T) +(scm_release_arbiter T) +(scm_remainder T) +(scm_remember_upto_here T) +(scm_remember_upto_here_1 T) +(scm_remember_upto_here_2 T) +(scm_remove_from_port_table T) +(scm_remove_hook_x T) +(scm_rename T) +(scm_report_stack_overflow T) +(scm_reset_hook_x T) +(scm_resolve_module T) +(scm_restore_signals T) +(scm_restricted_vector_sort_x T) +(scm_return_first T) +(scm_return_first_int T) +(scm_revealed_count T) +(scm_reverse T) +(scm_reverse_lookup T) +(scm_reverse_x T) +(scm_rewinddir T) +(scm_rmdir T) +(scm_round T) +(scm_run_asyncs T) +(scm_run_hook T) +(scm_s_bindings R) +(scm_s_body R) +(scm_s_clauses R) +(scm_s_duplicate_bindings R) +(scm_s_duplicate_formals R) +(scm_s_expression R) +(scm_s_formals R) +(scm_s_set_x R) +(scm_s_slot_set_x D) +(scm_s_test R) +(scm_s_variable R) +(scm_search_path T) +(scm_seed_to_random_state T) +(scm_seek T) +(scm_select T) +(scm_send T) +(scm_sendto T) +(scm_set_car_x T) +(scm_set_cdr_x T) +(scm_set_current_error_port T) +(scm_set_current_input_port T) +(scm_set_current_module T) +(scm_set_current_output_port T) +(scm_set_object_procedure_x T) +(scm_set_object_properties_x T) +(scm_set_object_property_x T) +(scm_set_port_close T) +(scm_set_port_column_x T) +(scm_set_port_end_input T) +(scm_set_port_equalp T) +(scm_set_port_filename_x T) +(scm_set_port_flush T) +(scm_set_port_free T) +(scm_set_port_input_waiting T) +(scm_set_port_line_x T) +(scm_set_port_mark T) +(scm_set_port_print T) +(scm_set_port_revealed_x T) +(scm_set_port_seek T) +(scm_set_port_truncate T) +(scm_set_procedure_properties_x T) +(scm_set_procedure_property_x T) +(scm_set_program_arguments T) +(scm_set_smob_apply T) +(scm_set_smob_equalp T) +(scm_set_smob_free T) +(scm_set_smob_mark T) +(scm_set_smob_print T) +(scm_set_source_properties_x T) +(scm_set_source_property_x T) +(scm_set_struct_vtable_name_x T) +(scm_setegid T) +(scm_seteuid T) +(scm_setgid T) +(scm_setgrent T) +(scm_sethost T) +(scm_sethostname T) +(scm_setitimer T) +(scm_setlocale T) +(scm_setnet T) +(scm_setpgid T) +(scm_setpriority T) +(scm_setproto T) +(scm_setpwent T) +(scm_setserv T) +(scm_setsid T) +(scm_setsockopt T) +(scm_setter T) +(scm_setuid T) +(scm_setvbuf T) +(scm_shap2ra T) +(scm_shared_array_increments T) +(scm_shared_array_offset T) +(scm_shared_array_root T) +(scm_shell T) +(scm_shell_usage T) +(scm_short2num T) +(scm_shutdown T) +(scm_sigaction T) +(scm_signal_condition_variable T) +(scm_simple_format T) +(scm_single_thread_p T) +(scm_size2num T) +(scm_sleep T) +(scm_sloppy_assoc T) +(scm_sloppy_assq T) +(scm_sloppy_assv T) +(scm_slot_bound_p T) +(scm_slot_bound_using_class_p T) +(scm_slot_exists_using_class_p T) +(scm_slot_ref T) +(scm_slot_ref_using_class T) +(scm_slot_set_using_class_x T) +(scm_slot_set_x T) +(scm_slots_exists_p T) +(scm_smob_class D) +(scm_smob_free T) +(scm_smob_prehistory T) +(scm_smob_print T) +(scm_smobs B) +(scm_socket T) +(scm_socketpair T) +(scm_sort T) +(scm_sort_list T) +(scm_sort_list_x T) +(scm_sort_x T) +(scm_sorted_p T) +(scm_source_properties T) +(scm_source_property T) +(scm_spawn_thread T) +(scm_srcprops_to_plist T) +(scm_stable_sort T) +(scm_stable_sort_x T) +(scm_stack_checking_enabled_p B) +(scm_stack_id T) +(scm_stack_length T) +(scm_stack_p T) +(scm_stack_ref T) +(scm_stack_report T) +(scm_stack_size T) +(scm_stack_type B) +(scm_standard_eval_closure T) +(scm_standard_interface_eval_closure T) +(scm_start_stack T) +(scm_stat T) +(scm_status_exit_val T) +(scm_status_stop_sig T) +(scm_status_term_sig T) +(scm_str2string T) +(scm_str2symbol T) +(scm_strerror T) +(scm_strftime T) +(scm_string T) +(scm_string_append T) +(scm_string_capitalize T) +(scm_string_capitalize_x T) +(scm_string_ci_equal_p T) +(scm_string_ci_geq_p T) +(scm_string_ci_gr_p T) +(scm_string_ci_leq_p T) +(scm_string_ci_less_p T) +(scm_string_ci_to_symbol T) +(scm_string_copy T) +(scm_string_downcase T) +(scm_string_downcase_x T) +(scm_string_equal_p T) +(scm_string_fill_x T) +(scm_string_geq_p T) +(scm_string_gr_p T) +(scm_string_hash T) +(scm_string_index T) +(scm_string_length T) +(scm_string_leq_p T) +(scm_string_less_p T) +(scm_string_null_p T) +(scm_string_p T) +(scm_string_ref T) +(scm_string_rindex T) +(scm_string_set_x T) +(scm_string_split T) +(scm_string_to_list T) +(scm_string_to_number T) +(scm_string_to_symbol T) +(scm_string_upcase T) +(scm_string_upcase_x T) +(scm_strport_to_string T) +(scm_strptime T) +(scm_struct_create_handle T) +(scm_struct_free_0 T) +(scm_struct_free_entity T) +(scm_struct_free_light T) +(scm_struct_free_standard T) +(scm_struct_ihashq T) +(scm_struct_p T) +(scm_struct_prehistory T) +(scm_struct_ref T) +(scm_struct_set_x T) +(scm_struct_table B) +(scm_struct_vtable T) +(scm_struct_vtable_name T) +(scm_struct_vtable_p T) +(scm_struct_vtable_tag T) +(scm_structs_to_free B) +(scm_subr_p T) +(scm_subr_table B) +(scm_subr_table_room D) +(scm_subr_table_size D) +(scm_substring T) +(scm_substring_fill_x T) +(scm_substring_move_x T) +(scm_sum T) +(scm_swap_bindings T) +(scm_swap_fluids T) +(scm_swap_fluids_reverse T) +(scm_switch_counter D) +(scm_sym2var T) +(scm_sym_and B) +(scm_sym_apply B) +(scm_sym_apply_frame B) +(scm_sym_arity B) +(scm_sym_arrow B) +(scm_sym_at_call_with_values B) +(scm_sym_atapply B) +(scm_sym_atcall_cc B) +(scm_sym_begin B) +(scm_sym_breakpoint B) +(scm_sym_case B) +(scm_sym_column B) +(scm_sym_cond B) +(scm_sym_copy B) +(scm_sym_define B) +(scm_sym_delay B) +(scm_sym_do B) +(scm_sym_dot B) +(scm_sym_else B) +(scm_sym_enter_frame B) +(scm_sym_exit_frame B) +(scm_sym_filename B) +(scm_sym_if B) +(scm_sym_lambda B) +(scm_sym_let B) +(scm_sym_letrec B) +(scm_sym_letstar B) +(scm_sym_line B) +(scm_sym_name B) +(scm_sym_or B) +(scm_sym_quasiquote B) +(scm_sym_quote B) +(scm_sym_set_x B) +(scm_sym_system_procedure B) +(scm_sym_trace B) +(scm_sym_unquote B) +(scm_sym_uq_splicing B) +(scm_symbol_fref T) +(scm_symbol_fset_x T) +(scm_symbol_hash T) +(scm_symbol_interned_p T) +(scm_symbol_p T) +(scm_symbol_pref T) +(scm_symbol_pset_x T) +(scm_symbol_to_string T) +(scm_symbols_prehistory T) +(scm_symlink T) +(scm_sync T) +(scm_sys_allocate_instance T) +(scm_sys_atan2 T) +(scm_sys_compute_applicable_methods T) +(scm_sys_compute_slots T) +(scm_sys_expt T) +(scm_sys_fast_slot_ref T) +(scm_sys_fast_slot_set_x T) +(scm_sys_inherit_magic_x T) +(scm_sys_initialize_object T) +(scm_sys_invalidate_class T) +(scm_sys_invalidate_method_cache_x T) +(scm_sys_library_dir T) +(scm_sys_make_void_port T) +(scm_sys_method_more_specific_p T) +(scm_sys_modify_class T) +(scm_sys_modify_instance T) +(scm_sys_package_data_dir T) +(scm_sys_prep_layout_x T) +(scm_sys_protects B) +(scm_sys_search_load_path T) +(scm_sys_set_object_setter_x T) +(scm_sys_site_dir T) +(scm_sys_tag_body T) +(scm_syserror T) +(scm_syserror_msg T) +(scm_system T) +(scm_system_async T) +(scm_system_async_mark T) +(scm_system_async_mark_from_signal_handler T) +(scm_system_environment B) +(scm_system_error_key B) +(scm_system_module_env_p T) +(scm_t_arrayo_list T) +(scm_tables_prehistory T) +(scm_take0str T) +(scm_take_from_input_buffers T) +(scm_take_str T) +(scm_tc16_allocated B) +(scm_tc16_array B) +(scm_tc16_condvar B) +(scm_tc16_continuation B) +(scm_tc16_debugobj B) +(scm_tc16_dir B) +(scm_tc16_dynamic_obj B) +(scm_tc16_environment B) +(scm_tc16_eval_closure B) +(scm_tc16_fluid B) +(scm_tc16_fport B) +(scm_tc16_hook B) +(scm_tc16_keyword B) +(scm_tc16_macro B) +(scm_tc16_malloc B) +(scm_tc16_memoized B) +(scm_tc16_mutex B) +(scm_tc16_observer B) +(scm_tc16_port_with_ps B) +(scm_tc16_promise B) +(scm_tc16_regex B) +(scm_tc16_root B) +(scm_tc16_rstate B) +(scm_tc16_srcprops B) +(scm_tc16_strport B) +(scm_tc16_thread B) +(scm_tc16_void_port D) +(scm_tcgetpgrp T) +(scm_tcsetpgrp T) +(scm_the_last_stack_fluid_var B) +(scm_the_rng B) +(scm_thread_count D) +(scm_thread_sleep T) +(scm_thread_usleep T) +(scm_threads_init T) +(scm_threads_mark_stacks T) +(scm_throw T) +(scm_thunk_p T) +(scm_times T) +(scm_tmpnam T) +(scm_top_level_env T) +(scm_transpose_array T) +(scm_truncate T) +(scm_truncate_file T) +(scm_try_arbiter T) +(scm_ttyname T) +(scm_type_eval_environment D) +(scm_type_export_environment D) +(scm_type_import_environment D) +(scm_type_leaf_environment D) +(scm_tzset T) +(scm_uint2num T) +(scm_ulong2num T) +(scm_ulong_long2num T) +(scm_umask T) +(scm_uname T) +(scm_ungetc T) +(scm_ungets T) +(scm_uniform_array_read_x T) +(scm_uniform_array_write T) +(scm_uniform_element_size T) +(scm_uniform_vector_length T) +(scm_uniform_vector_ref T) +(scm_unlock_mutex T) +(scm_unmask_signals T) +(scm_unmemocar T) +(scm_unmemocopy T) +(scm_unmemoize T) +(scm_unread_char T) +(scm_unread_string T) +(scm_upcase T) +(scm_usage_name D) +(scm_ushort2num T) +(scm_usleep T) +(scm_utime T) +(scm_valid_object_procedure_p T) +(scm_valid_oport_value_p T) +(scm_values T) +(scm_values_vtable B) +(scm_var_random_state B) +(scm_variable_bound_p T) +(scm_variable_p T) +(scm_variable_ref T) +(scm_variable_set_x T) +(scm_vector T) +(scm_vector_equal_p T) +(scm_vector_fill_x T) +(scm_vector_length T) +(scm_vector_move_left_x T) +(scm_vector_move_right_x T) +(scm_vector_p T) +(scm_vector_ref T) +(scm_vector_set_x T) +(scm_vector_to_list T) +(scm_version T) +(scm_void_port T) +(scm_wait_condition_variable T) +(scm_waitpid T) +(scm_weak_key_hash_table_p T) +(scm_weak_value_hash_table_p T) +(scm_weak_vector T) +(scm_weak_vector_p T) +(scm_weak_vectors B) +(scm_weaks_prehistory T) +(scm_with_fluids T) +(scm_with_traps T) +(scm_wrap_component T) +(scm_wrap_object T) +(scm_write T) +(scm_write_char T) +(scm_write_line T) +(scm_write_string_partial T) +(scm_wrong_num_args T) +(scm_wrong_type_arg T) +(scm_wrong_type_arg_msg T) +(scm_yield T) +(scm_your_base D) +(scm_zero_p T) +(terminating B) +) ;; end of C +) |