ikarus/scheme/makefile.ss

#!../src/ikarus -b ikarus.boot --r6rs-script
;;; Ikarus Scheme -- A compiler for R6RS Scheme.
;;; Copyright (C) 2006,2007,2008  Abdulaziz Ghuloum
;;; 
;;; This program is free software: you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License version 3 as
;;; published by the Free Software Foundation.
;;; 
;;; This program is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;;; General Public License for more details.
;;; 
;;; You should have received a copy of the GNU General Public License
;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.

;;; vim:syntax=scheme
(import (only (ikarus) import))
(import (except (ikarus) 
          current-letrec-pass
          current-core-eval
          assembler-output optimize-cp optimize-level
          cp0-size-limit cp0-effort-limit expand/optimize
          expand/scc-letrec expand
          optimizer-output tag-analysis-output perform-tag-analysis))
(import (ikarus.compiler))
(import (except (psyntax system $bootstrap)
                eval-core 
                current-primitive-locations
                compile-core-expr-to-port))
(import (ikarus.compiler)) ; just for fun
(optimize-level 2)
(perform-tag-analysis #t)
(pretty-width 160)
((pretty-format 'fix) ((pretty-format 'letrec)))
(strip-source-info #t)

(current-letrec-pass 'scc)
(define scheme-library-files
  ;;; Listed in the order in which they're loaded.
  ;;;
  ;;; Loading of the boot file may segfault if a library is
  ;;; loaded before its dependencies are loaded first.
  ;;;
  ;;; reason is that the base libraries are not a hierarchy of
  ;;; dependencies but rather an eco system in which every
  ;;; part depends on the other.
  ;;;
  ;;; For example, the printer may call error if it finds
  ;;;  an error (e.g. "not an output port"), while the error
  ;;;  procedure may call the printer to display the message.
  ;;;  This works fine as long as error does not itself cause
  ;;;  an error (which may lead to the infamous Error: Error: 
  ;;;  Error: Error: Error: Error: Error: Error: Error: ...).
  ;;;
  '(
    
    "ikarus.singular-objects.ss"
    "ikarus.handlers.ss"
    "ikarus.multiple-values.ss"
    "ikarus.control.ss"
    "ikarus.exceptions.ss"
    "ikarus.collect.ss"
    "ikarus.apply.ss"
    "ikarus.predicates.ss"
    "ikarus.equal.ss"
    "ikarus.pairs.ss"
    "ikarus.lists.ss"
    "ikarus.fixnums.ss"
    "ikarus.chars.ss"
    "ikarus.structs.ss"
    "ikarus.records.procedural.ss"
    "ikarus.strings.ss"
    "ikarus.unicode-conversion.ss"
    "ikarus.date-string.ss"
    "ikarus.symbols.ss"
    "ikarus.vectors.ss"
    "ikarus.unicode.ss"
    "ikarus.string-to-number.ss"
    "ikarus.numerics.ss"
    "ikarus.conditions.ss"
    "ikarus.guardians.ss"
    "ikarus.symbol-table.ss"
    "ikarus.codecs.ss"
    "ikarus.bytevectors.ss"
    "ikarus.posix.ss"
    "ikarus.io.ss"
    "ikarus.hash-tables.ss"
    "ikarus.pretty-formats.ss"
    "ikarus.writer.ss"
    "ikarus.reader.ss"
    "ikarus.reader.annotated.ss"
    "ikarus.code-objects.ss"
    "ikarus.intel-assembler.ss"
    "ikarus.fasl.write.ss"
    "ikarus.fasl.ss"
    "ikarus.compiler.ss"
    "psyntax.compat.ss"
    "psyntax.library-manager.ss"
    "psyntax.internal.ss"
    "psyntax.config.ss"
    "psyntax.builders.ss"
    "psyntax.expander.ss"
    "ikarus.apropos.ss"
    "ikarus.load.ss"
    "ikarus.pretty-print.ss"
    "ikarus.cafe.ss"
    "ikarus.timer.ss"
    "ikarus.time-and-date.ss"
    "ikarus.sort.ss"
    "ikarus.promises.ss"
    "ikarus.enumerations.ss"
    "ikarus.command-line.ss"
    "ikarus.pointers.ss"
    "ikarus.not-yet-implemented.ss"
    ;"ikarus.trace.ss"
    "ikarus.debugger.ss"
    "ikarus.main.ss"
    ))

(define ikarus-system-macros
  '([define              (define)]
    [define-syntax       (define-syntax)]
    [define-fluid-syntax (define-fluid-syntax)]
    [module              (module)]
    [library             (library)]
    [begin               (begin)]
    [import              (import)]
    [export              (export)]
    [set!                (set!)]
    [let-syntax          (let-syntax)]
    [letrec-syntax       (letrec-syntax)]
    [stale-when          (stale-when)]
    [foreign-call        (core-macro . foreign-call)]
    [quote               (core-macro . quote)]
    [syntax-case         (core-macro . syntax-case)]
    [syntax              (core-macro . syntax)]
    [lambda              (core-macro . lambda)]
    [case-lambda         (core-macro . case-lambda)]
    [type-descriptor     (core-macro . type-descriptor)]
    [letrec              (core-macro . letrec)]
    [letrec*             (core-macro . letrec*)]
    [if                  (core-macro . if)]
    [fluid-let-syntax    (core-macro . fluid-let-syntax)]
    [record-type-descriptor (core-macro . record-type-descriptor)]
    [record-constructor-descriptor (core-macro . record-constructor-descriptor)]
    [let-values          (macro . let-values)]
    [let*-values         (macro . let*-values)]
    [define-struct       (macro . define-struct)]
    [case                (macro . case)]
    [syntax-rules        (macro . syntax-rules)]
    [quasiquote          (macro . quasiquote)]
    [quasisyntax         (macro . quasisyntax)]
    [with-syntax         (macro . with-syntax)]
    [identifier-syntax   (macro . identifier-syntax)]
    [parameterize        (macro . parameterize)]
    [when                (macro . when)]         
    [unless              (macro . unless)]
    [let                 (macro . let)]
    [let*                (macro . let*)]
    [cond                (macro . cond)]
    [do                  (macro . do)]
    [and                 (macro . and)]
    [or                  (macro . or)]
    [time                (macro . time)]
    [delay               (macro . delay)]
    [endianness          (macro . endianness)]
    [assert              (macro . assert)]
    [...                 (macro . ...)]
    [=>                  (macro . =>)]
    [else                (macro . else)]
    [_                   (macro . _)]
    [unquote             (macro . unquote)]
    [unquote-splicing    (macro . unquote-splicing)]
    [unsyntax            (macro . unsyntax)]
    [unsyntax-splicing   (macro . unsyntax-splicing)]
    [trace-lambda        (macro . trace-lambda)]
    [trace-let           (macro . trace-let)]
    [trace-define        (macro . trace-define)]
    [trace-define-syntax (macro . trace-define-syntax)]
    [trace-let-syntax    (macro . trace-let-syntax)]
    [trace-letrec-syntax (macro . trace-letrec-syntax)]
    [guard               (macro . guard)]
    [eol-style           (macro . eol-style)]
    [buffer-mode         (macro . buffer-mode)]
    [file-options        (macro . file-options)]
    [error-handling-mode (macro . error-handling-mode)]
    [fields              (macro . fields)] 
    [mutable             (macro . mutable)]
    [immutable           (macro . immutable)] 
    [parent              (macro . parent)]
    [protocol            (macro . protocol)]
    [sealed              (macro . sealed)]
    [opaque              (macro . opaque )]
    [nongenerative       (macro . nongenerative)]
    [parent-rtd          (macro . parent-rtd)]
    [define-record-type  (macro . define-record-type)]
    [define-enumeration  (macro . define-enumeration)]
    [define-condition-type  (macro . define-condition-type)]
    [&condition                ($core-rtd . (&condition-rtd &condition-rcd))]
    [&message                  ($core-rtd . (&message-rtd &message-rcd))]
    [&warning                  ($core-rtd . (&warning-rtd &warning-rcd ))]
    [&serious                  ($core-rtd . (&serious-rtd &serious-rcd))]
    [&error                    ($core-rtd . (&error-rtd &error-rcd))]
    [&violation                ($core-rtd . (&violation-rtd &violation-rcd ))]
    [&assertion                ($core-rtd . (&assertion-rtd &assertion-rcd ))]
    [&irritants                ($core-rtd . (&irritants-rtd &irritants-rcd))]
    [&who                      ($core-rtd . (&who-rtd &who-rcd ))]
    [&non-continuable          ($core-rtd . (&non-continuable-rtd &non-continuable-rcd))]
    [&implementation-restriction  ($core-rtd . (&implementation-restriction-rtd &implementation-restriction-rcd))]
    [&lexical                  ($core-rtd . (&lexical-rtd &lexical-rcd ))]
    [&syntax                   ($core-rtd . (&syntax-rtd &syntax-rcd ))]
    [&undefined                ($core-rtd . (&undefined-rtd &undefined-rcd))]
    [&i/o                      ($core-rtd . (&i/o-rtd &i/o-rcd ))]
    [&i/o-read                 ($core-rtd . (&i/o-read-rtd &i/o-read-rcd ))]
    [&i/o-write                ($core-rtd . (&i/o-write-rtd &i/o-write-rcd))]
    [&i/o-invalid-position     ($core-rtd . (&i/o-invalid-position-rtd &i/o-invalid-position-rcd ))]
    [&i/o-filename             ($core-rtd . (&i/o-filename-rtd &i/o-filename-rcd))]
    [&i/o-file-protection      ($core-rtd . (&i/o-file-protection-rtd &i/o-file-protection-rcd))]
    [&i/o-file-is-read-only    ($core-rtd .  (&i/o-file-is-read-only-rtd &i/o-file-is-read-only-rcd ))]
    [&i/o-file-already-exists  ($core-rtd . (&i/o-file-already-exists-rtd &i/o-file-already-exists-rcd))]
    [&i/o-file-does-not-exist  ($core-rtd . (&i/o-file-does-not-exist-rtd &i/o-file-does-not-exist-rcd))]
    [&i/o-port                 ($core-rtd . (&i/o-port-rtd &i/o-port-rcd))]
    [&i/o-decoding             ($core-rtd . (&i/o-decoding-rtd &i/o-decoding-rcd))]
    [&i/o-encoding             ($core-rtd . (&i/o-encoding-rtd &i/o-encoding-rcd))]
    [&no-infinities            ($core-rtd . (&no-infinities-rtd &no-infinities-rcd ))]
    [&no-nans                  ($core-rtd . (&no-nans-rtd &no-nans-rcd))]
    [&interrupted              ($core-rtd . (&interrupted-rtd &interrupted-rcd))]
    [&source                   ($core-rtd . (&source-rtd &source-rcd))]
    ))

(define library-legend
  ;; abbr.       name                             visible? required?
  '([i           (ikarus)                              #t     #t]
    [cm          (chez modules)                        #t     #t]
    [symbols     (ikarus symbols)                      #t     #t]
    [parameters  (ikarus parameters)                   #t     #t]
    [r           (rnrs)                                #t     #t]
    [r5          (rnrs r5rs)                           #t     #t]
    [ct          (rnrs control)                        #t     #t]
    [ev          (rnrs eval)                           #t     #t]
    [mp          (rnrs mutable-pairs)                  #t     #t]
    [ms          (rnrs mutable-strings)                #t     #t]
    [pr          (rnrs programs)                       #t     #t]
    [sc          (rnrs syntax-case)                    #t     #t]
    [fi          (rnrs files)                          #t     #t]
    [sr          (rnrs sorting)                        #t     #t]
    [ba          (rnrs base)                           #t     #t]
    [ls          (rnrs lists)                          #t     #t]
    [is          (rnrs io simple)                      #t     #t]
    [bv          (rnrs bytevectors)                    #t     #t]
    [uc          (rnrs unicode)                        #t     #t]
    [ex          (rnrs exceptions)                     #t     #t]
    [bw          (rnrs arithmetic bitwise)             #t     #t]
    [fx          (rnrs arithmetic fixnums)             #t     #t]
    [fl          (rnrs arithmetic flonums)             #t     #t]
    [ht          (rnrs hashtables)                     #t     #t]
    [ip          (rnrs io ports)                       #t     #t]
    [en          (rnrs enums)                          #t     #t]
    [co          (rnrs conditions)                     #t     #t]
    [ri          (rnrs records inspection)             #t     #t]
    [rp          (rnrs records procedural)             #t     #t]
    [rs          (rnrs records syntactic)              #t     #t]
    [$pairs      (ikarus system $pairs)                #f     #t]
    [$lists      (ikarus system $lists)                #f     #t]
    [$chars      (ikarus system $chars)                #f     #t]
    [$strings    (ikarus system $strings)              #f     #t]
    [$vectors    (ikarus system $vectors)              #f     #t]
    [$flonums    (ikarus system $flonums)              #f     #t]
    [$bignums    (ikarus system $bignums)              #f     #t]
    [$bytes      (ikarus system $bytevectors)          #f     #t]
    [$transc     (ikarus system $transcoders)          #f     #t]
    [$fx         (ikarus system $fx)                   #f     #t]
    [$rat        (ikarus system $ratnums)              #f     #t]
    [$comp       (ikarus system $compnums)             #f     #t]
    [$symbols    (ikarus system $symbols)              #f     #t]
    [$structs    (ikarus system $structs)              #f     #t]
    ;[$ports      (ikarus system $ports)                #f     #t]
    [$codes      (ikarus system $codes)                #f     #t]
    [$tcbuckets  (ikarus system $tcbuckets)            #f     #t]
    [$arg-list   (ikarus system $arg-list)             #f     #t]
    [$stack      (ikarus system $stack)                #f     #t]
    [$interrupts (ikarus system $interrupts)           #f     #t]
    [$io         (ikarus system $io)                   #f     #t]
    [$for        (ikarus system $foreign)              #f     #t]
    [$all        (psyntax system $all)                 #f     #t]
    [$boot       (psyntax system $bootstrap)           #f     #t]
    [ne          (psyntax null-environment-5)          #f     #f]
    [se          (psyntax scheme-report-environment-5) #f     #f]
    ))

(define identifier->library-map
  '(
    [import                                      i]
    [export                                      i]
    [foreign-call                                i]
    [type-descriptor                             i]
    [parameterize                                i parameters]
    [define-struct                               i]
    [stale-when                                  i]
    [time                                        i]
    [trace-lambda                                i]
    [trace-let                                   i]
    [trace-define                                i]
    [trace-define-syntax                         i]
    [trace-let-syntax                            i]
    [trace-letrec-syntax                         i]
    [make-list                                   i]
    [last-pair                                   i]
    [bwp-object?                                 i]
    [weak-cons                                   i]
    [weak-pair?                                  i]
    [uuid                                        i]
    [date-string                                 i]
    [andmap                                      i]
    [ormap                                       i]
    [fx<                                         i]
    [fx<=                                        i]
    [fx>                                         i]
    [fx>=                                        i]
    [fx=                                         i]
    [fxadd1                                      i]
    [fxsub1                                      i]
    [fxquotient                                  i]
    [fxremainder                                 i]
    [fxmodulo                                    i]
    [fxsll                                       i]
    [fxsra                                       i]
    [sra                                         i]
    [sll                                         i]
    [fxlogand                                    i]
    [fxlogxor                                    i]
    [fxlogor                                     i]
    [fxlognot                                    i]
    [fixnum->string                              i]
    [string->flonum                              i]
    [add1                                        i]
    [sub1                                        i]
    [bignum?                                     i]
    [ratnum?                                     i]
    [compnum?                                    i]
    [cflonum?                                    i]
    [flonum-parts                                i]
    [flonum-bytes                                i]
    [quotient+remainder                          i]
    [flonum->string                              i]
    [random                                      i]
    [gensym?                                     i symbols]
    [getprop                                     i symbols]
    [putprop                                     i symbols]
    [remprop                                     i symbols]
    [property-list                               i symbols]
    [gensym->unique-string                       i symbols]
    [symbol-bound?                               i symbols]
    [top-level-value                             i symbols]
    [reset-symbol-proc!                          i symbols]
    [make-guardian                               i]
    [port-mode                                   i]
    [set-port-mode!                              i]
    [with-input-from-string                      i]
    [open-output-string                          i]
    [open-output-bytevector                      i]
    [get-output-string                           i]
    [get-output-bytevector                       i]
    [with-output-to-string                       i]
;    [with-output-to-bytevector                   i]
    [console-input-port                          i]
    [console-error-port                          i]
    [console-output-port                         i]
    [reset-input-port!                           i]
    [reset-output-port!                          i]
    [read-token                                  i]
    [printf                                      i]
    [fprintf                                     i]
    [format                                      i]
    [comment-handler                             i]
    [print-gensym                                i symbols]
    [print-graph                                 i]
    [print-unicode                               i]
    [unicode-printable-char?                     i]
    [gensym-count                                i symbols]
    [gensym-prefix                               i symbols]
    [make-parameter                              i parameters]
    [call/cf                                     i]
    [print-error                                 i]
    [strerror                                    i]
    [interrupt-handler                           i]
    [engine-handler                              i]
    [assembler-output                            i]
    [optimizer-output                            i]
    [new-cafe                                    i]
    [waiter-prompt-string                        i]
    [expand                                      i]
    [core-expand                                 i]
    [expand/optimize                             i]
    [expand/scc-letrec                           i]
    [environment?                                i]
    [environment-symbols                         i]
    [time-it                                     i]
    [verbose-timer                               i]
    [current-time                                i]
    [time?                                       i]
    [time-second                                 i]
    [time-gmt-offset                             i]
    [time-nanosecond                             i]
    [command-line-arguments                      i]
    [set-rtd-printer!                            i]
    [struct?                                     i]
    [make-struct-type                            i]
    [struct-type-name                            i]
    [struct-type-symbol                          i]
    [struct-type-field-names                     i]
    [struct-field-accessor                       i]
    [struct-length                               i]
    [struct-ref                                  i]
    [struct-set!                                 i]
    [struct-printer                              i]
    [struct-name                                 i]
    [struct-type-descriptor                      i]
    [code?                                       i]
    [immediate?                                  i]
    [pointer-value                               i]
    [system                                      i]
    [process                                     i]
    [process*                                    i]
    [process-nonblocking                         i]
    [waitpid                                     i]
    [wstatus-pid                                 i]
    [wstatus-exit-status                         i]
    [wstatus-received-signal                     i]
    [kill                                        i]
    [apropos                                     i]
    [installed-libraries                         i]
    [uninstall-library                           i]
    [library-path                                i]
    [library-extensions                          i]
    [current-primitive-locations                 $boot]
    [boot-library-expand                         $boot]
    [current-library-collection                  $boot]
    [library-name                                $boot]
    [find-library-by-name                        $boot]
    [$car                                        $pairs]
    [$cdr                                        $pairs]
    [$set-car!                                   $pairs]
    [$set-cdr!                                   $pairs]
    [$memq                                       $lists]
    [$memv                                       $lists]
    [$char?                                      $chars]
    [$char=                                      $chars]
    [$char<                                      $chars]
    [$char>                                      $chars]
    [$char<=                                     $chars]
    [$char>=                                     $chars]
    [$char->fixnum                               $chars]
    [$fixnum->char                               $chars]
    [$make-string                                $strings]
    [$string-ref                                 $strings]
    [$string-set!                                $strings]
    [$string-length                              $strings]
    [$make-bytevector                            $bytes]
    [$bytevector-length                          $bytes]
    [$bytevector-s8-ref                          $bytes]
    [$bytevector-u8-ref                          $bytes]
    [$bytevector-set!                            $bytes]
    [$bytevector-ieee-double-native-ref          $bytes]
    [$bytevector-ieee-double-native-set!         $bytes]
    [$bytevector-ieee-double-nonnative-ref       $bytes]
    [$bytevector-ieee-double-nonnative-set!      $bytes]
    [$bytevector-ieee-single-native-ref          $bytes]
    [$bytevector-ieee-single-native-set!         $bytes]
    [$bytevector-ieee-single-nonnative-ref       $bytes]
    [$bytevector-ieee-single-nonnative-set!      $bytes]
    [$flonum-u8-ref                              $flonums]
    [$make-flonum                                $flonums]
    [$flonum-set!                                $flonums]
    [$flonum-signed-biased-exponent              $flonums]
    [$flonum-rational?                           $flonums]
    [$flonum-integer?                            $flonums]
    [$fl+                                        $flonums]
    [$fl-                                        $flonums]
    [$fl*                                        $flonums]
    [$fl/                                        $flonums]
    [$fl=                                        $flonums]
    [$fl<                                        $flonums]
    [$fl<=                                       $flonums]
    [$fl>                                        $flonums]
    [$fl>=                                       $flonums]
    ;[$flround                                    $flonums]
    [$fixnum->flonum                             $flonums]
    [$flonum-sbe                                 $flonums]
    [$make-bignum                                $bignums]
    [$bignum-positive?                           $bignums]
    [$bignum-size                                $bignums]
    [$bignum-byte-ref                            $bignums]
    [$bignum-byte-set!                           $bignums]
    [$make-ratnum                                $rat]
    [$ratnum-n                                   $rat]
    [$ratnum-d                                   $rat]
    [$make-compnum                               $comp]
    [$compnum-real                               $comp]
    [$compnum-imag                               $comp]
    [$make-cflonum                               $comp]
    [$cflonum-real                               $comp]
    [$cflonum-imag                               $comp]
    [$make-vector                                $vectors]
    [$vector-length                              $vectors]
    [$vector-ref                                 $vectors]
    [$vector-set!                                $vectors]
    [$fxzero?                                    $fx]
    [$fxadd1                                     $fx]
    [$fxsub1                                     $fx]
    [$fx>=                                       $fx]
    [$fx<=                                       $fx]
    [$fx>                                        $fx]
    [$fx<                                        $fx]
    [$fx=                                        $fx]
    [$fxsll                                      $fx]
    [$fxsra                                      $fx]
    [$fxquotient                                 $fx]
    [$fxmodulo                                   $fx]
    [$int-quotient                               $fx]
    [$int-remainder                              $fx]
    [$fxlogxor                                   $fx]
    [$fxlogor                                    $fx]
    [$fxlognot                                   $fx]
    [$fxlogand                                   $fx]
    [$fx+                                        $fx]
    [$fx*                                        $fx]
    [$fx-                                        $fx]
    [$fxinthash                                  $fx]
    [$make-symbol                                $symbols]
    [$symbol-unique-string                       $symbols]
    [$symbol-value                               $symbols]
    [$symbol-string                              $symbols]
    [$symbol-plist                               $symbols]
    [$set-symbol-value!                          $symbols]
    [$set-symbol-proc!                           $symbols]
    [$set-symbol-string!                         $symbols]
    [$set-symbol-unique-string!                  $symbols]
    [$set-symbol-plist!                          $symbols]
    [$unintern-gensym                            $symbols]
    [$symbol-table-size                          $symbols]
    [$init-symbol-value!                         ]
    [$unbound-object?                            $symbols]
    ;;;
    [base-rtd                                    $structs]
    [$struct-set!                                $structs]
    [$struct-ref                                 $structs]
    [$struct-rtd                                 $structs]
    [$struct                                     $structs]
    [$make-struct                                $structs]
    [$struct?                                    $structs]
    [$struct/rtd?                                $structs]
    ;;;
    [$closure-code                               $codes]
    [$code->closure                              $codes]
    [$code-reloc-vector                          $codes]
    [$code-freevars                              $codes]
    [$code-size                                  $codes]
    [$code-annotation                            $codes]
    [$code-ref                                   $codes]
    [$code-set!                                  $codes]
    [$set-code-annotation!                       $codes]
    [procedure-annotation                        i]
    [$make-annotated-procedure                   $codes]
    [$annotated-procedure-annotation             $codes]
    [$make-tcbucket                              $tcbuckets]
    [$tcbucket-key                               $tcbuckets]
    [$tcbucket-val                               $tcbuckets]
    [$tcbucket-next                              $tcbuckets]
    [$set-tcbucket-val!                          $tcbuckets]
    [$set-tcbucket-next!                         $tcbuckets]
    [$set-tcbucket-tconc!                        $tcbuckets]
    [$arg-list                                   $arg-list]
    [$collect-key                                $arg-list]
    [$$apply                                     $stack]
    [$fp-at-base                                 $stack]
    [$primitive-call/cc                          $stack]
    [$frame->continuation                        $stack]
    [$current-frame                              $stack]
    [$seal-frame-and-call                        $stack]
    [$make-call-with-values-procedure            $stack]
    [$make-values-procedure                      $stack]
    [$interrupted?                               $interrupts]
    [$unset-interrupted!                         $interrupts]
    [$swap-engine-counter!                       $interrupts]
    [interrupted-condition?                      i]
    [make-interrupted-condition                  i]

    [source-position-condition?                  i]
    [make-source-position-condition              i]
    [source-position-file-name                   i]
    [source-position-character                   i]

    [$apply-nonprocedure-error-handler           ]
    [$incorrect-args-error-handler               ]
    [$multiple-values-error                      ]
    [$debug                                      ]
    [$underflow-misaligned-error                 ]
    [top-level-value-error                       ]
    [car-error                                   ]
    [cdr-error                                   ]
    [fxadd1-error                                ]
    [fxsub1-error                                ]
    [cadr-error                                  ]
    [fx+-type-error                              ]
    [fx+-types-error                             ]
    [fx+-overflow-error                          ]
    [$do-event                                   ]
    [do-overflow                                 ]
    [do-overflow-words                           ]
    [do-vararg-overflow                          ]
    [collect                                     i]
    [collect-key                                 i]
    [post-gc-hooks                               i]
    [do-stack-overflow                           ]
    [make-promise                                ]
    [make-traced-procedure                       i]
    [make-traced-macro                           i]
    [error@fx+                                   ]
    [error@fxarithmetic-shift-left               ]
    [error@fxarithmetic-shift-right              ]
    [error@fx*                                   ]
    [error@fx-                                   ]
    [error@add1                                  ]
    [error@sub1                                  ]
    [error@fxadd1                                ]
    [error@fxsub1                                ]
    [fasl-write                                  i]
    [fasl-read                                   i]
    [fasl-directory                              i]
    [lambda                                      i r ba se ne]
    [and                                         i r ba se ne]
    [begin                                       i r ba se ne]
    [case                                        i r ba se ne]
    [cond                                        i r ba se ne]
    [define                                      i r ba se ne]
    [define-syntax                               i r ba se ne]
    [define-fluid-syntax                         i]
    [identifier-syntax                           i r ba]
    [if                                          i r ba se ne]
    [let                                         i r ba se ne]
    [let*                                        i r ba se ne]
    [let*-values                                 i r ba]
    [let-syntax                                  i r ba se ne]
    [let-values                                  i r ba]
    [fluid-let-syntax                            i]
    [letrec                                      i r ba se ne]
    [letrec*                                     i r ba]
    [letrec-syntax                               i r ba se ne]
    [or                                          i r ba se ne]
    [quasiquote                                  i r ba se ne]
    [quote                                       i r ba se ne]
    [set!                                        i r ba se ne]
    [syntax-rules                                i r ba se ne]
    [unquote                                     i r ba se ne]
    [unquote-splicing                            i r ba se ne]
    [<                                           i r ba se]
    [<=                                          i r ba se]
    [=                                           i r ba se]
    [>                                           i r ba se]
    [>=                                          i r ba se]
    [+                                           i r ba se]
    [-                                           i r ba se]
    [*                                           i r ba se]
    [/                                           i r ba se]
    [abs                                         i r ba se]
    [asin                                        i r ba se]
    [acos                                        i r ba se]
    [atan                                        i r ba se]
    [sinh                                        i]
    [cosh                                        i]
    [tanh                                        i]
    [asinh                                       i]
    [acosh                                       i]
    [atanh                                       i]
    [angle                                       i r ba se]
    [append                                      i r ba se]
    [apply                                       i r ba se]
    [assert                                      i r ba]
    [assertion-error                             ]
    [assertion-violation                         i r ba]
    [boolean=?                                   i r ba]
    [boolean?                                    i r ba se]
    [car                                         i r ba se]
    [cdr                                         i r ba se]
    [caar                                        i r ba se]
    [cadr                                        i r ba se]
    [cdar                                        i r ba se]
    [cddr                                        i r ba se]
    [caaar                                       i r ba se]
    [caadr                                       i r ba se]
    [cadar                                       i r ba se]
    [caddr                                       i r ba se]
    [cdaar                                       i r ba se]
    [cdadr                                       i r ba se]
    [cddar                                       i r ba se]
    [cdddr                                       i r ba se]
    [caaaar                                      i r ba se]
    [caaadr                                      i r ba se]
    [caadar                                      i r ba se]
    [caaddr                                      i r ba se]
    [cadaar                                      i r ba se]
    [cadadr                                      i r ba se]
    [caddar                                      i r ba se]
    [cadddr                                      i r ba se]
    [cdaaar                                      i r ba se]
    [cdaadr                                      i r ba se]
    [cdadar                                      i r ba se]
    [cdaddr                                      i r ba se]
    [cddaar                                      i r ba se]
    [cddadr                                      i r ba se]
    [cdddar                                      i r ba se]
    [cddddr                                      i r ba se]
    [call-with-current-continuation              i r ba se]
    [call/cc                                     i r ba]
    [call-with-values                            i r ba se]
    [ceiling                                     i r ba se]
    [char->integer                               i r ba se]
    [char<=?                                     i r ba se]
    [char<?                                      i r ba se]
    [char=?                                      i r ba se]
    [char>=?                                     i r ba se]
    [char>?                                      i r ba se]
    [char?                                       i r ba se]
    [complex?                                    i r ba se]
    [cons                                        i r ba se]
    [cos                                         i r ba se]
    [denominator                                 i r ba se]
    [div                                         i r ba]
    [mod                                         i r ba]
    [div-and-mod                                 i r ba]
    [div0                                        i r ba]
    [mod0                                        i r ba]
    [div0-and-mod0                               i r ba]
    [dynamic-wind                                i r ba se]
    [eq?                                         i r ba se]
    [equal?                                      i r ba se]
    [eqv?                                        i r ba se]
    [error                                       i r ba]