;==============================================================================
;		       Copyright (C) 1992 by Marc Feeley -- all rights reserved

; file: "target-m68000-3.scm"

;------------------------------------------------------------------------------
;
; Primitive procedure database (for M68000):

; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

(define prim-procs '
(
;                                    side-effects?  strictness  result
;                                                \  pattern     type
; name                            call pattern     \   \          |
;  /                                    \            \   \        |
("not"                                   (1)          #f 0        BOOLEAN)
("boolean?"                              (1)          #f 0        BOOLEAN)
("eqv?"                                  (2)          #f 0        BOOLEAN)
("eq?"                                   (2)          #f 0        BOOLEAN)
("equal?"                                (2)          #f 0        BOOLEAN)
("pair?"                                 (1)          #f 0        BOOLEAN)
("cons"                                  (2)          #f ()       PAIR   )
("car"                                   (1)          #f 0        (#f)   )
("cdr"                                   (1)          #f 0        (#f)   )
("set-car!"                              (2)          #t (1)      PAIR   )
("set-cdr!"                              (2)          #t (1)      PAIR   )
("caar"                                  (1)          #f 0        (#f)   )
("cadr"                                  (1)          #f 0        (#f)   )
("cdar"                                  (1)          #f 0        (#f)   )
("cddr"                                  (1)          #f 0        (#f)   )
("caaar"                                 (1)          #f 0        (#f)   )
("caadr"                                 (1)          #f 0        (#f)   )
("cadar"                                 (1)          #f 0        (#f)   )
("caddr"                                 (1)          #f 0        (#f)   )
("cdaar"                                 (1)          #f 0        (#f)   )
("cdadr"                                 (1)          #f 0        (#f)   )
("cddar"                                 (1)          #f 0        (#f)   )
("cdddr"                                 (1)          #f 0        (#f)   )
("caaaar"                                (1)          #f 0        (#f)   )
("caaadr"                                (1)          #f 0        (#f)   )
("caadar"                                (1)          #f 0        (#f)   )
("caaddr"                                (1)          #f 0        (#f)   )
("cadaar"                                (1)          #f 0        (#f)   )
("cadadr"                                (1)          #f 0        (#f)   )
("caddar"                                (1)          #f 0        (#f)   )
("cadddr"                                (1)          #f 0        (#f)   )
("cdaaar"                                (1)          #f 0        (#f)   )
("cdaadr"                                (1)          #f 0        (#f)   )
("cdadar"                                (1)          #f 0        (#f)   )
("cdaddr"                                (1)          #f 0        (#f)   )
("cddaar"                                (1)          #f 0        (#f)   )
("cddadr"                                (1)          #f 0        (#f)   )
("cdddar"                                (1)          #f 0        (#f)   )
("cddddr"                                (1)          #f 0        (#f)   )
("null?"                                 (1)          #f 0        BOOLEAN)
("list?"                                 (1)          #f 0        BOOLEAN)
("list"                                  0            #f ()       LIST   )
("length"                                (1)          #f 0        INTEGER)
("append"                                0            #f 0        LIST   )
("reverse"                               (1)          #f 0        LIST   )
("list-ref"                              (2)          #f 0        (#f)   )
("memq"                                  (2)          #f 0        LIST   )
("memv"                                  (2)          #f 0        LIST   )
("member"                                (2)          #f 0        LIST   )
("assq"                                  (2)          #f 0        #f     )
("assv"                                  (2)          #f 0        #f     )
("assoc"                                 (2)          #f 0        #f     )
("symbol?"                               (1)          #f 0        BOOLEAN)
("symbol->string"                        (1)          #f 0        STRING )
("string->symbol"                        (1)          #f 0        SYMBOL )
("number?"                               (1)          #f 0        BOOLEAN)
("complex?"                              (1)          #f 0        BOOLEAN)
("real?"                                 (1)          #f 0        BOOLEAN)
("rational?"                             (1)          #f 0        BOOLEAN)
("integer?"                              (1)          #f 0        BOOLEAN)
("exact?"                                (1)          #f 0        BOOLEAN)
("inexact?"                              (1)          #f 0        BOOLEAN)
("="                                     0            #f 0        BOOLEAN)
("<"                                     0            #f 0        BOOLEAN)
(">"                                     0            #f 0        BOOLEAN)
("<="                                    0            #f 0        BOOLEAN)
(">="                                    0            #f 0        BOOLEAN)
("zero?"                                 (1)          #f 0        BOOLEAN)
("positive?"                             (1)          #f 0        BOOLEAN)
("negative?"                             (1)          #f 0        BOOLEAN)
("odd?"                                  (1)          #f 0        BOOLEAN)
("even?"                                 (1)          #f 0        BOOLEAN)
("max"                                   1            #f 0        NUMBER )
("min"                                   1            #f 0        NUMBER )
("+"                                     0            #f 0        NUMBER )
("*"                                     0            #f 0        NUMBER )
("-"                                     1            #f 0        NUMBER )
("/"                                     1            #f 0        NUMBER )
("abs"                                   (1)          #f 0        NUMBER )
("quotient"                              1            #f 0        INTEGER)
("remainder"                             (2)          #f 0        INTEGER)
("modulo"                                (2)          #f 0        INTEGER)
("gcd"                                   1            #f 0        INTEGER)
("lcm"                                   1            #f 0        INTEGER)
("numerator"                             (1)          #f 0        INTEGER)
("denominator"                           (1)          #f 0        INTEGER)
("floor"                                 (1)          #f 0        INTEGER)
("ceiling"                               (1)          #f 0        INTEGER)
("truncate"                              (1)          #f 0        INTEGER)
("round"                                 (1)          #f 0        INTEGER)
("rationalize"                           (2)          #f 0        NUMBER )
("exp"                                   (1)          #f 0        NUMBER )
("log"                                   (1)          #f 0        NUMBER )
("sin"                                   (1)          #f 0        NUMBER )
("cos"                                   (1)          #f 0        NUMBER )
("tan"                                   (1)          #f 0        NUMBER )
("asin"                                  (1)          #f 0        NUMBER )
("acos"                                  (1)          #f 0        NUMBER )
("atan"                                  (1 2)        #f 0        NUMBER )
("sqrt"                                  (1)          #f 0        NUMBER )
("expt"                                  (2)          #f 0        NUMBER )
("make-rectangular"                      (2)          #f 0        NUMBER )
("make-polar"                            (2)          #f 0        NUMBER )
("real-part"                             (1)          #f 0        REAL   )
("imag-part"                             (1)          #f 0        REAL   )
("magnitude"                             (1)          #f 0        REAL   )
("angle"                                 (1)          #f 0        REAL   )
("exact->inexact"                        (1)          #f 0        NUMBER )
("inexact->exact"                        (1)          #f 0        NUMBER )
("number->string"                        (1 2)        #f 0        STRING )
("string->number"                        (1 2)        #f 0        NUMBER )
("char?"                                 (1)          #f 0        BOOLEAN)
("char=?"                                0            #f 0        BOOLEAN)
("char<?"                                0            #f 0        BOOLEAN)
("char>?"                                0            #f 0        BOOLEAN)
("char<=?"                               0            #f 0        BOOLEAN)
("char>=?"                               0            #f 0        BOOLEAN)
("char-ci=?"                             0            #f 0        BOOLEAN)
("char-ci<?"                             0            #f 0        BOOLEAN)
("char-ci>?"                             0            #f 0        BOOLEAN)
("char-ci<=?"                            0            #f 0        BOOLEAN)
("char-ci>=?"                            0            #f 0        BOOLEAN)
("char-alphabetic?"                      (1)          #f 0        BOOLEAN)
("char-numeric?"                         (1)          #f 0        BOOLEAN)
("char-whitespace?"                      (1)          #f 0        BOOLEAN)
("char-upper-case?"                      (1)          #f 0        BOOLEAN)
("char-lower-case?"                      (1)          #f 0        BOOLEAN)
("char->integer"                         (1)          #f 0        INTEGER)
("integer->char"                         (1)          #f 0        CHAR   )
("char-upcase"                           (1)          #f 0        CHAR   )
("char-downcase"                         (1)          #f 0        CHAR   )
("string?"                               (1)          #f 0        BOOLEAN)
("make-string"                           (1 2)        #f 0        STRING )
("string"                                0            #f 0        STRING )
("string-length"                         (1)          #f 0        INTEGER)
("string-ref"                            (2)          #f 0        CHAR   )
("string-set!"                           (3)          #t 0        STRING )
("string=?"                              0            #f 0        BOOLEAN)
("string<?"                              0            #f 0        BOOLEAN)
("string>?"                              0            #f 0        BOOLEAN)
("string<=?"                             0            #f 0        BOOLEAN)
("string>=?"                             0            #f 0        BOOLEAN)
("string-ci=?"                           0            #f 0        BOOLEAN)
("string-ci<?"                           0            #f 0        BOOLEAN)
("string-ci>?"                           0            #f 0        BOOLEAN)
("string-ci<=?"                          0            #f 0        BOOLEAN)
("string-ci>=?"                          0            #f 0        BOOLEAN)
("substring"                             (3)          #f 0        STRING )
("string-append"                         0            #f 0        STRING )
("vector?"                               (1)          #f 0        BOOLEAN)
("make-vector"                           (1 2)        #f (1)      VECTOR )
("vector"                                0            #f ()       VECTOR )
("vector-length"                         (1)          #f 0        INTEGER)
("vector-ref"                            (2)          #f 0        (#f)   )
("vector-set!"                           (3)          #t (1 2)    VECTOR )
("procedure?"                            (1)          #f 0        BOOLEAN)
("apply"                                 2            #t 0        (#f)   )
("map"                                   2            #t 0        LIST   )
("for-each"                              2            #t 0        #f     )
("call-with-current-continuation"        (1)          #t 0        (#f)   )
("call-with-input-file"                  (2)          #t 0        (#f)   )
("call-with-output-file"                 (2)          #t 0        (#f)   )
("input-port?"                           (1)          #f 0        BOOLEAN)
("output-port?"                          (1)          #f 0        BOOLEAN)
("current-input-port"                    (0)          #f 0        PORT   )
("current-output-port"                   (0)          #f 0        PORT   )
("open-input-file"                       (1)          #t 0        PORT   )
("open-output-file"                      (1)          #t 0        PORT   )
("close-input-port"                      (1)          #t 0        #f     )
("close-output-port"                     (1)          #t 0        #f     )
("eof-object?"                           (1)          #f 0        BOOLEAN)
("read"                                  (0 1)        #t 0        #f     )
("read-char"                             (0 1)        #t 0        #f     )
("peek-char"                             (0 1)        #t 0        #f     )
("write"                                 (0 1)        #t 0        #f     )
("display"                               (0 1)        #t 0        #f     )
("newline"                               (0 1)        #t 0        #f     )
("write-char"                            (1 2)        #t 0        #f     )

; for R4RS Scheme

("list-tail"                             (2)          #f 0        (#f)   )
("string->list"                          (1)          #f 0        LIST   )
("list->string"                          (1)          #f 0        STRING )
("string-copy"                           (1)          #f 0        STRING )
("string-fill!"                          (2)          #t 0        STRING )
("vector->list"                          (1)          #f 0        LIST   )
("list->vector"                          (1)          #f 0        VECTOR )
("vector-fill!"                          (2)          #t 0        VECTOR )
("force"                                 (1)          #t 0        #f     )
("with-input-from-file"                  (2)          #t 0        (#f)   )
("with-output-to-file"                   (2)          #t 0        (#f)   )
("char-ready?"                           (0 1)        #f 0        BOOLEAN)
("load"                                  (1)          #t 0        (#f)   )
("transcript-on"                         (1)          #t 0        #f     )
("transcript-off"                        (0)          #t 0        #f     )

; for Multilisp

("touch"                                 (1)          #t 0        #f     )

; for system interface

("##type"                                (1)          #f ()       INTEGER)
("##type-cast"                           (2)          #f ()       (#f)   )
("##subtype"                             (1)          #f ()       INTEGER)
("##subtype-set!"                        (2)          #t ()       #f     )

("##not"                                 (1)          #f ()       BOOLEAN)
("##null?"                               (1)          #f ()       BOOLEAN)
("##unassigned?"                         (1)          #f ()       BOOLEAN)
("##unbound?"                            (1)          #f ()       BOOLEAN)
("##eq?"                                 (2)          #f ()       BOOLEAN)

("##fixnum?"                             (1)          #f ()       BOOLEAN)
("##special?"                            (1)          #f ()       BOOLEAN)
("##pair?"                               (1)          #f ()       BOOLEAN)
("##weak-pair?"                          (1)          #f ()       BOOLEAN)
("##subtyped?"                           (1)          #f ()       BOOLEAN)
("##procedure?"                          (1)          #f ()       BOOLEAN)
("##placeholder?"                        (1)          #f ()       BOOLEAN)
("##vector?"                             (1)          #f ()       BOOLEAN)
("##symbol?"                             (1)          #f ()       BOOLEAN)
("##ratnum?"                             (1)          #f ()       BOOLEAN)
("##cpxnum?"                             (1)          #f ()       BOOLEAN)
("##string?"                             (1)          #f ()       BOOLEAN)
("##bignum?"                             (1)          #f ()       BOOLEAN)
("##flonum?"                             (1)          #f ()       BOOLEAN)
("##char?"                               (1)          #f ()       BOOLEAN)

("##fixnum.+"                            0            #f ()       INTEGER)
("##fixnum.*"                            0            #f ()       INTEGER)
("##fixnum.-"                            1            #f ()       INTEGER)
("##fixnum.quotient"                     (2)          #f ()       INTEGER)
("##fixnum.remainder"                    (2)          #f ()       INTEGER)
("##fixnum.modulo"                       (2)          #f ()       INTEGER)
("##fixnum.logior"                       0            #f ()       INTEGER)
("##fixnum.logxor"                       0            #f ()       INTEGER)
("##fixnum.logand"                       0            #f ()       INTEGER)
("##fixnum.lognot"                       (1)          #f ()       INTEGER)
("##fixnum.ash"                          (2)          #f ()       INTEGER)
("##fixnum.zero?"                        (1)          #f ()       BOOLEAN)
("##fixnum.positive?"                    (1)          #f ()       BOOLEAN)
("##fixnum.negative?"                    (1)          #f ()       BOOLEAN)
("##fixnum.odd?"                         (1)          #f ()       BOOLEAN)
("##fixnum.even?"                        (1)          #f ()       BOOLEAN)
("##fixnum.="                            0            #f ()       BOOLEAN)
("##fixnum.<"                            0            #f ()       BOOLEAN)
("##fixnum.>"                            0            #f ()       BOOLEAN)
("##fixnum.<="                           0            #f ()       BOOLEAN)
("##fixnum.>="                           0            #f ()       BOOLEAN)

("##logior"                              0            #f ()       INTEGER)
("##logxor"                              0            #f ()       INTEGER)
("##logand"                              0            #f ()       INTEGER)
("##lognot"                              (1)          #f ()       INTEGER)
("##ash"                                 (2)          #f ()       INTEGER)

("##flonum.->fixnum"                     (1)          #f ()       INTEGER)
("##flonum.<-fixnum"                     (1)          #f ()       REAL   )
("##flonum.+"                            0            #f ()       REAL   )
("##flonum.*"                            0            #f ()       REAL   )
("##flonum.-"                            1            #f ()       REAL   )
("##flonum./"                            1            #f ()       REAL   )
("##flonum.abs"                          (1)          #f ()       REAL   )
("##flonum.truncate"                     (1)          #f ()       REAL   )
("##flonum.round"                        (1)          #f ()       REAL   )
("##flonum.exp"                          (1)          #f ()       REAL   )
("##flonum.log"                          (1)          #f ()       REAL   )
("##flonum.sin"                          (1)          #f ()       REAL   )
("##flonum.cos"                          (1)          #f ()       REAL   )
("##flonum.tan"                          (1)          #f ()       REAL   )
("##flonum.asin"                         (1)          #f ()       REAL   )
("##flonum.acos"                         (1)          #f ()       REAL   )
("##flonum.atan"                         (1)          #f ()       REAL   )
("##flonum.sqrt"                         (1)          #f ()       REAL   )
("##flonum.zero?"                        (1)          #f ()       BOOLEAN)
("##flonum.positive?"                    (1)          #f ()       BOOLEAN)
("##flonum.negative?"                    (1)          #f ()       BOOLEAN)
("##flonum.="                            0            #f ()       BOOLEAN)
("##flonum.<"                            0            #f ()       BOOLEAN)
("##flonum.>"                            0            #f ()       BOOLEAN)
("##flonum.<="                           0            #f ()       BOOLEAN)
("##flonum.>="                           0            #f ()       BOOLEAN)

("##char=?"                              0            #f ()       BOOLEAN)
("##char<?"                              0            #f ()       BOOLEAN)
("##char>?"                              0            #f ()       BOOLEAN)
("##char<=?"                             0            #f ()       BOOLEAN)
("##char>=?"                             0            #f ()       BOOLEAN)

("##cons"                                (2)          #f ()       PAIR   )
("##set-car!"                            (2)          #t ()       PAIR   )
("##set-cdr!"                            (2)          #t ()       PAIR   )
("##car"                                 (1)          #f ()       (#f)   )
("##cdr"                                 (1)          #f ()       (#f)   )
("##caar"                                (1)          #f ()       (#f)   )
("##cadr"                                (1)          #f ()       (#f)   )
("##cdar"                                (1)          #f ()       (#f)   )
("##cddr"                                (1)          #f ()       (#f)   )
("##caaar"                               (1)          #f ()       (#f)   )
("##caadr"                               (1)          #f ()       (#f)   )
("##cadar"                               (1)          #f ()       (#f)   )
("##caddr"                               (1)          #f ()       (#f)   )
("##cdaar"                               (1)          #f ()       (#f)   )
("##cdadr"                               (1)          #f ()       (#f)   )
("##cddar"                               (1)          #f ()       (#f)   )
("##cdddr"                               (1)          #f ()       (#f)   )
("##caaaar"                              (1)          #f ()       (#f)   )
("##caaadr"                              (1)          #f ()       (#f)   )
("##caadar"                              (1)          #f ()       (#f)   )
("##caaddr"                              (1)          #f ()       (#f)   )
("##cadaar"                              (1)          #f ()       (#f)   )
("##cadadr"                              (1)          #f ()       (#f)   )
("##caddar"                              (1)          #f ()       (#f)   )
("##cadddr"                              (1)          #f ()       (#f)   )
("##cdaaar"                              (1)          #f ()       (#f)   )
("##cdaadr"                              (1)          #f ()       (#f)   )
("##cdadar"                              (1)          #f ()       (#f)   )
("##cdaddr"                              (1)          #f ()       (#f)   )
("##cddaar"                              (1)          #f ()       (#f)   )
("##cddadr"                              (1)          #f ()       (#f)   )
("##cdddar"                              (1)          #f ()       (#f)   )
("##cddddr"                              (1)          #f ()       (#f)   )

("##weak-cons"                           (2)          #f ()       PAIR   )
("##weak-set-car!"                       (2)          #t ()       PAIR   )
("##weak-set-cdr!"                       (2)          #t ()       PAIR   )
("##weak-car"                            (1)          #f ()       (#f)   )
("##weak-cdr"                            (1)          #f ()       (#f)   )

("##vector"                              0            #f ()       VECTOR )
("##make-vector"                         (2)          #f ()       VECTOR )
("##vector-length"                       (1)          #f ()       INTEGER)
("##vector-ref"                          (2)          #f ()       (#f)   )
("##vector-set!"                         (3)          #t ()       VECTOR )
("##vector-shrink!"                      (2)          #t ()       VECTOR )

("##string"                              0            #f ()       STRING )
("##make-string"                         (2)          #f ()       STRING )
("##string-length"                       (1)          #f ()       INTEGER)
("##string-ref"                          (2)          #f ()       CHAR   )
("##string-set!"                         (3)          #t ()       STRING )
("##string-shrink!"                      (2)          #t ()       STRING )

("##vector8"                             0            #f ()       STRING )
("##make-vector8"                        (2)          #f ()       STRING )
("##vector8-length"                      (1)          #f ()       INTEGER)
("##vector8-ref"                         (2)          #f ()       INTEGER)
("##vector8-set!"                        (3)          #t ()       STRING )
("##vector8-shrink!"                     (2)          #t ()       STRING )

("##vector16"                            0            #f ()       STRING )
("##make-vector16"                       (2)          #f ()       STRING )
("##vector16-length"                     (1)          #f ()       INTEGER)
("##vector16-ref"                        (2)          #f ()       INTEGER)
("##vector16-set!"                       (3)          #t ()       STRING )
("##vector16-shrink!"                    (2)          #t ()       STRING )

("##slot-ref"                            (2)          #f ()       (#f)   )
("##slot-set!"                           (3)          #t ()       #f     )

("##make-cell"                           (1)          #f ()       PAIR   )
("##cell-ref"                            (1)          #f ()       (#f)   )
("##cell-set!"                           (2)          #t ()       PAIR   )

("##pstate"                              (0)          #f ()       #f     )

("##touch"                               (1)          #t 0        #f     )

("##apply"                               (2)          #t ()       (#f)   )
("##call-with-current-continuation"      (1)          #t ()       (#f)   )
("##global-var"                          (1)          #t ()       #f     )
("##global-var-ref"                      (1)          #f ()       (#f)   )
("##global-var-set!"                     (2)          #t ()       #f     )

("##atomic-car"                          (1)          #f ()       (#f)   )
("##atomic-cdr"                          (1)          #f ()       (#f)   )
("##atomic-set-car!"                     (2)          #t ()       PAIR   )
("##atomic-set-cdr!"                     (2)          #t ()       PAIR   )
("##atomic-set-car-if-eq?!"              (3)          #t ()       BOOLEAN)
("##atomic-set-cdr-if-eq?!"              (3)          #t ()       BOOLEAN)

; for front end

("##quasi-append"                        0            #f 0        LIST   )
("##quasi-list"                          0            #f ()       LIST   )
("##quasi-cons"                          (2)          #f ()       PAIR   )
("##quasi-list->vector"                  (1)          #f 0        VECTOR )
("##case-memv"                           (2)          #f 0        LIST   )

)
)

;==============================================================================
